0:\n pos_phi = rf.from_cartesian_to_cyl(np.array(pos1))[:,1]\n _, var_phi = rf.phi_mean_var(pos_phi, q1)\n\n pos_z = np.array(pos1)[:,2]\n mean_z = np.average(pos_z, weights=q1)\n var_z = np.average((pos_z-mean_z)**2, weights=q1)\n r = np.sqrt(true_pos[0][0]**2 + true_pos[0][1]**2)\n\n var_phi1 .append(var_phi)\n var_z1 .append(var_z)\n touched_sipms1.append(len(pos1))\n true_r1 .append(r)\n\n else:\n var_phi1 .append(1.e9)\n var_z1 .append(1.e9)\n touched_sipms1.append(1.e9)\n true_r1 .append(1.e9)\n\n if len(pos2) > 0:\n pos_phi = rf.from_cartesian_to_cyl(np.array(pos2))[:,1]\n _, var_phi = rf.phi_mean_var(pos_phi, q2)\n\n pos_z = np.array(pos2)[:,2]\n mean_z = np.average(pos_z, weights=q2)\n var_z = np.average((pos_z-mean_z)**2, weights=q2)\n r = np.sqrt(true_pos[1][0]**2 + true_pos[1][1]**2)\n\n var_phi2 .append(var_phi)\n var_z2 .append(var_z)\n touched_sipms2.append(len(pos2))\n true_r2 .append(r)\n\n else:\n var_phi2 .append(1.e9)\n var_z2 .append(1.e9)\n touched_sipms2.append(1.e9)\n true_r2 .append(1.e9)\n\n a_true_r1 = np.array(true_r1)\n a_true_r2 = np.array(true_r2)\n a_var_phi1 = np.array(var_phi1)\n a_var_phi2 = np.array(var_phi2)\n a_var_z1 = np.array(var_z1)\n a_var_z2 = np.array(var_z2)\n\n a_touched_sipms1 = np.array(touched_sipms1)\n a_touched_sipms2 = np.array(touched_sipms2)\n\n\n np.savez(output_file, a_true_r1=a_true_r1, a_true_r2=a_true_r2, a_var_phi1=a_var_phi1, a_var_phi2=a_var_phi2, a_var_z1=a_var_z1, a_var_z2=a_var_z2, a_touched_sipms1=a_touched_sipms1, a_touched_sipms2=a_touched_sipms2)","def _map_elements3(self, nid_map, model, unused_j, unused_dim_max,\n nid_cp_cd, xref_loads=True):\n settings = self.gui.settings # type: Settings\n\n # these normals point inwards\n # 4\n # / | \\\n # / | \\\n # 3-------2\n # \\ | /\n # \\ | /\n # 1\n _ctetra_faces = (\n (0, 1, 2), # (1, 2, 3),\n (0, 3, 1), # (1, 4, 2),\n (0, 3, 2), # (1, 3, 4),\n (1, 3, 2), # (2, 4, 3),\n )\n\n # these normals point inwards\n #\n #\n #\n #\n # /4-----3\n # / /\n # / 5 /\n # / \\ /\n # / \\ /\n # 1---------2\n _cpyram_faces = (\n (0, 1, 2, 3), # (1, 2, 3, 4),\n (1, 4, 2), # (2, 5, 3),\n (2, 4, 3), # (3, 5, 4),\n (0, 3, 4), # (1, 4, 5),\n (0, 4, 1), # (1, 5, 2),\n )\n\n # these normals point inwards\n # /6\n # / | \\\n # / | \\\n # 3\\ | \\\n # | \\ /4-----5\n # | \\/ /\n # | / \\ /\n # | / \\ /\n # | / \\ /\n # 1---------2\n _cpenta_faces = (\n (0, 2, 1), # (1, 3, 2),\n (3, 4, 5), # (4, 5, 6),\n\n (0, 1, 4, 3), # (1, 2, 5, 4), # bottom\n (1, 2, 5, 4), # (2, 3, 6, 5), # right\n (0, 3, 5, 2), # (1, 4, 6, 3), # left\n )\n\n # these normals point inwards\n # 8----7\n # /| /|\n # / | / |\n # / 5-/--6\n # 4-----3 /\n # | / | /\n # | / | /\n # 1-----2\n _chexa_faces = (\n (4, 5, 6, 7), # (5, 6, 7, 8),\n (0, 3, 2, 1), # (1, 4, 3, 2),\n (1, 2, 6, 5), # (2, 3, 7, 6),\n (2, 3, 7, 6), # (3, 4, 8, 7),\n (0, 4, 7, 3), # (1, 5, 8, 4),\n (0, 6, 5, 4), # (1, 7, 6, 5),\n )\n\n elements, nelements, unused_superelements = get_elements_nelements_unvectorized(model)\n xyz_cid0 = self.xyz_cid0\n pids_array = np.zeros(nelements, dtype='int32')\n eids_array = np.zeros(nelements, dtype='int32')\n mcid_array = np.full(nelements, -1, dtype='int32')\n material_theta_array = np.full(nelements, np.nan, dtype='float32')\n dim_array = np.full(nelements, -1, dtype='int32')\n nnodes_array = np.full(nelements, -1, dtype='int32')\n\n # quality\n min_interior_angle = np.zeros(nelements, 'float32')\n max_interior_angle = np.zeros(nelements, 'float32')\n dideal_theta = np.zeros(nelements, 'float32')\n max_skew_angle = np.zeros(nelements, 'float32')\n max_warp_angle = np.zeros(nelements, 'float32')\n max_aspect_ratio = np.zeros(nelements, 'float32')\n area = np.zeros(nelements, 'float32')\n area_ratio = np.zeros(nelements, 'float32')\n taper_ratio = np.zeros(nelements, 'float32')\n min_edge_length = np.zeros(nelements, 'float32')\n normals = np.full((nelements, 3), np.nan, 'float32')\n\n nids_list = []\n ieid = 0\n cell_offset = 0\n\n dtype = get_numpy_idtype_for_vtk()\n\n cell_types_array = np.zeros(nelements, dtype=dtype)\n cell_offsets_array = np.zeros(nelements, dtype=dtype)\n\n cell_type_point = 1 # vtk.vtkVertex().GetCellType()\n cell_type_line = 3 # vtk.vtkLine().GetCellType()\n cell_type_tri3 = 5 # vtkTriangle().GetCellType()\n cell_type_tri6 = 22 # vtkQuadraticTriangle().GetCellType()\n cell_type_quad4 = 9 # vtkQuad().GetCellType()\n #cell_type_quad8 = 23 # vtkQuadraticQuad().GetCellType()\n cell_type_tetra4 = 10 # vtkTetra().GetCellType()\n cell_type_tetra10 = 24 # vtkQuadraticTetra().GetCellType()\n cell_type_pyram5 = 14 # vtkPyramid().GetCellType()\n #cell_type_pyram13 = 27 # vtk.vtkQuadraticPyramid().GetCellType()\n cell_type_penta6 = 13 # vtkWedge().GetCellType()\n cell_type_penta15 = 26 # vtkQuadraticWedge().GetCellType()\n cell_type_hexa8 = 12 # vtkHexahedron().GetCellType()\n cell_type_hexa20 = 25 # vtkQuadraticHexahedron().GetCellType()\n\n # per gui/testing_methods.py/create_vtk_cells_of_constant_element_type\n #1 = vtk.vtkVertex().GetCellType()\n #3 = vtkLine().GetCellType()\n #5 = vtkTriangle().GetCellType()\n #9 = vtk.vtkQuad().GetCellType()\n #10 = vtkTetra().GetCellType()\n #vtkPenta().GetCellType()\n #vtkHexa().GetCellType()\n #vtkPyram().GetCellType()\n\n skipped_etypes = set()\n all_nids = nid_cp_cd[:, 0]\n ieid = 0\n for eid, elem in sorted(elements.items()):\n if ieid % 5000 == 0 and ieid > 0:\n print(' map_elements = %i' % ieid)\n etype = elem.type\n nnodes = None\n nids = None\n pid = None\n cell_type = None\n inids = None\n\n dideal_thetai = np.nan\n min_thetai = np.nan\n max_thetai = np.nan\n #max_thetai = np.nan\n max_skew = np.nan\n max_warp = np.nan\n aspect_ratio = np.nan\n areai = np.nan\n area_ratioi = np.nan\n taper_ratioi = np.nan\n min_edge_lengthi = np.nan\n normali = np.nan\n if etype in ['CTRIA3', 'CTRIAR', 'CTRAX3', 'CPLSTN3', 'CPLSTS3']:\n nids = elem.nodes\n pid = elem.pid\n cell_type = cell_type_tri3 # 5\n inids = np.searchsorted(all_nids, nids)\n p1, p2, p3 = xyz_cid0[inids, :]\n out = tri_quality(p1, p2, p3)\n (areai, max_skew, aspect_ratio,\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi) = out\n normali = np.cross(p1 - p2, p1 - p3)\n if isinstance(elem.theta_mcid, float):\n material_theta_array[ieid] = elem.theta_mcid\n else:\n mcid_array[ieid] = elem.theta_mcid\n nnodes = 3\n dim = 2\n\n elif etype in {'CQUAD4', 'CQUADR', 'CPLSTN4', 'CPLSTS4', 'CQUADX4',\n 'CQUAD1'}: # nastran95\n nids = elem.nodes\n pid = elem.pid\n cell_type = cell_type_quad4 #9\n inids = np.searchsorted(all_nids, nids)\n p1, p2, p3, p4 = xyz_cid0[inids, :]\n out = quad_quality(elem, p1, p2, p3, p4)\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\n normali = np.cross(p1 - p3, p2 - p4)\n if isinstance(elem.theta_mcid, float):\n material_theta_array[ieid] = elem.theta_mcid\n else:\n mcid_array[ieid] = elem.theta_mcid\n nnodes = 4\n dim = 2\n\n elif etype in ['CTRIA6']:\n nids = elem.nodes\n pid = elem.pid\n if None in nids:\n cell_type = cell_type_tri3\n inids = np.searchsorted(all_nids, nids[:3])\n nids = nids[:3]\n p1, p2, p3 = xyz_cid0[inids, :]\n nnodes = 3\n else:\n cell_type = cell_type_tri6\n inids = np.searchsorted(all_nids, nids)\n p1, p2, p3, p4, unused_p5, unused_p6 = xyz_cid0[inids, :]\n nnodes = 6\n out = tri_quality(p1, p2, p3)\n (areai, max_skew, aspect_ratio,\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi) = out\n normali = np.cross(p1 - p2, p1 - p3)\n if isinstance(elem.theta_mcid, float):\n material_theta_array[ieid] = elem.theta_mcid\n else:\n mcid_array[ieid] = elem.theta_mcid\n dim = 2\n elif etype == 'CQUAD8':\n nids = elem.nodes\n pid = elem.pid\n if None in nids:\n cell_type = cell_type_tri3\n inids = np.searchsorted(all_nids, nids[:4])\n nids = nids[:4]\n p1, p2, p3, p4 = xyz_cid0[inids, :]\n nnodes = 4\n else:\n cell_type = cell_type_tri6\n inids = np.searchsorted(all_nids, nids)\n p1, p2, p3, p4 = xyz_cid0[inids[:4], :]\n nnodes = 8\n out = quad_quality(elem, p1, p2, p3, p4)\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\n normali = np.cross(p1 - p3, p2 - p4)\n if isinstance(elem.theta_mcid, float):\n material_theta_array[ieid] = elem.theta_mcid\n else:\n mcid_array[ieid] = elem.theta_mcid\n nnodes = 4\n dim = 2\n\n elif etype == 'CSHEAR':\n nids = elem.nodes\n pid = elem.pid\n cell_type = cell_type_quad4 #9\n inids = np.searchsorted(all_nids, nids)\n p1, p2, p3, p4 = xyz_cid0[inids, :]\n out = quad_quality(elem, p1, p2, p3, p4)\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\n normali = np.cross(p1 - p3, p2 - p4)\n nnodes = 4\n dim = 2\n\n elif etype == 'CTETRA':\n nids = elem.nodes\n pid = elem.pid\n if None in nids:\n cell_type = cell_type_tetra4\n nids = nids[:4]\n nnodes = 4\n else:\n cell_type = cell_type_tetra10\n nnodes = 10\n inids = np.searchsorted(all_nids, nids)\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\n _ctetra_faces, nids, nid_map, xyz_cid0)\n dim = 3\n\n elif etype == 'CHEXA':\n nids = elem.nodes\n pid = elem.pid\n if None in nids:\n cell_type = cell_type_hexa8\n nids = nids[:8]\n nnodes = 8\n else:\n cell_type = cell_type_hexa20\n nnodes = 20\n inids = np.searchsorted(all_nids, nids)\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\n _chexa_faces, nids, nid_map, xyz_cid0)\n dim = 3\n\n elif etype == 'CPENTA':\n nids = elem.nodes\n pid = elem.pid\n\n if None in nids:\n cell_type = cell_type_penta6\n nids = nids[:6]\n nnodes = 6\n else:\n cell_type = cell_type_penta15\n nnodes = 15\n\n inids = np.searchsorted(all_nids, nids)\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\n _cpenta_faces, nids, nid_map, xyz_cid0)\n dim = 3\n elif etype == 'CPYRAM':\n # TODO: assuming 5\n nids = elem.nodes\n pid = elem.pid\n if None in nids:\n cell_type = cell_type_pyram5\n nids = nids[:5]\n nnodes = 5\n else:\n cell_type = cell_type_penta15\n nnodes = 15\n inids = np.searchsorted(all_nids, nids)\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\n _cpyram_faces, nids, nid_map, xyz_cid0)\n dim = 3\n elif etype in ['CELAS2', 'CELAS4', 'CDAMP4']:\n # these can have empty nodes and have no property\n # CELAS1: 1/2 GRID/SPOINT and pid\n # CELAS2: 1/2 GRID/SPOINT, k, ge, and s\n # CELAS3: 1/2 SPOINT and pid\n # CELAS4: 1/2 SPOINT and k\n nids = elem.nodes\n assert nids[0] != nids[1]\n if None in nids:\n assert nids[0] is not None, nids\n assert nids[1] is None, nids\n nids = [nids[0]]\n cell_type = cell_type_point\n nnodes = 1\n else:\n nids = elem.nodes\n assert nids[0] != nids[1]\n cell_type = cell_type_line\n nnodes = 2\n inids = np.searchsorted(all_nids, nids)\n pid = 0\n dim = 0\n elif etype in ['CBUSH', 'CBUSH1D', 'CBUSH2D',\n 'CELAS1', 'CELAS3',\n 'CDAMP1', 'CDAMP2', 'CDAMP3', 'CDAMP5',\n 'CFAST', 'CGAP', 'CVISC']:\n nids = elem.nodes\n assert nids[0] != nids[1]\n assert None not in nids, 'nids=%s\\n%s' % (nids, elem)\n pid = elem.pid\n cell_type = cell_type_line\n inids = np.searchsorted(all_nids, nids)\n nnodes = 2\n dim = 0\n elif etype in ['CBAR', 'CBEAM']:\n nids = elem.nodes\n pid = elem.pid\n pid_ref = model.Property(pid)\n areai = pid_ref.Area()\n cell_type = cell_type_line\n inids = np.searchsorted(all_nids, nids)\n p1, p2 = xyz_cid0[inids, :]\n min_edge_lengthi = norm(p2 - p1)\n nnodes = 2\n dim = 1\n elif etype in ['CROD', 'CTUBE']:\n nids = elem.nodes\n pid = elem.pid\n pid_ref = model.Property(pid)\n areai = pid_ref.Area()\n cell_type = cell_type_line\n inids = np.searchsorted(all_nids, nids)\n p1, p2 = xyz_cid0[inids, :]\n min_edge_lengthi = norm(p2 - p1)\n nnodes = 2\n dim = 1\n elif etype == 'CONROD':\n nids = elem.nodes\n areai = elem.Area()\n pid = 0\n cell_type = cell_type_line\n inids = np.searchsorted(all_nids, nids)\n p1, p2 = xyz_cid0[inids, :]\n min_edge_lengthi = norm(p2 - p1)\n nnodes = 2\n dim = 1\n #------------------------------\n # rare\n #elif etype == 'CIHEX1':\n #nids = elem.nodes\n #pid = elem.pid\n #cell_type = cell_type_hexa8\n #inids = np.searchsorted(all_nids, nids)\n #min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\n #_chexa_faces, nids, nid_map, xyz_cid0)\n #nnodes = 8\n #dim = 3\n elif etype == 'CHBDYE':\n #self.eid_map[eid] = ieid\n eid_solid = elem.eid2\n side = elem.side\n element_solid = model.elements[eid_solid]\n\n mapped_inids = SIDE_MAP[element_solid.type][side]\n side_inids = [nid - 1 for nid in mapped_inids]\n nodes = element_solid.node_ids\n\n pid = 0\n nnodes = len(side_inids)\n nids = [nodes[inid] for inid in side_inids]\n inids = np.searchsorted(all_nids, nids)\n\n if len(side_inids) == 4:\n cell_type = cell_type_quad4\n else:\n msg = 'element_solid:\\n%s' % (str(element_solid))\n msg += 'mapped_inids = %s\\n' % mapped_inids\n msg += 'side_inids = %s\\n' % side_inids\n msg += 'nodes = %s\\n' % nodes\n #msg += 'side_nodes = %s\\n' % side_nodes\n raise NotImplementedError(msg)\n elif etype == 'GENEL':\n nids = []\n if len(elem.ul_nodes):\n nids.append(elem.ul_nodes)\n if len(elem.ud_nodes):\n nids.append(elem.ud_nodes)\n nids = np.unique(np.hstack(nids))\n #print(elem.get_stats())\n nids = nids[:2]\n\n areai = np.nan\n pid = 0\n cell_type = cell_type_line\n inids = np.searchsorted(all_nids, nids)\n p1, p2 = xyz_cid0[inids, :]\n min_edge_lengthi = norm(p2 - p1)\n nnodes = len(nids)\n dim = 1\n else:\n #raise NotImplementedError(elem)\n skipped_etypes.add(etype)\n nelements -= 1\n continue\n #for nid in nids:\n #assert isinstance(nid, integer_types), 'not an integer. nids=%s\\n%s' % (nids, elem)\n #assert nid != 0, 'not a positive integer. nids=%s\\n%s' % (nids, elem)\n\n assert inids is not None\n if not np.array_equal(all_nids[inids], nids):\n msg = 'all_nids[inids]=%s nids=%s\\n%s' % (all_nids[inids], nids, elem)\n raise RuntimeError(msg)\n\n assert cell_type is not None\n assert cell_offset is not None\n assert eid is not None\n assert pid is not None\n assert dim is not None\n assert nnodes is not None\n nids_list.append(nnodes)\n nids_list.extend(inids)\n normals[ieid] = normali\n eids_array[ieid] = eid\n pids_array[ieid] = pid\n dim_array[ieid] = dim\n cell_types_array[ieid] = cell_type\n cell_offsets_array[ieid] = cell_offset # I assume the problem is here\n cell_offset += nnodes + 1\n self.eid_map[eid] = ieid\n\n min_interior_angle[ieid] = min_thetai\n max_interior_angle[ieid] = max_thetai\n dideal_theta[ieid] = dideal_thetai\n max_skew_angle[ieid] = max_skew\n max_warp_angle[ieid] = max_warp\n max_aspect_ratio[ieid] = aspect_ratio\n area[ieid] = areai\n area_ratio[ieid] = area_ratioi\n taper_ratio[ieid] = taper_ratioi\n min_edge_length[ieid] = min_edge_lengthi\n ieid += 1\n\n #print('self.eid_map =', self.eid_map)\n\n icells_zero = np.where(cell_types_array == 0)[0]\n # TODO: I'd like to get rid of deep=1, but it'll crash the edges\n deep = 1\n if len(icells_zero):\n icells = np.where(cell_types_array != 0)[0]\n if len(icells) == 0:\n self.log.error('skipped_etypes = %s' % skipped_etypes)\n raise RuntimeError('there are no elements...')\n eids_array = eids_array[icells]\n pids_array = pids_array[icells]\n #dim_array = pids_array[dim_array]\n cell_types_array = cell_types_array[icells]\n cell_offsets_array = cell_offsets_array[icells]\n nnodes_array = nnodes_array[icells]\n normals = normals[icells, :]\n #deep = 1\n #print('deep = %s' % deep)\n if skipped_etypes:\n self.log.error('skipped_etypes = %s' % list(skipped_etypes))\n #print('skipped_etypes = %s' % skipped_etypes)\n if len(pids_array) != nelements:\n msg = 'nelements=%s len(pids_array)=%s' % (nelements, len(pids_array))\n raise RuntimeError(msg)\n if len(cell_offsets_array) != nelements:\n msg = 'nelements=%s len(cell_offsets_array)=%s' % (nelements, len(cell_offsets_array))\n raise RuntimeError(msg)\n\n nids_array = np.array(nids_list, dtype=dtype)\n\n #-----------------------------------------------------------------\n # saving some data members\n self.element_ids = eids_array\n\n #print('cell_types_array* = ', cell_types_array.tolist())\n #print('cell_offsets_array* = ', cell_offsets_array.tolist())\n\n #-----------------------------------------------------------------\n # build the grid\n\n #self.log.info('nids_array = %s' % nids_array)\n #self.log.info('cell_offsets_array = %s' % cell_offsets_array)\n #self.log.info('cell_types_array = %s' % cell_types_array)\n\n # Create the array of cells\n cells_id_type = numpy_to_vtkIdTypeArray(nids_array, deep=1)\n vtk_cells = vtk.vtkCellArray()\n vtk_cells.SetCells(nelements, cells_id_type)\n\n # Cell types\n vtk_cell_types = numpy_to_vtk(\n cell_types_array, deep=deep,\n array_type=vtk.vtkUnsignedCharArray().GetDataType())\n\n vtk_cell_offsets = numpy_to_vtk(cell_offsets_array, deep=deep,\n array_type=vtk.VTK_ID_TYPE)\n\n grid = self.grid\n #grid = vtk.vtkUnstructuredGrid()\n grid.SetCells(vtk_cell_types, vtk_cell_offsets, vtk_cells)\n\n #-----------------------------------------------------------------\n # fill the results\n nid_to_pid_map = None\n self.isubcase_name_map = {1: ['Nastran', '']}\n icase = 0\n cases = OrderedDict()\n form = ['Geometry', None, []]\n form0 = form[2]\n\n subcase_id = 0\n\n #nids_set = True\n #if nids_set:\n # this intentionally makes a deepcopy\n #nids = np.array(nid_cp_cd[:, 0])\n\n # this intentionally makes a deepcopy\n cds = np.array(nid_cp_cd[:, 2])\n colormap = settings.colormap\n nid_res = GuiResult(subcase_id, 'NodeID', 'NodeID', 'node', all_nids,\n mask_value=0,\n nlabels=None,\n labelsize=None,\n ncolors=None,\n colormap=colormap,\n data_format=None,\n uname='GuiResult')\n cases[icase] = (nid_res, (0, 'Node ID'))\n form0.append(('Node ID', icase, []))\n icase += 1\n\n if cds.max() > 0:\n cd_res = GuiResult(0, header='NodeCd', title='NodeCd',\n location='node', scalar=cds)\n cases[icase] = (cd_res, (0, 'NodeCd'))\n form0.append(('NodeCd', icase, []))\n icase += 1\n\n eid_res = GuiResult(subcase_id, 'ElementID', 'ElementID', 'centroid', eids_array,\n mask_value=0,\n nlabels=None,\n labelsize=None,\n ncolors=None,\n colormap=colormap,\n data_format=None,\n uname='GuiResult')\n cases[icase] = (eid_res, (0, 'ElementID'))\n form0.append(('ElementID', icase, []))\n icase += 1\n\n is_element_dim = True\n #if len(np.unique(dim_array)) > 1:\n #dim_res = GuiResult(subcase_id, 'ElementDim', 'ElementDim', 'centroid', dim_array,\n #mask_value=-1,\n #nlabels=None,\n #labelsize=None,\n #ncolors=None,\n #colormap=colormap,\n #data_format=None,\n #uname='GuiResult')\n #cases[icase] = (dim_res, (0, 'ElementDim'))\n #form0.append(('ElementDim', icase, []))\n #icase += 1\n\n if nnodes_array.max() > -1:\n nnodes_res = GuiResult(subcase_id, 'NNodes/Elem', 'NNodes/Elem',\n 'centroid', nnodes_array,\n mask_value=0,\n nlabels=None,\n labelsize=None,\n ncolors=None,\n colormap=colormap,\n data_format=None,\n uname='GuiResult')\n cases[icase] = (nnodes_res, (0, 'NNodes/Elem'))\n form0.append(('NNodes/Elem', icase, []))\n icase += 1\n\n #pid_res = GuiResult(subcase_id, 'PropertyID', 'PropertyID', 'centroid', pids_array,\n #mask_value=0,\n #nlabels=None,\n #labelsize=None,\n #ncolors=None,\n #colormap=colormap,\n #data_format=None,\n #uname='GuiResult')\n #cases[icase] = (pid_res, (0, 'PropertyID'))\n #form0.append(('PropertyID', icase, []))\n #icase += 1\n\n if len(model.properties) and nelements and settings.nastran_is_properties:\n icase, upids, pcomp, pshell, is_pshell_pcomp = self._build_properties(\n model, nelements, eids_array, pids_array, cases, form0, icase)\n icase = _build_materials(model, pcomp, pshell, is_pshell_pcomp,\n cases, form0, icase)\n try:\n icase = _build_optimization(model, pids_array, upids,\n nelements, cases, form0, icase)\n except Exception:\n #raise\n s = StringIO()\n traceback.print_exc(file=s)\n sout = s.getvalue()\n self.gui.log_error(sout)\n print(sout)\n\n #if isgreater_int(mcid_array, -1):\n #mcid_res = GuiResult(subcase_id, 'Material Coordinate System', 'MaterialCoord',\n #'centroid', mcid_array,\n #mask_value=-1,\n #nlabels=None,\n #labelsize=None,\n #ncolors=None,\n #colormap=colormap,\n #data_format=None,\n #uname='GuiResult')\n #cases[icase] = (mcid_res, (0, 'Material Coordinate System'))\n #form0.append(('Material Coordinate System', icase, []))\n #icase += 1\n\n #if np.isfinite(theta_array).any():\n #print('np.nanmax(theta_array) =', np.nanmax(theta_array))\n #theta_res = GuiResult(subcase_id, 'Theta', 'Theta', 'centroid', theta_array,\n #mask_value=None,\n #nlabels=None,\n #labelsize=None,\n #ncolors=None,\n #colormap=colormap,\n #data_format=None,\n #uname='GuiResult')\n #cases[icase] = (theta_res, (0, 'Theta'))\n #form0.append(('Theta', icase, []))\n #icase += 1\n\n normal_mag = underflow_norm(normals, axis=1)\n assert len(normal_mag) == nelements\n normals /= normal_mag.reshape(nelements, 1)\n i_not_nan = np.isnan(normal_mag)\n\n #if self.make_offset_normals_dim and nelements:\n #material_coord = None\n #icase, normals = _build_normals_quality(\n #model, self.gui.eid_map, nelements, cases, form0, icase,\n #xyz_cid0, material_coord, material_theta,\n #min_interior_angle, max_interior_angle, dideal_theta,\n #area, max_skew_angle, taper_ratio,\n #max_warp_angle, area_ratio, min_edge_length, max_aspect_ratio,\n #make_offset_normals_dim=self.make_offset_normals_dim)\n #self.normals = normals\n\n #----------------------------------------------------------\n\n is_shell = False\n if False in i_not_nan:\n #max_normal = np.nanmax(normal_mag[i_not_nan])\n #is_shell = np.abs(max_normal) > 0.\n is_shell = True\n is_solid = isfinite_and_nonzero(max_interior_angle)\n #print('is_shell=%s is_solid=%s' % (is_shell, is_solid))\n if is_shell:\n nx_res = GuiResult(\n 0, header='NormalX', title='NormalX',\n location='centroid', scalar=normals[:, 0], data_format='%.2f')\n ny_res = GuiResult(\n 0, header='NormalY', title='NormalY',\n location='centroid', scalar=normals[:, 1], data_format='%.2f')\n nz_res = GuiResult(\n 0, header='NormalZ', title='NormalZ',\n location='centroid', scalar=normals[:, 2], data_format='%.2f')\n nxyz_res = NormalResult(0, 'Normals', 'Normals',\n nlabels=2, labelsize=5, ncolors=2,\n colormap=colormap, data_format='%.1f',\n uname='NormalResult')\n\n\n area_res = GuiResult(0, header='Area', title='Area',\n location='centroid', scalar=area)\n min_edge_length_res = GuiResult(\n 0, header='Min Edge Length', title='Min Edge Length',\n location='centroid', scalar=min_edge_length)\n\n min_theta_res = GuiResult(\n 0, header='Min Interior Angle', title='Min Interior Angle',\n location='centroid', scalar=np.degrees(min_interior_angle))\n max_theta_res = GuiResult(\n 0, header='Max Interior Angle', title='Max Interior Angle',\n location='centroid', scalar=np.degrees(max_interior_angle))\n dideal_theta_res = GuiResult(\n 0, header='Delta Ideal Angle', title='Delta Ideal Angle',\n location='centroid', scalar=np.degrees(dideal_theta))\n\n skew = np.degrees(max_skew_angle)\n skew_res = GuiResult(\n 0, header='Max Skew Angle', title='MaxSkewAngle',\n location='centroid', scalar=skew)\n aspect_res = GuiResult(\n 0, header='Aspect Ratio', title='AspectRatio',\n location='centroid', scalar=max_aspect_ratio)\n\n form_checks = []\n form0.append(('Element Checks', None, form_checks))\n if is_element_dim:\n form_checks.append(('ElementDim', icase, []))\n\n if self.make_offset_normals_dim and self.make_nnodes_result and 0: # pragma: no cover\n nnodes_res = GuiResult(\n 0, header='NNodes/Elem', title='NNodes/Elem',\n location='centroid', scalar=nnodes_array)\n form_checks.append(('NNodes', icase + 1, []))\n cases[icase + 1] = (nnodes_res, (0, 'NNodes'))\n icase += 1\n\n if self.make_offset_normals_dim or 1:\n cases[icase + 1] = (nx_res, (0, 'NormalX'))\n cases[icase + 2] = (ny_res, (0, 'NormalY'))\n cases[icase + 3] = (nz_res, (0, 'NormalZ'))\n cases[icase + 4] = (nxyz_res, (0, 'Normal'))\n\n form_checks.append(('NormalX', icase + 1, []))\n form_checks.append(('NormalY', icase + 2, []))\n form_checks.append(('NormalZ', icase + 3, []))\n form_checks.append(('Normal', icase + 4, []))\n\n cases[icase + 5] = (area_res, (0, 'Area'))\n cases[icase + 6] = (min_edge_length_res, (0, 'Min Edge Length'))\n cases[icase + 7] = (min_theta_res, (0, 'Min Interior Angle'))\n cases[icase + 8] = (max_theta_res, (0, 'Max Interior Angle'))\n cases[icase + 9] = (dideal_theta_res, (0, 'Delta Ideal Angle'))\n cases[icase + 10] = (skew_res, (0, 'Max Skew Angle'))\n cases[icase + 11] = (aspect_res, (0, 'Aspect Ratio'))\n\n form_checks.append(('Area', icase + 5, []))\n form_checks.append(('Min Edge Length', icase + 6, []))\n form_checks.append(('Min Interior Angle', icase + 7, []))\n form_checks.append(('Max Interior Angle', icase + 8, []))\n form_checks.append(('Delta Ideal Angle', icase + 9, []))\n form_checks.append(('Max Skew Angle', icase + 10, []))\n form_checks.append(('Aspect Ratio', icase + 11, []))\n icase += 12\n\n if np.any(np.isfinite(area_ratio)) and np.nanmax(area_ratio) > 1.:\n arearatio_res = GuiResult(\n 0, header='Area Ratio', title='Area Ratio',\n location='centroid', scalar=area_ratio)\n cases[icase] = (arearatio_res, (0, 'Area Ratio'))\n form_checks.append(('Area Ratio', icase, []))\n icase += 1\n\n if np.any(np.isfinite(taper_ratio)) and np.nanmax(taper_ratio) > 1.:\n taperratio_res = GuiResult(\n 0, header='Taper Ratio', title='Taper Ratio',\n location='centroid', scalar=taper_ratio)\n cases[icase] = (taperratio_res, (0, 'Taper Ratio'))\n form_checks.append(('Taper Ratio', icase, []))\n icase += 1\n\n if isfinite_and_nonzero(max_warp_angle):\n warp_res = GuiResult(\n 0, header='Max Warp Angle', title='MaxWarpAngle',\n location='centroid', scalar=np.degrees(max_warp_angle))\n cases[icase + 4] = (warp_res, (0, 'Max Warp Angle'))\n form_checks.append(('Max Warp Angle', icase, []))\n icase += 1\n\n #if (np.abs(xoffset).max() > 0.0 or np.abs(yoffset).max() > 0.0 or\n #np.abs(zoffset).max() > 0.0):\n # offsets\n #offset_res = GuiResult(\n #0, header='Offset', title='Offset',\n #location='centroid', scalar=offset, data_format='%g')\n #offset_x_res = GuiResult(\n #0, header='OffsetX', title='OffsetX',\n #location='centroid', scalar=xoffset, data_format='%g')\n #offset_y_res = GuiResult(\n #0, header='OffsetY', title='OffsetY',\n #location='centroid', scalar=yoffset, data_format='%g')\n #offset_z_res = GuiResult(\n #0, header='OffsetZ', title='OffsetZ',\n #location='centroid', scalar=zoffset, data_format='%g')\n\n #cases[icase] = (offset_res, (0, 'Offset'))\n #cases[icase + 1] = (offset_x_res, (0, 'OffsetX'))\n #cases[icase + 2] = (offset_y_res, (0, 'OffsetY'))\n #cases[icase + 3] = (offset_z_res, (0, 'OffsetZ'))\n\n #form_checks.append(('Offset', icase, []))\n #form_checks.append(('OffsetX', icase + 1, []))\n #form_checks.append(('OffsetY', icase + 2, []))\n #form_checks.append(('OffsetZ', icase + 3, []))\n #icase += 4\n\n if self.make_xyz or IS_TESTING:\n x_res = GuiResult(\n 0, header='X', title='X',\n location='node', scalar=xyz_cid0[:, 0], data_format='%g')\n y_res = GuiResult(\n 0, header='Y', title='Y',\n location='node', scalar=xyz_cid0[:, 1], data_format='%g')\n z_res = GuiResult(\n 0, header='Z', title='Z',\n location='node', scalar=xyz_cid0[:, 2], data_format='%g')\n cases[icase] = (x_res, (0, 'X'))\n cases[icase + 1] = (y_res, (0, 'Y'))\n cases[icase + 2] = (z_res, (0, 'Z'))\n form_checks.append(('X', icase + 0, []))\n form_checks.append(('Y', icase + 1, []))\n form_checks.append(('Z', icase + 2, []))\n icase += 3\n\n elif is_solid:\n # only solid elements\n form_checks = []\n form0.append(('Element Checks', None, form_checks))\n\n min_edge_length_res = GuiResult(\n 0, header='Min Edge Length', title='Min Edge Length',\n location='centroid', scalar=min_edge_length)\n min_theta_res = GuiResult(\n 0, header='Min Interior Angle', title='Min Interior Angle',\n location='centroid', scalar=np.degrees(min_interior_angle))\n max_theta_res = GuiResult(\n 0, header='Max Interior Angle', title='Max Interior Angle',\n location='centroid', scalar=np.degrees(max_interior_angle))\n skew = 90. - np.degrees(max_skew_angle)\n #skew_res = GuiResult(0, header='Max Skew Angle', title='MaxSkewAngle',\n #location='centroid', scalar=skew)\n if is_element_dim:\n form_checks.append(('ElementDim', icase, []))\n form_checks.append(('Min Edge Length', icase + 1, []))\n form_checks.append(('Min Interior Angle', icase + 2, []))\n form_checks.append(('Max Interior Angle', icase + 3, []))\n form_checks.append(('Max Skew Angle', icase + 4, []))\n cases[icase + 1] = (min_edge_length_res, (0, 'Min Edge Length'))\n cases[icase + 2] = (min_theta_res, (0, 'Min Interior Angle'))\n cases[icase + 3] = (max_theta_res, (0, 'Max Interior Angle'))\n #cases[icase + 4] = (skew_res, (0, 'Max Skew Angle'))\n icase += 4\n\n else:\n form0.append(('ElementDim', icase, []))\n icase += 1\n\n if isgreater_int(mcid_array, -1):\n material_coord_res = GuiResult(\n 0, header='MaterialCoord', title='MaterialCoord',\n location='centroid',\n scalar=mcid_array, mask_value=-1, data_format='%i')\n cases[icase] = (material_coord_res, (0, 'MaterialCoord'))\n form0.append(('MaterialCoord', icase, []))\n icase += 1\n if isfinite(material_theta_array):\n material_theta_res = GuiResult(\n 0, header='MaterialTheta', title='MaterialTheta',\n location='centroid',\n scalar=material_theta_array, data_format='%.3f')\n cases[icase] = (material_theta_res, (0, 'MaterialTheta'))\n form0.append(('MaterialTheta', icase, []))\n icase += 1\n\n #print(normals)\n #----------------------------------------------------------\n # finishing up vtk\n if nelements and isfinite(min_edge_length):\n mean_edge_length = np.nanmean(min_edge_length)\n self.set_glyph_scale_factor(mean_edge_length * 2.5) # was 1.5\n\n grid.Modified()\n #----------------------------------------------------------\n # finishing up parameters\n self.node_ids = all_nids\n self.normals = normals\n\n return nid_to_pid_map, icase, cases, form","def _gtTSmap(self):\n if os.path.isfile(self.outtsmap):\n # Already exists\n return\n\n if self.csys == 'GAL':\n center_icrs = SkyCoord(ra=self.ra*u.degree, dec=self.dec*u.degree, frame='icrs')\n self.ra = center_icrs.galactic.l.deg\n self.dec = center_icrs.galactic.b.deg\n\n model = os.path.join(self.workpath, 'TSmapModel.xml') \n rfil = open(self.outmodel, 'r')\n wfil = open(model, 'w')\n isSrc = False\n isDif = False\n for line in rfil:\n if (isSrc) and ('<source name' in line):\n # Arrived to a new source, restart copying\n isSrc = False\n if (isDif) and ('<source name' in line) and ('PointSource' in line):\n isDif = False\n if 'TARGET' in line:\n isSrc = True\n if ('<source name=\"gll_iem_v06\"' in line) or ('<source name=\"iso_source_v06\"' in line): \n isDif = True\n \n if isSrc:\n # Do not copy the Target model to make it appear in the TS map\n pass\n else:\n if isDif:\n # Leave Diffuse model normalizations free\n wfil.write(line)\n else:\n # Make sur the gtlike output source model has all source parameters fixed\n wfil.write(line.replace('free=\"1\"', 'free=\"0\"'))\n rfil.close()\n wfil.close()\n\n # Launch the gttsmap tool \n if self.mode == 'binned':\n os.popen(\"gttsmap evfile={} scfile={} bexpmap={} expcube={} cmap={} srcmdl={}\\\n outfile={} evtype={} irfs=CALDB optimizer=NewMinuit statistic=BINNED ftol=1e-2\\\n coordsys={} proj=AIT nxpix={} nypix={} binsz={} xref={} yref={}\".format(self.outmktime,\n self.ft2, self.outbinexp, self.outltcube, self.outbincub, model, self.outtsmap, self.evtype,\n self.csys, self.imwid, self.imwid, self.binsz, self.ra, self.dec))\n elif self.mode == 'unbinned':\n os.popen(\"gttsmap evfile={} scfile={} expmap={} expcube={} srcmdl={}\\\n outfile={} evtype={} irfs=CALDB optimizer=NewMinuit statistic=UNBINNED ftol=1e-2\\\n coordsys={} proj=AIT nxpix={} nypix={} binsz={} xref={} yref={}\".format(self.outmktime,\n self.ft2, self.outexpmap, self.outltcube, model, self.outtsmap, self.evtype,\n self.csys, self.imwid, self.imwid, self.binsz, self.ra, self.dec))\n else:\n return\n\n if self.csys == 'GAL':\n self.ra = center_icrs.ra.deg\n self.dec = center_icrs.dec.deg\n return","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CCLB').get('abstractTypes')\n exolinks = globalMap.get('CCLB').get('exolinks')\n\n # Class AtomLabel\n currentMap = {}\n abstractTypes['AtomLabel'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'] = currentMap\n loadMaps['CCLB.AtomLabel'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'atomLabels'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AtomLabel.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AtomLabel.isotopeCode\n currentMap = {}\n contentMap['isotopeCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'] = currentMap\n loadMaps['CCLB.AtomLabel.isotopeCode'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.isotopeCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'\n currentMap['name'] = 'isotopeCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AtomLabel.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'] = currentMap\n loadMaps['CCLB.AtomLabel.name'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AtomLabel.subType\n currentMap = {}\n contentMap['subType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'] = currentMap\n loadMaps['CCLB.AtomLabel.subType'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.subType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'\n currentMap['name'] = 'subType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['default'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute AtomLabel.weight\n currentMap = {}\n contentMap['weight'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'] = currentMap\n loadMaps['CCLB.AtomLabel.weight'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.weight'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'\n currentMap['name'] = 'weight'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 1.0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\n\n # Role AtomLabel.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of AtomLabel\n\n currentMap = abstractTypes.get('AtomLabel')\n aList = ['isotopeCode', 'name', 'subType', 'weight']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ChemCompLabel\n currentMap = {}\n abstractTypes['ChemCompLabel'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'] = currentMap\n loadMaps['CCLB.ChemCompLabel'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemCompLabels'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemCompLabel.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemCompLabel.ccpCode\n currentMap = {}\n contentMap['ccpCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'] = currentMap\n loadMaps['CCLB.ChemCompLabel.ccpCode'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.ccpCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'\n currentMap['name'] = 'ccpCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ChemCompLabel.molType\n currentMap = {}\n contentMap['molType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'] = currentMap\n loadMaps['CCLB.ChemCompLabel.molType'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.molType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'\n currentMap['name'] = 'molType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\n\n # Role ChemCompLabel.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemCompLabel.isotopomers\n currentMap = {}\n contentMap['isotopomers'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'] = currentMap\n loadMaps['CCLB.ChemCompLabel.isotopomers'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.isotopomers'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'\n currentMap['name'] = 'isotopomers'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of ChemCompLabel\n\n currentMap = abstractTypes.get('ChemCompLabel')\n aList = ['ccpCode', 'molType']\n currentMap['headerAttrs'] = aList\n aList = ['isotopomers', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['isotopomers']\n currentMap['children'] = aList\n\n # Class Isotopomer\n currentMap = {}\n abstractTypes['Isotopomer'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'] = currentMap\n loadMaps['CCLB.Isotopomer'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'isotopomers'\n currentMap['objkey'] = 'serial'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Isotopomer.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Isotopomer.serial\n currentMap = {}\n contentMap['serial'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'] = currentMap\n loadMaps['CCLB.Isotopomer.serial'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.serial'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'\n currentMap['name'] = 'serial'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Isotopomer.weight\n currentMap = {}\n contentMap['weight'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'] = currentMap\n loadMaps['CCLB.Isotopomer.weight'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.weight'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'\n currentMap['name'] = 'weight'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 1.0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\n\n # Role Isotopomer.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role Isotopomer.atomLabels\n currentMap = {}\n contentMap['atomLabels'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'] = currentMap\n loadMaps['CCLB.Isotopomer.atomLabels'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.atomLabels'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'\n currentMap['name'] = 'atomLabels'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of Isotopomer\n\n currentMap = abstractTypes.get('Isotopomer')\n aList = ['serial', 'weight']\n currentMap['headerAttrs'] = aList\n aList = ['atomLabels', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['atomLabels']\n currentMap['children'] = aList\n\n # Class LabelingScheme\n currentMap = {}\n abstractTypes['LabelingScheme'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'] = currentMap\n loadMaps['CCLB.LabelingScheme'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'labelingSchemes'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute LabelingScheme.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute LabelingScheme.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'] = currentMap\n loadMaps['CCLB.LabelingScheme.details'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute LabelingScheme.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute LabelingScheme.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.longName\n currentMap = {}\n contentMap['longName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'] = currentMap\n loadMaps['CCLB.LabelingScheme.longName'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.longName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'\n currentMap['name'] = 'longName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute LabelingScheme.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'] = currentMap\n loadMaps['CCLB.LabelingScheme.name'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role LabelingScheme.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role LabelingScheme.chemCompLabels\n currentMap = {}\n contentMap['chemCompLabels'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'] = currentMap\n loadMaps['CCLB.LabelingScheme.chemCompLabels'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.chemCompLabels'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'\n currentMap['name'] = 'chemCompLabels'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of LabelingScheme\n\n currentMap = abstractTypes.get('LabelingScheme')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy', 'name']\n currentMap['headerAttrs'] = aList\n aList = ['details', 'longName']\n currentMap['simpleAttrs'] = aList\n aList = ['chemCompLabels', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['chemCompLabels']\n currentMap['children'] = aList\n\n # Out-of-package link to AtomLabel\n currentMap = {}\n exolinks['AtomLabel'] = currentMap\n loadMaps['CCLB.exo-AtomLabel'] = currentMap\n currentMap['tag'] = 'CCLB.exo-AtomLabel'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\n currentMap['name'] = 'AtomLabel'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n\n # Out-of-package link to ChemCompLabel\n currentMap = {}\n exolinks['ChemCompLabel'] = currentMap\n loadMaps['CCLB.exo-ChemCompLabel'] = currentMap\n currentMap['tag'] = 'CCLB.exo-ChemCompLabel'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\n currentMap['name'] = 'ChemCompLabel'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n\n # Out-of-package link to Isotopomer\n currentMap = {}\n exolinks['Isotopomer'] = currentMap\n loadMaps['CCLB.exo-Isotopomer'] = currentMap\n currentMap['tag'] = 'CCLB.exo-Isotopomer'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\n currentMap['name'] = 'Isotopomer'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n\n # Out-of-package link to LabelingScheme\n currentMap = {}\n exolinks['LabelingScheme'] = currentMap\n loadMaps['CCLB.exo-LabelingScheme'] = currentMap\n currentMap['tag'] = 'CCLB.exo-LabelingScheme'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\n currentMap['name'] = 'LabelingScheme'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))","def run(input_f, output_f):\n with open(input_f) as f:\n lines = f.readlines()\n\n # Collect the array dims\n PE_defs = []\n module_start = False\n is_PE = False \n PE_indices = []\n for line_id in range(len(lines)):\n line = lines[line_id]\n if line.find('Module Definition') != -1:\n module_start = not module_start\n if module_start:\n module_start_pos = line_id\n is_PE = False\n else:\n module_end_pos = line_id\n if is_PE:\n PE_defs.append({'def': lines[module_start_pos : module_end_pos + 1], \\\n 'pos': [module_start_pos, module_end_pos]})\n if module_start:\n #print(line_id)\n nxt_line_id = line_id + 1\n while nxt_line_id < len(lines): \n nxt_line = lines[nxt_line_id]\n if nxt_line.find('kernel void PE') != -1:\n is_PE = True\n m = re.search(r'void PE(.+?)\\(', nxt_line)\n #print(nxt_line)\n if m:\n PE_index = m.group(1).split('_')[1:]\n PE_indices.append(PE_index)\n if is_PE:\n break\n if nxt_line.find('Module Definition') != -1:\n break\n nxt_line_id += 1\n\n #print(PE_indices)\n PE_dims = [int(d) for d in PE_indices[0]]\n for ind in PE_indices:\n for dim in range(len(PE_dims)):\n PE_dims[dim] = max(PE_dims[dim], int(ind[dim]) + 1)\n #print(PE_dims)\n \n PE_lines = PE_defs[0]['def']\n # Parse the data transfer information\n data_trans_info = extract_data_trans_info(PE_lines, PE_dims) \n\n # Compose the new PE function\n PE_lines = compose_PE(data_trans_info, PE_dims, PE_defs)\n\n line_offset = 0\n for PE_def in PE_defs:\n lines = lines[:PE_def['pos'][0] - line_offset] + lines[PE_def['pos'][1] + 1 - line_offset:]\n line_offset += (PE_def['pos'][1] - PE_def['pos'][0] + 1)\n\n lines = lines + PE_lines\n\n # Modify the channels\n lines = modify_channels(lines, data_trans_info, PE_dims)\n\n with open(output_f, 'w') as f:\n for line in lines:\n f.write(line)\n # f.writelines(PE_lines)","def load_ftmap(\n *paths,\n group=None,\n max_cs=3,\n plot=True,\n plot_annot=True,\n plot_class=None,\n plot_method=\"overlap\",\n table=True,\n _self=pm,\n):\n if all(ch in \"1234567890\" for ch in paths[0]):\n jobid = paths[0]\n fp, temp = tempfile.mkstemp(suffix=\".pdb\")\n open(fp).close()\n session = requests.Session()\n session.get(\"https://ftmap.bu.edu/nousername.php\")\n with session.get(\n f\"https://ftmap.bu.edu/file.php\"\n f\"?jobid={jobid}\"\n f\"&coeffi=0&model=0&filetype=model_file\",\n stream=True,\n ) as ret:\n with open(temp, \"wb\") as fp:\n shutil.copyfileobj(ret.raw, fp)\n if not ret.content:\n raise CmdException(f\"Invalid response id {jobid}\")\n return process_session(\n Kozakov2015Ensemble.collect_ftmap,\n [temp],\n group,\n int(max_cs),\n plot=plot,\n plot_annot=bool(int(plot_annot)),\n plot_class=plot_class,\n table=table,\n plot_method=plot_method,\n base_root=\"fftmap\" + jobid,\n )\n return process_session(\n Kozakov2015Ensemble.collect_ftmap,\n paths,\n group,\n int(max_cs),\n plot=plot,\n plot_annot=bool(int(plot_annot)),\n plot_class=plot_class,\n table=table,\n plot_method=plot_method,\n )","def loadSubjActFlowFC_NoHidden(subj,inputtype,fcdir):\n \n if inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:\n h5f = h5py.File(fcdir + inputtype + 'ToOutputLayer_FC_subj' + subj + '.h5','r')\n fcmapping = h5f['sourceToTargetMapping'][:].copy()\n eigenvectors_input = h5f['eigenvectors'][:].copy()\n h5f.close()\n fc_input2output = fcmapping\n\n if inputtype=='12' or inputtype=='fpn' or inputtype=='nounimodal':\n h5f = h5py.File(fcdir + '12RuleToOutputLayer_FC_subj' + subj + '.h5','r')\n fcmapping = h5f['sourceToTargetMapping'][:].copy()\n eigenvectors_input = h5f['eigenvectors'][:].copy()\n h5f.close()\n fc_input2output = fcmapping\n\n return fc_input2output, eigenvectors_input","def initialize_undistortion_maps(self):\n\n new_camera_matrix, valid_roi = cv2.getOptimalNewCameraMatrix(\n self.camera_matrix, self.distortion_coefficients, self.image_size,\n 0)\n\n self.map1, self.map2 = cv2.initUndistortRectifyMap(\n self.camera_matrix, self.distortion_coefficients, None,\n new_camera_matrix, self.image_size, cv2.CV_16SC2)","def create_dicts(self):\n \n # remove this string from filename to make output file names more manageable\n pre_output1 = self.file1.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n pre_output2 = self.file2.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n \n # Build the output file name.\n # if prefix is present add it\n if self.out_file_prefix is not None:\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n # if no prefix don't add it!\n else:\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n\n # add temp to end of file name to create a temporary output filename\n self.tempoutputfilename = self.outputfilename.replace(\".txt\", '') + \"temp.txt\"\n\n # open temp output file\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\n\n \n # open FE files\n file1_open = open(self.chosenfolder + self.file1, 'r')\n file2_open = open(self.chosenfolder + self.file2, 'r')\n\n # open file1 and create a dict of the features.\n for linenumber, line in enumerate(file1_open):\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file1_dict[int(splitline[1])] = line\n # get n of rows in file1 (take the linenumber of the last line)\n self.file1_len = linenumber\n\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \"header\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\n for linenumber, line in enumerate(file2_open):\n if linenumber < 10:\n self.tempoutputfile.write(line)\n # then add all features to a dictionary, with the unique feature number as a key\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file2_dict[int(splitline[1])] = line\n # get n of rows in file2\n self.file2_len = linenumber\n\n # close files\n file1_open.close()\n file2_open.close()","def _update_farness_map(self,ind):","def read_flat_map(filename,i_map=0) :\n hdul=fits.open(filename)\n w=WCS(hdul[0].header)\n\n maps=hdul[i_map].data\n ny,nx=maps.shape\n\n return w,maps","def deconv_compute_fusion_para(x, y):\n input_memory_type = x.op.attrs[\"addr_type\"].value \\\n if \"addr_type\" in x.op.attrs else 0\n valid_shape = x.op.attrs[\"valid_shape\"] \\\n if \"valid_shape\" in x.op.attrs else ()\n slice_offset = x.op.attrs[\"slice_offset\"] \\\n if \"slice_offset\" in x.op.attrs else ()\n output_offset = y.get(\"slice_offset\") \\\n if \"slice_offset\" in y else ()\n l1_fusion_type = x.op.attrs[\"L1_fusion_type\"].value \\\n if \"L1_fusion_type\" in x.op.attrs else -1\n fmap_l1_addr_flag = x.op.attrs[\"L1_addr_flag\"].value \\\n if \"L1_addr_flag\" in x.op.attrs else False\n fmap_l1_valid_size = x.op.attrs[\"L1_valid_size\"].value\\\n if \"L1_valid_size\" in x.op.attrs else 0\n\n l1_fusion_enable_flag = get_L1_info(\"L1_fusion_enabled\")\n\n if input_memory_type not in (0, 1, 2):\n args_dict = {\n \"errCode\": \"E65008\",\n \"input_memory_type_range\": \"(0, 1, 2)\",\n \"input_memory_type\": str(input_memory_type)\n }\n raise RuntimeError(args_dict,\n err_man.get_error_message(args_dict))\n\n if valid_shape and not slice_offset:\n reason = \"valid shape exists, slice shape cannot be []\"\n args_dict = {\n \"errCode\": \"E60108\",\n \"reason\": reason\n }\n raise RuntimeError(args_dict,\n err_man.get_error_message(args_dict))\n if valid_shape and not output_offset:\n reason = \"valid shape exists, output offset cannot be []\"\n args_dict = {\n \"errCode\": \"E60108\",\n \"reason\": reason\n }\n raise RuntimeError(args_dict,\n err_man.get_error_message(args_dict))\n\n valid_shape = shape_to_list(valid_shape)\n slice_offset = shape_to_list(slice_offset)\n output_offset = shape_to_list(output_offset)\n\n if not l1_fusion_enable_flag:\n input_memory_type = 0\n valid_shape = []\n slice_offset = []\n output_offset = []\n l1_fusion_type = -1\n fmap_l1_addr_flag = False\n fmap_l1_valid_size = 0\n\n fusion_para = {\"input_memory_type\": input_memory_type,\n \"output_memory_type\": \"fuse_flag\",\n \"valid_shape\": valid_shape,\n \"slice_offset\": slice_offset,\n \"output_offset\": output_offset,\n \"l1_fusion_type\": l1_fusion_type,\n \"fmap_l1_addr_flag\": fmap_l1_addr_flag,\n \"fmap_l1_valid_size\": fmap_l1_valid_size}\n\n return fusion_para","def inferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping,\n sequences_mapping, protein_mapping, verbose=False, throwOnMismatch=False, fileType=None):\n import csv, os\n\n if fileType == \"simple\":\n return simpleInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\n elif fileType == \"traml\":\n return tramlInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\n elif fileType == \"sqmass\":\n return sqlInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\n\n nomatch_found = set([])\n for file_nr, f in enumerate(aligned_pg_files):\n header_dict = {}\n if f.endswith('.gz'):\n import gzip \n filehandler = gzip.open(f,'rb')\n else:\n filehandler = open(f)\n reader = csv.reader(filehandler, delimiter=\"\\t\")\n header = next(reader)\n for i,n in enumerate(header):\n header_dict[n] = i\n\n if not \"align_origfilename\" in header_dict or not \"align_runid\" in header_dict:\n\n # Check whether we have a single mzML file and a single result\n # file. If so, simply map these to each other.\n if len(rawdata_files) == 1 and len(aligned_pg_files) == 1:\n mapping[\"0_0\"] = rawdata_files\n return\n\n print (header_dict)\n raise Exception(\"need column header align_origfilename and align_runid\")\n\n for this_row in reader:\n\n if len(this_row) == 0: \n continue\n\n # Get the transition mapping ... \n mapRow(this_row, header_dict, precursors_mapping, sequences_mapping, protein_mapping)\n\n # 1. Get the original filename (find a non-NA entry) and the corresponding run id\n aligned_fname, aligned_id = getAlignedFilename(this_row, header_dict)\n\n if aligned_id is None or aligned_id in mapping:\n continue \n\n # 2. Go through all chromatogram input files and try to find\n # one that matches the one from align_origfilename\n for rfile in rawdata_files:\n\n # 2.1 remove common file endings from the raw data\n rfile_base = os.path.basename(rfile)\n for ending in [\".sqMass\", \".filter\", \".mzML\", \".chrom\"]:\n rfile_base = rfile_base.split(ending)[0]\n\n # 2.3 Check if we have a match\n if aligned_fname == rfile_base:\n if verbose: \n print(\"- Found match:\", os.path.basename(rfile), \"->\", os.path.basename(this_row[ header_dict[\"align_origfilename\"] ]))\n mapping[aligned_id] = [rfile]\n\n if not aligned_id in mapping:\n if True:\n nomatch_found.update( [aligned_fname] )\n if throwOnMismatch:\n raise Exception(\"Mismatch, alignment filename could not be matched to input chromatogram\")\n\n if verbose:\n print(\"- No match found for :\", list(nomatch_found), \"in any of\", \\\n [os.path.basename(rfile) for rfile in rawdata_files])\n print(\"- This may be a bad sign if you expected a match here. You might have \" +\\\n \"to either rename your files to have matching filenames \" +\\\n \"or provide an input yaml file describing the matching in detail.\")","def WriteDepMappingFile(translated_source_files,\n objc_file_path,\n output_dependency_mapping_file,\n file_open=open):\n dep_mapping = dict()\n input_file_queue = Queue.Queue()\n output_dep_mapping_queue = Queue.Queue()\n error_message_queue = Queue.Queue()\n for output_file in translated_source_files.split(','):\n input_file_queue.put(output_file)\n\n for _ in xrange(multiprocessing.cpu_count()):\n t = threading.Thread(target=_ReadDepMapping, args=(input_file_queue,\n output_dep_mapping_queue,\n error_message_queue,\n objc_file_path,\n file_open))\n t.start()\n\n input_file_queue.join()\n\n if not error_message_queue.empty():\n error_messages = [error_message for error_message in\n error_message_queue.queue]\n raise RuntimeError('\\n'.join(error_messages))\n\n while not output_dep_mapping_queue.empty():\n entry_file, deps = output_dep_mapping_queue.get()\n dep_mapping[entry_file] = deps\n\n f = file_open(output_dependency_mapping_file, 'w')\n for entry in sorted(dep_mapping):\n for dep in dep_mapping[entry]:\n f.write(entry + ':' + dep + '\\n')\n f.close()","def main():\r\n option_parser, opts, args = parse_command_line_parameters(**script_info)\r\n\r\n sff_files = opts.sff_fps\r\n\r\n for f in sff_files:\r\n if (not exists(f)):\r\n option_parser.error(('Flowgram file path does not exist:\\n %s \\n' +\r\n 'Pass a valid one via -i.') % f)\r\n outdir = opts.output_dir\r\n\r\n create_dir(outdir, fail_on_exist=not opts.force)\r\n\r\n log_fh = None\r\n\r\n if (not (opts.primer or opts.map_fname)):\r\n raise ApplicationError(\"Either mapping file or primer required\")\r\n # Read primer from Meta data file if not set on command line\r\n if not opts.primer:\r\n mapping_data, header, comments = \\\r\n parse_mapping_file(open(opts.map_fname, \"U\"))\r\n\r\n index = header.index(\"LinkerPrimerSequence\")\r\n all_primers = set(array(mapping_data)[:, index])\r\n\r\n if len(all_primers) != 1:\r\n raise ValueError(\"Currently only data sets with one primer are allowed.\\n\" +\r\n \"Make separate mapping files with only one primer, re-run split_libraries and\\n\"\r\n + \"denoise with each split_library output separately.\")\r\n primer = list(all_primers)[0]\r\n last_char = primer[-1]\r\n if(last_char not in \"ACGT\"):\r\n raise ValueError(\"We currently do not support primer with \" +\r\n \"degenerate bases at it's 3' end.\")\r\n\r\n else:\r\n primer = opts.primer\r\n\r\n centroids, cluster_mapping = fast_denoiser(opts.sff_fps, opts.fasta_fp,\r\n outdir, opts.num_cpus, primer,\r\n titanium=opts.titanium)\r\n\r\n # store mapping file and centroids\r\n result_otu_path = '%s/denoised_clusters.txt' % outdir\r\n of = open(result_otu_path, 'w')\r\n for i, cluster in cluster_mapping.iteritems():\r\n of.write('%s\\t%s\\n' % (str(i), '\\t'.join(cluster)))\r\n of.close()\r\n\r\n result_fasta_path = '%s/denoised_seqs.fasta' % outdir\r\n oh = open(result_fasta_path, 'w')\r\n write_Fasta_from_name_seq_pairs(centroids, oh)","def fusion(inputs, inp_index, out_index):\n shortcut = inputs[out_index]\n if data_format == 'channel_first':\n _, _, out_h, out_w = shortcut.get_shape().as_list()\n else:\n _, out_h, out_w, _ = shortcut.get_shape().as_list()\n \n for ind in inp_index:\n input_branch = inputs[ind]\n with tf.variable_scope('input_{}_output_{}'.format(ind, out_index)):\n if ind > out_index:\n input_branch = conv2d_fixed_padding(\n inputs=input_branch, filters=num_outchannels[out_index],\n kernel_size=1, strides=1, data_format=data_format)\n input_branch = batch_norm(input_branch, training, data_format)\n input_branch = tf.nn.relu(input_branch)\n if data_format == 'channel_first':\n input_branch = tf.transpose(input_branch, perm=[0, 2, 3, 1])\n input_branch = tf.image.resize(input_branch, (out_h, out_w), \n method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n input_branch = tf.transpose(input_branch, perm=[0, 3, 1, 2])\n else:\n input_branch = tf.image.resize(input_branch, (out_h, out_w), \n method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n elif ind == out_index:\n continue\n else:\n for k in range(out_index - ind):\n if k == out_index - ind - 1:\n input_branch = conv2d_fixed_padding(\n inputs=input_branch, filters=num_outchannels[out_index],\n kernel_size=3, strides=2, data_format=data_format)\n input_branch = batch_norm(input_branch, training, data_format)\n else:\n input_branch = conv2d_fixed_padding(\n inputs=input_branch, filters=num_outchannels[out_index],\n kernel_size=3, strides=2, data_format=data_format)\n input_branch = batch_norm(input_branch, training, data_format)\n input_branch = tf.nn.relu(input_branch)\n\n shortcut += input_branch\n shortcut = tf.nn.relu(shortcut)\n return shortcut","def main():\n print \"=\" * 78\n print \"%s %s\" % (__prog_name__, __version__)\n debug, input_file_names = check_cli()\n if not input_file_names:\n _error(\"No input file name found!\\n\\n%s\" % __help__)\n for input_file_name in input_file_names:\n print \"* Reading\", input_file_name\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\n file_dir_name = os.path.dirname(input_file_name)\n sections = {}\n tex_map = {}\n with open(input_file_name, 'rU') as in_fd:\n sections = get_sections(in_fd.read())\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"sec\",\n {\"sections\": sections})\n\n if not sections:\n _error(\"Nothing could be read from '%s'.\\nIs this an Oolite .dat file?\" \\\n % input_file_name)\n\n # Magically call the 'check' functions\n for name in sections.keys():\n f_name = \"check_%s\" % name.lower()\n if f_name in globals().keys():\n if not globals()[f_name](sections):\n _error(\"Number of entries in '%s' section is different as declared!\" % name)\n\n def get_data(name, sections=sections):\n \"\"\"Returns the 'data' object from the 'name' one found in the\n 'sections' one.\n :sections: dictionary: Object returned by 'get_sections'.\n :name: string: The name of the section to get the 'data'.\n Returns a list of 'lines'.\n \"\"\"\n return sections.get(name, {}).get(\"data\", [])\n\n oti_file_name = build_file_path(file_dir_name, file_base_name, \"oti\")\n tex_map = parse_names(get_data(\"NAMES\"), oti_file_name)\n\n tex_refs, tex_lines_out = parse_textures(get_data(\"TEXTURES\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"tex\",\n {\"tex_refs\": tex_refs,\n \"tex_lines_out\": tex_lines_out})\n\n # Update the tex_map object if textures indexes and names are both\n # used in 'TEXTURES'.\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\"named\").keys()):\n tex_map = update_tex_map(tex_map,\n set(tex_refs[\"named\"].keys()).difference(tex_map.keys()))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"txm\",\n {\"tex_map\": tex_map})\n\n n_verts, vertex_lines_out = parse_vertex(get_data(\"VERTEX\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"ver\",\n {\"n_verts\": n_verts,\n \"vertex_lines_out\": vertex_lines_out})\n\n n_normals, normals_lines_out = parse_normals(get_data(\"NORMALS\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"nor\",\n {\"n_normals\": n_normals,\n \"normals_lines_out\": normals_lines_out})\n\n n_faces, faces_groups = parse_faces(get_data(\"FACES\"), tex_refs,\n normals_lines_out)\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"fac\",\n {\"n_faces\": n_faces,\n \"faces_groups\": faces_groups})\n\n output_file_name = build_file_path(file_dir_name,\n file_base_name, 'obj')\n material_file_name = build_file_path(file_dir_name,\n file_base_name, 'mtl')\n mtl_lib_file = os.path.basename(material_file_name)\n\n write_obj(output_file_name, file_base_name, mtl_lib_file,\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\n n_normals, normals_lines_out, n_faces, faces_groups)\n\n write_mtl(material_file_name, tex_map)\n\n _exit(\"* Done\")","def test_mapping_file_removal(self):\r\n # doesn't change in test\r\n mf_exp, _ = parse_mapping_file_to_dict(self.MF_IN_2)\r\n bt_exp = parse_biom_table(self.BT_OUT_2)\r\n mf_obs, bt_obs, nonshared_samples = \\\r\n sync_biom_and_mf(parse_mapping_file_to_dict(self.MF_IN_2)[0],\r\n parse_biom_table(self.BT_IN_1))\r\n self.assertEqual(mf_exp, mf_obs)\r\n self.assertEqual(bt_exp, bt_obs)\r\n self.assertEqual(nonshared_samples, set(['Sample5', 'Sample6']))","def __init__(self):\n\n self.gm = GradientMapper()\n self.im = SpringMapper()\n self.fm = FullMapper(self.im, self.gm)\n # self.lm = LineMapper(self.fm)\n self.exit = False","def step2(step2_input, step2_output):\n\n global graf\n logger.info(\"###Step 2:\")\n graf = defaultdict(dict)\n start2 = clock()\n info = []\n for input_file in step2_input:\n logger.info(\"Reading input file {}\".format(input_file))\n with open(input_file) as csv_file:\n start_file=clock()\n rdr = csv.reader(csv_file)\n header = rdr.next()\n header_last = len(header) - 1\n try: \n for chunk in gen_chunks(rdr, 10000):\n info.extend([(row[0], row[header_last]) for row in chunk])\n info = list(set(info))\n process_info(info)\n except csv.Error as e:\n logger.error(\"Exception {}: {}\".format(type(e), e))\n logger.error(\"Check Problems section in readme for known issues.\")\n return 1\n check_time(start_file, \"Done reading.\")\n check_time(start2, \"Done generating full link dict...\")\n start_write = clock()\n write_to_file(step2_output, graf)\n check_time(start_write, \"Done writing output file.\")\n check_time(start2, \"Done with Step 2.\")\n return 0","def makeAMixOf2Annotations(inputAnnotPath1, inputAnnotPath2, outputMixPath):\n # make sure the paths end in a slash\n if inputAnnotPath1[-1] != u'/':\n inputAnnotPath1 = u'{0}/'.format(inputAnnotPath1)\n if inputAnnotPath2[-1] != u'/':\n inputAnnotPath2 = u'{0}/'.format(inputAnnotPath2)\n if outputMixPath[-1] != u'/':\n outputMixPath = u'{0}/'.format(outputMixPath)\n # for each input open\n for inPath in [inputAnnotPath1, inputAnnotPath2]:\n # open the file, read the lines\n with open(u'{0}sample.en'.format(inPath)) as inEnFile:\n enLns = inEnFile.readlines()\n with open(u'{0}sample.fr'.format(inPath)) as inFrFile:\n frLns = inFrFile.readlines()\n with open(u'{0}sampleAnnotation.tsv'.format(inPath)) as inAnnotFile:\n annotLns = inAnnotFile.readlines()\n with open(u'{0}sampleReference.tsv'.format(inPath)) as inRefFile:\n refLns = inRefFile.readlines()\n with open(u'{0}scores.tsv'.format(inPath)) as inScFile:\n scLns = inScFile.readlines()\n with open(u'{0}scoresAndMetaData.tsv'.format(inPath)) as inScMetaFile:\n scMetaLns = inScMetaFile.readlines()\n # choose and index randomly\n dejaVus = set([])\n while len(dejaVus) < int(len(enLns)/2.0):\n randomInd = randint(0, len(enLns)-1)\n while randomInd in dejaVus:\n randomInd = randint(0, len(enLns)-1)\n # add to dejavus\n dejaVus.add(randomInd)\n # dump to output file\n utilsOs.appendLineToFile(enLns[randomInd], u'{0}sample.en'.format(outputMixPath), addNewLine=False)\n utilsOs.appendLineToFile(frLns[randomInd], u'{0}sample.fr'.format(outputMixPath), False)\n utilsOs.appendLineToFile(annotLns[randomInd], u'{0}sampleAnnotation.tsv'.format(outputMixPath), False)\n utilsOs.appendLineToFile(refLns[randomInd], u'{0}sampleReference.tsv'.format(outputMixPath), False)\n utilsOs.appendLineToFile(scLns[randomInd], u'{0}scores.tsv'.format(outputMixPath), False)\n utilsOs.appendLineToFile(scMetaLns[randomInd], u'{0}scoresAndMetaData.tsv'.format(outputMixPath), False)","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('ANAP').get('abstractTypes')\n exolinks = globalMap.get('ANAP').get('exolinks')\n\n # DataType GraphicsHandlerType\n currentMap = {}\n abstractTypes['GraphicsHandlerType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'] = currentMap\n loadMaps['ANAP.GraphicsHandlerType'] = currentMap\n currentMap['tag'] = 'ANAP.GraphicsHandlerType'\n currentMap['type'] = 'simple'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'\n currentMap['toStr'] = 'text'\n currentMap['cnvrt'] = 'text'\n\n # Class AnalysisProfile\n currentMap = {}\n abstractTypes['AnalysisProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'] = currentMap\n loadMaps['ANAP.AnalysisProfile'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'analysisProfiles'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AnalysisProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AnalysisProfile.bgColor\n currentMap = {}\n contentMap['bgColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'] = currentMap\n loadMaps['ANAP.AnalysisProfile.bgColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.bgColor'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'\n currentMap['name'] = 'bgColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['default'] = '#FFFFFF'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute AnalysisProfile.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.fgColor\n currentMap = {}\n contentMap['fgColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'] = currentMap\n loadMaps['ANAP.AnalysisProfile.fgColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.fgColor'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'\n currentMap['name'] = 'fgColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['default'] = '#000000'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute AnalysisProfile.font\n currentMap = {}\n contentMap['font'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'] = currentMap\n loadMaps['ANAP.AnalysisProfile.font'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.font'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'\n currentMap['name'] = 'font'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.graphicsHandler\n currentMap = {}\n contentMap['graphicsHandler'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'] = currentMap\n loadMaps['ANAP.AnalysisProfile.graphicsHandler'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.graphicsHandler'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'\n currentMap['name'] = 'graphicsHandler'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'Tk'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001')\n\n # Attribute AnalysisProfile.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute AnalysisProfile.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'] = currentMap\n loadMaps['ANAP.AnalysisProfile.name'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AnalysisProfile.panView\n currentMap = {}\n contentMap['panView'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'] = currentMap\n loadMaps['ANAP.AnalysisProfile.panView'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.panView'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'\n currentMap['name'] = 'panView'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.sendBugReports\n currentMap = {}\n contentMap['sendBugReports'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'] = currentMap\n loadMaps['ANAP.AnalysisProfile.sendBugReports'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.sendBugReports'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'\n currentMap['name'] = 'sendBugReports'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'maybe'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2010-11-17-16:21:33_00001')\n\n # Attribute AnalysisProfile.transientDialogs\n currentMap = {}\n contentMap['transientDialogs'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'] = currentMap\n loadMaps['ANAP.AnalysisProfile.transientDialogs'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientDialogs'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'\n currentMap['name'] = 'transientDialogs'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.transientWindows\n currentMap = {}\n contentMap['transientWindows'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'] = currentMap\n loadMaps['ANAP.AnalysisProfile.transientWindows'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientWindows'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'\n currentMap['name'] = 'transientWindows'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.twoCharShortcuts\n currentMap = {}\n contentMap['twoCharShortcuts'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'] = currentMap\n loadMaps['ANAP.AnalysisProfile.twoCharShortcuts'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.twoCharShortcuts'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'\n currentMap['name'] = 'twoCharShortcuts'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.useCrosshair\n currentMap = {}\n contentMap['useCrosshair'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'] = currentMap\n loadMaps['ANAP.AnalysisProfile.useCrosshair'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.useCrosshair'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'\n currentMap['name'] = 'useCrosshair'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.useGlobalShortcuts\n currentMap = {}\n contentMap['useGlobalShortcuts'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'] = currentMap\n loadMaps['ANAP.AnalysisProfile.useGlobalShortcuts'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.useGlobalShortcuts'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'\n currentMap['name'] = 'useGlobalShortcuts'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.userEmail\n currentMap = {}\n contentMap['userEmail'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userEmail'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userEmail'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'\n currentMap['name'] = 'userEmail'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute AnalysisProfile.userName\n currentMap = {}\n contentMap['userName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userName'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'\n currentMap['name'] = 'userName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.userOrganisation\n currentMap = {}\n contentMap['userOrganisation'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userOrganisation'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userOrganisation'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'\n currentMap['name'] = 'userOrganisation'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.webBrowser\n currentMap = {}\n contentMap['webBrowser'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'] = currentMap\n loadMaps['ANAP.AnalysisProfile.webBrowser'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.webBrowser'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'\n currentMap['name'] = 'webBrowser'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role AnalysisProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role AnalysisProfile.colorSchemes\n currentMap = {}\n contentMap['colorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'] = currentMap\n loadMaps['ANAP.AnalysisProfile.colorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.colorSchemes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'\n currentMap['name'] = 'colorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.macros\n currentMap = {}\n contentMap['macros'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'] = currentMap\n loadMaps['ANAP.AnalysisProfile.macros'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.macros'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'\n currentMap['name'] = 'macros'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.marksColor\n currentMap = {}\n contentMap['marksColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'] = currentMap\n loadMaps['ANAP.AnalysisProfile.marksColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.marksColor'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'\n currentMap['name'] = 'marksColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['implSkip'] = True\n currentMap['copyOverride'] = True\n\n # Role AnalysisProfile.refExpProfiles\n currentMap = {}\n contentMap['refExpProfiles'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'] = currentMap\n loadMaps['ANAP.AnalysisProfile.refExpProfiles'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.refExpProfiles'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'\n currentMap['name'] = 'refExpProfiles'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.residueProfiles\n currentMap = {}\n contentMap['residueProfiles'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'] = currentMap\n loadMaps['ANAP.AnalysisProfile.residueProfiles'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.residueProfiles'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'\n currentMap['name'] = 'residueProfiles'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.rulersColor\n currentMap = {}\n contentMap['rulersColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'] = currentMap\n loadMaps['ANAP.AnalysisProfile.rulersColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.rulersColor'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'\n currentMap['name'] = 'rulersColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['implSkip'] = True\n currentMap['copyOverride'] = True\n # End of AnalysisProfile\n\n currentMap = abstractTypes.get('AnalysisProfile')\n aList = ['createdBy', 'graphicsHandler', 'guid', 'isModifiable', 'lastUnlockedBy', 'name', 'panView', 'sendBugReports', 'transientDialogs', 'transientWindows', 'twoCharShortcuts', 'useCrosshair', 'useGlobalShortcuts', 'userEmail', 'webBrowser']\n currentMap['headerAttrs'] = aList\n aList = ['bgColor', 'fgColor', 'font', 'userName', 'userOrganisation', 'marksColor', 'rulersColor']\n currentMap['simpleAttrs'] = aList\n aList = ['residueProfiles', 'refExpProfiles', 'macros', 'colorSchemes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['colorSchemes', 'macros', 'refExpProfiles', 'residueProfiles']\n currentMap['children'] = aList\n\n # Class ColorScheme\n currentMap = {}\n abstractTypes['ColorScheme'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'] = currentMap\n loadMaps['ANAP.ColorScheme'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'colorSchemes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ColorScheme.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ColorScheme.colors\n currentMap = {}\n contentMap['colors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'] = currentMap\n loadMaps['ANAP.ColorScheme.colors'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme.colors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'\n currentMap['name'] = 'colors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute ColorScheme.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'] = currentMap\n loadMaps['ANAP.ColorScheme.name'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role ColorScheme.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of ColorScheme\n\n currentMap = abstractTypes.get('ColorScheme')\n aList = ['colors', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class Macro\n currentMap = {}\n abstractTypes['Macro'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'] = currentMap\n loadMaps['ANAP.Macro'] = currentMap\n currentMap['tag'] = 'ANAP.Macro'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'macros'\n currentMap['objkey'] = 'serial'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Macro.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Macro.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'] = currentMap\n loadMaps['ANAP.Macro.details'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute Macro.function\n currentMap = {}\n contentMap['function'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'] = currentMap\n loadMaps['ANAP.Macro.function'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.function'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'\n currentMap['name'] = 'function'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute Macro.isInMenu\n currentMap = {}\n contentMap['isInMenu'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'] = currentMap\n loadMaps['ANAP.Macro.isInMenu'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.isInMenu'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'\n currentMap['name'] = 'isInMenu'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute Macro.isInMouseMenu\n currentMap = {}\n contentMap['isInMouseMenu'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'] = currentMap\n loadMaps['ANAP.Macro.isInMouseMenu'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.isInMouseMenu'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'\n currentMap['name'] = 'isInMouseMenu'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute Macro.module\n currentMap = {}\n contentMap['module'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'] = currentMap\n loadMaps['ANAP.Macro.module'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.module'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'\n currentMap['name'] = 'module'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute Macro.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'] = currentMap\n loadMaps['ANAP.Macro.name'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute Macro.ordering\n currentMap = {}\n contentMap['ordering'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'] = currentMap\n loadMaps['ANAP.Macro.ordering'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.ordering'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'\n currentMap['name'] = 'ordering'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['default'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Macro.path\n currentMap = {}\n contentMap['path'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'] = currentMap\n loadMaps['ANAP.Macro.path'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.path'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'\n currentMap['name'] = 'path'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00003')\n\n # Attribute Macro.serial\n currentMap = {}\n contentMap['serial'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'] = currentMap\n loadMaps['ANAP.Macro.serial'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.serial'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'\n currentMap['name'] = 'serial'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Macro.shortcut\n currentMap = {}\n contentMap['shortcut'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'] = currentMap\n loadMaps['ANAP.Macro.shortcut'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.shortcut'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'\n currentMap['name'] = 'shortcut'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role Macro.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of Macro\n\n currentMap = abstractTypes.get('Macro')\n aList = ['function', 'isInMenu', 'isInMouseMenu', 'module', 'ordering', 'serial', 'shortcut']\n currentMap['headerAttrs'] = aList\n aList = ['details', 'name', 'path']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class RefExpProfile\n currentMap = {}\n abstractTypes['RefExpProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'] = currentMap\n loadMaps['ANAP.RefExpProfile'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'refExpProfiles'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute RefExpProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute RefExpProfile.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'] = currentMap\n loadMaps['ANAP.RefExpProfile.name'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute RefExpProfile.peakSymbolColors\n currentMap = {}\n contentMap['peakSymbolColors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'] = currentMap\n loadMaps['ANAP.RefExpProfile.peakSymbolColors'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.peakSymbolColors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'\n currentMap['name'] = 'peakSymbolColors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute RefExpProfile.peakTextColors\n currentMap = {}\n contentMap['peakTextColors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'] = currentMap\n loadMaps['ANAP.RefExpProfile.peakTextColors'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.peakTextColors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'\n currentMap['name'] = 'peakTextColors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute RefExpProfile.refExpNames\n currentMap = {}\n contentMap['refExpNames'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'] = currentMap\n loadMaps['ANAP.RefExpProfile.refExpNames'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.refExpNames'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'\n currentMap['name'] = 'refExpNames'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role RefExpProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role RefExpProfile.negColorSchemes\n currentMap = {}\n contentMap['negColorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'] = currentMap\n loadMaps['ANAP.RefExpProfile.negColorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.negColorSchemes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'\n currentMap['name'] = 'negColorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n\n # Role RefExpProfile.posColorSchemes\n currentMap = {}\n contentMap['posColorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'] = currentMap\n loadMaps['ANAP.RefExpProfile.posColorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.posColorSchemes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'\n currentMap['name'] = 'posColorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of RefExpProfile\n\n currentMap = abstractTypes.get('RefExpProfile')\n aList = ['name']\n currentMap['headerAttrs'] = aList\n aList = ['peakSymbolColors', 'peakTextColors', 'refExpNames', 'negColorSchemes', 'posColorSchemes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ResidueProfile\n currentMap = {}\n abstractTypes['ResidueProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'] = currentMap\n loadMaps['ANAP.ResidueProfile'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'residueProfiles'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ResidueProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ResidueProfile.ccpCode\n currentMap = {}\n contentMap['ccpCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'] = currentMap\n loadMaps['ANAP.ResidueProfile.ccpCode'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.ccpCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'\n currentMap['name'] = 'ccpCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ResidueProfile.guiName\n currentMap = {}\n contentMap['guiName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'] = currentMap\n loadMaps['ANAP.ResidueProfile.guiName'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.guiName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'\n currentMap['name'] = 'guiName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ResidueProfile.molType\n currentMap = {}\n contentMap['molType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'] = currentMap\n loadMaps['ANAP.ResidueProfile.molType'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.molType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'\n currentMap['name'] = 'molType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\n\n # Role ResidueProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of ResidueProfile\n\n currentMap = abstractTypes.get('ResidueProfile')\n aList = ['ccpCode', 'guiName', 'molType']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to AnalysisProfile\n currentMap = {}\n exolinks['AnalysisProfile'] = currentMap\n loadMaps['ANAP.exo-AnalysisProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-AnalysisProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\n currentMap['name'] = 'AnalysisProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to ColorScheme\n currentMap = {}\n exolinks['ColorScheme'] = currentMap\n loadMaps['ANAP.exo-ColorScheme'] = currentMap\n currentMap['tag'] = 'ANAP.exo-ColorScheme'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\n currentMap['name'] = 'ColorScheme'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to Macro\n currentMap = {}\n exolinks['Macro'] = currentMap\n loadMaps['ANAP.exo-Macro'] = currentMap\n currentMap['tag'] = 'ANAP.exo-Macro'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\n currentMap['name'] = 'Macro'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n\n # Out-of-package link to RefExpProfile\n currentMap = {}\n exolinks['RefExpProfile'] = currentMap\n loadMaps['ANAP.exo-RefExpProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-RefExpProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\n currentMap['name'] = 'RefExpProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n\n # Out-of-package link to ResidueProfile\n currentMap = {}\n exolinks['ResidueProfile'] = currentMap\n loadMaps['ANAP.exo-ResidueProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-ResidueProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\n currentMap['name'] = 'ResidueProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))","def _fp_setup2(self):\n # TODO: right now it's hard to implement this required stage","def main(input_filepath, output_filepath):\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')","def main(input_filepath, output_filepath):\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')","def visualize_saliency_of_output(FLAGS, model, input_images=[]):\n if len(input_images) == 0:\n # use predefined images\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\n\n print(\"[tools.py]: extracting saliency maps of {0} in {1}\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\n \n \n inputs = load_images(input_images, model.input_size[1:])\n\n print 'shape: ',inputs.shape\n\n if 'nfc' in FLAGS.network:\n inputs = np.concatenate([inputs]*FLAGS.n_frames, axis=-1)\n \n # extract deconvolution\n import tf_cnnvis\n\n # layers = ['c']\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D']\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D','MobilenetV1_1/AvgPool_1a/AvgPool']\n\n # layers = [str(i.name) for i in model.sess.graph.get_operations() if 'outputs' in i.name and not 'activations' in i.name and not 'gradients' in i.name]\n layers = [model.endpoints['eval']['outputs'].name[:-2]] #cut out :0 in the end to change name from tensor to operation name\n # layers = ['outputs']\n \n # results = tf_cnnvis.activation_visualization(sess_graph_path = model.sess, \n # value_feed_dict = {model.inputs : inputs}, \n # layers=layers)\n results = tf_cnnvis.deconv_visualization(sess_graph_path = model.sess, \n value_feed_dict = {model.inputs : inputs}, \n layers=layers)\n\n # Normalize deconvolution within 0:1 range\n num_rows=0\n clean_results={} \n # Loop over layers\n for k in results.keys():\n clean_results[k]=[]\n # Loop over channels\n for c in range(len(results[k])):\n num_rows+=1\n clean_results[k].append(np.zeros((results[k][c].shape[0:3])))\n # Loop over images\n for i in range(results[k][c].shape[0]):\n clean_results[k][c][i]=deprocess_image(results[k][c][i],one_channel=True)\n if num_rows > 6:\n print(\"[tools.py]: There are too many columns to create a proper image.\")\n return\n\n # create one combined image with each input image on each column\n fig, axes = plt.subplots(num_rows+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\n # fig, axes = plt.subplots(num_columns+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\n # add original images in first row\n for i in range(axes.shape[1]):\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\n axes[0, i].axis('off')\n \n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\n\n # add deconvolutions over the columns\n row_index = 1\n for k in results.keys(): # go over layers\n for c in range(len(results[k])): # add each channel in 2 new column\n for i in range(axes.shape[1]): # fill row going over input images\n # axes[row_index, i].set_title(k.split('/')[1]+'/'+k.split('/')[2]+'_'+str(c))\n axes[row_index, i].set_title(k+'_'+str(c))\n # axes[row_index, i].set_title(experts[c])\n \n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[k][c][i],axis=2)), axis=2))\n axes[row_index, i].axis('off')\n # row_index+=2\n row_index+=1\n # plt.show()\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/saliency_maps.jpg',bbox_inches='tight')","def __init__(self, model_source = None, train_log_dir = None, name = \"DNN2\", auto_reload = False, only_final=False, denorm_out=True): \n super().__init__(name = name)\n self.model_source = model_source\n self.train_log_dir = train_log_dir\n \n self.feat_in_pipe_out, self.feat_in_pipe_in = multiprocessing.Pipe(False)\n self.mapping_process = None\n self.run_map = multiprocessing.Value('b', False)\n self.auto_reload = auto_reload\n self.observer = None\n self.only_final = only_final\n self.denorm_out = denorm_out","def preprocess(self):\n inputMatrix = pd.read_csv(self.input, index_col = 0)\n\n original_filename = self.input.split(\"/\")[-1]\n mapped_filename = \"mapped_\" + self.desiredFormat + \"_\" + original_filename\n output = self.input\n output_filepath = \"/\".join(self.input.split(\"/\")[0:-1])\n #as the DataFormatter always transposes the data before any further processing, we can expect all genes to be in the columns\n genesInColumn = \"true\"\n #only map genes if the current format is not the desired format\n if (self.currentFormat != self.desiredFormat):\n output = output_filepath + \"/\" + mapped_filename\n benchutils.mapDataMatrix(inputMatrix, genesInColumn, self.currentFormat, self.desiredFormat, output, self.labeled)\n\n return output","def infer():\n\n # Create StreamManagerApi object\n stream_manager_api = StreamManagerApi()\n # Use InitManager method init StreamManagerApi\n ret = stream_manager_api.InitManager()\n if ret != 0:\n print(\"Failed to init Stream manager, ret=%s\" % str(ret))\n exit()\n\n # create streams by pipeline config file\n with open(args.pipeline_path, \"rb\") as f:\n pipeline_str = f.read()\n\n # Configuring a stream\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\n if ret != 0:\n print(\"Failed to create Stream, ret=%s\" % str(ret))\n exit()\n\n # Construct the input of the stream\n data_input = MxDataInput()\n # Stream_name encoded in UTF-8\n stream_name = args.stream_name.encode()\n print(stream_name)\n predictions = []\n with open(args.label_path, 'rt') as f:\n val_cls = f.read().rstrip(\"\\n\").split(\"\\n\")\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(args.instances_path)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n for file_name in os.listdir(args.img_path):\n pred_data = []\n # Gets the Address of each image\n img_id = int(file_name.split('.')[0])\n file_path = args.img_path + file_name\n size = (cv2.imread(file_path)).shape\n\n # Read each photo in turn\n with open(file_path, \"rb\") as f:\n img_data = f.read()\n if not img_data:\n print(f\"read empty data from img:{file_name}\")\n continue\n # The element value img_data\n data_input.data = img_data\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\n pred_data.append({\"boxes\": boxes_output,\n \"box_scores\": scores_output,\n \"img_id\": img_id,\n \"image_shape\": size})\n\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\n print(f\"Inferred image:{file_name} success!\")\n\n # Save the result in JSON format\n if not os.path.exists(args.res_path):\n os.makedirs(args.res_path)\n with open(args.res_path + 'predictions_test.json', 'w') as f:\n json.dump(predictions, f)\n stream_manager_api.DestroyAllStreams()","def nominal_map(options):\n pass","def analysis_dFF_map(self):\r\n\r\n \r\n\r\n print ('Starting dF/F analysis:')\r\n\r\n self.print_image_info()\r\n\r\n # smoothwin = int(self.imageData.shape[1]/8.)\r\n\r\n # get the average image and the average of the whole image over time\r\n\r\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\r\n\r\n \r\n\r\n mpl.figure(99)\r\n\r\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\r\n\r\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\r\n\r\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\r\n\r\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\r\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\r\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\r\n\r\n mpl.figure(98)\r\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\r\n mpl.figure(97)\r\n mpl.imshow(np.mean(imgdatasm,axis=0))\r\n self.n_times = self.timebase\r\n\r\n periodsize = int(self.period*self.framerate)\r\n print('periodsize: ',periodsize)\r\n\r\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\r\n\r\n # r = range(0, self.imageData.shape[0], windowsize)\r\n\r\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \r\n\r\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\r\n\r\n delresp=np.zeros([19,256,256])\r\n repback = np.mean(sig[:,1:4,:,:],axis=1)\r\n resp = np.mean(sig[:,5:9,:,:],axis=1)\r\n for counter in range(19):\r\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\r\n quot=np.mean(delresp,axis=0)\r\n quot=-quot\r\n print ('shape of quot: ', np.shape(quot))\r\n # quot=(resp-repback)/repback\r\n # quot[quot>0]=0\r\n # quot=-1000*quot\r\n\r\n mpl.figure(7)\r\n mpl.imshow(quot,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n\r\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n mpl.figure(8)\r\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n \r\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\r\n\r\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n\r\n\r\n # print (' windowsize: ', windowsize)\r\n\r\n # print (' periodsize: ', periodsize)\r\n # mc = matplotlib.cm\r\n\r\n # only use sequential maps here\r\n\r\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\r\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\r\n\r\n cs = {}\r\n\r\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\r\n# \r\n # localmax = {}\r\n\r\n # sigmax = 0.\r\n# \r\n # kernel = np.ones((5, 5))\r\n\r\n # psf = kernel / np.sum(kernel)\r\n\r\n # compute dF/F, and get maximum over all frequencies\r\n\r\n print (' sig shape: ', sig.shape)\r\n\r\n # print (' bl shape: ', bl.shape)\r\n\r\n # smax = np.zeros(bl.shape[0])\r\n\r\n # for i in range(bl.shape[0]):\r\n\r\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\r\n\r\n # sigd[i] = sigd[i]**2.0\r\n\r\n # smooth\r\n\r\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # deconvolve\r\n\r\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\r\n\r\n# sm = sigd[i].max().max()\r\n\r\n# if sm > sigmax:\r\n\r\n# sigmax = sm\r\n\r\n# smax[i] = sm\r\n\r\n# print( ' i, sm: ', i, sm)\r\n\r\n# # now process for display\r\n\r\n# print (' sigd shape: ', sigd.shape)\r\n\r\n# wdat = np.mean(sig, axis=0)\r\n\r\n# wds = wdat.shape\r\n\r\n# print('wdat shape: ', wds)\r\n\r\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\r\n\r\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\r\n\r\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\r\n\r\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\r\n\r\n# mpl.figure(1)\r\n\r\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\r\n\r\n\r\n\r\n# mpl.figure(2)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\r\n\r\n# # find center of mass of areas above threshold\r\n\r\n# # mass = sigd[i].copy()\r\n\r\n# # mass[sigd[i] > 0.] = 1.\r\n\r\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\r\n\r\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\r\n\r\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\r\n\r\n# # xcoords = np.array([x[1] for x in coords])\r\n\r\n# # ycoords = np.array([x[0] for x in coords])\r\n\r\n# # cs[i] = (xcoords, ycoords)\r\n\r\n\r\n\r\n# # Calculating local maxima\r\n\r\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \r\n\r\n# indices=True, num_peaks=10, footprint=None, labels=None)\r\n\r\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\r\n\r\n# # print ('i, local max: ',i, localmax)\r\n\r\n# mpl.subplot(5,5,i+1)\r\n# print ('shape of sigd: ',[np.shape(sigd),i])\r\n\r\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\r\n\r\n# if len(localmax[i]) > 0:\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# else:\r\n\r\n# continue\r\n\r\n# scattersize = 30.\r\n\r\n# for k, lm in enumerate(localmax[i]):\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\r\n\r\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\r\n\r\n# mpl.subplot(6,5,i+15+1)\r\n\r\n# wr = range(i*windowsize, i*windowsize+windowsize)\r\n\r\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\r\n\r\n# wmax = 0.\r\n\r\n# for lmax in localmax[i]: # was xcoords\r\n\r\n# wave = wdat[wr, lmax[0],lmax[1]]\r\n\r\n# wdff = (wave-wave[0])/wave[0]\r\n\r\n# if np.max(wdff) > wmax:\r\n\r\n# wmax = np.max(wdff)\r\n\r\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\r\n\r\n# wdff, color=clist2[i])\r\n\r\n# mpl.ylim(-0.1*wmax, wmax)\r\n\r\n# fig = mpl.figure(3)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# if len(localmax[i]) == 0:\r\n\r\n# continue\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# for lm in localmax[i]:\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \r\n\r\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\r\n\r\n# mpl.ylim(0, sigd.shape[2])\r\n\r\n# mpl.xlim(0, sigd.shape[1])\r\n\r\n# mpl.axis('equal')\r\n\r\n mpl.show()\r\n\r\n print (' DF/F analysis finished.\\n')"],"string":"[\n \"def post_process(fasta_fp, mapping_fp, denoised_seqs_fp,\\r\\n otu_picker_otu_map_fp, out_dir):\\r\\n\\r\\n combine_mappings(open(fasta_fp), open(mapping_fp),\\r\\n open(denoised_seqs_fp),\\r\\n open(otu_picker_otu_map_fp), out_dir)\",\n \"def _standard_mapping(self):\\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\\n self.camvidMap = mapping_raw['camvidMap'] * 255\\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255\",\n \"def test_read_mapping_file(case):\\n reference = collections.defaultdict(lambda: collections.defaultdict(dict))\\n for from_ff, to_ff in itertools.product(case.from_ff, case.to_ff):\\n reference[from_ff][to_ff][case.name] = (\\n case.mapping, case.weights, case.extra\\n )\\n\\n ffs = case_to_dummy_ffs(case.from_ff + case.to_ff, [case.name], case.mapping,\\n case.weights, case.extra)\\n\\n reference = vermouth.map_input._default_to_dict(reference)\\n\\n mappings = vermouth.map_input.read_backmapping_file(\\n ['[ molecule ]'] + case.string.split('\\\\n'),\\n ffs\\n )\\n compare_old_new_mappings(mappings, reference)\",\n \"def _do_mapping(self):\\n pass\",\n \"def update_maps(self):\\n if self.fmodel is None:\\n return\\n def fft_map(map_coeffs, resolution_factor = 0.25):\\n return map_coeffs.fft_map(resolution_factor = resolution_factor,\\n ).apply_sigma_scaling().real_map_unpadded()\\n map_types = [\\\"2mFo-DFc\\\", \\\"mFo-DFc\\\"]\\n map_keys = [\\\"2mFo-DFc\\\", \\\"mFo-DFc\\\"]\\n if (self.fmodel.f_obs().anomalous_flag()):\\n if (self.params.anom_map_type == \\\"phaser\\\"):\\n map_types.append(\\\"llg\\\")\\n elif (self.params.anom_map_type == \\\"residual\\\"):\\n map_types.append(\\\"anom_residual\\\")\\n else :\\n map_types.append(\\\"anom\\\")\\n map_keys.append(\\\"anom\\\")\\n if (self.use_svm):\\n map_types.append(\\\"mFo\\\")\\n map_keys.append(\\\"mFo\\\")\\n # To save memory, we sample atomic positions immediately and throw out\\n # the actual maps (instead of keeping up to 3 in memory)\\n sites_frac = self.xray_structure.sites_frac()\\n sites_cart = self.xray_structure.sites_cart()\\n self._principal_axes_of_inertia = [ None ] * len(sites_frac)\\n self._map_variances = [ None ] * len(sites_frac)\\n self._map_gaussian_fits = {}\\n self.calpha_mean_two_fofc = 0\\n for map_type, map_key in zip(map_types, map_keys):\\n real_map = self.get_map(map_type)\\n if (real_map is not None):\\n # Gather values for map peaks at each site\\n self._map_values[map_key] = flex.double(sites_frac.size(), 0)\\n self._map_gaussian_fits[map_key] = [ None ] * len(sites_frac)\\n for i_seq, site_frac in enumerate(sites_frac):\\n atom = self.pdb_atoms[i_seq]\\n resname = atom.fetch_labels().resname.strip().upper()\\n if (resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED or\\n atom.segid.strip().upper() in [\\\"ION\\\"]):\\n value = real_map.eight_point_interpolation(site_frac)\\n self._map_values[map_key][i_seq] = value\\n if (self.use_svm):\\n gaussian_fit = utils.fit_gaussian(\\n unit_cell=self.unit_cell,\\n site_cart=atom.xyz,\\n real_map=real_map)\\n self._map_gaussian_fits[map_key][i_seq] = gaussian_fit\\n\\n if map_type in [\\\"2mFo-DFc\\\"]:\\n # Gather values on map variance and principal axes of interia\\n from cctbx import maptbx\\n for i_seq, site_cart in enumerate(sites_cart):\\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\\n if resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED:\\n # XXX not totally confident about how I'm weighting this...\\n p_a_i = maptbx.principal_axes_of_inertia(\\n real_map = real_map,\\n site_cart = site_cart,\\n unit_cell = self.unit_cell,\\n radius = self.params.map_sampling_radius)\\n self._principal_axes_of_inertia[i_seq] = p_a_i\\n variance = maptbx.spherical_variance_around_point(\\n real_map = real_map,\\n unit_cell = self.unit_cell,\\n site_cart = site_cart,\\n radius = self.params.map_sampling_radius)\\n self._map_variances[i_seq] = variance\\n elif (i_seq in self.calpha_sel):\\n # Also collect some info in average C_alpha 2FoFc peak heights\\n self.calpha_mean_two_fofc += real_map.eight_point_interpolation(\\n sites_frac[i_seq])\\n del real_map\\n\\n if (self.calpha_mean_two_fofc > 0):\\n n_calpha = len(self.calpha_sel)\\n assert (n_calpha > 0)\\n self.calpha_mean_two_fofc /= n_calpha\\n\\n # Gather info on carbons' average Fo peak height for use in estimating other\\n # sites' atomic weight\\n self.carbon_fo_values = None\\n if (len(self.carbon_sel) > 0):\\n self.carbon_fo_values = flex.double()\\n self._map_values[\\\"mFo\\\"] = flex.double(sites_frac.size(), 0)\\n fo_map = fft_map(self.fmodel.map_coefficients(\\n map_type = \\\"mFo\\\",\\n exclude_free_r_reflections = True,\\n fill_missing = True))\\n\\n for i_seq, site_frac in enumerate(sites_frac):\\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\\n element = self.pdb_atoms[i_seq].element.strip()\\n if (element == \\\"C\\\") or ((element == \\\"O\\\") and (resname in WATER_RES_NAMES)):\\n map_value = fo_map.eight_point_interpolation(site_frac)\\n self._map_values[\\\"mFo\\\"][i_seq] = map_value\\n if (element == \\\"C\\\"):\\n self.carbon_fo_values.append(map_value)\\n del fo_map\",\n \"def read_activity_mappings_both(self):\\n with open('oca.translate', \\\"r\\\") as file:\\n for line in file:\\n x = str(str(line).strip()).split(' ', 3)\\n self.amappings[x[0]] = x[1]\\n self.amappings2[x[0]] = x[2]\",\n \"def mmap2Channel(self):\\n self.memmap = np.memmap(self.inputFilenames['ofd'],\\n dtype='uint16',\\n mode='r',\\n offset=0,\\n shape=(\\n 2, self.reconstructionSettings['numSamples'], self.scanSettings['numAlinesPerRawFrame'],\\n self.scanSettings['numFrames']), order='F')\",\n \"def call_Compare_maps(Ag_file, dust_file=None, CO_file=None):\\n\\n print('Read extinction map:')\\n Ag_map = Read_H5(Ag_file, 'Ag')\\n Nside_Ag = hp.pixelfunc.get_nside(Ag_map)\\n Ag_smap = smoothing(Ag_map, Nside_Ag)\\n print(Nside_Ag)\\n # get power spectrum for smoothed Ag\\n cl_Ag, ell_Ag = powerspectrum(Ag_smap/np.max(Ag_smap))\\n plot_cl(cl_Ag, ell_Ag, 'b', 'Ag')\\n if (dust_file != None):\\n # compare dust to extinction\\n dust_map, Nside_dust = get_Planck_map(dust_file)\\n #print(len(dust_map), dust_map)\\n #Nside_dust = hp.pixelfunc.get_nside(dust_map)\\n print('Dust:', Nside_dust)\\n if Nside_dust != Nside_Ag:\\n dust_map, dust_smap = fix_resolution(dust_map, Nside_Ag)\\n else:\\n dust_smap = smoothin(dust_map, Nside_Ag)\\n\\n # power spectrum:\\n cl_dust, ell_dust = powerspectrum(dust_smap/np.max(dust_smap))\\n fx, coeffs1, ind1 = line_fit(Ag_smap, dust_smap, ymax=7.5)\\n gx, coeffs2, ind2 = line_fit(Ag_smap, dust_smap, ymax=7.5, upper=True)\\n print('plotting dust')\\n # plotting\\n #map_plots(Ag_map, 'Ag', Nside_Ag)\\n #map_plots(dust_map, 'Dust', Nside_Ag)\\n #vs_plot(Ag_map, dust_map, 'Dust')\\n\\n # smoothed\\n map_plots(dust_smap, 'dust', Nside_Ag, '$K_{RJ}$', smooth=True)\\n map_plots(np.log(dust_smap), 'Dust', Nside_Ag, '$K_{RJ}$', smooth=True)\\n vs_plot(Ag_smap, dust_smap, 'Dust', '$K_{RJ}$', ymax=7.5, smooth=True)\\n\\n map_comparison(Ag_smap, dust_smap, Nside_Ag, 'dust', '$K_{RJ}$', coeffs2[0],\\\\\\n coeffs2[0], ind1, ind2)\\n plot_line_scatter(Ag_smap, dust_map, fx, gx, 'dust', '$K_{RJ}$')\\n plot_cl(cl_dust, ell_dust, 'r', 'dust')\\n\\n if (CO_file != None):\\n # compare CO to extinction\\n CO_map, Nside_CO = get_Planck_map(CO_file)\\n #Nside_CO = hp.pixelfunc.get_nside(CO_map)\\n print('CO:', Nside_CO)\\n if Nside_CO != Nside_Ag:\\n CO_map, CO_smap = fix_resolution(CO_map, Nside_Ag)\\n else:\\n CO_smap = smoothing(CO_map, Nside_Ag)\\n\\n # power spectrum:\\n cl_co, ell = powerspectrum(CO_smap/np.max(CO_smap))\\n fx, coeffs1, ind1 = line_fit(Ag_smap, CO_smap, ymax=5)\\n gx, coeffs2, ind2 = line_fit(Ag_smap, CO_smap, ymax=5, upper=True)\\n print('Plotting CO')\\n # plotting\\n #map_plots(Ag_map, 'Ag', Nside_Ag, '$K_{RJ} km s^{-1}$')\\n #map_plots(CO_map, 'CO', Nside_Ag, '$K_{RJ} km s^{-1}$')\\n #vs_plot(Ag_map, CO_map, 'CO', '$K_{RJ} km s^{-1}$')\\n\\n # smoothed\\n map_plots(CO_smap, 'CO', Nside_Ag, '$K_{RJ} km s^{-1}$', smooth=True)\\n map_plots(np.log(CO_smap), 'CO', Nside_Ag, '$K_{RJ} km s^{-1}$', smooth=True)\\n vs_plot(Ag_smap, CO_smap, 'CO', '$K_{RJ} km s^{-1}$', ymax=5, smooth=True)\\n map_comparison(Ag_smap, CO_smap, Nside_Ag, 'CO', '$K_{RJ} km s^{-1}$',\\\\\\n coeffs1[0], coeffs2[0], ind1, ind2)\\n plot_line_scatter(Ag_smap, CO_map, fx, gx, 'CO', '$K_{RJ} km s^{-1}$')\\n plot_cl(cl_co, ell, 'g', 'CO')\\n\\n else:\\n print('Need to compare with dust and/or CO')\\n sys.exit()\",\n \"def mapping_runner(self):\\n if not isinstance(self.model_source, str):\\n raise ValueError(\\\"Tried to initialize mapping without a model\\\")\\n \\n import keras\\n sys.stdout.flush()\\n keras.backend.clear_session()\\n sys.stdout.flush()\\n \\n # Load model and normalization parameters\\n print(\\\"Loading model\\\", self.model_source)\\n model = keras.models.load_model(self.model_source)\\n x_mean_std = [np.load(self.model_source + \\\"_x_mean.npy\\\"), np.load(self.model_source + \\\"_x_std.npy\\\")]\\n y_mean_std = [np.load(self.model_source + \\\"_y_mean.npy\\\"), np.load(self.model_source + \\\"_y_std.npy\\\")]\\n \\n while self.run_map.value:\\n sample = self.feat_in_pipe_out.recv()\\n \\n # Reload if needed\\n if self.auto_reload == True and self.observer.check_change():\\n model = keras.models.load_model(self.model_source)\\n \\n # Normalize\\n sample = (sample - x_mean_std[0]) / x_mean_std[1]\\n \\n # Map\\n result_sample = model.predict(sample, batch_size = 1)\\n\\n # Denormalize\\n if self.denorm_out:\\n result_sample = (result_sample * y_mean_std[1]) + y_mean_std[0]\\n \\n self.output_data(result_sample)\\n \\n sys.stdout.flush()\\n keras.backend.clear_session()\\n sys.stdout.flush()\",\n \"def get_forward_mapping(self):\",\n \"def load2Channel(self):\\n if self.endBytePos <= self.totalBytes:\\n with open(self.inputFilenames['ofd'], 'rb') as f:\\n self.rawBScan = cp.fromfile(f, count=self.scanSettings['frameSizeBytes'], offset=self.startBytePos * 2,\\n dtype='uint16').copy()\\n rawX = cp.reshape(self.rawBScan[0::2], (self.reconstructionSettings['numSamples'],\\n self.scanSettings['numAlinesPerRawFrame']), order=\\\"F\\\")\\n rawY = cp.reshape(self.rawBScan[1::2], (self.reconstructionSettings['numSamples'],\\n self.scanSettings['numAlinesPerRawFrame']), order=\\\"F\\\")\\n self.ch1 = rawX[:, self.scanSettings['AlinesToProcTomo']].astype(cp.int)\\n self.ch2 = rawY[:, self.scanSettings['AlinesToProcTomo']].astype(cp.int)\\n\\n else:\\n logging.warning('End of frame byte location: {} , Total number of bytes: {}'.format(self.totalBytes /\\n self.endBytePos))\",\n \"def calc_variational_inference_map(imgA_filename, imgB_filename, flo_filename, out_filename, dataset):\\n shell_command = '{0} {1} {2} {3} {4} {5}'.format('./src/SrcVariational/variational_main', imgA_filename,\\n imgB_filename, flo_filename, out_filename, dataset)\\n # shell_command = './SrcVariational/variational_main ' + imgA_filename + ' ' + imgB_filename + ' ' + flo_filename + \\\\\\n # ' ' + out_filename + ' -' + dataset\\n exit_code = os.system(shell_command)\",\n \"def generate_maps(dl: DatasetLoader, model, map_out: str, graph, all_classes=True, batch_size=10, mode='cv2'):\\n # o_generator = get_outputs_generator(model, 'CAM')\\n input = model.input\\n output = model.get_layer('CAM').output\\n output_predict = model.get_layer('W').output\\n output_fn = K.function([input], [output])\\n fn_predict = K.function([input], [output_predict])\\n\\n o_resizer = tf.image.resize_images\\n o_dot = K.dot\\n\\n # plot CAMs only for the validation data:\\n k = 0\\n counter = 0\\n img_arr = []\\n with K.get_session() as sess:\\n in_place = tf.placeholder(tf.float32, [None, None, None, 512])\\n size_place = tf.placeholder(tf.int32, [2])\\n convert_place = tf.placeholder(tf.float32, [512, len(dl.directories)])\\n first_func = o_resizer(in_place, size_place, ResizeMethod.BICUBIC)\\n second_func = o_dot(in_place, convert_place)\\n graph.finalize()\\n\\n for i in range(dl.number_of_imgs_for_train, dl.number_of_imgs):\\n with graph.as_default() as gr:\\n if i == dl.number_of_imgs - 1:\\n k = batch_size - 1\\n rpath = dl.baseDirectory + \\\"/\\\" + dl.imgDataArray[i].directory + \\\"/\\\" + dl.imgDataArray[i].name\\n img = cv2.imread(rpath, cv2.IMREAD_COLOR)\\n # print('!!!!!!!!debug', rpath, i)\\n img_arr.append(img)\\n k += 1\\n if k == batch_size:\\n start_time = time.time()\\n predict_input = np.asarray(img_arr, dtype='float32')\\n predict_input = preprocess_input(predict_input)\\n\\n k = 0\\n img_arr = []\\n\\n layer_outputs = output_fn([predict_input])[0]\\n predictions = fn_predict([predict_input])[0]\\n\\n if mode == 'cv2': # model, layer_outputs, nb_classes, im_width=256):\\n maps_arr = cam_generate_cv2(model, layer_outputs, dl.nb_classes)\\n else:\\n maps_arr = cam_generate_tf_ops(model, layer_outputs, sess, first_func, second_func, in_place,\\n size_place,\\n convert_place)\\n\\n for l, prediction in enumerate(predictions):\\n inc = i - batch_size + l + 1\\n outpath = map_out + \\\"/\\\" + dl.imgDataArray[inc].directory + \\\"/\\\" + dl.imgDataArray[inc].name\\n # print('[DEBUG]', outpath, inc, i, batch_size, l)\\n\\n try:\\n os.makedirs(outpath)\\n except OSError:\\n continue\\n\\n value = np.argmax(prediction)\\n if all_classes:\\n a = 0\\n b = dl.nb_classes\\n else:\\n a = value\\n b = value + 1\\n for j in range(a, b):\\n outname = outpath + \\\"/\\\" + str(j) + '.tiff'\\n if mode == 'cv2':\\n Image.fromarray(maps_arr[l][j]).save(outname)\\n else:\\n Image.fromarray(maps_arr[l, :, :, j]).save(outname)\\n with open(outpath + '/resuts.json', 'w') as outfile:\\n json.dump({'predicted': str(value), \\\"true_label\\\": str(dl.imgDataArray[inc].img_class)},\\n outfile)\\n print(\\\"cam(\\\", counter, \\\"/\\\", dl.number_of_imgs_for_test, \\\"completed\\\")\\n counter += 1\\n print(\\\"got cams in\\\", time.time() - start_time)\",\n \"def make_input_map(self) :\\n\\n self.input_map = \\\"\\\"\\n stencil = self.core.stencil\\n pattern = self.core.pattern\\n reflect = len(pattern)+1 # reflector id, last material\\n N = self.dimension\\n coremap = np.zeros((N+2,N+2), dtype='i')\\n \\n # reflections and vacuum\\n coremap[0, 1:N+1] = -1 \\n coremap[1:N+1, 0] = -1\\n coremap[N+1, 1:N+1] = -2\\n coremap[1:N+1, N+1] = -2\\n \\n fuelindex = 0\\n \\n for i in range(1, N+1) :\\n for j in range(1, N+1) :\\n if j == 1 and i > 1 :\\n pass\\n else :\\n if stencil[i-1, j-1] > 0 : # a fuel\\n coremap[i, j] = pattern[fuelindex]+1\\n fuelindex += 1\\n elif stencil[i-1, j-1] == 0 : # a reflector\\n coremap[i, j] = reflect\\n else : # a void\\n pass \\n # Copy elements such that rotational symmetry is enforced. \\n for j in range(2, N+1) :\\n coremap[j, 1] = coremap[1, j]\\n for i in range(0, N+2) :\\n for j in range(0, N+2) :\\n self.input_map +='%4i' % (coremap[i, j])\\n self.input_map += '\\\\n'\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n )\\n\\n parser.add_argument('-V', '--version', action='version', version=VERSION)\\n\\n\\n file_group = parser.add_argument_group('Input Files')\\n file_group.add_argument('-f', dest='traj', required=True, type=str,\\n help='trajectory file (XTC/TRR/GRO/PDB ...)')\\n file_group.add_argument('-s', dest='tpr', required=True, type=str,\\n help='tpr file (TPR)')\\n file_group.add_argument('-o', dest='outpath', type=str,\\n help='name of the mapped trajectory (XTC/GRO)')\\n file_group.add_argument('-m', dest='map_file', type=str,\\n help='.mapping file or path to directory of .map files')\\n\\n mapping_group = parser.add_argument_group('Mapping Options')\\n mapping_group.add_argument('-mode', dest='mode', required=False, type=str,\\n help='COG or COM mapping', default='COG')\\n mapping_group.add_argument('-pbc', action='store_true', required=False, dest='pbc_complete',\\n help='complete pbc with MDAnalysis; this is slow!')\\n mapping_group.add_argument('-mols', dest='mol_names', required=True, type=str, nargs='+',\\n help='names of molecules to consider when mapping as in the [moleculetypes] directive')\\n mapping_group.add_argument('-add_H', dest='h_association', nargs='+', type=lambda s: s.split(':'),\\n default=[],\\n help='atom-types corresponding to CH3, CH2, CH1 for aliphatic groups and CH2d for double bonds.')\\n args = parser.parse_args()\\n\\n print(\\\"INFO - Loading universe\\\")\\n # load trajectory\\n init_universe = UniverseHandler(args.mol_names,\\n args.tpr,\\n args.traj,\\n in_memory=True)\\n if args.pbc_complete:\\n print(\\\"INFO - PBC completing trajectory\\\")\\n init_universe.pbc_complete()\\n\\n if args.h_association:\\n print(\\\"INFO - Adding Hydrogen to united-atoms\\\")\\n treated_atoms = init_universe.shift_united_atom_carbons(dict(args.h_association))\\n else:\\n treated_atoms = np.array([])\\n\\n print(\\\"INFO - Loading mapping files\\\")\\n #determine if we have a single .mapping file or a directory of .map files\\n map_path = pathlib.Path(args.map_file)\\n if map_path.is_file() == True:\\n with open(args.map_file, \\\"r\\\") as _file:\\n lines = _file.readlines()\\n elif map_path.is_dir() == True:\\n l = []\\n for i in map_path.glob('*.map'):\\n with open(i, \\\"r\\\") as _file:\\n l.append(_file.readlines())\\n if len(l) > 0:\\n lines = [item for sublist in l for item in sublist]\\n else:\\n msg = (\\\"Couldn't find any .map files in the directory given.\\\"\\n \\\"Please check the -m argument!\\\")\\n raise IOError(msg)\\n else:\\n msg = (\\\"\\\\nCannot determine if you have given me a single .mapping file\\\\n\\\"\\n \\\"or a directory of .map files. Please check!\\\\n\\\")\\n raise IOError(msg)\\n\\n mappings = read_mapping(lines)[0]\\n\\n print(\\\"INFO - Mapping universe - indices\\\")\\n # first mapp the atom indices\\n mapped_atoms, bead_idxs = forward_map_indices(init_universe,\\n mappings)\\n n_frames = len(init_universe.trajectory)\\n\\n print(\\\"INFO - Mapping universe - positions\\\")\\n mapped_atoms = numba.typed.List(mapped_atoms)\\n bead_idxs = numba.typed.List(bead_idxs)\\n # extract the position array from universe\\n # if it's not a trajectory we have to emulate\\n # a single frame\\n path = pathlib.Path(args.traj)\\n file_extension = path.suffix.casefold()[1:]\\n if file_extension in [\\\"xtc\\\", \\\"trr\\\"]:\\n positions = init_universe.trajectory.coordinate_array\\n else:\\n positions = init_universe.atoms.positions\\n positions = positions.reshape(1, -1, 3)\\n\\n mapped_trajectory = forward_map_positions(mapped_atoms,\\n bead_idxs,\\n positions,\\n n_frames,\\n args.mode,\\n treated_atoms)\\n\\n print(\\\"INFO - Mapping universe - building pos-array\\\")\\n cg_universe = create_new_universe(init_universe, mapped_trajectory, mappings)\\n\\n # write coordinate\\n print(\\\"INFO - Writing CG trajectory\\\")\\n if args.traj:\\n path = pathlib.Path(args.traj)\\n file_extension = path.suffix.casefold()[1:]\\n else:\\n file_extension = \\\"xtc\\\"\\n\\n if file_extension in [\\\"xtc\\\", \\\"trr\\\"]:\\n cg_beads = cg_universe.atoms\\n with mda.Writer(args.outpath,\\n multiframe=True,\\n n_atoms=len(cg_universe.atoms)) as mapped:\\n for time_step in cg_universe.trajectory:\\n mapped.write(cg_beads)\\n else:\\n cg_universe.atoms.positions = cg_universe.trajectory.coordinate_array[0]\\n cg_beads = cg_universe.atoms\\n cg_universe.atoms.dimensions = init_universe.atoms.dimensions\\n with mda.Writer(args.outpath, n_atoms=len(cg_universe.atoms)) as mapped:\\n mapped.write(cg_beads)\",\n \"def applyMapping(self):\\n pass\",\n \"def combine_mappings(fasta_fh, mapping_fh, denoised_seqs_fh,\\r\\n otu_picker_otu_map_fh, out_dir):\\r\\n\\r\\n # read in mapping from split_library file\\r\\n labels = imap(lambda a_b: a_b[0], parse_fasta(fasta_fh))\\r\\n # mapping from seq_id to sample_id\\r\\n sample_id_mapping = extract_read_to_sample_mapping(labels)\\r\\n\\r\\n denoiser_mapping = read_denoiser_mapping(mapping_fh)\\r\\n # read in cd_hit otu map\\r\\n # and write out combined otu_picker+denoiser map\\r\\n otu_fh = open(out_dir + \\\"/denoised_otu_map.txt\\\", \\\"w\\\")\\r\\n for otu_line in otu_picker_otu_map_fh:\\r\\n otu_split = otu_line.split()\\r\\n\\r\\n otu = otu_split[0]\\r\\n ids = otu_split[1:]\\r\\n\\r\\n get_sample_id = sample_id_mapping.get\\r\\n # concat lists\\r\\n # make sure the biggest one is first for pick_repr\\r\\n all_ids = sort_ids(ids, denoiser_mapping)\\r\\n all_ids.extend(sum([denoiser_mapping[id] for id in ids], []))\\r\\n try:\\r\\n otu_fh.write(\\\"%s\\\\t\\\" % otu +\\r\\n \\\"\\\\t\\\".join(map(get_sample_id, all_ids)) + \\\"\\\\n\\\")\\r\\n except TypeError:\\r\\n # get returns Null if denoiser_mapping id not present in\\r\\n # sample_id_mapping\\r\\n print \\\"Found id in denoiser output, which was not found in split_libraries \\\" +\\\\\\r\\n \\\"output FASTA file. Wrong file?\\\"\\r\\n exit()\\r\\n\\r\\n fasta_out_fh = open(out_dir + \\\"/denoised_all.fasta\\\", \\\"w\\\")\\r\\n for label, seq in parse_fasta(denoised_seqs_fh):\\r\\n id = label.split()[0]\\r\\n newlabel = \\\"%s %s\\\" % (sample_id_mapping[id], id)\\r\\n fasta_out_fh.write(BiologicalSequence(seq, id=newlabel).to_fasta())\",\n \"def debug_flow_input_to_pcds_raw(self, depth_img_dict_1, depth_img_dict_2, flow_dict_1to2, flow_dict_2to1, cam_info):\\n ### load four point clouds predictions and two ground truths to pcd file\\n clouds_pred_1, clouds_gt_1 = self.debug_flow_dep_to_pcd(depth_img_dict_1, cam_info)\\n clouds_pred_2, clouds_gt_2 = self.debug_flow_dep_to_pcd(depth_img_dict_2, cam_info)\\n\\n clouds_flowed_2_from_1 = self.debug_flow_depflow_to_pcd(depth_img_dict_1, flow_dict_1to2, cam_info)\\n clouds_flowed_1_from_2 = self.debug_flow_depflow_to_pcd(depth_img_dict_2, flow_dict_2to1, cam_info)\\n\\n path = self.opts.debug_path\\n name = \\\"n{:04d}_b{}_s{}_{}\\\"\\n batch_size = len(clouds_pred_1)\\n assert batch_size == len(clouds_gt_1) and batch_size == len(clouds_pred_2) and batch_size == len(clouds_gt_2)\\n for ib in range(batch_size):\\n pcl_write(clouds_pred_1[ib], os.path.join(path, name.format(self.internal_count, ib, 0, \\\"pred\\\") ) )\\n pcl_write(clouds_pred_2[ib], os.path.join(path, name.format(self.internal_count, ib, 1, \\\"pred\\\") ) )\\n pcl_write(clouds_gt_1[ib], os.path.join(path, name.format(self.internal_count, ib, 0, \\\"gt\\\") ) )\\n pcl_write(clouds_gt_2[ib], os.path.join(path, name.format(self.internal_count, ib, 1, \\\"gt\\\") ) )\\n pcl_write(clouds_flowed_2_from_1[ib], os.path.join(path, name.format(self.internal_count, ib, 1, \\\"flowed\\\") ) )\\n pcl_write(clouds_flowed_1_from_2[ib], os.path.join(path, name.format(self.internal_count, ib, 0, \\\"flowed\\\") ) )\\n\\n return\",\n \"def map():\",\n \"def test_mapping(self):\\n\\n # Input PatternDS has constraints fake, file and pattern.\\n # Use fake from first input as animal constraint.\\n the_process_unit = ProcessUnit([self.a_pattern_ds], '/a/new/pattern/%animal%/%file%/%pattern%.file',\\n 'echo', map_dict={'animal': ('fake', 0)})\\n output = the_process_unit.execute(simulate=True)\\n\\n all_files = [thing for thing in output.files]\\n\\n self.assertEqual(len(all_files), 1)\\n self.assertEqual(all_files[0].full_path, '/a/new/pattern/fake_1/file_1/pattern_1.file')\",\n \"def process_data(self):\\n\\n # direct and opposite mappings for items\\n idpool = itertools.count(start=1)\\n FVMap = collections.namedtuple('FVMap', ['dir', 'opp'])\\n self.fvmap = FVMap(dir={}, opp={})\\n\\n # mapping features to ids\\n for i in range(len(self.names) - 1):\\n feats = sorted(self.feats[i])\\n\\n # try to rangify this feature\\n if self.intvs and len(feats) > len(self.intvs) + 1:\\n feats = self.rangify(feats, i)\\n self.feats[i] = set(feats)\\n\\n if len(feats) != 2:\\n for l in feats:\\n self.fvmap.dir[(self.names[i], l)] = next(idpool)\\n else:\\n var = next(idpool)\\n self.fvmap.dir[(self.names[i], feats[0])] = var\\n self.fvmap.dir[(self.names[i], feats[1])] = -var\\n\\n # use ranges for updating samples\\n if self.vimap:\\n for i, s in enumerate(self.samps):\\n self.samps[i] = [self.vimap[j][v] if j in self.vimap and v != '' else v for j, v in enumerate(s)]\\n\\n # recomputing the weights\\n counter = collections.Counter()\\n for s, w in zip(self.samps, self.wghts):\\n counter[tuple(s)] += w\\n\\n self.samps = []\\n self.wghts = []\\n for s, w in six.iteritems(counter):\\n self.samps.append(list(s))\\n self.wghts.append(w)\\n\\n # all labels are marked with distinct ids\\n for l in sorted(self.feats[-1]):\\n self.fvmap.dir[(self.names[-1], l)] = next(idpool)\\n\\n # opposite mapping\\n for key, val in six.iteritems(self.fvmap.dir):\\n self.fvmap.opp[val] = key\\n\\n # encoding samples and filtering out features with only 1 value\\n for i in range(len(self.samps)):\\n self.samps[i] = [self.fvmap.dir[(self.names[j], self.samps[i][j])] for j in range(len(self.samps[i])) if self.samps[i][j] and len(self.feats[j]) > 1]\\n\\n # determining feature variables (excluding class variables)\\n for v, pair in six.iteritems(self.fvmap.opp):\\n if pair[0] == self.names[-1]:\\n self.fvars = v - 1\\n break\",\n \"def infer_confidence_map(DATA_DIR=DATA_DIR, SAVE_ROOT=SAVE_ROOT, FILE_LIST=FILE_LIST,\\n DS_NAME=DS_NAME, MODEL_DIR=MODEL_DIR ,LOAD_EPOCH=LOAD_EPOCH, extra_save_name=None ):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--gpu', type=int, default=GPU)\\n parser.add_argument('--model_dir', type=str, default=MODEL_DIR)\\n parser.add_argument('--data_dir', type=str, default=DATA_DIR)\\n parser.add_argument('--save_root', type=str, default=SAVE_ROOT)\\n parser.add_argument('--load_epoch', type=int, default=LOAD_EPOCH)\\n parser.add_argument('--ds_name', type=str, default=DS_NAME)\\n parser.add_argument('--patch_size', type=str, default=PATCH_SIZE)\\n parser.add_argument('--file_list', type=str, default=FILE_LIST)\\n parser.add_argument('--compute_iou', dest='iou_eval', action='store_true')\\n parser.add_argument('--no_compute_iou', dest='iou_eval', action='store_false')\\n parser.set_defaults(iou_eval=False)\\n super_args = parser.parse_args()\\n\\n # device, _ = misc_utils.set_gpu(super_args.gpu)\\n device = 'cuda:{}'.format(super_args.gpu)\\n\\n\\n def load_func_ct_tiles(data_dir, file_list=super_args.file_list, class_names=['panel', ]):\\n if file_list:\\n if not os.path.isfile(file_list):\\n make_file_list(data_dir)\\n with open(file_list, 'r') as f:\\n rgb_files = f.read().splitlines()\\n else:\\n from glob import glob\\n rgb_files = natsorted(glob(os.path.join(data_dir, '*.jpg')))\\n lbl_files = [None] * len(rgb_files)\\n assert len(rgb_files) == len(lbl_files)\\n return rgb_files, lbl_files\\n\\n # # make file list for this\\n # if not os.path.exists(FILE_LIST):\\n # make_file_list(DATA_DIR, 'png')\\n \\n # make file list for this\\n if not os.path.exists(FILE_LIST):\\n make_file_list(DATA_DIR)\\n\\n # init model\\n args = network_io.load_config(super_args.model_dir)\\n model = network_io.create_model(args)\\n if LOAD_EPOCH:\\n args['trainer']['epochs'] = super_args.load_epoch\\n ckpt_dir = os.path.join(\\n super_args.model_dir, 'epoch-{}.pth.tar'.format(args['trainer']['epochs']))\\n network_utils.load(model, ckpt_dir)\\n print('Loaded from {}'.format(ckpt_dir))\\n model.to(device)\\n model.eval()\\n\\n # eval on dataset\\n if os.path.exists(os.path.join('/home/wh145/mrs/data/stats/custom', '{}.npy'.format(DS_NAME))):\\n mean, std = np.load(os.path.join(\\n '/home/wh145/mrs/data/stats/custom', '{}.npy'.format(DS_NAME)))\\n print('Use {} mean and std stats: {}'.format(DS_NAME, (mean, std)))\\n else:\\n mean = (0.485, 0.456, 0.406)\\n std = (0.229, 0.224, 0.225)\\n print('Use default (imagenet) mean and std stats: {}'.format((mean, std)))\\n\\n tsfm_valid = A.Compose([\\n A.Normalize(mean=mean, std=std),\\n ToTensorV2(),\\n ])\\n if extra_save_name is None:\\n save_dir = os.path.join(super_args.save_root, os.path.basename(\\n network_utils.unique_model_name(args)))\\n else:\\n save_dir = os.path.join(super_args.save_root, extra_save_name)\\n evaluator = eval_utils.Evaluator(\\n super_args.ds_name, super_args.data_dir, tsfm_valid, device, load_func=load_func_ct_tiles)\\n # evaluator.evaluate(model, PATCHS_SIZE, 2*model.lbl_margin,\\n # pred_dir=save_dir, report_dir=save_dir)\\n evaluator.infer(model=model, patch_size=PATCH_SIZE, overlap=2*model.lbl_margin,\\n pred_dir=save_dir, save_conf=True)\\n\\n if super_args.iou_eval:\\n # calculate tile-wise IOU\\n with open(super_args.file_list, 'r') as fp:\\n tile_list = [os.path.basename(s).split('.')[0] for s in fp.readlines()]\\n\\n print(\\n tile_wise_validation(\\n super_args.data_dir, save_dir, tile_list, min_conf=0.5, min_area=0,\\n gt_max=1, conf_max=255, gt_postfix='.png', conf_postfix='_conf.png'\\n )\\n )\\n # Ben's comment here\",\n \"def write_maps(self):\\n if np.allclose(self.xmap.origin, 0):\\n ext = \\\"ccp4\\\"\\n else:\\n ext = \\\"mrc\\\"\\n\\n for q, coor, b in zip(self._occupancies, self._coor_set, self._bs):\\n self.conformer.q = q\\n self.conformer.coor = coor\\n self.conformer.b = b\\n self._transformer.density()\\n fname = os.path.join(self.directory_name, f\\\"model.{ext}\\\")\\n self._transformer.xmap.tofile(fname)\\n self._transformer.xmap.array -= self.xmap.array\\n fname = os.path.join(self.directory_name, f\\\"diff.{ext}\\\")\\n self._transformer.xmap.tofile(fname)\\n self._transformer.reset(full=True)\",\n \"def plot_act_fn_mapping(self, act_fn1, act_fn2):\\n\\n # plot input space\\n fig, ax = plt.subplots(figsize=(7,5))\\n circle = plt.Circle((0,0),1, color=\\\"k\\\", fill=False, linewidth=2)\\n ax.add_artist(circle)\\n ax.axis(\\\"equal\\\")\\n ax.set(xlim=(-2,2), ylim=(-2,2))\\n ax.axvline(0, linestyle=\\\"--\\\", alpha=0.25,color=\\\"k\\\")\\n ax.axhline(0, linestyle=\\\"--\\\", alpha=0.25,color=\\\"k\\\")\\n # plt.savefig(\\\"unit_circle.svg\\\")\\n\\n # plot output space\\n fig, ax = plt.subplots(figsize=(7,5))\\n ax.axis(\\\"equal\\\")\\n ax.set(xlim=(-2,2), ylim=(-2,2))\\n ax.axvline(0, linestyle=\\\"--\\\", alpha=0.25,color=\\\"k\\\")\\n ax.axhline(0, linestyle=\\\"--\\\", alpha=0.25,color=\\\"k\\\")\\n x = np.arange(0,2*np.pi, 1/100)\\n x1 = torch.tensor(np.sin(x))\\n x2 = torch.tensor(np.cos(x))\\n ax.plot(x1, x2, \\\"k:\\\", linewidth=2, label=\\\"Input\\\")\\n\\n # output space\\n ax.plot(act_fn1(x1), act_fn1(x2), \\\"b--\\\", linewidth=2, label=\\\"act_fn1\\\")\\n ax.plot(act_fn2(x1), act_fn2(x2), \\\"g--\\\", linewidth=2, label=\\\"act_fn2\\\")\\n\\n # mixed space\\n ax.plot(act_fn1(x1), act_fn2(x2), \\\"r\\\", linewidth=2, label=\\\"Mixed\\\")\\n plt.legend()\\n\\n # optional saving\\n if not self.save_fig:\\n print(\\\"Not saving.\\\")\\n plt.show()\\n return\\n \\n sub_dir = ensure_sub_dir(self.data_dir, f\\\"figures/act_fns/\\\")\\n fn_names = \\\" & \\\".join([str(fn) for fn in act_fns])\\n filename = f\\\"{fn_names}.svg\\\"\\n filename = os.path.join(sub_dir, filename)\\n print(f\\\"Saving... {filename}\\\")\\n plt.savefig(filename, dpi=300)\",\n \"def _series_merging_map(self, map_list, feature_option=\\\"sift\\\"):\\n print(\\\" --- Start ---\\\")\\n # Transform state into 3 specified values\\n for i in range(len(map_list)):\\n map_list[i] = cv2.cvtColor(map_list[i], cv2.COLOR_RGB2GRAY)\\n map_list[i] = MF._transform_state(map_list[i])\\n \\n\\n map_ref = map_list[0]\\n for i in range(len(map_list)-1):\\n map_align = map_list[i+1]\\n\\n \\n if feature_option == \\\"orb\\\":\\n orb = cv2.ORB_create()\\n key_points_1, descriptor_1 = orb.detectAndCompute(map_ref, None)\\n key_points_2, descriptor_2 = orb.detectAndCompute(map_align, None)\\n \\n elif feature_option == \\\"surf\\\":\\n surf = cv2.xfeatures2d.SURF_create(400)\\n key_points_1, descriptor_1 = surf.detectAndCompute(map_ref, None)\\n key_points_2, descriptor_2 = surf.detectAndCompute(map_align, None)\\n else:\\n siftDetector = cv2.xfeatures2d.SIFT_create()\\n key_points_1, descriptor_1 = siftDetector.detectAndCompute(map_ref, None)\\n key_points_2, descriptor_2 = siftDetector.detectAndCompute(map_align, None)\\n\\n bf = cv2.BFMatcher()\\n matches = bf.knnMatch(descriptor_1, descriptor_2, k=2)\\n\\n good = []\\n for m, n in matches:\\n if m.distance < 0.75*n.distance:\\n good.append(m)\\n \\n pts_1, pts_2 = [], []\\n for i in good:\\n query_idx = i.queryIdx\\n train_idx = i.trainIdx\\n\\n pts_1.append([\\n key_points_1[query_idx].pt[0],\\n key_points_1[query_idx].pt[1],\\n ])\\n pts_2.append([\\n key_points_2[train_idx].pt[0],\\n key_points_2[train_idx].pt[1],\\n ])\\n \\n pts1 = np.array(pts_1)\\n pts2 = np.array(pts_2)\\n\\n # relation, value, _ = RMM._ransac_find_rotation_translation(pts_set_1=pts2, pts_set_2=pts1, sigma=0.5, max_iter=5000)\\n # print(\\\"- Inlier Percent: %f\\\"%value)\\n # # Because the coordinates between the maps and the SIFT features are different:\\n # # SIFT Features: Right: +x, Down: +y\\n # # Maps: Down: +x, Right: +y\\n # # Hence the dx and dy should be changed.\\n # dx = relation[1]\\n # dy = relation[0]\\n # dyaw = relation[2]\\n # print(\\\"- (x, y, t): (%f, %f, %f)\\\"%(dx,dy,dyaw))\\n\\n # # index, agr, dis = RMM._similarity_index(x=[dy, dx, dyaw], map1=map_ref, map2=map_align)\\n # # print(\\\"Similarity Index: %f\\\\nAgree Number: %f\\\\nDisargee Number: %f\\\"%(index, agr, dis))\\n # index, agr, dis, _ = RMM._similarity_index_2(x=[dx, dy, dyaw], map1=map_ref, map2=map_align)\\n # print(\\\"- Similarity Index: %f\\\\n- Agree Number: %f\\\\n- Disargee Number: %f\\\"%(index, agr, dis))\\n \\n # map_merged = MF._merging_map(dx=dx, dy=dy, dtheta=dyaw, map1=map_ref, map2=map_align)\\n # map_ref = map_merged.astype(np.uint8)\\n # map_ref = MF._modify_map_size(merged_map=map_ref)\\n\\n relation, value, _ = RANSAC_Map_Merging()._ransac_find_all(pts_set_1=pts2, pts_set_2=pts1, sigma=5, max_iter=2000)\\n dx = relation[1]\\n dy = relation[0]\\n dyaw = relation[2]\\n dr = relation[3]\\n print(\\\"- Inlier Percent: %f\\\"%value)\\n print(\\\"- (dx, dy, dyaw, dr) = %f, %f, %f, %f\\\"%(dx,dy,dyaw, dr))\\n map_merged = MAP_Function()._merging_map_ratio(dx=dx, dy=dy, dtheta=dyaw, dr=dr, map1=map_ref, map2=map_align)\\n map_ref = map_merged.astype(np.uint8)\\n map_ref = MF._modify_map_size(merged_map=map_ref)\\n\\n # return map_ref, (dx, dy, dyaw)\\n return map_ref, (dx, dy, dyaw, dr)\",\n \"def test_read_mapping_file_multiple(reference_multi):\\n content, reference = reference_multi\\n from_names = list(reference.keys())\\n to_names = []\\n block_names = []\\n\\n for k in reference:\\n to_names.extend(reference[k].keys())\\n for to in reference[k]:\\n block_names.extend(reference[k][to].keys())\\n force_fields = case_to_dummy_ffs(from_names + to_names, block_names,\\n {(0, 'X1'): [(0, 'A')], (0, 'X2'): [(0, 'B')], (0, 'X3'): [(0, 'D')]},\\n {(0, 'A'): {(0, 'X1'): 1.0}, (0, 'B'): {(0, 'X2'): 1.0}, (0, 'C'): {(0, 'X2'): 1.0}, (0, 'D'): {(0, 'X3'): 1.0}},\\n [])\\n mappings = vermouth.map_input.read_backmapping_file(content, force_fields)\\n compare_old_new_mappings(mappings, reference)\",\n \"def phase_two_data():\\n from pathlib import Path\\n try:\\n import cPickle as pickle\\n except ImportError:\\n import pickle\\n \\n from annotation import parse_fulltext\\n from features import ALL_FEATURES\\n \\n from feature_template import apply_templates\\n from feature_selection import filter_by_frequency\\n from feature_encoding import encode\\n\\n # Feature templates considered if heading by 1:\\n # ----------------------------\\n # Position + Voice\\n # Path length + Clause layer\\n # 1 Predicate + Path\\n # Path + Position + Voice\\n # Path + Position + Voice + Predicate\\n # 1 Head word stem + Predicate\\n # 1 Head word stem + Predicate + Path\\n # 1 Head word stem + Phrase\\n # Clause layer + Position + Predicate\\n templates = [tuple([f.name]) for f in ALL_FEATURES] + \\\\\\n [('path_to_frame', 'frame'), ('head_stem', 'frame'), ('head_stem', 'frame', 'path_to_frame'), ('head_stem', 'phrase_type')]\\n \\n size = 40\\n instances = []\\n for i, p in enumerate(Path(\\\"/cs/fs2/home/hxiao/Downloads/fndata-1.5/fulltext/\\\").glob(\\\"*.xml\\\")):\\n if i == size:\\n break\\n sys.stderr.write(\\\"Processing file: '%s'\\\\n\\\" %p.absolute())\\n annotations = parse_fulltext(str(p.absolute()))\\n instances += make_training_data(ALL_FEATURES, annotations)\\n\\n sys.stderr.write(\\\"Feature selection...\\\\n\\\")\\n x, y = zip(*instances)\\n x = apply_templates(x, templates)\\n features = filter_by_frequency(x, 5)\\n sys.stderr.write(\\\"Feature encoding...\\\\n\\\")\\n x, feature_map = encode(x, features)\\n \\n sys.stderr.write(\\\"Dumping data...\\\\n\\\") \\n pickle.dump((x, y, ALL_FEATURES, templates, feature_map), open('dump/test_data.pkl', 'w'))\\n import pdb\\n pdb.set_trace()\\n print len(instances)\",\n \"def visactmap(testloader, model, save_dir, width, height, print_freq, use_gpu, **kwargs):\\n model.eval()\\n\\n imagenet_mean = [0.485, 0.456, 0.406]\\n imagenet_std = [0.229, 0.224, 0.225]\\n\\n # original images and activation maps are saved individually\\n actmap_dir = osp.join(save_dir, 'actmap_layer2')\\n mkdir_if_missing(actmap_dir)\\n print('Visualizing activation maps ...')\\n\\n for batch_idx, data in enumerate(testloader):\\n # imgs, paths = data[0], data[3]\\n # imgs, paths = data[0], data[3]\\n imgs, contours, paths = data[0], data[1], data[4]\\n\\n if use_gpu:\\n imgs = imgs.cuda()\\n contours = contours.cuda()\\n\\n # forward to get convolutional feature maps\\n try:\\n # outputs = model(segments, imgs, return_featuremaps=True)\\n outputs = model(imgs, contours, return_featuremaps=True)\\n except TypeError:\\n raise TypeError('forward() got unexpected keyword argument \\\"return_featuremaps\\\". ' \\\\\\n 'Please add return_featuremaps as an input argument to forward(). When ' \\\\\\n 'return_featuremaps=True, return feature maps only.')\\n\\n if outputs.dim() != 4:\\n raise ValueError('The model output is supposed to have ' \\\\\\n 'shape of (b, c, h, w), i.e. 4 dimensions, but got {} dimensions. '\\n 'Please make sure you set the model output at eval mode '\\n 'to be the last convolutional feature maps'.format(outputs.dim()))\\n\\n # compute activation maps\\n outputs = (outputs ** 2).sum(1)\\n b, h, w = outputs.size()\\n outputs = outputs.view(b, h * w)\\n outputs = F.normalize(outputs, p=2, dim=1)\\n outputs = outputs.view(b, h, w)\\n\\n if use_gpu:\\n imgs, outputs = imgs.cpu(), outputs.cpu()\\n\\n for j in range(outputs.size(0)):\\n # get image name\\n path = paths[j]\\n\\n # imname = osp.basename(osp.splitext(path)[0])\\n path = path.split('/')\\n imname = osp.splitext(path[-2] + '_' + path[-1])[0]\\n\\n # RGB image\\n img = imgs[j, ...]\\n for t, m, s in zip(img, imagenet_mean, imagenet_std):\\n t.mul_(s).add_(m).clamp_(0, 1)\\n img_np = np.uint8(np.floor(img.numpy() * 255))\\n img_np = img_np.transpose((1, 2, 0)) # (c, h, w) -> (h, w, c)\\n\\n # activation map\\n am = outputs[j, ...].numpy()\\n am = cv2.resize(am, (width, height))\\n am = 255 * (am - np.max(am)) / (np.max(am) - np.min(am) + 1e-12)\\n am = np.uint8(np.floor(am))\\n am = cv2.applyColorMap(am, cv2.COLORMAP_JET)\\n\\n # overlapped\\n overlapped = img_np * 0.3 + am * 0.7\\n overlapped[overlapped > 255] = 255\\n overlapped = overlapped.astype(np.uint8)\\n\\n # # save images in a single figure (add white spacing between images)\\n # # from left to right: original image, activation map, overlapped image\\n # grid_img = 255 * np.ones((height, 3 * width + 2 * GRID_SPACING, 3), dtype=np.uint8)\\n # grid_img[:, :width, :] = img_np[:, :, ::-1]\\n # grid_img[:, width + GRID_SPACING: 2 * width + GRID_SPACING, :] = am\\n # grid_img[:, 2 * width + 2 * GRID_SPACING:, :] = overlapped\\n\\n cv2.imwrite(osp.join(actmap_dir, imname+'_ori.jpg'), img_np[:, :, ::-1])\\n cv2.imwrite(osp.join(actmap_dir, imname + '_am.jpg'), am)\\n cv2.imwrite(osp.join(actmap_dir, imname + '_overlap.jpg'), overlapped)\\n\\n if (batch_idx + 1) % print_freq == 0:\\n print('- done batch {}/{}'.format(batch_idx + 1, len(testloader)))\",\n \"def main(hotstart_input, hotstart_bcg, hotstart_output):\\r\\n fpath_in = hotstart_input\\r\\n fpath_out = hotstart_output\\r\\n fpath_bcg = hotstart_bcg\\r\\n\\r\\n with nc.Dataset(fpath_in, 'r') as src, \\\\\\r\\n nc.Dataset(fpath_bcg, 'r') as bcg, \\\\\\r\\n nc.Dataset(fpath_out, \\\"w\\\") as dst:\\r\\n # copy attributes\\r\\n for name in src.ncattrs():\\r\\n dst.setncattr(name, src.getncattr(name))\\r\\n # copy dimensions\\r\\n print(\\\"Copy dimensions...\\\")\\r\\n for name, dimension in src.dimensions.items():\\r\\n dst.createDimension(\\r\\n name,\\r\\n (len(dimension) if not dimension.isunlimited()\\r\\n else None))\\r\\n # Copy variables\\r\\n print(\\\"Copy variables...\\\")\\r\\n for name, variable in src.variables.items():\\r\\n print(\\\"Variable: \\\", name)\\r\\n dimensions = variable.dimensions\\r\\n dst.createVariable(\\r\\n name, variable.datatype, dimensions)\\r\\n if name == 'SED3D_bedfrac':\\r\\n dst.variables[name][:] = bcg.variables[name][:]\\r\\n else:\\r\\n dst.variables[name][:] = src.variables[name][:]\",\n \"def open_input(self):\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"YES\\\")\\n gdal.AllRegister()\\n # self.options.verbose=True\\n if self.options.tms_osm:\\n self.s_y_type=\\\"osm\\\"\\n else:\\n self.s_y_type=\\\"tms\\\"\\n if self.options.verbose:\\n print \\\"open_input :\\\", self.input,\\\" osm[\\\",self.options.tms_osm,\\\",\\\",self.s_y_type,\\\"] mbtiles[\\\",self.options.mbtiles,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"]\\\";\\n # Open the input file\\n if self.input:\\n self.in_ds = gdal.Open(self.input, gdal.GA_ReadOnly)\\n else:\\n raise Exception(\\\"No input file was specified\\\")\\n\\n if self.options.verbose:\\n print \\\"Input file:\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\\n\\n if not self.in_ds:\\n # Note: GDAL prints the ERROR message too\\n self.error(\\\"It is not possible to open the input file '%s'.\\\" % self.input )\\n\\n # Read metadata from the input file\\n if self.in_ds.RasterCount == 0:\\n self.error( \\\"Input file '%s' has no raster band\\\" % self.input )\\n\\n if self.in_ds.GetRasterBand(1).GetRasterColorTable():\\n # TODO: Process directly paletted dataset by generating VRT in memory\\n self.error( \\\"Please convert this file to RGB/RGBA and run gdal2mbtiles on the result.\\\",\\n \\\"\\\"\\\"From paletted file you can create RGBA file (temp.vrt) by:\\ngdal_translate -of vrt -expand rgba %s temp.vrt\\nthen run:\\ngdal2mbtiles temp.vrt\\\"\\\"\\\" % self.input )\\n\\n # Get NODATA value\\n # User supplied values overwrite everything else.\\n if self.options.srcnodata is not None:\\n nds = map(float, self.options.srcnodata.split(','))\\n if len(nds) < self.in_ds.RasterCount:\\n self.in_nodata = (nds * self.in_ds.RasterCount)[:self.in_ds.RasterCount]\\n else:\\n self.in_nodata = nds\\n else:\\n # If the source dataset has NODATA, use it.\\n self.in_nodata = []\\n for i in range(1, self.in_ds.RasterCount+1):\\n if self.in_ds.GetRasterBand(i).GetNoDataValue() != None:\\n self.in_nodata.append( self.in_ds.GetRasterBand(i).GetNoDataValue() )\\n\\n if self.options.verbose:\\n print \\\"NODATA: %s\\\" % self.in_nodata\\n\\n # INIT DEST\\n if self.options.init_dest is not None:\\n if self.options.tile_format == \\\"jpeg\\\":\\n if self.in_ds.RasterCount == 4:\\n nbands = 3\\n else:\\n nbands = self.in_ds.RasterCount\\n\\n nds = map(float, self.options.init_dest.split(','))\\n\\n if len(nds) == 1:\\n init_dest = nds * nbands\\n elif len(nds) == nbands:\\n init_dest = nds\\n else:\\n print \\\"WARNING: you suplied %d '--init-dest' values but the dataset has %d data bands\\\" % (len(nds), nbands)\\n init_dest = None\\n else:\\n init_dest = None\\n print \\\"WARNING: --init-dest can be used only with 'jpeg' tile format\\\"\\n else:\\n if self.options.tile_format == \\\"jpeg\\\":\\n init_dest = [255,255,255]\\n else:\\n init_dest = None\\n\\n #\\n # Here we should have RGBA input dataset opened in self.in_ds\\n #\\n\\n if self.options.verbose:\\n print \\\"Preprocessed file:\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\\n\\n # Spatial Reference System of the input raster\\n\\n\\n self.in_srs = None\\n\\n if self.options.s_srs:\\n self.in_srs = osr.SpatialReference()\\n self.in_srs.SetFromUserInput(self.options.s_srs)\\n self.in_srs_wkt = self.in_srs.ExportToWkt()\\n else:\\n self.in_srs_wkt = self.in_ds.GetProjection()\\n if not self.in_srs_wkt and self.in_ds.GetGCPCount() != 0:\\n self.in_srs_wkt = self.in_ds.GetGCPProjection()\\n if self.in_srs_wkt:\\n self.in_srs = osr.SpatialReference()\\n self.in_srs.ImportFromWkt(self.in_srs_wkt)\\n #elif self.options.profile != 'raster':\\n # self.error(\\\"There is no spatial reference system info included in the input file.\\\",\\\"You should run gdal2mbtiles with --s_srs EPSG:XXXX or similar.\\\")\\n\\n # Spatial Reference System of tiles\\n\\n self.out_srs = osr.SpatialReference()\\n\\n if self.options.profile == 'mercator':\\n self.out_srs.ImportFromEPSG(900913)\\n elif self.options.profile in ('geodetic', 'gearth', 'garmin'):\\n self.out_srs.ImportFromEPSG(4326)\\n else:\\n self.out_srs = self.in_srs\\n\\n # Are the reference systems the same? Reproject if necessary.\\n\\n self.out_ds = None\\n\\n if self.options.profile in ('mercator', 'geodetic', 'gearth', 'garmin'):\\n\\n if (self.in_ds.GetGeoTransform() == (0.0, 1.0, 0.0, 0.0, 0.0, 1.0)) and (self.in_ds.GetGCPCount() == 0):\\n self.error(\\\"There is no georeference - neither affine transformation (worldfile) nor GCPs. You can generate only 'raster' profile tiles.\\\",\\n \\\"Either gdal2mbtiles with parameter -p 'raster' or use another GIS software for georeference e.g. gdal_transform -gcp / -a_ullr / -a_srs\\\")\\n\\n if self.in_srs:\\n\\n if (self.in_srs.ExportToProj4() != self.out_srs.ExportToProj4()) or (self.in_ds.GetGCPCount() != 0):\\n\\n # Generation of VRT dataset in tile projection, default 'nearest neighbour' warping\\n self.out_ds = gdal.AutoCreateWarpedVRT( self.in_ds, self.in_srs_wkt, self.out_srs.ExportToWkt() )\\n\\n # TODO: HIGH PRIORITY: Correction of AutoCreateWarpedVRT according the max zoomlevel for correct direct warping!!!\\n\\n if self.options.verbose:\\n print \\\"Warping of the raster by AutoCreateWarpedVRT (result saved into 'tiles.vrt')\\\"\\n self.out_ds.GetDriver().CreateCopy(\\\"tiles.vrt\\\", self.out_ds)\\n\\n # Note: self.in_srs and self.in_srs_wkt contain still the non-warped reference system!!!\\n\\n # Correction of AutoCreateWarpedVRT for NODATA values\\n if self.in_nodata != []:\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"<GDALWarpOptions>\\\"\\\"\\\",\\\"\\\"\\\"<GDALWarpOptions>\\n <Option name=\\\"UNIFIED_SRC_NODATA\\\">YES</Option>\\n <Option name=\\\"INIT_DEST\\\">NO_DATA</Option>\\\"\\\"\\\")\\n # replace BandMapping tag for NODATA bands....\\n if init_dest is None:\\n dstnodata = self.in_nodata\\n else:\\n dstnodata = init_dest\\n for i in range(len(self.in_nodata)):\\n s = s.replace(\\\"\\\"\\\"<BandMapping src=\\\"%i\\\" dst=\\\"%i\\\"/>\\\"\\\"\\\" % ((i+1),(i+1)),\\\"\\\"\\\"<BandMapping src=\\\"%i\\\" dst=\\\"%i\\\">\\n <SrcNoDataReal>%i</SrcNoDataReal>\\n <SrcNoDataImag>0</SrcNoDataImag>\\n <DstNoDataReal>%i</DstNoDataReal>\\n <DstNoDataImag>0</DstNoDataImag>\\n </BandMapping>\\\"\\\"\\\" % ((i+1), (i+1), self.in_nodata[i], dstnodata[i]))\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n # set NODATA_VALUE metadata\\n self.out_ds.SetMetadataItem('NODATA_VALUES','%s' % \\\" \\\".join(str(int(f)) for f in self.in_nodata))\\n\\n if self.options.verbose:\\n print \\\"Modified warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n # -----------------------------------\\n # Correction of AutoCreateWarpedVRT for Mono (1 band) and RGB (3 bands) files without NODATA:\\n # equivalent of gdalwarp -dstalpha\\n elif self.in_nodata == [] and self.out_ds.RasterCount in (1,3):\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"<BlockXSize>\\\"\\\"\\\",\\\"\\\"\\\"<VRTRasterBand dataType=\\\"Byte\\\" band=\\\"%i\\\" subClass=\\\"VRTWarpedRasterBand\\\">\\n <ColorInterp>Alpha</ColorInterp>\\n </VRTRasterBand>\\n <BlockXSize>\\\"\\\"\\\" % (self.out_ds.RasterCount + 1))\\n s = s.replace(\\\"\\\"\\\"</GDALWarpOptions>\\\"\\\"\\\", \\\"\\\"\\\"<DstAlphaBand>%i</DstAlphaBand>\\n </GDALWarpOptions>\\\"\\\"\\\" % (self.out_ds.RasterCount + 1))\\n if init_dest is None:\\n init_dest_str = \\\"0\\\"\\n else:\\n init_dest_str = \\\",\\\".join(str(f) for f in init_dest)\\n s = s.replace(\\\"\\\"\\\"</WorkingDataType>\\\"\\\"\\\", \\\"\\\"\\\"</WorkingDataType>\\n <Option name=\\\"INIT_DEST\\\">%s</Option>\\\"\\\"\\\" % init_dest_str)\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n if self.options.verbose:\\n print \\\"Modified -dstalpha warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n elif init_dest is not None:\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"</WorkingDataType>\\\"\\\"\\\", \\\"\\\"\\\"</WorkingDataType>\\n <Option name=\\\"INIT_DEST\\\">%s</Option>\\\"\\\"\\\" % \\\",\\\".join(str(f) for f in init_dest))\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n if self.options.verbose:\\n print \\\"Modified warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n # For raster with 4-bands: 4th unknown band set to alpha\\n if (self.out_ds.RasterCount == 4\\n and self.out_ds.GetRasterBand(4).GetRasterColorInterpretation() == gdal.GCI_Undefined):\\n self.out_ds.GetRasterBand(4).SetRasterColorInterpretation(gdal.GCI_AlphaBand)\\n\\n s = '''\\n '''\\n\\n else:\\n self.error(\\\"Input file has unknown SRS.\\\", \\\"Use --s_srs ESPG:xyz (or similar) to provide source reference system.\\\" )\\n\\n if self.out_ds and self.options.verbose:\\n print \\\"Projected file:\\\", \\\"tiles.vrt\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.out_ds.RasterXSize, self.out_ds.RasterYSize, self.out_ds.RasterCount)\\n\\n if not self.out_ds:\\n self.out_ds = self.in_ds\\n\\n #\\n # Here we should have a raster (out_ds) in the correct Spatial Reference system\\n #\\n\\n # KML test\\n self.isepsg4326 = False\\n srs4326 = osr.SpatialReference()\\n srs4326.ImportFromEPSG(4326)\\n if self.out_srs and srs4326.ExportToProj4() == self.out_srs.ExportToProj4():\\n self.kml = True\\n self.isepsg4326 = True\\n if self.options.verbose:\\n print \\\"KML autotest OK!\\\"\\n\\n # Read the georeference\\n\\n self.out_gt = self.out_ds.GetGeoTransform()\\n\\n #originX, originY = self.out_gt[0], self.out_gt[3]\\n #pixelSize = self.out_gt[1] # = self.out_gt[5]\\n\\n # Test the size of the pixel\\n\\n # MAPTILER - COMMENTED\\n #if self.out_gt[1] != (-1 * self.out_gt[5]) and self.options.profile != 'raster':\\n # TODO: Process corectly coordinates with are have swichted Y axis (display in OpenLayers too)\\n #self.error(\\\"Size of the pixel in the output differ for X and Y axes.\\\")\\n\\n # Report error in case rotation/skew is in geotransform (possible only in 'raster' profile)\\n if (self.out_gt[2], self.out_gt[4]) != (0,0):\\n self.error(\\\"Georeference of the raster contains rotation or skew. Such raster is not supported. Please use gdalwarp first.\\\")\\n # TODO: Do the warping in this case automaticaly\\n\\n #\\n # Here we expect: pixel is square, no rotation on the raster\\n #\\n\\n # Output Bounds - coordinates in the output SRS\\n self.ominx = self.out_gt[0]\\n self.omaxx = self.out_gt[0]+self.out_ds.RasterXSize*self.out_gt[1]\\n self.omaxy = self.out_gt[3]\\n self.ominy = self.out_gt[3]-self.out_ds.RasterYSize*self.out_gt[1]\\n # Note: maybe round(x, 14) to avoid the gdal_translate behaviour, when 0 becomes -1e-15\\n # user defined bounds to extract - coordinates in the output SRS\\n if self.options.te_bounds != '':\\n if self.te_minx >= self.ominx and self.te_minx <= self.omaxx:\\n if self.te_maxx >= self.ominx and self.te_maxx <= self.omaxx:\\n if self.te_miny >= self.ominy and self.te_miny <= self.omaxy:\\n if self.te_maxy >= self.ominy and self.te_maxy <= self.omaxy:\\n # replace only if inside the read bounds\\n self.ominx = self.te_minx\\n self.omaxx = self.te_maxx\\n self.ominy = self.te_miny\\n self.omaxy = self.te_maxy\\n if self.options.verbose:\\n print \\\"User defined Bounds (output srs) have been set:\\\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.verbose:\\n print \\\"Bounds (output srs):\\\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.mbtiles:\\n self.options.profile = 'mercator'\\n if self.options.profile == 'mercator':\\n self.mercator = GlobalMercator(self.options.tms_osm) # from globalmaptiles.py\\n\\n #\\n # Calculating ranges for tiles in different zoom levels\\n #\\n\\n # Function which generates SWNE in LatLong for given tile\\n self.tileswne = self.mercator.TileLatLonBounds\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0,32)\\n for tz in range(0, 32):\\n tminx, tminy = self.mercator.MetersToTile( self.ominx, self.ominy, tz )\\n tmaxx, tmaxy = self.mercator.MetersToTile( self.omaxx, self.omaxy, tz )\\n # crop tiles extending world limits (+-180,+-90)\\n tminx, tminy = max(0, tminx), max(0, tminy)\\n tmaxx, tmaxy = min(2**tz-1, tmaxx), min(2**tz-1, tmaxy)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # TODO: Maps crossing 180E (Alaska?)\\n\\n # Get the minimal zoom level (map covers area equivalent to one tile)\\n if self.tminz == None:\\n self.tminz = self.mercator.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.mercator.ZoomForPixelSize( self.out_gt[1] )\\n\\n if self.options.verbose:\\n print \\\"Bounds (latlong):\\\", self.mercator.MetersToLatLon( self.ominx, self.ominy), self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\\n print 'MinZoomLevel:', self.tminz\\n print \\\"MaxZoomLevel:\\\", self.tmaxz, \\\"(\\\", self.mercator.Resolution( self.tmaxz ),\\\")\\\"\\n\\n # this must be call befor ImageOutput is called (self.output may be changed)\\n if self.options.mbtiles:\\n if not self.mbtiles_db:\\n self.mbtiles_setup(1);\\n\\n # Instantiate image output.\\n self.image_output = ImageOutput(self.options.tile_format, self.out_ds, self.tilesize,\\n self.options.resampling, init_dest, self.output,\\n self.options.verbose,self.options.mbtiles)\\n if self.options.profile == 'geodetic':\\n\\n self.geodetic = GlobalGeodetic() # from globalmaptiles.py\\n\\n # Function which generates SWNE in LatLong for given tile\\n self.tileswne = self.geodetic.TileLatLonBounds\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0,32)\\n for tz in range(0, 32):\\n tminx, tminy = self.geodetic.LatLonToTile( self.ominx, self.ominy, tz )\\n tmaxx, tmaxy = self.geodetic.LatLonToTile( self.omaxx, self.omaxy, tz )\\n # crop tiles extending world limits (+-180,+-90)\\n tminx, tminy = max(0, tminx), max(0, tminy)\\n tmaxx, tmaxy = min(2**(tz+1)-1, tmaxx), min(2**tz-1, tmaxy)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # TODO: Maps crossing 180E (Alaska?)\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tminz == None:\\n self.tminz = self.geodetic.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.geodetic.ZoomForPixelSize( self.out_gt[1] )\\n\\n if self.options.verbose:\\n print \\\"Bounds (latlong):\\\", self.ominx, self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.profile in ('raster', 'gearth', 'garmin'):\\n\\n log2 = lambda x: math.log10(x) / math.log10(2) # log2 (base 2 logarithm)\\n\\n self.nativezoom = int(max( math.ceil(log2(self.out_ds.RasterXSize/float(self.tilesize))),\\n math.ceil(log2(self.out_ds.RasterYSize/float(self.tilesize)))))\\n\\n if self.options.verbose:\\n print \\\"Native zoom of the raster:\\\", self.nativezoom\\n\\n # Get the minimal zoom level (whole raster in one tile)\\n if self.tminz == None:\\n self.tminz = 0\\n\\n # Get the maximal zoom level (native resolution of the raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.nativezoom\\n\\n # Garmin has maximally 100 tiles - lower the tmaxz if necessary\\n if self.options.profile == 'garmin':\\n tno = math.ceil(self.out_ds.RasterXSize / self.tilesize) * math.ceil(self.out_ds.RasterYSize / self.tilesize)\\n for tz in range(self.tmaxz, 1, -1):\\n if tno > 100:\\n tno /= 4\\n self.tmaxz -= 1\\n print \\\"Warning: GARMIN has a limit 100 tiles per device: lowering the max zoom level to:\\\", self.tmaxz\\n else:\\n continue\\n\\n # Force only one zoom level for the 'garmin' tile profile\\n if self.options.profile == 'garmin':\\n self.tminz = self.tmaxz\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0, self.tmaxz+1)\\n self.tsize = range(0, self.tmaxz+1)\\n for tz in range(0, self.tmaxz+1):\\n tsize = 2.0**(self.nativezoom-tz)*self.tilesize\\n tminx, tminy = 0, 0\\n tmaxx = int(math.ceil( self.out_ds.RasterXSize / tsize )) - 1\\n tmaxy = int(math.ceil( self.out_ds.RasterYSize / tsize )) - 1\\n self.tsize[tz] = math.ceil(tsize)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # Function which generates SWNE in LatLong for given tile\\n if self.kml and self.in_srs_wkt:\\n self.ct = osr.CoordinateTransformation(self.in_srs, srs4326)\\n def rastertileswne(x,y,z):\\n pixelsizex = (2**(self.nativezoom-z) * self.out_gt[1]) # X-pixel size in level\\n pixelsizey = (2**(self.nativezoom-z) * self.out_gt[5]) # Y-pixel size in level (usually -1*pixelsizex)\\n west = self.out_gt[0] + x*self.tilesize*pixelsizex\\n east = west + self.tilesize*pixelsizex\\n south = self.ominy + y*self.tilesize*pixelsizex\\n north = south + self.tilesize*pixelsizex\\n if not self.isepsg4326:\\n # Transformation to EPSG:4326 (WGS84 datum)\\n west, south = self.ct.TransformPoint(west, south)[:2]\\n east, north = self.ct.TransformPoint(east, north)[:2]\\n return south, west, north, east\\n\\n self.tileswne = rastertileswne\\n else:\\n self.tileswne = lambda x, y, z: (0,0,0,0)\",\n \"def ReadInput(f1, f2):\\n\\tprint \\\"Reading input file %s\\\" % f1\\n\\ttopoFile = open(f1, \\\"r\\\")\\t# Topology file\\n\\tnodeDic = {}\\n\\tnodes = []\\t# names of nodes\\n\\tlinks = []\\t# links as an ordered pair of node IDs\\n\\tlength = []\\t# lengths of links\\n\\tcapacity = []\\t# link capacities\\n\\tfor line in topoFile:\\n\\t\\ttoken = line.split()\\n\\t\\tif (len(token) < 2): continue\\n\\t\\tif token[0] == \\\"N\\\":\\t# specifying a node by its name\\n\\t\\t\\tnodes.append(token[1])\\n\\t\\t\\tnodeDic[token[1]] = len(nodes) - 1\\n\\t\\telif token[0] == \\\"l\\\":\\t# specifying a link as a connection between two nodes\\n\\t\\t\\te = (nodeDic[token[1]], nodeDic[token[2]])\\n\\t\\t\\tlinks.append(e)\\n\\t\\t\\tlength.append(1 if len(token) < 4 else token[3])\\n\\t\\t\\tcapacity.append(1 if len(token) < 5 else token[4])\\n\\t\\t\\tif not digraph:\\n\\t\\t\\t\\tlinks.append((e[1],e[0]))\\n\\t\\t\\t\\tlength.append(length[-1])\\n\\t\\t\\t\\tcapacity.append(capacity[-1])\\n\\ttopoFile.close()\\n\\n\\tprint \\\"Reading input file %s\\\" % f2\\n\\ttrafficFile = open(f2, \\\"r\\\")\\t# Traffic matrix file\\n\\ttraffic = {}\\n\\tfor line in trafficFile:\\n\\t\\ttoken = line.split()\\n\\t\\tif (len(token) < 3): continue\\n\\t\\ttraffic[nodeDic[token[0]], nodeDic[token[1]]] = float(token[2])\\n\\ttrafficFile.close()\\n\\treturn nodes, links, length, capacity, traffic\",\n \"def generate_FreeSurferLUT(labels,data,mapname,filename):\",\n \"def forward(self, x): \\n pal1_sources = list()\\n pal2_sources = list()\\n loc_pal1 = list()\\n conf_pal1 = list()\\n loc_pal2 = list()\\n conf_pal2 = list()\\n\\n # apply vgg up to conv3_3 relu\\n for k in range(16):\\n x = self.vgg[k](x)\\n\\n of1 = x\\n s = self.L2Normof1(of1)\\n pal1_sources.append(s)\\n \\n # apply vgg up to conv4_3 relu\\n for k in range(16, 23):\\n x = self.vgg[k](x)\\n\\n of2 = x\\n s = self.L2Normof2(of2)\\n pal1_sources.append(s)\\n\\n # apply vgg up to conv5_3 relu\\n for k in range(23, 30):\\n x = self.vgg[k](x)\\n of3 = x\\n s = self.L2Normof3(of3)\\n pal1_sources.append(s)\\n\\n # apply vgg up to fc7\\n for k in range(30, len(self.vgg)):\\n x = self.vgg[k](x)\\n of4 = x\\n pal1_sources.append(of4)\\n \\n # apply extra layers and cache source layer outputs\\n for k in range(2):\\n x = F.relu(self.extras[k](x), inplace=True)\\n of5 = x\\n pal1_sources.append(of5)\\n for k in range(2, 4):\\n x = F.relu(self.extras[k](x), inplace=True)\\n of6 = x\\n pal1_sources.append(of6)\\n\\n ## fpn module\\n \\\"\\\"\\\"\\n lfpn6 = self.fpn_topdown6(of6)\\n lfpn5 = self._upsample_product(self.fpn_topdown5(of6), self.fpn_latlayer5(of5))\\n lfpn4 = self._upsample_product(self.fpn_topdown4(of5), self.fpn_latlayer4(of4))\\n lfpn3 = self._upsample_product(self.fpn_topdown3(of4), self.fpn_latlayer3(of3))\\n lfpn2 = self._upsample_product(self.fpn_topdown2(of3), self.fpn_latlayer2(of2))\\n lfpn1 = self._upsample_product(self.fpn_topdown1(of2), self.fpn_latlayer1(of1))\\n\\n\\n ef1 = self.fpn_fem3_3(lfpn1)\\n ef1 = self.L2Normef1(ef1)\\n ef2 = self.fpn_fem4_3(lfpn2)\\n ef2 = self.L2Normef2(ef2)\\n ef3 = self.fpn_fem5_3(lfpn3)\\n ef3 = self.L2Normef3(ef3)\\n\\n ef4 = self.fpn_fem7(lfpn4)\\n ef5 = self.fpn_fem6_2(lfpn5)\\n ef6 = self.fpn_fem7_2(lfpn6)\\n \\\"\\\"\\\"\\n\\n conv7 = F.relu(self.fpn_topdown[0](of6), inplace=True)\\n x = F.relu(self.fpn_topdown[1](conv7), inplace=True)\\n conv6 = F.relu(self._upsample_product(x, self.fpn_latlayer[0](of5)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[2](conv6), inplace=True)\\n convfc7_2 = F.relu(self._upsample_product(x, self.fpn_latlayer[1](of4)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[3](convfc7_2), inplace=True)\\n conv5 = F.relu(self._upsample_product(x, self.fpn_latlayer[2](of3)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[4](conv5), inplace=True)\\n conv4 = F.relu(self._upsample_product(x, self.fpn_latlayer[3](of2)), inplace=True)\\n\\n x = F.relu(self.fpn_topdown[5](conv4), inplace=True)\\n conv3 = F.relu(self._upsample_product(x, self.fpn_latlayer[4](of1)), inplace=True)\\n\\n ef1 = self.fpn_fem[0](conv3)\\n ef1 = self.L2Normef1(ef1)\\n ef2 = self.fpn_fem[1](conv4)\\n ef2 = self.L2Normef2(ef2)\\n ef3 = self.fpn_fem[2](conv5)\\n ef3 = self.L2Normef3(ef3)\\n ef4 = self.fpn_fem[3](convfc7_2)\\n ef5 = self.fpn_fem[4](conv6)\\n ef6 = self.fpn_fem[5](conv7)\\n\\n pal2_sources = (ef1, ef2, ef3, ef4, ef5, ef6)\\n\\n ## first shot \\n for (x, l, c) in zip(pal1_sources, self.loc_pal1, self.conf_pal1):\\n loc_pal1.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf_pal1.append(c(x).permute(0, 2, 3, 1).contiguous())\\n \\n ## second shot\\n for (x, l, c) in zip(pal2_sources, self.loc_pal2, self.conf_pal2):\\n loc_pal2.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf_pal2.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n # first shot\\n loc_pal1 = torch.cat([o.view(o.size(0), -1) for o in loc_pal1], 1)\\n conf_pal1 = torch.cat([o.view(o.size(0), -1) for o in conf_pal1], 1)\\n \\n # second shot\\n loc_pal2 = torch.cat([o.view(o.size(0), -1) for o in loc_pal2], 1)\\n conf_pal2 = torch.cat([o.view(o.size(0), -1) for o in conf_pal2], 1)\\n\\n if self.phase == 'test':\\n # 测试时， 仅使用shot2 的输出\\n output = self.detect(\\n loc_pal2.view(loc_pal2.size(0), -1, 4),\\n self.softmax(conf_pal2.view(conf_pal2.size(0), -1,\\n self.num_classes)), # conf preds\\n )\\n else:\\n ## 训练时，使用shot1 和 shot2 的输出\\n output = (\\n loc_pal1.view(loc_pal1.size(0), -1, 4),\\n conf_pal1.view(conf_pal1.size(0), -1, self.num_classes),\\n loc_pal2.view(loc_pal2.size(0), -1, 4),\\n conf_pal2.view(conf_pal2.size(0), -1, self.num_classes))\\n return output\",\n \"def deconvolution_fusion_para(x, y):\\n input_memory_type = x.get(\\\"addr_type\\\") \\\\\\n if \\\"addr_type\\\" in x else 0\\n output_memory_type = y.get(\\\"addr_type\\\") \\\\\\n if \\\"addr_type\\\" in y else 0\\n valid_shape = x.get(\\\"valid_shape\\\") \\\\\\n if \\\"valid_shape\\\" in x else ()\\n slice_offset = x.get(\\\"slice_offset\\\") \\\\\\n if \\\"slice_offset\\\" in x else ()\\n output_offset = y.get(\\\"slice_offset\\\") \\\\\\n if \\\"slice_offset\\\" in y else ()\\n l1_fusion_type = x.get(\\\"L1_fusion_type\\\") \\\\\\n if \\\"L1_fusion_type\\\" in x else -1\\n fmap_l1_addr_flag = x.get(\\\"L1_addr_flag\\\", False)\\n fmap_l1_valid_size = x.get(\\\"L1_valid_size\\\", 0)\\n\\n\\n\\n l1_fusion_enable_flag = get_L1_info(\\\"L1_fusion_enabled\\\")\\n\\n if input_memory_type not in (0, 1, 2):\\n args_dict = {\\n \\\"errCode\\\": \\\"E65008\\\",\\n \\\"input_memory_type_range\\\": \\\"(0, 1, 2)\\\",\\n \\\"input_memory_type\\\": str(input_memory_type)\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n if output_memory_type not in (0, 1, 2):\\n args_dict = {\\n \\\"errCode\\\": \\\"E65009\\\",\\n \\\"output_memory_type_range\\\": \\\"(0, 1, 2)\\\",\\n \\\"output_memory_type\\\": str(output_memory_type)\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n if valid_shape and not slice_offset:\\n reason = \\\"valid shape exists, slice shape cannot be []\\\"\\n args_dict = {\\n \\\"errCode\\\": \\\"E60108\\\",\\n \\\"reason\\\": reason\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n if valid_shape and not output_offset:\\n reason = \\\"valid shape exists, output offset cannot be []\\\"\\n args_dict = {\\n \\\"errCode\\\": \\\"E60108\\\",\\n \\\"reason\\\": reason\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n\\n valid_shape = shape_to_list(valid_shape)\\n slice_offset = shape_to_list(slice_offset)\\n output_offset = shape_to_list(output_offset)\\n\\n if not l1_fusion_enable_flag:\\n input_memory_type = 0\\n output_memory_type = 0\\n valid_shape = []\\n slice_offset = []\\n output_offset = []\\n l1_fusion_type = -1\\n fmap_l1_addr_flag = False\\n fmap_l1_valid_size = 0\\n\\n fusion_para = {\\\"input_memory_type\\\": input_memory_type,\\n \\\"output_memory_type\\\": output_memory_type,\\n \\\"valid_shape\\\": valid_shape,\\n \\\"slice_offset\\\": slice_offset,\\n \\\"output_offset\\\": output_offset,\\n \\\"l1_fusion_type\\\": l1_fusion_type,\\n \\\"fmap_l1_addr_flag\\\": fmap_l1_addr_flag,\\n \\\"fmap_l1_valid_size\\\": fmap_l1_valid_size}\\n\\n return fusion_para\",\n \"def _fusion(self, expert_outputs):\\n raise NotImplementedError\",\n \"def get_new_input_output_maps(self, mapped_input_output_maps={}):\\n inputs = self.get_input_contents()\\n mapped_inputs = self.get_mapped_inputs(mapped_input_output_maps)\\n mapped_inputs_scope_name = [ip['scope'] + \\\":\\\" + ip['name'] for ip in mapped_inputs]\\n\\n new_inputs = []\\n new_input_output_maps = {}\\n for ip in inputs:\\n ip_scope_name = ip['scope'] + \\\":\\\" + ip['name']\\n if ip_scope_name not in mapped_inputs_scope_name:\\n new_inputs.append(ip)\\n\\n # to avoid cheking new inputs if there are no new inputs anymore\\n if (not new_inputs and 'status' in self.collections[self._primary_input_collection]\\n and self.collections[self._primary_input_collection]['status'] in [CollectionStatus.Closed]): # noqa: W503\\n self.set_has_new_inputs(False)\\n else:\\n mapped_keys = mapped_input_output_maps.keys()\\n if mapped_keys:\\n next_key = max(mapped_keys) + 1\\n else:\\n next_key = 1\\n for ip in new_inputs:\\n out_ip = copy.deepcopy(ip)\\n out_ip['coll_id'] = self.collections[self._primary_output_collection]['coll_id']\\n new_input_output_maps[next_key] = {'inputs': [ip],\\n 'outputs': [out_ip]}\\n next_key += 1\\n\\n self.unfinished_points = 1\\n\\n return new_input_output_maps\",\n \"def run(prefix=\\\"tst_map_model_cc\\\"):\\n # original (zero-origin) map and model\\n pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)\\n pdb_inp.write_pdb_file(file_name=\\\"%s_%s\\\"%(prefix,\\\"orig.pdb\\\"))\\n ph = pdb_inp.construct_hierarchy()\\n xrs = pdb_inp.xray_structure_simple()\\n fc = xrs.structure_factors(d_min=1.5).f_calc()\\n fft_map = fc.fft_map(resolution_factor = 0.25)\\n fft_map.apply_sigma_scaling()\\n map_data = fft_map.real_map_unpadded()\\n assert map_data.all() == (40, 45, 54)\\n assert map_data.origin() == (0, 0, 0)\\n assert map_data.focus() == (40, 45, 54)\\n write_ccp4_map(map_data=map_data, cs=xrs.crystal_symmetry(),\\n file_name=\\\"%s_%s\\\"%(prefix,\\\"orig.ccp4\\\"))\\n # shift origin of the map\\n g = flex.grid((-20,-25,-27), (20,20,27))\\n map_data.reshape(g)\\n assert map_data.all() == (40, 45, 54)\\n assert map_data.origin() == (-20, -25, -27)\\n assert map_data.focus() == (20, 20, 27)\\n write_ccp4_map(map_data=map_data, cs=xrs.crystal_symmetry(),\\n file_name=\\\"%s_%s\\\"%(prefix,\\\"shifted.ccp4\\\"))\\n # apply same shift to the model\\n a,b,c = xrs.crystal_symmetry().unit_cell().parameters()[:3]\\n N = map_data.all()\\n O=map_data.origin()\\n sites_cart = ph.atoms().extract_xyz()\\n sx,sy,sz = a/N[0]*O[0], b/N[1]*O[1], c/N[2]*O[2]\\n sites_cart_shifted = sites_cart+\\\\\\n flex.vec3_double(sites_cart.size(), [sx,sy,sz])\\n ph.atoms().set_xyz(sites_cart_shifted)\\n ph.write_pdb_file(file_name=\\\"%s_%s\\\"%(prefix,\\\"shifted.pdb\\\"))\\n # run phenix.real_space_refine\\n checked = 0\\n cmd = \\\" \\\".join([\\n \\\"phenix.map_model_cc\\\",\\n \\\"%s_shifted.pdb\\\"%prefix,\\n \\\"%s_shifted.ccp4\\\"%prefix,\\n \\\"resolution=1.5\\\",\\n \\\"> %s.zlog\\\"%prefix\\n ])\\n print cmd\\n easy_run.call(cmd)\\n # check results\\n fo = open(\\\"%s.zlog\\\"%prefix,\\\"r\\\")\\n for l in fo.readlines():\\n if(l.startswith(\\\" CC_mask :\\\")):\\n cc = float(l.split()[2])\\n assert cc>0.989\\n checked+=1\\n fo.close()\\n assert checked==1\\n # Exercise corresponding library function\\n params = mmtbx.maps.map_model_cc.master_params().extract()\\n params.map_model_cc.resolution=1.5\\n task_obj = mmtbx.maps.map_model_cc.map_model_cc(\\n map_data = map_data,\\n pdb_hierarchy = ph,\\n crystal_symmetry = xrs.crystal_symmetry(),\\n params = params.map_model_cc)\\n task_obj.validate()\\n task_obj.run()\\n result = task_obj.get_results()\\n assert approx_equal(result.cc_mask , 1.0, 1.e-3)\\n assert approx_equal(result.cc_peaks , 1.0, 1.e-3)\\n assert approx_equal(result.cc_volume, 1.0, 1.e-3)\",\n \"def process_file(cmap, source, destination):\\n line = source.readline()\\n while line:\\n destination.write(process_line(cmap, line))\\n line = source.readline()\\n\\n source.close()\\n destination.close()\",\n \"def fetchChannelMapping(verbose=False):\\n\\n # Check (from pbworks):\\n #High freq. 305 473 360 170.312 \\n #Medium freq. 154 424 209 140.820 \\n #Low freq. 079 400 134 126.172 \\n\\n calibrator_chans=[55, 57, 63, 66, 68, 69, 71, 72, 73, 76, 77, 79, 83, 84, 85, 86, 90, 92, 99, 100, 101, 103, 104, 107, 108, 110, 117, 119, 121, 122, 123, 126, 130, 131, 134, 136, 137, 140, 141, 145, 147, 150, 151, 156, 157, 161, 162, 168, 170, 175, 176, 178, 185, 188, 196, 197, 201, 202, 209, 213, 217, 221, 224, 230, 235, 238, 242, 246, 254, 255, 258, 259, 260, 264, 268, 269, 271, 274, 278, 279, 280, 283, 286, 291, 295, 297, 301, 306, 307, 312, 313, 314, 317, 319, 322, 323, 325, 328, 329, 332, 341, 343, 344, 346, 347, 352, 356, 360, 361, 364, 369, 371, 382, 383, 390, 398, 401, 404, 411, 412, 414, 419]\\n\\n lofar2beams={}; cal2field={}; field2cal={}; cal2lofar={}; field2lofar={}\\n\\n zero_chan=55\\n num_field_chans=366\\n num_total_chans=488\\n for nf in range(zero_chan,zero_chan+num_total_chans):\\n lofar_chan=nf\\n field_chan=lofar_chan-zero_chan\\n field2lofar[field_chan]=lofar_chan\\n if lofar_chan in calibrator_chans:\\n cal_chan=num_field_chans+calibrator_chans.index(lofar_chan)\\n if verbose:\\n print lofar_chan, field_chan, ' C ', cal_chan\\n lofar2beams[lofar_chan]=(field_chan,cal_chan)\\n cal2field[cal_chan]=field_chan\\n field2cal[field_chan]=cal_chan\\n cal2lofar[cal_chan]=lofar_chan\\n else:\\n if verbose:\\n print lofar_chan, lofar_chan-zero_chan, ' - ', ' - '\\n lofar2beams[lofar_chan]=(field_chan,None)\\n field2cal[field_chan]=None\\n\\n return lofar2beams,cal2field,field2cal,cal2lofar,field2lofar\",\n \"def idft_map(input_visibilities, output_map, input_uv):\\n m, n = output_map.shape\\n size = m * n\\n\\n x = Visibility.generate_xy(m, 1)\\n y = Visibility.generate_xy(n, 1)\\n\\n x, y = np.meshgrid(x, y)\\n x = x.reshape(size)\\n y = y.reshape(size)\\n\\n im = np.zeros(size)\\n\\n for i in range(size):\\n im[i] = (1 / input_visibilities.size) * np.sum(\\n input_visibilities * np.exp(\\n 2j * np.pi * (input_uv[0, :] * x[i] + input_uv[1, :] * y[i])))\\n\\n return im.reshape(m, n)\",\n \"def residmapComparison():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('dataFiles/6gev_image.fits')\\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = -25.0\\n vmax = 25.0\\n cbStep = 5.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Point Source ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Extended Source ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\\n plt.show()\",\n \"def test_read_mapping_directory(ref_mapping_directory):\\n dirpath, ref_mappings = ref_mapping_directory\\n from_names = list(ref_mappings.keys())\\n to_names = []\\n block_names = []\\n mapping = {}\\n weights = {}\\n\\n\\n for k in ref_mappings:\\n to_names.extend(ref_mappings[k].keys())\\n for to in ref_mappings[k]:\\n block_names.extend(ref_mappings[k][to].keys())\\n for block_name in ref_mappings[k][to]:\\n m, w, _ = ref_mappings[k][to][block_name]\\n mapping.update(m)\\n weights.update(w)\\n force_fields = case_to_dummy_ffs(from_names + to_names, block_names,\\n mapping, weights, [])\\n\\n\\n mappings = vermouth.map_input.read_mapping_directory(dirpath, force_fields)\\n compare_old_new_mappings(mappings, ref_mappings)\",\n \"def get_inputs_for_output(self, output):\\n for inps,out in self.io_mapping:\\n if type(output) == str:\\n if os.path.normpath(output) == os.path.normpath(out.get_name()):\\n return inps\\n else:\\n if out == output: \\n return inps\\n return output\",\n \"def testFilledExporter(self):\\n filename_a = os.path.join(FLAGS.test_tmpdir, 'test_a.far')\\n filename_b = os.path.join(FLAGS.test_tmpdir, 'test_b.far')\\n FLAGS.outputs = 'a=' + filename_a + ',b=' + filename_b\\n with self.assertRaises(SystemExit):\\n multi_grm.run(generator_method)\\n\\n stored_fsts_a = _read_fst_map(filename_a)\\n self.assertLen(stored_fsts_a, 1)\\n self.assertTrue(stored_fsts_a['FST1'])\\n\\n stored_fsts_b = _read_fst_map(filename_b)\\n self.assertLen(stored_fsts_b, 2)\\n self.assertTrue(stored_fsts_b['FST2'])\\n self.assertTrue(stored_fsts_b['FST3'])\",\n \"def _process_raw_output(self,\\r\\n raw_output_fp,\\r\\n log_fp,\\r\\n output_observation_map_fp):\\r\\n hits, failures = clusters_from_blast_uc_file(\\r\\n open(raw_output_fp, 'U'), 9)\\r\\n observation_map_f = open(output_observation_map_fp, 'w')\\r\\n for line in format_observation_map(hits.items(), ''):\\r\\n observation_map_f.write(line)\\r\\n observation_map_f.close()\",\n \"def FlowMapTwoColourComparisonWithCatchmentsHelper(self,ref_flowmap_filename,data_flowmap_filename,\\n ref_catchment_filename,data_catchment_filename,\\n ref_rdirs_filename,data_rdirs_filename,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n lsmask_filename=None,minflowcutoff=100,flip_data=False,\\n rotate_data=False,flip_ref=False,rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=True,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,matching_parameter_set='default',\\n rivers_to_plot=None,\\n rivers_to_plot_alt_color=None,\\n rivers_to_plot_secondary_alt_color=None,\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n additional_matches_list_filename=None,\\n additional_truesink_matches_list_filename=None,\\n catchment_and_outflows_mods_list_filename=None,\\n first_datasource_name=\\\"Reference\\\",\\n second_datasource_name=\\\"Data\\\",use_title=True,\\n remove_antartica=False,\\n difference_in_catchment_label=\\\"Discrepancy\\\",\\n glacier_mask_filename=None,\\n extra_lsmask_filename=None,\\n show_true_sinks=False,\\n fig_size=(12,5),\\n grid_type='HD',\\n glacier_mask_grid_type='LatLong10min',\\n glacier_mask_grid_kwargs={},\\n flip_glacier_mask=False,\\n rotate_glacier_mask=False,\\n **grid_kwargs):\\n if grid_type == \\\"LatLong10min\\\":\\n scale_factor = 3\\n else:\\n scale_factor = 1\\n if (rivers_to_plot_secondary_alt_color is not None):\\n if (rivers_to_plot is None) or (rivers_to_plot_alt_color is None):\\n raise RuntimeError(\\\"Invalid options - Secondary alternative color set when primary and/or\\\"\\n \\\"secondary colors unused\\\")\\n else:\\n rivers_to_plot_alt_color.extend(rivers_to_plot_secondary_alt_color)\\n else:\\n rivers_to_plot_secondary_alt_color = []\\n flowmap_grid=grid.makeGrid(grid_type)\\n ref_flowmaps_filepath = os.path.join(self.plots_data_dir,ref_flowmap_filename)\\n data_flowmaps_filepath = os.path.join(self.plots_data_dir,data_flowmap_filename)\\n ref_catchment_filepath = os.path.join(self.plots_data_dir,\\n ref_catchment_filename)\\n data_catchment_filepath = os.path.join(self.plots_data_dir,\\n data_catchment_filename)\\n flowmap_ref_field = iodriver.load_field(ref_flowmaps_filepath,\\n file_type=iodriver.get_file_extension(ref_flowmaps_filepath),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n flowmap_data_field = iodriver.load_field(data_flowmaps_filepath,\\n file_type=iodriver.get_file_extension(data_flowmaps_filepath),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n data_catchment_field = iodriver.load_field(data_catchment_filepath,\\n file_type=iodriver.get_file_extension(data_catchment_filepath),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n ref_catchment_field = iodriver.load_field(ref_catchment_filepath,\\n file_type=iodriver.get_file_extension(ref_catchment_filepath),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n if data_rdirs_filename:\\n data_rdirs_filepath = os.path.join(self.plots_data_dir,\\n data_rdirs_filename)\\n ref_rdirs_filepath = os.path.join(self.plots_data_dir,ref_rdirs_filename)\\n if data_rdirs_filename:\\n data_rdirs_field = iodriver.load_field(data_rdirs_filepath,\\n file_type=iodriver.get_file_extension(data_rdirs_filepath),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n else:\\n data_rdirs_field = None\\n ref_rdirs_field = iodriver.load_field(ref_rdirs_filepath,\\n file_type=iodriver.get_file_extension(ref_rdirs_filepath),\\n field_type='RiverDirections',\\n grid_type=grid_type,**grid_kwargs)\\n if lsmask_filename:\\n lsmask_field = iodriver.load_field(lsmask_filename,\\n file_type=iodriver.get_file_extension(lsmask_filename),\\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\\n else:\\n lsmask_field = field.Field(ref_rdirs_field.get_lsmask(),grid=\\\"LatLong10min\\\")\\n if extra_lsmask_filename:\\n extra_lsmask_field = iodriver.load_field(extra_lsmask_filename,\\n file_type=iodriver.\\n get_file_extension(extra_lsmask_filename),\\n field_type='Generic',\\n grid_type=grid_type,**grid_kwargs)\\n if catchment_and_outflows_mods_list_filename:\\n catchment_and_outflows_mods_list_filepath = os.path.join(self.catchment_and_outflows_mods_list_directory,\\n catchment_and_outflows_mods_list_filename)\\n if additional_matches_list_filename:\\n additional_matches_list_filepath = os.path.join(self.additional_matches_list_directory,\\n additional_matches_list_filename)\\n if additional_truesink_matches_list_filename:\\n additional_truesink_matches_list_filepath = os.path.join(self.additional_truesink_matches_list_directory,\\n additional_truesink_matches_list_filename)\\n if glacier_mask_filename:\\n glacier_mask_field = iodriver.load_field(glacier_mask_filename,\\n file_type=iodriver.\\\\\\n get_file_extension(glacier_mask_filename),\\n fieldname='sftgif',\\n field_type='Generic',\\n grid_type=glacier_mask_grid_type,\\n **glacier_mask_grid_kwargs)\\n if glacier_mask_grid_type != grid_type:\\n glacier_mask_field = utilities.upscale_field(glacier_mask_field,\\n output_grid_type=grid_type,\\n method=\\\"Mode\\\",\\n output_grid_kwargs=grid_kwargs,\\n scalenumbers=False)\\n else:\\n glacier_mask_field=None\\n if flip_data:\\n flowmap_data_field.flip_data_ud()\\n data_catchment_field.flip_data_ud()\\n if data_rdirs_filename:\\n data_rdirs_field.flip_data_ud()\\n if rotate_data:\\n flowmap_data_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n data_catchment_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if data_rdirs_filename:\\n data_rdirs_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if flip_ref:\\n flowmap_ref_field.flip_data_ud()\\n ref_catchment_field.flip_data_ud()\\n ref_rdirs_field.flip_data_ud()\\n if lsmask_filename and lsmask_has_same_orientation_as_ref:\\n lsmask_field.flip_data_ud()\\n if rotate_ref:\\n flowmap_ref_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n ref_catchment_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n ref_rdirs_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if lsmask_filename and lsmask_has_same_orientation_as_ref:\\n lsmask_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if invert_ls_mask:\\n lsmask_field.invert_data()\\n if extra_lsmask_filename:\\n extra_lsmask_field.invert_data()\\n if flip_lsmask and not lsmask_has_same_orientation_as_ref:\\n lsmask_field.flip_data_ud()\\n if rotate_lsmask and not lsmask_has_same_orientation_as_ref:\\n lsmask_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if glacier_mask_filename:\\n if flip_glacier_mask:\\n glacier_mask_field.flip_data_ud()\\n if rotate_glacier_mask:\\n glacier_mask_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n plt.figure(figsize=fig_size)\\n ax = plt.subplot(111)\\n if extra_lsmask_filename:\\n image_array,extra_lsmask =fmp_pts.\\\\\\n make_basic_flowmap_comparison_plot(ax,flowmap_ref_field.get_data(),\\n flowmap_data_field.get_data(),\\n minflowcutoff,\\n first_datasource_name,\\n second_datasource_name,\\n lsmask_field.get_data(),\\n return_image_array_instead_of_plotting=True,\\n glacier_mask=glacier_mask_field,\\n second_lsmask = extra_lsmask,\\n scale_factor=scale_factor)\\n else:\\n image_array =fmp_pts.\\\\\\n make_basic_flowmap_comparison_plot(ax,flowmap_ref_field.get_data(),\\n flowmap_data_field.get_data(),\\n minflowcutoff,\\n first_datasource_name,\\n second_datasource_name,\\n lsmask_field.get_data(),\\n return_image_array_instead_of_plotting=True,\\n glacier_mask=glacier_mask_field.get_data()\\n if glacier_mask_field is not None else None,\\n scale_factor=scale_factor)\\n temp_file_list = []\\n if catchment_and_outflows_mods_list_filename:\\n ref_outflow_field = iodriver.load_field(reference_rmouth_outflows_filename,\\n file_type=iodriver.\\\\\\n get_file_extension(reference_rmouth_outflows_filename),\\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\\n data_outflow_field = iodriver.load_field(data_rmouth_outflows_filename,\\n file_type=iodriver.\\\\\\n get_file_extension(data_rmouth_outflows_filename),\\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\\n if flip_data:\\n data_outflow_field.flip_data_ud()\\n if rotate_data:\\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n ref_catchment_field, ref_outflow_field, data_catchment_field, data_outflow_field =\\\\\\n rc_pts.modify_catchments_and_outflows(ref_catchment_field,ref_outflow_field,flowmap_ref_field,\\n ref_rdirs_field,data_catchment_field,data_outflow_field,\\n catchment_and_outflows_modifications_list_filename=\\\\\\n catchment_and_outflows_mods_list_filepath,\\n grid_type=grid_type)\\n if flip_data:\\n data_outflow_field.flip_data_ud()\\n if rotate_data:\\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n reference_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n data_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n temp_file_list.append(reference_rmouth_outflows_filename)\\n temp_file_list.append(data_rmouth_outflows_filename)\\n iodriver.write_field(reference_rmouth_outflows_filename,\\n field=ref_outflow_field,\\n file_type=iodriver.\\\\\\n get_file_extension(reference_rmouth_outflows_filename))\\n iodriver.write_field(data_rmouth_outflows_filename,\\n field=data_outflow_field,\\n file_type=iodriver.\\\\\\n get_file_extension(data_rmouth_outflows_filename))\\n #Using get data to convert field type causes confusion... possibly rewrite\\n if lsmask_filename:\\n lsmask = lsmask_field.get_data()\\n else:\\n lsmask = None\\n if extra_lsmask_filename:\\n extra_lsmask = extra_lsmask_field.get_data()\\n flowmap_ref_field = flowmap_ref_field.get_data()\\n flowmap_data_field = flowmap_data_field.get_data()\\n data_catchment_field = data_catchment_field.get_data()\\n ref_catchment_field = ref_catchment_field.get_data()\\n if data_rdirs_filename:\\n data_rdirs_field = data_rdirs_field.get_data()\\n ref_rdirs_field = ref_rdirs_field.get_data()\\n if glacier_mask_filename:\\n glacier_mask_field = glacier_mask_field.get_data()\\n matchedpairs,_ = mtch_rm.main(reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n flip_data_field=flip_data,\\n rotate_data_field=rotate_data,\\n flip_ref_field=flip_ref,\\n rotate_ref_field=rotate_ref,\\n param_set=matching_parameter_set,\\n grid_type=grid_type,**grid_kwargs)\\n if additional_matches_list_filename:\\n additional_matches = mtch_rm.load_additional_manual_matches(additional_matches_list_filepath,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n flip_data_field=flip_data,\\n rotate_data_field=rotate_data,\\n grid_type=grid_type,**grid_kwargs)\\n matchedpairs.extend(additional_matches)\\n if additional_truesink_matches_list_filename:\\n additional_matches = mtch_rm.load_additional_manual_truesink_matches(additional_truesink_matches_list_filepath,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n ref_flowmap_filename,\\n data_flowmap_filename,\\n flip_data_rmouth_outflow_field=\\\\\\n flip_data,\\n rotate_data_rmouth_outflow_field=\\\\\\n rotate_data,\\n flip_data_flowmap_field=\\\\\\n flip_data,\\n rotate_data_flowmap_field=\\\\\\n rotate_data,\\n grid_type=grid_type,\\n **grid_kwargs)\\n matchedpairs.extend(additional_matches)\\n for pair in matchedpairs:\\n if pair[0].get_lat() > 310*scale_factor:\\n continue\\n alt_color_num = 8\\n if (rivers_to_plot is not None) and (rivers_to_plot_alt_color is not None):\\n if ((not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot) and\\n (not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot_alt_color)):\\n continue\\n elif (((pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot) and\\n ((pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot_alt_color)):\\n raise RuntimeError(\\\"Cannot plot a catchment in both original and alternative colors - check for duplicate\\\")\\n elif ((pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot):\\n alt_color=False\\n elif ((pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot_secondary_alt_color):\\n alt_color=True\\n alt_color_num = 9\\n else:\\n alt_color=True\\n elif rivers_to_plot is not None:\\n alt_color = False\\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot:\\n continue\\n elif rivers_to_plot_alt_color is not None:\\n alt_color = True\\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot_alt_color:\\n continue\\n else:\\n alt_color = False\\n print(\\\"Ref Point: \\\" + str(pair[0]) + \\\"Matches: \\\" + str(pair[1]))\\n image_array = fmp_pts.add_selected_catchment_to_existing_plot(image_array,data_catchment_field,\\n ref_catchment_field,data_catchment_field,\\n flowmap_data_field, ref_rdirs_field,\\n data_rdirs_field, pair=pair,\\n catchment_grid_changed=False,\\n use_alt_color=alt_color,\\n alt_color_num=alt_color_num,\\n use_single_color_for_discrepancies=\\\\\\n use_single_color_for_discrepancies,\\n use_only_one_color_for_flowmap=\\\\\\n use_only_one_color_for_flowmap,\\n allow_new_sink_points=show_true_sinks,\\n grid_type=grid_type,\\n data_original_scale_grid_type=grid_type)\\n if extra_lsmask_filename:\\n image_array = fmp_pts.add_extra_flowmap(image_array,extra_lsmask)\\n if show_true_sinks:\\n image_array[np.logical_and(ref_rdirs_field == 5,\\n data_rdirs_field == 5)] = -4\\n image_array[np.logical_and(ref_rdirs_field == 5,\\n data_rdirs_field != 5)] = -5\\n image_array[np.logical_and(ref_rdirs_field != 5,\\n data_rdirs_field == 5)] = -6\\n if remove_antartica:\\n image_array = image_array[:320*scale_factor]\\n fmp_pts.plot_composite_image(ax,image_array,minflowcutoff,first_datasource_name,second_datasource_name,\\n use_single_color_for_discrepancies,use_only_one_color_for_flowmap,use_title,\\n colors=self.colors,difference_in_catchment_label=difference_in_catchment_label,\\n flowmap_grid=flowmap_grid,plot_glaciers=True if glacier_mask_filename else False,\\n second_ls_mask=True if extra_lsmask_filename else False,\\n show_true_sinks=show_true_sinks)\\n for temp_file in temp_file_list:\\n if os.path.basename(temp_file).startswith(\\\"temp_\\\"):\\n print(\\\"Deleting File: {0}\\\".format(temp_file))\\n os.remove(temp_file)\",\n \"def read_preprocessed_data(out_fp=\\\"/tmp/\\\"):\\r\\n # read mapping, and extract seqs\\r\\n # mapping has fasta_header like this:\\r\\n # > id: count\\r\\n\\r\\n seqs = dict([(a.split(':')[0], b) for (a, b) in\\r\\n (parse_fasta(open(out_fp + \\\"/prefix_dereplicated.fasta\\\")))])\\r\\n\\r\\n mapping = read_denoiser_mapping(open(out_fp + \\\"/prefix_mapping.txt\\\"))\\r\\n\\r\\n return(out_fp + \\\"/prefix_dereplicated.sff.txt\\\", len(mapping), mapping, seqs)\",\n \"def MakeFieldmaps(self):\\n if self.verbose:\\n print 'Compute fieldmaps.'\\n for entry in self.info:\\n if self.info[entry]['type'] == 'fmap':\\n if self.info[entry]['imgfile'] == None:\\n# Fieldmap data not found.\\n return\\n# Make a magnitude image for use in checking registration.\\n cmd = 'convert_file -f0 -m0 %s %s nii' % \\\\\\n (entry, self.info[entry]['magfile'])\\n self.CheckExec(cmd, [self.info[entry]['magfile'] + '.nii'])\\n\\n# Make fieldmap. Use separate loop in case make_fmap aborts.\\n for entry in self.info:\\n if self.info[entry]['type'] == 'fmap':\\n fmapname = self.info[entry]['imgfile']\\n if not os.path.exists('%s.nii' % fmapname) or self.redo:\\n# Couldn't find or existing fmap, compute a new one.\\n if self.verbose:\\n extra_args = '-v'\\n else:\\n extra_args = ''\\n if self.info[entry]['correct_fmap_phase'] == 'force':\\n extra_args += ' --force-slicecorr'\\n elif self.info[entry]['correct_fmap_phase'] == 'omit':\\n extra_args += ' --omit-slicecorr'\\n cmd = 'make_fmap %s %s %s' % (extra_args, entry, fmapname)\\n# error = self.ExecCmd(cmd, halt_on_error=False)\\n if self.no_fmapcorr:\\n halt_on_error = False\\n else:\\n halt_on_error = True\\n error = self.CheckExec(cmd, ['%s.nii' % fmapname], \\\\\\n halt_on_error=halt_on_error)\\n if error:\\n self.info[entry]['valid'] = False\\n del self.fmaps[entry]\",\n \"def read_orig_values(self):\\n\\n self.ovmap = {}\\n\\n for line in open(self.mname, 'r'):\\n featval, bits = line.strip().split(',')\\n feat, val = featval.split(':')\\n\\n for i, b in enumerate(bits):\\n f = '{0}:b{1}'.format(feat, i + 1)\\n v = self.fvmap.dir[(f, '1')]\\n\\n if v not in self.ovmap:\\n self.ovmap[v] = [feat]\\n\\n if -v not in self.ovmap:\\n self.ovmap[-v] = [feat]\\n\\n self.ovmap[v if b == '1' else -v].append(val)\",\n \"def mainFunction(f):\\n\\n #############################################################################\\n \\n \\n # biomass hexagon\\n predF = '/vol/v3/lt_stem_v3.1/models/biomassfiaald_20180708_0859/2000/biomassfiaald_20180708_0859_2000_mean.tif'\\n trainF = '/vol/v2/datasets/biomass/nbcd/fia_ald/nbcd_fia_ald_biomass_clipped_to_conus.tif'\\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\\n trainND = -32768\\n predND = -9999\\n trgField = 'id'\\n descrField = 'id'\\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/biomassfiaald_20180708_0859/hexagon_correlation'\\n xyLim = (500, 500)\\n xLab = 'Reference (tons/ha)'\\n yLab = 'Prediction (tons/ha)'\\n annoXY = (15,420)\\n \\n \\n \\\"\\\"\\\"\\n # cc\\n predF = '/vol/v3/lt_stem_v3.1/models/canopy_20180915_1631/2001/canopy_20180915_1631_2001_mean.tif'\\n trainF = '/vol/v2/stem/conus/reference_rasters/nlcd_2001_canopy_clipped_to_conus_train.tif'\\n #shpF = '/vol/v2/datasets/Eco_Level_III_US/us_eco_l3_no_states_multipart.shp'\\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\\n trainND = 255\\n predND = 255\\n trgField = 'id'\\n descrField = 'id'\\n #trgField = 'US_L3CODE'\\n #descrField = 'US_L3NAME'\\n #outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/ecoregion_correlation'\\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/hexagon_correlation'\\n xyLim = (100, 100)\\n xLab = 'Reference (%)'\\n yLab = 'Prediction (%)'\\n annoXY = (5,82)\\n \\\"\\\"\\\"\\n #############################################################################\\n\\n\\n # get color setup\\n norm = colors.Normalize(vmin=0, vmax=1)\\n f2rgb = cm.ScalarMappable(norm=norm, cmap=cm.get_cmap('YlGnBu_r'))\\n \\n # open the shapefile\\t\\n vDriver = ogr.GetDriverByName(\\\"ESRI Shapefile\\\")\\n vSrc = vDriver.Open(shpF, 0)\\n vLayer = vSrc.GetLayer()\\n \\n commonBox = get_intersec([predF, trainF])\\n\\n#for f in range(vLayer.GetFeatureCount()):\\n feature = vLayer[f]\\n name = feature.GetField(trgField)\\n print('f: '+str(f))\\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\\n if os.path.exists(outFig):\\n #break\\n return\\n \\n descr = feature.GetField(descrField)\\n \\n predP, coords = get_zone_pixels(feature, shpF, predF, 1, [commonBox[0], commonBox[2], commonBox[3], commonBox[1]])#.compressed() [commonBox[0], commonBox[2], commonBox[3], commonBox[1]]\\n trainP, coords = get_zone_pixels(feature, shpF, trainF, 1, [coords[0], coords[1], coords[2], coords[3]])#.compressed()\\n \\n predP = ma.masked_equal(predP, predND)\\n trainP = ma.masked_equal(trainP, trainND)\\n trainP = ma.masked_equal(trainP, 0)\\n\\n combMask = np.logical_not(np.logical_not(predP.mask) * np.logical_not(trainP.mask))\\n predP[combMask] = ma.masked\\n trainP[combMask] = ma.masked\\n predP = predP.compressed()\\n trainP = trainP.compressed()\\n if (predP.shape[0] == 0) | (trainP.shape[0] == 0) | (predP==0).all() | (trainP==0).all():\\n predP = np.array([0,0,1,1], dtype='float64')\\n trainP = np.array([0,0,1,1], dtype='float64')\\n mae = round(np.mean(np.absolute(np.subtract(predP, trainP))),1)\\n rmse = round(np.sqrt(np.mean((predP-trainP)**2)),1)\\n \\n\\n totPixs = trainP.shape[0]\\n sampSize = round(totPixs*1)\\n pickFrom = range(sampSize)\\n #sampIndex = np.random.choice(pickFrom, size=sampSize)\\n sampIndex = pickFrom\\n\\n r = round(np.corrcoef(trainP[sampIndex], predP[sampIndex])[0][1], 2)\\n if (mae == 0) & (r == 1):\\n r = 0.0\\n rColor = f2hex(f2rgb, r)\\n p = sns.jointplot(trainP[sampIndex], predP[sampIndex], kind=\\\"hex\\\", color='blue', xlim=(0,xyLim[0]), ylim=(0,xyLim[1]), size=5)\\n p.ax_joint.set_xlabel(xLab)\\n p.ax_joint.set_ylabel(yLab)\\n p.ax_joint.annotate('r: '+str(r)+'\\\\nrmse: '+str(rmse)+'\\\\nmae: '+str(mae), annoXY)\\n plt.tight_layout()\\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\\n p.savefig(outFig)\\n \\n df = pd.DataFrame({'id':name, 'descr':descr, 'r':r, 'rmse':rmse, 'mae':mae, 'color':rColor, 'img':os.path.basename(outFig)}, index=[0])\\n outCSV = outFig.replace('.png','.csv')\\n df.to_csv(outCSV, ',', index=False)\",\n \"def DNN_Spectral_Mapping(args):\\r\\n PATH_ROOT = os.getcwd()\\r\\n os.chdir(PATH_ROOT)\\r\\n\\r\\n # noisy_train ; input of DNN\\r\\n path_dnn_noisy_train = os.path.join(PATH_ROOT, args.input_noisy_train)\\r\\n dnn_magnitude_noisy_train,_,sr = perform_stft(path_dnn_noisy_train, args)\\r\\n # dnn_magnitude_noisy_train= splice_frames(dnn_magnitude_noisy_train.T, args.left_context, args.right_context).T\\r\\n\\r\\n # clean_train ; output of DNN\\r\\n path_dnn_clean_train = os.path.join(PATH_ROOT, args.input_clean_train)\\r\\n dnn_magnitude_clean_train,_,_ = perform_stft(path_dnn_clean_train, args)\\r\\n\\r\\n # noise_train\\r\\n path_noise = os.path.join(PATH_ROOT, args.input_noise)\\r\\n dnn_magnitude_noise_train,_,_ = perform_stft(path_noise, args)\\r\\n\\r\\n path_clean_test = os.path.join(PATH_ROOT , args.input_clean_test)\\r\\n (sr, clean_test) = wav.read(path_clean_test)\\r\\n\\r\\n # noisy_test\\r\\n path_noisy_test = os.path.join(PATH_ROOT, args.input_noisy_test)\\r\\n (sr, noisy_test) = wav.read(path_noisy_test)\\r\\n dnn_magnitude_noisy_test, dnn_phase_noisy_test, _ = perform_stft(path_noisy_test, args)\\r\\n # magnitude_noisy_test= splice_frames(magnitude_noisy_test.T, args.left_context, args.right_context).T\\r\\n\\r\\n X_train = np.log(dnn_magnitude_noisy_train.T**2)\\r\\n y_train = np.log(dnn_magnitude_clean_train.T**2)\\r\\n X_test = np.log(dnn_magnitude_noisy_test.T**2)\\r\\n\\r\\n # DNN training stage\\r\\n #####################################################################################\\r\\n k.clear_session()\\r\\n def get_dnn_model(X_train, y_train, args):\\r\\n # LeakyReLU, PReLU, ELU, ThresholdedReLU, SReLU\\r\\n model = Sequential()\\r\\n model.add(Dense(args.n_hidden, input_dim=X_train.shape[1], init='glorot_normal')) # glorot_normal,he_normal\\r\\n model.add(BatchNormalization())\\r\\n # model.add(Activation('relu'))\\r\\n model.add(LeakyReLU(alpha=0.1))\\r\\n model.add(Dropout(args.drop_out))\\r\\n\\r\\n model.add(Dense(args.n_hidden, init='glorot_normal'))\\r\\n model.add(BatchNormalization())\\r\\n # model.add(Activation('relu'))\\r\\n model.add(LeakyReLU(alpha=0.1))\\r\\n model.add(Dropout(args.drop_out))\\r\\n\\r\\n model.add(Dense(args.n_hidden, init='glorot_normal'))\\r\\n model.add(BatchNormalization())\\r\\n # model.add(Activation('relu'))\\r\\n model.add(LeakyReLU(alpha=0.1))\\r\\n model.add(Dropout(args.drop_out))\\r\\n\\r\\n model.add(Dense(units=y_train.shape[1], init='glorot_normal'))\\r\\n model.add(BatchNormalization())\\r\\n model.add(Activation('linear'))\\r\\n\\r\\n model.compile(loss='mse',\\r\\n optimizer='adam',\\r\\n metrics=['mse'])\\r\\n # model.summary()\\r\\n return model\\r\\n\\r\\n model = get_dnn_model(X_train, y_train, args)\\r\\n with tf.device('/gpu:0'):\\r\\n model_info = model.fit(X_train, y_train, batch_size=args.n_batch, epochs=args.n_epoch)\\r\\n # plot_model_history(model_info)\\r\\n print(\\\"Training complete.\\\")\\r\\n\\r\\n # Enhancement stage\\r\\n #####################################################################################\\r\\n magnitude_estimated_clean = model.predict(X_test).T\\r\\n magnitude_estimated_clean = np.exp(np.sqrt(magnitude_estimated_clean))\\r\\n # magnitude_estimated_clean = magnitude_estimated_clean.astype('int16')\\r\\n\\r\\n # magnitude_estimated_clean=norm(magnitude_estimated_clean)\\r\\n #Reconstruction\\r\\n stft_reconstructed_clean = merge_magphase(magnitude_estimated_clean, dnn_phase_noisy_test)\\r\\n signal_reconstructed_clean =librosa.istft(stft_reconstructed_clean, hop_length=args.hop_size, window=args.window)\\r\\n signal_reconstructed_clean = signal_reconstructed_clean.astype('int16')\\r\\n #####################################################################################\\r\\n output_path_estimated_noisy_test = os.path.join(PATH_ROOT, args.output_file)\\r\\n wav.write(output_path_estimated_noisy_test,sr,signal_reconstructed_clean)\\r\\n\\r\\n # Display signals, spectrograms\\r\\n show_signal(clean_test,noisy_test,signal_reconstructed_clean,sr)\\r\\n show_spectrogram(clean_test,noisy_test, signal_reconstructed_clean, sr, args.num_FFT,args.hop_size)\\r\\n # =============================================================================\\r\\n # PESQ\\r\\n # =============================================================================\\r\\n # PATH_MATLAB='\\\"C:/Program Files/MATLAB/R2014a/bin/matlab.exe\\\"'\\r\\n\\r\\n # PATH_MATLAB1 = os.path.join(PATH_ROOT , 'PESQ_MATLAB/execute_pesq.m')\\r\\n # from pymatbridge import Matlab\\r\\n # mlab = Matlab()\\r\\n # mlab = Matlab(executable=PATH_MATLAB)\\r\\n # mlab.start()\\r\\n\\r\\n # #PATH_MATLAB1 = os.path.join(PATH_ROOT , \\\"PESQ_MATLAB\\\",\\\"execute_pesq.m\\\")\\r\\n # result_PESQ = mlab.run_func(PATH_MATLAB1, {'arg1': sr})\\r\\n # noisy_original_PESQ = result_PESQ['result'][0][0]\\r\\n # enhanced_PESQ = result_PESQ['result'][1][0]\\r\\n # mlab.stop()\\r\\n\\r\\n # snr=args.input_noisy_test\\r\\n # name=snr[53:-9]\\r\\n # print(\\\"[%s]\\\\n Original: %.2f\\\\n Spectral-Mapping\\\\t: %.2f\\\"%(name,noisy_original_PESQ,enhanced_PESQ))\\r\",\n \"def _compute_maps_data(self, feature1, feature2, samples):\\n # TODO Refactor:\\n\\n # Reshape the data as ndimensional array. But account for the lower and upper bins.\\n coverage_data = np.zeros(shape=(feature1.num_cells, feature2.num_cells), dtype=int)\\n misbehaviour_data = np.zeros(shape=(feature1.num_cells, feature2.num_cells), dtype=int)\\n\\n coverage_outer_data = np.zeros(shape=(feature1.num_cells + 2, feature2.num_cells + 2), dtype=int)\\n misbehaviour_outer_data = np.zeros(shape=(feature1.num_cells + 2, feature2.num_cells + 2), dtype=int)\\n\\n for sample in samples:\\n\\n # Coordinates reason in terms of bins 1, 2, 3, while data is 0-indexed\\n x_coord = feature1.get_coordinate_for(sample, is_outer_map=False) - 1\\n y_coord = feature2.get_coordinate_for(sample, is_outer_map=False) - 1\\n\\n # Increment the coverage cell\\n coverage_data[x_coord, y_coord] += 1\\n\\n # Increment the misbehaviour cell\\n if sample.is_misbehavior():\\n misbehaviour_data[x_coord, y_coord] += 1\\n\\n # Outer Maps\\n x_coord = feature1.get_coordinate_for(sample, is_outer_map=True) - 1\\n y_coord = feature2.get_coordinate_for(sample, is_outer_map=True) - 1\\n\\n # Increment the coverage cell\\n coverage_outer_data[x_coord, y_coord] += 1\\n\\n # Increment the misbehaviour cell\\n if sample.is_misbehavior():\\n misbehaviour_outer_data[x_coord, y_coord] += 1\\n\\n return coverage_data, misbehaviour_data, coverage_outer_data, misbehaviour_outer_data\",\n \"def main(argv):\\r\\n\\r\\n mapperAbbrs = {'C':'cushaw', 'S':'shrimp', 'B':'bfast', 'W':'bwa-mem', 'N':'novoalign'}\\r\\n\\r\\n #Dictionary of commands to use for various mappers - configure your mapper commands here\\r\\n aligner_dict = {\\r\\n\\t'B,CS,S':[\\r\\n\\t\\t'bfast fasta2brg -f DDiFasta -A 0',\\r\\n\\t\\t'bfast fasta2brg -f DDiFasta -A 1',\\r\\n\\t\\t'bfast index -f DDiFasta -m 1111111111111111111111 -w 14 -i 1 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 111110100111110011111111111 -w 14 -i 2 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 10111111011001100011111000111111 -w 14 -i 3 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 1111111100101111000001100011111011 -w 14 -i 4 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 111111110001111110011111111 -w 14 -i 5 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 11111011010011000011000110011111111 -w 14 -i 6 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 1111111111110011101111111 -w 14 -i 7 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 111011000011111111001111011111 -w 14 -i 8 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 1110110001011010011100101111101111 -w 14 -i 9 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast index -f DDiFasta -m 111111001000110001011100110001100011111 -w 14 -i 10 -A 1 -n DDiProcs',\\r\\n\\t\\t'bfast match -f DDiFasta -A 1 -i 1-10 -k 18 -K 100000 -w 0 -t -n DDiProcs -Q 100000 -l -r DDiFastq1 > DDiBMF',\\r\\n\\t\\t'bfast localalign -f DDiFasta -m DDiBMF -A 1 -n DDiProcs -U -q 20 -Q 100000 -t > DDiBAF',\\r\\n\\t\\t'rm DDiBMF',\\r\\n\\t\\t'bfast postprocess -f DDiFasta -i DDiBAF -o DDiAligned -O 1 -a 3 -z -n DDiProcs -q 20 -Q 100000 -t > DDiSAM',\\r\\n\\t\\t'rm DDiBAF'\\r\\n\\t ],\\r\\n 'C,CS,S':[\\r\\n 'cushaw3 index DDiFasta -c -p bwtindex',\\r\\n 'cushaw3 calign -r bwtindex -f DDiFastq1 -t DDiProcs -multi 1 CushawOpts -o DDiSAM'\\r\\n ],\\r\\n 'C,NT,S':[\\r\\n 'cushaw3 index DDiFasta -p bwtindex',\\r\\n 'cushaw3 align -r bwtindex -f DDiFastq1 -t DDiProcs -multi 1 CushawOpts -o DDiSAM'\\r\\n ],\\r\\n 'C,NT,P':[\\r\\n 'cushaw3 index DDiFasta -p bwtindex',\\r\\n 'cushaw3 align -r bwtindex -q DDiFastq1 DDiFastq2 -t DDiProcs -multi 1 CushawOpts -o DDiSAM'\\r\\n ],\\r\\n 'S,CS,S':[\\r\\n 'gmapper-cs -N DDiProcs -Q -o 1 --strata --all-contigs ShrimpOpts DDiFastq1 DDiFasta > DDiSAM'\\r\\n ],\\r\\n 'S,NT,S':[\\r\\n 'gmapper-ls -N DDiProcs -Q -o 1 --strata --all-contigs ShrimpOpts DDiFastq1 DDiFasta > DDiSAM'\\r\\n ],\\r\\n 'S,NT,P':[\\r\\n 'gmapper-ls -N DDiProcs -Q -o 1 --strata --all-contigs ShrimpOpts -1 DDiFastq1 -2 DDiFastq2 DDiFasta > DDiSAM'\\r\\n ],\\r\\n\\t'W,NT,S':[\\r\\n 'bwa index DDiFasta',\\r\\n\\t 'bwa mem -t DDiProcs BwaMemOpts DDiFasta DDiFastq1 > DDiSAM'\\r\\n ],\\r\\n\\t'W,NT,P':[\\r\\n 'bwa index DDiFasta',\\r\\n\\t 'bwa mem -t DDiProcs BwaMemOpts DDiFasta DDiFastq1 DDiFastq2 > DDiSAM'\\r\\n ],\\r\\n\\t'N,NT,S':[\\r\\n\\t 'novoindex DDiNIX DDiFasta',\\r\\n 'novoalign -r Random -n 100 -o SAM -d DDiNIX -f DDiFastq1 > DDiSAM'\\r\\n ],\\r\\n\\t'N,NT,P':[\\r\\n\\t 'novoindex DDiNIX DDiFasta',\\r\\n 'novoalign -r Random -n 100 -o SAM NovoOpts -d DDiNIX -f DDiFastq1 DDiFastq2 > DDiSAM'\\r\\n ]\\r\\n }\\r\\n\\r\\n #Arguments that are required\\r\\n required = ['fastqFiles', 'mappingRefSeqFiles', 'outputDir']\\r\\n\\r\\n parser = argparse.ArgumentParser(description='Iteratively calls 3rd party mappers and DDiMap executable')\\r\\n\\r\\n #Argument options\\r\\n parser.add_argument('-q', type=str, metavar='file', nargs='+', help='list of fastq files', dest='fastqFiles')\\r\\n parser.add_argument('-r', type=str, metavar='file', nargs='+', help='list of files to use for reference sequences', dest='mappingRefSeqFiles')\\r\\n parser.add_argument('-j', type=str, metavar='file', nargs='+', help='list of files to use for junctions', dest='junctionRefSeqFiles')\\r\\n parser.add_argument('-o', type=str, metavar='directory', help='output directory', dest='outputDir')\\r\\n \\r\\n group = parser.add_mutually_exclusive_group()\\r\\n group.add_argument('-p', '--paired', action='store_true', help='fastq files have paired ends', dest='pairedEnds')\\r\\n group.add_argument('-s', '--single', action='store_false', help='fastq files have single ends', dest='pairedEnds')\\r\\n parser.add_argument('-n', type=int, metavar='cpus', help='number of processors to use', dest='nProcs')\\r\\n parser.add_argument('-c', type=str, metavar='config_file', help='location of config file', dest='configFile')\\r\\n parser.add_argument('-v', action='store_true', help='turns on verbosity', dest='verbose')\\r\\n\\r\\n parser.add_argument('--aligner_order', type=str, metavar='{'+','.join(mapperAbbrs.keys())+'}', help='mapper sequence as a string. ie CSC', dest='alignerOrder')\\r\\n parser.add_argument('--first_iter', metavar='n', type=int, help='first iteration', dest='firstIter')\\r\\n parser.add_argument('--max_iters', metavar='n', type=int, help='maximum iterations', dest='maxIters')\\r\\n parser.add_argument('--read_length', metavar='n', type=int, help='read length', dest='readLength')\\r\\n parser.add_argument('--read_type', type=str, help='read type', choices=['CS','NT'], dest='readType')\\r\\n parser.add_argument('--req_frag_conv', help='require frags to converge as well as SNVs', action='store_true', dest='reqFragConv')\\r\\n parser.add_argument('--no-req_frag_conv', help='does not require frags to converge as well as SNVs', action='store_false', dest='reqFragConv')\\r\\n\\r\\n parser.add_argument('--frag_maker_thresh',type=float, metavar='threshold', help='verified frag maker threshold', dest='fragMakerThresh')\\r\\n parser.add_argument('--frag_thresh', type=float, metavar='threshold', help='unverified frag maker threshold', dest='fragThresh')\\r\\n parser.add_argument('--min_absolute_cover', type=int, metavar='n', help='minimum absolute cover', dest='minAbsoluteCover')\\r\\n parser.add_argument('--snv_thresh', type=float, metavar='threshold', help='SNV threshold', dest='SNVthresh')\\r\\n parser.add_argument('--snv_type2_thresh', type=float, metavar='threshold', help='SNV type 2 threshold', dest='SNVtype2thresh')\\r\\n parser.add_argument('--snv_type3_thresh', type=float, metavar='threshold', help='SNV type 3 threshold', dest='SNVtype3thresh')\\r\\n parser.add_argument('--roa_size', type=int, metavar='size', help='Size to use for region of analysis in DDiMAP', dest='roaSize')\\r\\n\\r\\n group = parser.add_mutually_exclusive_group()\\r\\n group.add_argument('--use_DI', action='store_true', help='use reads mapped with deletion and insertion', dest='useDI')\\r\\n group.add_argument('--no-use_DI', action='store_false', help='do not use reads mapped with deletion and insertion', dest='useDI')\\r\\n\\r\\n parser.add_argument('--cushaw_opts', type=str, metavar=\\\"'options'\\\", help='cushaw specific options', dest='cushawOpts')\\r\\n parser.add_argument('--shrimp_opts', type=str, metavar=\\\"'options'\\\", help='shrimp specific options', dest='shrimpOpts')\\r\\n parser.add_argument('--bwamem_opts', type=str, metavar=\\\"'options'\\\", help='bwa-mem specific options', dest='bwaMemOpts')\\r\\n parser.add_argument('--novo_opts', type=str, metavar=\\\"'options'\\\", help='novoalign specific options', dest='novoOpts')\\r\\n\\r\\n\\r\\n #Parse args and check for config file\\r\\n args = parser.parse_args()\\r\\n if args.configFile:\\r\\n configFile = args.configFile\\r\\n if not path.isfile(configFile):\\r\\n print 'config file specified, but not found'\\r\\n exit(1)\\r\\n else:\\r\\n configFile = 'DDiMap.cfg'\\r\\n\\r\\n #Read in settings from config file\\r\\n Settings = read_config(configFile)\\r\\n\\r\\n # Loop over each section and replace values with those passed in on command line. \\r\\n # Also create a local variable that matches the keys in the settings dictionary.\\r\\n\\r\\n for section in Settings.keys():\\r\\n for key in Settings[section].keys():\\r\\n if getattr(args, key):\\r\\n Settings[section][key] = getattr(args, key)\\r\\n exec '%s = Settings[section][key]' % key\\r\\n if key in required and not Settings[section][key]:\\r\\n print '%s not specified on command line or in config file. Aborting...' % key\\r\\n print Settings[section][key]\\r\\n parser.print_help()\\r\\n exit(1)\\r\\n if (type(Settings[section][key]) == list):\\r\\n Settings[section][key] = ', '.join(Settings[section][key])\\r\\n\\r\\n if useDI: # reads with CIGARs containing both I and D are processed\\r\\n kFlag='-k'\\r\\n else: # reads with CIGARs containing both I and D are not processed\\r\\n kFlag=''\\r\\n\\r\\n if pairedEnds:\\r\\n pair_str='P'\\r\\n else:\\r\\n pair_str='S'\\r\\n\\r\\n # do the work - set up for the iteration\\r\\n aligners = list(alignerOrder)\\r\\n iterMin = len(aligners)\\r\\n iterMax = max(maxIters, iterMin); # always do as many iters as are in alignerOrder string\\r\\n aligners = aligners + list(repeat(aligners[-1], iterMax - iterMin)) # define the aligner ID sequence to be used over the iterations\\r\\n\\r\\n\\r\\n # Make paths absolute\\r\\n fastqFiles = [path.abspath(x) for x in fastqFiles]\\r\\n mappingRefSeqFiles = [path.abspath(x) for x in mappingRefSeqFiles]\\r\\n junctionRefSeqFiles = [path.abspath(x) for x in junctionRefSeqFiles]\\r\\n outputDir = path.abspath(outputDir) + '/'\\r\\n\\r\\n # Make sure the output directory exists\\r\\n\\r\\n if not path.isdir(outputDir):\\r\\n makedirs(outputDir)\\r\\n\\r\\n # Write configuration file in outputDir\\r\\n write_config(outputDir, Settings)\\r\\n\\r\\n # INITIAL VALUES OF LOOP CONTROL PARAMETERS\\r\\n converged = False\\r\\n prevFragList = [] # this will be replaced by counts of fragments created for each baseline refernce sequence\\r\\n prevSNVList = [] # this will be replaced by counts of SNV candidates found for each baseline reference sequence\\r\\n\\r\\n thisIter = firstIter\\r\\n\\r\\n\\r\\n for RefSeqFile in fastqFiles:\\r\\n if not path.isfile(RefSeqFile):\\r\\n print 'Unable to find fastqFile at ' + RefSeqFile\\r\\n exit(1)\\r\\n\\r\\n # Delete old enhanced fast file if present. It should never be...\\r\\n\\r\\n enhancedFastaFile = outputDir + 'refSeqEnhanced.fa'\\r\\n if path.isfile(enhancedFastaFile): # see if one is already here - need to zap it\\r\\n remove(enhancedFastaFile) # remove if present because fastawrite appends to existing files\\r\\n output_handle = open(enhancedFastaFile, 'a')\\r\\n\\r\\n # Add reference sequences to file with _Ref tag\\r\\n RefSeqs=[]\\r\\n for RefSeqFile in mappingRefSeqFiles:\\r\\n\\tprint 'ref seq file = ' + RefSeqFile\\r\\n if not path.isfile(RefSeqFile):\\r\\n print 'Unable to find RefSeqFile at ' + RefSeqFile\\r\\n exit(1)\\r\\n RefSeqs = RefSeqs + list(SeqIO.parse(RefSeqFile, 'fasta'))\\r\\n if (RefSeqs):\\r\\n formattedRefSeqs = add_ref_tag(RefSeqs)\\r\\n SeqIO.write(formattedRefSeqs, output_handle, 'fasta') # modified MATLAB fastawrite to not put in extra newlines\\r\\n\\r\\n \\r\\n # Create junctions if they are needed and then add to ref seq file as mapping targets for chimeric reads\\r\\n RefSeqs=[]\\r\\n for RefSeqFile in junctionRefSeqFiles:\\r\\n if not path.isfile(RefSeqFile):\\r\\n print 'Unable to find RefSeqFile at ' + RefSeqFile\\r\\n exit(1)\\r\\n RefSeqs = RefSeqs + list(SeqIO.parse(RefSeqFile, 'fasta'))\\r\\n if (RefSeqs):\\r\\n formattedRefSeqs = add_ref_tag(RefSeqs)\\r\\n junctionSeqs = make_junctions(formattedRefSeqs,readLength);\\r\\n SeqIO.write(junctionSeqs, output_handle, 'fasta') # modified MATLAB fastawrite to not put in extra newlines\\r\\n\\r\\n output_handle.close() \\r\\n\\r\\n\\r\\n # allows restarts\\r\\n if thisIter > 1: # there is no previous iteration, so start fresh\\r\\n prevWorkingDir = outputDir + ('Gen%d/' % (thisIter-1))\\r\\n for i in range(1, thisIter):\\r\\n prevWorkingDir = '%sGen%d/' % (outputDir, i) \\r\\n fragFile = prevWorkingDir + 'fasta.fa'\\r\\n snvFile = prevWorkingDir + 'snv.csv'\\r\\n ddimap_convergence_test(fragFile, snvFile, prevFragList, prevSNVList, reqFragConv)\\r\\n\\r\\n\\r\\n while not converged and thisIter <= iterMax:\\r\\n \\r\\n print '======= Iteration %d of %d ========' % (thisIter, iterMax)\\r\\n\\r\\n # creates working dir if not present\\r\\n thisWorkingDir = outputDir + ('Gen%d/' % thisIter)\\r\\n if path.isdir(thisWorkingDir):\\r\\n rmtree(thisWorkingDir)\\r\\n makedirs(thisWorkingDir)\\r\\n \\r\\n # Delete old enhanced fast file if present. It should never be...\\r\\n enhancedFastaFile = thisWorkingDir + 'refSeqEnhanced.fa'\\r\\n if path.isfile(enhancedFastaFile): \\r\\n remove(enhancedFastaFile) \\r\\n copyfile(outputDir + 'refSeqEnhanced.fa', enhancedFastaFile)\\r\\n\\r\\n output_handle = open(enhancedFastaFile, 'a')\\r\\n \\r\\n # Append frags from previous iteration if any (these sequences are tagged as fragments when the file is written by DDiMAP)\\r\\n if (thisIter > 1):\\r\\n prevFragFile=prevWorkingDir + '/fasta.fa'\\r\\n if path.isfile(prevFragFile) and path.getsize(prevFragFile) > 0:\\r\\n fragSeqs=list(SeqIO.parse(prevFragFile, 'fasta'))\\r\\n SeqIO.write(fragSeqs, output_handle, 'fasta') # modified MATLAB fastawrite to not put in extra newlines\\r\\n\\r\\n output_handle.close() \\r\\n\\r\\n # Setup variables for aligner\\r\\n thisAligner=aligners[thisIter-1]\\r\\n thisAligned='DDiMAP_%s' % thisAligner\\r\\n \\r\\n if path.isfile(thisWorkingDir + 'mapper.log'):\\r\\n remove(thisWorkingDir + 'mapper.log')\\r\\n\\r\\n if not ','.join([thisAligner,readType,pair_str]) in aligner_dict.keys():\\r\\n print mapperAbbrs[thisAligner] + ' does not support ' + readType + ' read type with ' + ('paired ends' if pairedEnds else 'non paired ends')\\r\\n exit(1)\\r\\n\\r\\n\\r\\n # execute commands for aligner\\r\\n\\r\\n open(thisWorkingDir + 'mapper.log', 'w').close()\\r\\n if verbose:\\r\\n b=Popen(['tail', '-F', thisWorkingDir + 'mapper.log'])\\r\\n\\r\\n # set substitutions for aligner commands\\r\\n commandsubs={'DDiFastq1':fastqFiles[0], \\r\\n 'DDiProcs':nProcs, \\r\\n 'DDiFasta':enhancedFastaFile, \\r\\n 'DDiBMF':thisAligned + '.bmf', \\r\\n 'DDiBAF':thisAligned + '.baf', \\r\\n 'DDiSAM':thisAligned + '.sam',\\r\\n 'DDiNIX':thisAligned + '.nix', \\r\\n 'DDiAligned':thisAligned, \\r\\n 'CushawOpts':cushawOpts, \\r\\n 'ShrimpOpts':shrimpOpts, \\r\\n 'BwaMemOpts':bwaMemOpts, \\r\\n 'NovoOpts':novoOpts}\\r\\n\\r\\n if (len(fastqFiles) > 1):\\r\\n commandsubs['DDiFastq2']=fastqFiles[1]\\r\\n\\r\\n for command in aligner_dict[','.join([thisAligner,readType,pair_str])]:\\r\\n cmdlist=re.split('\\\\s*',command)\\r\\n #remove empty arguments and subsitute in values from commandsubs \\r\\n args=filter(None,[str(commandsubs[x]) if x in commandsubs.keys() else x for x in cmdlist])\\r\\n args=re.split('\\\\s*',' '.join(args)) \\r\\n print ' '.join(args) # output actual command\\r\\n if 'DDiFastq2' in args: #This hasn't been substituted because one wasn't provided\\r\\n print mapperAbbrs[thisAligner] + ' expects 2 fastq files for use with ' + readType + ' read type with ' + ('paired ends' if pairedEnds else 'non paired ends')\\r\\n exit(1)\\r\\n\\r\\n # Now we need to detect stdout redirection and do it properly using pOpen\\r\\n if '>' in args: \\r\\n i = args.index('>')\\r\\n outfile = args[i+1]\\r\\n del args[i:i+2]\\r\\n else:\\r\\n outfile = None\\r\\n \\r\\n log_file = open(thisWorkingDir + 'mapper.log', 'a')\\r\\n \\r\\n if (outfile):\\r\\n with open(thisWorkingDir + outfile, 'w') as output_file:\\r\\n a=Popen(args, cwd=thisWorkingDir, stdout=output_file, stderr=log_file)\\r\\n else:\\r\\n a=Popen(args, cwd=thisWorkingDir, stderr=log_file, stdout=log_file)\\r\\n\\r\\n success=a.wait()\\r\\n log_file.close()\\r\\n if not success == 0:\\r\\n print '*** mapper exited with error', success\\r\\n print 'See ' + thisWorkingDir + 'mapper.log' + ' for more details'\\r\\n exit(success)\\r\\n\\r\\n if verbose:\\r\\n b.terminate()\\r\\n # Perform sam to bam conversion for DDiMap\\r\\n args=['samtools', 'view', '-b', '-S', '-o', thisAligned + '.bam', thisAligned + '.sam']\\r\\n print ' '.join(args) \\r\\n\\r\\n open(thisWorkingDir + 'samtools.log', 'w').close()\\r\\n if verbose:\\r\\n b=Popen(['tail', '-F', thisWorkingDir + 'samtools.log'])\\r\\n log_file = open(thisWorkingDir + 'samtools.log', 'w')\\r\\n a=Popen(args, cwd=thisWorkingDir, stderr=log_file, stdout=log_file)\\r\\n success=a.wait()\\r\\n log_file.close()\\r\\n if verbose:\\r\\n b.terminate()\\r\\n if not success == 0:\\r\\n print '*** samtools exited with error', success\\r\\n print 'See ' + thisWorkingDir + 'samtools.log' + ' for more details' \\r\\n exit(success)\\r\\n # remove the uncompressed sam file\\r\\n args=['rm', thisAligned + '.sam'];\\r\\n a=Popen(args, cwd=thisWorkingDir)\\r\\n\\r\\n # now run the DDiMAP code\\r\\n thisAlignedFile = thisWorkingDir + thisAligned + '.bam'\\r\\n args = (['DDiMAP', kFlag, '-r', roaSize, '-f', enhancedFastaFile, '-b', \\r\\n thisAlignedFile, '-c', minAbsoluteCover, '-n', fragThresh, '-a', \\r\\n fragMakerThresh, '-p', SNVthresh, '-s', SNVtype2thresh, '-l', \\r\\n SNVtype3thresh, '-o', thisWorkingDir])\\r\\n args = [str(x) for x in args]\\r\\n print ' '.join(args)\\r\\n open(thisWorkingDir + 'DDiMap.log', 'w').close()\\r\\n if verbose:\\r\\n b=Popen(['tail', '-F', thisWorkingDir + 'DDiMap.log'])\\r\\n log_file = open(thisWorkingDir + 'DDiMap.log', 'a')\\r\\n a = Popen(args, cwd=thisWorkingDir, stdout=log_file, stderr=log_file)\\r\\n success=a.wait()\\r\\n if verbose:\\r\\n b.terminate()\\r\\n log_file.close()\\r\\n if not success == 0:\\r\\n print '*** DDiMap exited with error', success\\r\\n print 'See ' + thisWorkingDir + 'DDiMap.log' + ' for more details'\\r\\n exit(success)\\r\\n \\r\\n # now check for convergence\\r\\n \\r\\n fragFile = thisWorkingDir + 'fasta.fa'\\r\\n snvFile = thisWorkingDir + 'snv.csv'\\r\\n \\r\\n # call to the convergence test matlab function\\r\\n # result history kept in currFrags/prevFrags and currSNVs/prevSNVs\\r\\n \\r\\n if ddimap_convergence_test(fragFile, snvFile, prevFragList, prevSNVList, reqFragConv):\\r\\n print 'Convergence found. Stopping...'\\r\\n break\\r\\n\\r\\n prevWorkingDir = thisWorkingDir; # all done with the previous, this will be the next iteration previous directory\\r\\n thisIter = thisIter+1\\r\\n else:\\r\\n print 'Failed to converge'\\r\\n\\r\\n print '%10s %10s %10s' % ('Iteration', 'nFrags', 'nSNVs')\\r\\n for i, (frags, snvs) in enumerate(zip(prevFragList, prevSNVList)):\\r\\n print '%10d %10d %10d' % (i+1, sum(frags), sum(snvs))\\r\\n\\r\\n # put final results into outputDir\\r\\n # make renamed copies of the final iteration result files, naming them using\\r\\n copyfile(thisWorkingDir+'fasta.fa',outputDir+'convergedFrags.fa')\\r\\n copyfile(thisWorkingDir+'dictionary.csv',outputDir+'convergedDictionary.csv')\\r\\n copyfile(thisWorkingDir+'snv.csv',outputDir+'convergedSNVs.csv')\\r\\n copyfile(thisWorkingDir+'coverage.csv',outputDir+'convergedCoverage.csv')\\r\\n copyfile(thisWorkingDir+'refSeqEnhanced.fa',outputDir+'convergedEnhancedRefSeqs.fa')\",\n \"def readMappedData(options,phase):\\n whole_mapped_data={}\\n mapped_data_per_size_per_register={}\\n alignment_filename=options.output_directory+\\\"/\\\"+options.input_filename+\\\"_bowtie1.bwt\\\"\\n fhr=open(alignment_filename,\\\"r\\\")\\n for line in fhr:\\n try:\\n read_id, strand, chromosome, coordinate, sequence, quality, mapped_times = line.strip().split()\\n except ValueError:\\n print(line)\\n continue\\n try:\\n coordinate=int(coordinate)\\n mapped_times=int(mapped_times)+1\\n length=len(sequence)\\n except ValueError:\\n print(line)\\n continue\\n if strand==\\\"-\\\":\\n coordinate+=2\\n if chromosome not in whole_mapped_data:\\n whole_mapped_data[chromosome]={}\\n if coordinate not in whole_mapped_data[chromosome]: \\n whole_mapped_data[chromosome][coordinate]=0\\n whole_mapped_data[chromosome][coordinate]+=1\\n \\n if phase!=length:\\n continue\\n if chromosome not in mapped_data_per_size_per_register:\\n mapped_data_per_size_per_register[chromosome]={}\\n register=coordinate % length\\n if register not in mapped_data_per_size_per_register[chromosome]:\\n mapped_data_per_size_per_register[chromosome][register]={}\\n if coordinate not in mapped_data_per_size_per_register[chromosome][register]:\\n mapped_data_per_size_per_register[chromosome][register][coordinate]=0\\n mapped_data_per_size_per_register[chromosome][register][coordinate]+=1\\n if mapped_data_per_size_per_register[chromosome][register][coordinate]>2:\\n print(\\\"Trouble with alignments\\\",length,chromosome,register,coordinate)\\n \\n return whole_mapped_data,mapped_data_per_size_per_register\",\n \"def map(inputs, e0,e1,k):\\r\\n codebook = tf.cast(inputs[0][0:2 ** k], tf.float32)\\r\\n soft_map = tf.TensorArray(tf.float32, size=0, dynamic_size=True)\\r\\n for y in inputs[1]:\\r\\n Pxy_map = pyx(y, codebook, e0, e1)\\r\\n soft_map = soft_map.write(soft_map.size(), Pxy_map)\\r\\n\\r\\n soft_map = soft_map.stack()\\r\\n return soft_map\",\n \"def __init__(self, cls_filt: dict[str: np.ndarray], transfs: dict[str: np.ndarray], inoise: dict[str: np.ndarray or float]):\\n job = []\\n for f in transfs:\\n if f + f in cls_filt:\\n job.append(f)\\n\\n for i, f in enumerate(job):\\n assert (f + f) in cls_filt\\n assert f in transfs\\n assert f + f in inoise or f in inoise\\n if f in inoise:\\n inoise[f + f] = inoise[f]\\n for g in job: # always want f + g in the keys\\n if g != f:\\n for cl in [cls_filt, inoise]:\\n if g + f in cl:\\n cl[f + g] = cl[g + f]\\n if f + g in cl:\\n cl[g + f] = cl[f + g]\\n\\n lmaxs_wted = {field: len(transfs[field]) - 1 for field in job}\\n lmaxs_ivfs = {field: len(transfs[field]) - 1 for field in job}\\n\\n maps_labels = job # input map labels\\n alms_labels = job # filtered solutions labels\\n\\n lmax = np.max([lmax for lmax in lmaxs_ivfs.values()])\\n transfs_i = {lab: np.zeros(lmax + 1) for lab in transfs}\\n for lab in transfs:\\n ls = np.where(transfs[lab] != 0)\\n transfs_i[lab][ls] = 1. / transfs[lab][ls]\\n\\n self.job = job\\n self.maps_labels = maps_labels\\n\\n self.cls = cls_filt\\n self.inoise = inoise\\n\\n\\n self.lmax_wted = lmaxs_wted\\n self.lmax_ivfs = lmaxs_ivfs\\n self.mmax_ivfs = lmaxs_ivfs # not necessary\\n\\n self.nalm = len(job)\\n\\n self.transfs = transfs\\n self.transfs_i = transfs_i\\n\\n\\n print('OpFilt setup')\\n for f in self.job:\\n print(f + ' lmax %s' % lmaxs_ivfs[f])\\n print('expected input maps: ' + ' '.join(maps_labels))\\n print('filtered alms : ' + ' '.join(alms_labels))\\n\\n self._fal = None\\n self._fal = self._build_fal()\",\n \"def mapper2():\\n\\n # Takes in variables indicating whether it is foggy and/or rainy and\\n # returns a formatted key that you should output. The variables passed in\\n # can be booleans, ints (0 for false and 1 for true) or floats (0.0 for\\n # false and 1.0 for true), but the strings '0.0' and '1.0' will not work,\\n # so make sure you convert these values to an appropriate type before\\n # calling the function.\\n def format_key(fog, rain):\\n return '{}fog-{}rain'.format(\\n '' if fog else 'no',\\n '' if rain else 'no'\\n )\\n\\n for line in sys.stdin:\\n data = line.strip().split(',')\\n\\n if len(data) != 22 or data[5] != 'REGULAR':\\n continue\\n\\n print('{}\\\\t{}'.format(format_key(float(data[14]), float(data[15])), data[6]))\",\n \"def Mapping2Cmnd(decode_cfg, valuemapping, filename=\\\"\\\"):\\n if isinstance(decode_cfg, str):\\n decode_cfg = bytearray(decode_cfg)\\n\\n # get binary header data to use the correct version template from device\\n _, version, _, setting = GetTemplateSetting(decode_cfg)\\n\\n cmnds = {}\\n\\n if setting is not None:\\n # iterate through restore data mapping\\n for name in valuemapping:\\n # key must exist in both dict\\n if name in setting:\\n cmnds = SetCmnd(cmnds, name, setting[name], valuemapping, valuemapping[name], addroffset=0)\\n else:\\n if name != 'header':\\n exit(ExitCode.RESTORE_DATA_ERROR, \\\"Restore file '{}' contains obsolete name '{}', skipped\\\".format(filename, name), type_=LogType.WARNING, doexit=not args.ignorewarning)\\n\\n return cmnds\\n\\n else:\\n exit(ExitCode.UNSUPPORTED_VERSION,\\\"File '{}', Tasmota configuration version 0x{:x} not supported\\\".format(filename, version), type_=LogType.WARNING, doexit=not args.ignorewarning)\\n\\n return None\",\n \"def FlowMapTwoColourComparisonHelper(self,ref_filename,data_filename,lsmask_filename=None,\\n grid_type='HD',minflowcutoff=100,flip_data=False,\\n rotate_data=False,flip_ref=False,rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=True,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"Reference\\\",\\n second_datasource_name=\\\"Data\\\",\\n add_title=True,**kwargs):\\n flowmap_ref_field = iodriver.load_field(ref_filename,\\n file_type=iodriver.get_file_extension(ref_filename),\\n field_type='Generic',\\n grid_type=grid_type,**kwargs)\\n flowmap_data_field = iodriver.load_field(data_filename,\\n file_type=iodriver.get_file_extension(data_filename),\\n field_type='Generic',\\n grid_type=grid_type,**kwargs)\\n if lsmask_filename:\\n lsmask_field = iodriver.load_field(lsmask_filename,\\n file_type=iodriver.get_file_extension(lsmask_filename),\\n field_type='Generic', grid_type=grid_type,**kwargs)\\n if flip_data:\\n flowmap_data_field.flip_data_ud()\\n if rotate_data:\\n flowmap_data_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if flip_ref:\\n flowmap_ref_field.flip_data_ud()\\n if lsmask_filename and lsmask_has_same_orientation_as_ref:\\n lsmask_field.flip_data_ud()\\n if rotate_ref:\\n flowmap_ref_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if lsmask_filename and lsmask_has_same_orientation_as_ref:\\n lsmask_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if invert_ls_mask:\\n lsmask_field.invert_data()\\n if lsmask_filename:\\n lsmask = lsmask_field.get_data()\\n flowmap_ref_field = flowmap_ref_field.get_data()\\n flowmap_data_field = flowmap_data_field.get_data()\\n plt.figure(figsize=(20,8))\\n ax = plt.subplot(111)\\n fmp_pts.make_basic_flowmap_comparison_plot(ax,flowmap_ref_field,flowmap_data_field,minflowcutoff,\\n first_datasource_name,second_datasource_name,lsmask,\\n colors=self.colors,add_title=add_title)\",\n \"def ref_mapping_directory(tmpdir_factory):\\n basedir = tmpdir_factory.mktemp('data')\\n mapdir = basedir.mkdir('mappings')\\n\\n template = textwrap.dedent(\\\"\\\"\\\"\\n [ molecule ]\\n dummy_{0}\\n\\n [ from ]\\n {1}\\n\\n [ to ]\\n {2}\\n\\n [ atoms ]\\n 0 X1{0} A{0} B{0}\\n 1 X2{0} C{0} D{0}\\n \\\"\\\"\\\")\\n\\n mappings = collections.defaultdict(lambda: collections.defaultdict(dict))\\n\\n force_fields_from = ['ff{}'.format(i) for i in range(4)]\\n force_fields_to = force_fields_from + ['only_to']\\n force_fields_from = force_fields_from + ['only_from']\\n iterate_on = itertools.product(force_fields_from, force_fields_to, range(3))\\n for idx, (from_ff, to_ff, _) in enumerate(iterate_on):\\n mapfile = mapdir / 'file{}.map'.format(idx)\\n with open(str(mapfile), 'w') as outfile:\\n outfile.write(template.format(idx, from_ff, to_ff))\\n\\n mapping = {\\n (0, 'X1{}'.format(idx)): [(0, 'A{}'.format(idx)), (0, 'B{}'.format(idx))],\\n (0, 'X2{}'.format(idx)): [(0, 'C{}'.format(idx)), (0, 'D{}'.format(idx))],\\n }\\n weights = {\\n (0, 'A{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\\n (0, 'B{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\\n (0, 'C{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\\n (0, 'D{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\\n }\\n extra = []\\n mappings[from_ff][to_ff]['dummy_{}'.format(idx)] = (mapping, weights, extra)\\n\\n mappings = {from_ff: dict(to_ff) for from_ff, to_ff in mappings.items()}\\n\\n return Path(str(basedir)), mappings\",\n \"def test_combine_mappings(self):\\r\\n\\r\\n self.tmp_dir = mkdtemp(dir=\\\"./\\\", suffix=\\\"/\\\")\\r\\n\\r\\n combine_mappings(\\r\\n fasta,\\r\\n denoiser_mapping,\\r\\n denoised_seqs,\\r\\n otu_picker_map,\\r\\n self.tmp_dir)\\r\\n\\r\\n observed_otu_map = \\\"\\\".join(\\r\\n list(open(self.tmp_dir + \\\"/denoised_otu_map.txt\\\")))\\r\\n\\r\\n expected_otu_map = \\\"\\\"\\\"1:\\\\tS1_1\\\\tS1_2\\\\tS2_4\\\\tS2_5\\r\\n2:\\\\tS2_3\\\\tS1_6\\r\\n\\\"\\\"\\\"\\r\\n self.assertEqual(observed_otu_map, expected_otu_map)\\r\\n\\r\\n observed_fasta = \\\"\\\".join(\\r\\n list(open(self.tmp_dir + \\\"/denoised_all.fasta\\\")))\\r\\n expected_fasta = \\\"\\\"\\\">S1_1 Read1\\r\\nAAA\\r\\n>S1_2 Read2\\r\\nTTT\\r\\n>S2_3 Read3\\r\\nGGG\\r\\n\\\"\\\"\\\"\\r\\n self.assertEqual(observed_fasta, expected_fasta)\",\n \"def f2d(forfile, opath):\\n return f2suff(forfile, opath, 'd')\",\n \"def process(self):\\n coo_adj = sp.load_npz(os.path.join(self.raw_path, \\\"adj_full.npz\\\"))\\n g = from_scipy(coo_adj)\\n\\n features = np.load(os.path.join(self.raw_path, \\\"feats.npy\\\"))\\n features = F.tensor(features, dtype=F.float32)\\n\\n y = [-1] * features.shape[0]\\n with open(os.path.join(self.raw_path, \\\"class_map.json\\\")) as f:\\n class_map = json.load(f)\\n for key, item in class_map.items():\\n y[int(key)] = item\\n labels = F.tensor(np.array(y), dtype=F.int64)\\n\\n with open(os.path.join(self.raw_path, \\\"role.json\\\")) as f:\\n role = json.load(f)\\n\\n train_mask = np.zeros(features.shape[0], dtype=bool)\\n train_mask[role[\\\"tr\\\"]] = True\\n\\n val_mask = np.zeros(features.shape[0], dtype=bool)\\n val_mask[role[\\\"va\\\"]] = True\\n\\n test_mask = np.zeros(features.shape[0], dtype=bool)\\n test_mask[role[\\\"te\\\"]] = True\\n\\n g.ndata[\\\"feat\\\"] = features\\n g.ndata[\\\"label\\\"] = labels\\n g.ndata[\\\"train_mask\\\"] = generate_mask_tensor(train_mask)\\n g.ndata[\\\"val_mask\\\"] = generate_mask_tensor(val_mask)\\n g.ndata[\\\"test_mask\\\"] = generate_mask_tensor(test_mask)\\n\\n if self._reorder:\\n self._graph = reorder_graph(\\n g,\\n node_permute_algo=\\\"rcmk\\\",\\n edge_permute_algo=\\\"dst\\\",\\n store_ids=False,\\n )\\n else:\\n self._graph = g\",\n \"def gen_input(args, datareader, bkd_gids):\\n As = {}\\n Xs = {}\\n for gid in bkd_gids:\\n if gid not in As: As[gid] = torch.tensor(datareader.data['adj_list'][gid], dtype=torch.float)\\n if gid not in Xs: Xs[gid] = torch.tensor(datareader.data['features'][gid], dtype=torch.float)\\n Ainputs = {}\\n Xinputs = {}\\n \\n if args.gtn_input_type == '1hop':\\n for gid in bkd_gids:\\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n elif args.gtn_input_type == '2hop':\\n for gid in bkd_gids:\\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\\n torch.tensor(0.0, requires_grad=True))\\n As[gid].fill_diagonal_(0.0)\\n \\n for gid in bkd_gids:\\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n \\n elif args.gtn_input_type == '1hop_degree': \\n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\\n \\n for i in range(len(bkd_gids)):\\n gid = bkd_gids[i]\\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n \\n elif args.gtn_input_type == '2hop_degree':\\n for gid in bkd_gids:\\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\\n torch.tensor(0.0, requires_grad=True))\\n As[gid].fill_diagonal_(0.0)\\n \\n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\\n \\n for i in range(len(bkd_gids)):\\n gid = bkd_gids[i]\\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n else: raise NotImplementedError('not support other types of aggregated inputs')\\n\\n # pad each input into maxi possible size (N, N) / (N, F)\\n NodeMax = int(datareader.data['n_node_max'])\\n FeatDim = np.array(datareader.data['features'][0]).shape[1]\\n for gid in Ainputs.keys():\\n a_input = Ainputs[gid]\\n x_input = Xinputs[gid]\\n \\n add_dim = NodeMax - a_input.shape[0]\\n Ainputs[gid] = np.pad(a_input, ((0, add_dim), (0, add_dim))).tolist()\\n Xinputs[gid] = np.pad(x_input, ((0, add_dim), (0, 0))).tolist()\\n Ainputs[gid] = torch.tensor(Ainputs[gid])\\n Xinputs[gid] = torch.tensor(Xinputs[gid])\\n\\n return Ainputs, Xinputs\",\n \"def test_mapping(self, mapping: AbstractionMapping,\\n allow_multi_iteration=False) -> Dict[Tuple[SerializedType, SerializedType], Any]:\\n self.curr_mapping: AbstractionMapping = mapping\\n\\n icd = InterchangeDataset(mapping, self, collate_fn=self.collate_fn)\\n icd_dataloader = icd.get_dataloader(batch_size=self.batch_size, shuffle=False)\\n\\n results = {} # this accumulates all results\\n # dict of Tuple[keys] -> dict, usually\\n iteration = 0\\n while True:\\n # print(f\\\"======== iteration {iteration} ========\\\")\\n new_realizations: RealizationMapping = {}\\n total_new_realizations = 0\\n num_interventions = 0\\n results_total = 0\\n log.debug(f'Running DL with outer iteration {iteration}, DL size {len(icd_dataloader)}')\\n if iteration >= 2:\\n assert allow_multi_iteration, f'Loop will run more than 2 total iterations. This should happen only' \\\\\\n f'if intervening on multiple high level nodes simultaneously'\\n for batch in tqdm(icd_dataloader):\\n # batch is a list of dicts, each dict contains a batched low and high intervention\\n for minibatch in batch:\\n minibatch = {k: v.to(self.device) \\\\\\n if isinstance(v, (torch.Tensor, Intervention, GraphInput)) else v\\n for k, v in minibatch.items()}\\n\\n low_intervention = minibatch[\\\"low_intervention\\\"]\\n high_intervention = minibatch[\\\"high_intervention\\\"]\\n\\n actual_batch_size = low_intervention.get_batch_size()\\n num_interventions += actual_batch_size\\n\\n high_base_res, high_ivn_res = self.high_model.intervene_all_nodes(high_intervention)\\n low_base_res, low_ivn_res = self.low_model.intervene_all_nodes(low_intervention)\\n\\n if not high_intervention.is_empty():\\n new_results_ct = self._add_results(\\n results, high_intervention, low_intervention,\\n high_base_res, high_ivn_res, low_base_res, low_ivn_res,\\n actual_batch_size\\n )\\n results_total += new_results_ct\\n\\n realizations, num_new_realizations = \\\\\\n self._create_new_realizations(\\n icd, high_intervention, low_intervention,\\n high_ivn_res, low_ivn_res, actual_batch_size)\\n\\n total_new_realizations += num_new_realizations\\n merge_realization_mappings(new_realizations, realizations)\\n\\n log.debug(f'end of iter {iteration}; {total_new_realizations} new realizations')\\n if iteration == 0:\\n icd.did_empty_interventions = True\\n iteration += 1\\n if total_new_realizations == 0:\\n # if intervening on only 1 HL var, then will terminate after 2 loops\\n break\\n else:\\n icd.update_realizations(new_realizations)\\n\\n # potentially useful to not run out of cuda memory\\n del icd\\n del icd_dataloader\\n\\n log.info(f'looked at {results_total} total results')\\n\\n return results\",\n \"def edge_mapping(self):\\n ...\",\n \"def CC_2Dfilter(\\n h5path_labels,\\n map_propnames,\\n criteria,\\n h5path_int='',\\n slicedim=0,\\n usempi=False,\\n outputfile='',\\n protective=False,\\n ):\\n\\n (min_area,\\n max_area,\\n max_intensity_mb,\\n max_eccentricity,\\n min_solidity,\\n min_euler_number,\\n min_extent) = criteria\\n\\n # prepare mpi\\n mpi_info = utils.get_mpi_info(usempi)\\n\\n # TODO: check output path\\n\\n # open data for reading\\n h5file_mm, ds_mm, _, _ = utils.h5_load(h5path_labels, comm=mpi_info['comm'])\\n if h5path_int:\\n h5file_mb, ds_mb, _, _ = utils.h5_load(h5path_int, comm=mpi_info['comm'])\\n else:\\n ds_mb = None\\n # mask used as intensity image in mean_intensity criterium\\n\\n # get the maximum labelvalue in the input\\n root = h5path_labels.split('.h5')[0]\\n maxlabel = get_maxlabel(root, ds_mm)\\n\\n # prepare mpi\\n n_slices = ds_mm.shape[slicedim]\\n series = np.array(range(0, n_slices), dtype=int)\\n if mpi_info['enabled']:\\n series = utils.scatter_series(mpi_info, series)[0]\\n if mpi_info['rank'] == 0:\\n fws_reduced = np.zeros((maxlabel + 1, len(map_propnames)),\\n dtype='float')\\n else:\\n fws_reduced = None\\n\\n fws = np.zeros((maxlabel + 1, len(map_propnames)),\\n dtype='float')\\n\\n mapall = criteria.count(None) == len(criteria)\\n\\n # pick labels observing the constraints\\n go2D = ((max_eccentricity is not None) or\\n (min_solidity is not None) or\\n (min_euler_number is not None) or\\n mapall)\\n if go2D:\\n\\n for i in series:\\n slcMM = utils.get_slice(ds_mm, i, slicedim)\\n if h5path_int:\\n slcMB = utils.get_slice(ds_mb, i, slicedim) # , 'bool'\\n else:\\n slcMB = None\\n fws = check_constraints(slcMM, fws, map_propnames,\\n criteria, slcMB, mapall)\\n if mpi_info['enabled']:\\n mpi_info['comm'].Reduce(fws, fws_reduced, op=MPI.MAX, root=0)\\n else:\\n fws_reduced = fws\\n\\n else:\\n\\n if mpi_info['rank'] == 0:\\n fws = check_constraints(ds_mm, fws, map_propnames,\\n criteria, ds_mb, mapall)\\n fws_reduced = fws\\n\\n # write the forward maps to a numpy vector\\n if mpi_info['rank'] == 0:\\n slc = int(n_slices/2)\\n slcMM = ds_mm[slc, :, :]\\n slcMB = ds_mb[slc, :, :] if h5path_int else None\\n datatypes = get_prop_datatypes(slcMM, map_propnames, slcMB)\\n for i, propname in enumerate(map_propnames):\\n root = outputfile.split('.h5')[0]\\n nppath = '{}_{}.npy'.format(root, propname)\\n outarray = np.array(fws_reduced[:, i], dtype=datatypes[i])\\n np.save(nppath, outarray)\\n\\n # close and return\\n h5file_mm.close()\\n if h5path_int:\\n h5file_mb.close()\\n\\n if mpi_info['rank'] == 0:\\n return outarray\",\n \"def _mappings(self, inputs):\\n return self.mapbias + tensor.dot(\\n self._factorsX(inputs) * self._factorsY(inputs), self.whf_in.T)\",\n \"def doit(inputDir, outputDir=\\\"./\\\"):\\n\\n os.makedirs(outputDir)\\n\\n postprocessing.draw_map(\\n inputDir, os.path.join(outputDir, \\\"initial_map.pdf\\\"),\\n filePaths, state=\\\"initial\\\")\\n postprocessing.draw_map(\\n inputDir, os.path.join(outputDir, \\\"final_map.pdf\\\"),\\n filePaths, state=\\\"final\\\")\\n postprocessing.draw_map(\\n inputDir, os.path.join(outputDir, \\\"hardware_map.pdf\\\"),\\n filePaths, state=None)\\n\\n # Draw relaxation data\\n opsData = pd.read_csv(os.path.join(inputDir, filePaths[\\\"anneal_ops\\\"]))\\n determinedData = opsData[opsData[\\\"Determination\\\"] == 1]\\n numberOfPoints = 100\\n sliceStep = math.ceil((len(determinedData) - 1) / (numberOfPoints - 1))\\n figure, axes = postprocessing.plot_fitness(\\n list(determinedData[::sliceStep].index),\\n list(determinedData[::sliceStep][\\\"Transformed Clustering Fitness\\\"]),\\n list(determinedData[::sliceStep][\\\"Transformed Locality Fitness\\\"]))\\n del determinedData\\n figure.savefig(os.path.join(outputDir, \\\"fitness.pdf\\\"))\\n\\n # Draw determination data\\n figure, axes = postprocessing.plot_determination_histogram(\\n opsData[opsData[\\\"Determination\\\"] == 0].index, opsData.index.max())\\n figure.savefig(os.path.join(outputDir, \\\"determination.pdf\\\"))\\n\\n # Draw hardware node loading data\\n loadingData = pd.read_csv(os.path.join(inputDir,\\n filePaths[\\\"h_node_loading\\\"]))\\n figure, axes = postprocessing.plot_loading_histogram(\\n loadingData[\\\"Number of contained application nodes\\\"])\\n figure.savefig(os.path.join(outputDir, \\\"loading.pdf\\\"))\",\n \"def build_r_map(input_file: str, output_file: str, threshold: float):\\n\\n DataSiPM = db.DataSiPMsim_only('petalo', 0) # full body PET\\n DataSiPM_idx = DataSiPM.set_index('SensorID')\\n\\n try:\\n sns_response = pd.read_hdf(input_file, 'MC/sns_response')\\n except ValueError:\\n print(f'File {input_file} not found')\\n exit()\\n except OSError:\\n print(f'File {input_file} not found')\\n exit()\\n except KeyError:\\n print(f'No object named MC/sns_response in file {input_file}')\\n exit()\\n print(f'Analyzing file {input_file}')\\n\\n sel_df = rf.find_SiPMs_over_threshold(sns_response, threshold)\\n\\n particles = pd.read_hdf(input_file, 'MC/particles')\\n hits = pd.read_hdf(input_file, 'MC/hits')\\n events = particles.event_id.unique()\\n\\n true_r1, true_r2 = [], []\\n var_phi1, var_phi2 = [], []\\n var_z1, var_z2 = [], []\\n\\n touched_sipms1, touched_sipms2 = [], []\\n\\n for evt in events:\\n\\n ### Select photoelectric events only\\n evt_parts = particles[particles.event_id == evt]\\n evt_hits = hits [hits .event_id == evt]\\n select, true_pos = mcf.select_photoelectric(evt_parts, evt_hits)\\n if not select: continue\\n\\n sns_resp = sel_df[sel_df.event_id == evt]\\n if len(sns_resp) == 0: continue\\n\\n _, _, pos1, pos2, q1, q2 = rf.assign_sipms_to_gammas(sns_resp, true_pos, DataSiPM_idx)\\n\\n if len(pos1) > 0:\\n pos_phi = rf.from_cartesian_to_cyl(np.array(pos1))[:,1]\\n _, var_phi = rf.phi_mean_var(pos_phi, q1)\\n\\n pos_z = np.array(pos1)[:,2]\\n mean_z = np.average(pos_z, weights=q1)\\n var_z = np.average((pos_z-mean_z)**2, weights=q1)\\n r = np.sqrt(true_pos[0][0]**2 + true_pos[0][1]**2)\\n\\n var_phi1 .append(var_phi)\\n var_z1 .append(var_z)\\n touched_sipms1.append(len(pos1))\\n true_r1 .append(r)\\n\\n else:\\n var_phi1 .append(1.e9)\\n var_z1 .append(1.e9)\\n touched_sipms1.append(1.e9)\\n true_r1 .append(1.e9)\\n\\n if len(pos2) > 0:\\n pos_phi = rf.from_cartesian_to_cyl(np.array(pos2))[:,1]\\n _, var_phi = rf.phi_mean_var(pos_phi, q2)\\n\\n pos_z = np.array(pos2)[:,2]\\n mean_z = np.average(pos_z, weights=q2)\\n var_z = np.average((pos_z-mean_z)**2, weights=q2)\\n r = np.sqrt(true_pos[1][0]**2 + true_pos[1][1]**2)\\n\\n var_phi2 .append(var_phi)\\n var_z2 .append(var_z)\\n touched_sipms2.append(len(pos2))\\n true_r2 .append(r)\\n\\n else:\\n var_phi2 .append(1.e9)\\n var_z2 .append(1.e9)\\n touched_sipms2.append(1.e9)\\n true_r2 .append(1.e9)\\n\\n a_true_r1 = np.array(true_r1)\\n a_true_r2 = np.array(true_r2)\\n a_var_phi1 = np.array(var_phi1)\\n a_var_phi2 = np.array(var_phi2)\\n a_var_z1 = np.array(var_z1)\\n a_var_z2 = np.array(var_z2)\\n\\n a_touched_sipms1 = np.array(touched_sipms1)\\n a_touched_sipms2 = np.array(touched_sipms2)\\n\\n\\n np.savez(output_file, a_true_r1=a_true_r1, a_true_r2=a_true_r2, a_var_phi1=a_var_phi1, a_var_phi2=a_var_phi2, a_var_z1=a_var_z1, a_var_z2=a_var_z2, a_touched_sipms1=a_touched_sipms1, a_touched_sipms2=a_touched_sipms2)\",\n \"def _map_elements3(self, nid_map, model, unused_j, unused_dim_max,\\n nid_cp_cd, xref_loads=True):\\n settings = self.gui.settings # type: Settings\\n\\n # these normals point inwards\\n # 4\\n # / | \\\\\\n # / | \\\\\\n # 3-------2\\n # \\\\ | /\\n # \\\\ | /\\n # 1\\n _ctetra_faces = (\\n (0, 1, 2), # (1, 2, 3),\\n (0, 3, 1), # (1, 4, 2),\\n (0, 3, 2), # (1, 3, 4),\\n (1, 3, 2), # (2, 4, 3),\\n )\\n\\n # these normals point inwards\\n #\\n #\\n #\\n #\\n # /4-----3\\n # / /\\n # / 5 /\\n # / \\\\ /\\n # / \\\\ /\\n # 1---------2\\n _cpyram_faces = (\\n (0, 1, 2, 3), # (1, 2, 3, 4),\\n (1, 4, 2), # (2, 5, 3),\\n (2, 4, 3), # (3, 5, 4),\\n (0, 3, 4), # (1, 4, 5),\\n (0, 4, 1), # (1, 5, 2),\\n )\\n\\n # these normals point inwards\\n # /6\\n # / | \\\\\\n # / | \\\\\\n # 3\\\\ | \\\\\\n # | \\\\ /4-----5\\n # | \\\\/ /\\n # | / \\\\ /\\n # | / \\\\ /\\n # | / \\\\ /\\n # 1---------2\\n _cpenta_faces = (\\n (0, 2, 1), # (1, 3, 2),\\n (3, 4, 5), # (4, 5, 6),\\n\\n (0, 1, 4, 3), # (1, 2, 5, 4), # bottom\\n (1, 2, 5, 4), # (2, 3, 6, 5), # right\\n (0, 3, 5, 2), # (1, 4, 6, 3), # left\\n )\\n\\n # these normals point inwards\\n # 8----7\\n # /| /|\\n # / | / |\\n # / 5-/--6\\n # 4-----3 /\\n # | / | /\\n # | / | /\\n # 1-----2\\n _chexa_faces = (\\n (4, 5, 6, 7), # (5, 6, 7, 8),\\n (0, 3, 2, 1), # (1, 4, 3, 2),\\n (1, 2, 6, 5), # (2, 3, 7, 6),\\n (2, 3, 7, 6), # (3, 4, 8, 7),\\n (0, 4, 7, 3), # (1, 5, 8, 4),\\n (0, 6, 5, 4), # (1, 7, 6, 5),\\n )\\n\\n elements, nelements, unused_superelements = get_elements_nelements_unvectorized(model)\\n xyz_cid0 = self.xyz_cid0\\n pids_array = np.zeros(nelements, dtype='int32')\\n eids_array = np.zeros(nelements, dtype='int32')\\n mcid_array = np.full(nelements, -1, dtype='int32')\\n material_theta_array = np.full(nelements, np.nan, dtype='float32')\\n dim_array = np.full(nelements, -1, dtype='int32')\\n nnodes_array = np.full(nelements, -1, dtype='int32')\\n\\n # quality\\n min_interior_angle = np.zeros(nelements, 'float32')\\n max_interior_angle = np.zeros(nelements, 'float32')\\n dideal_theta = np.zeros(nelements, 'float32')\\n max_skew_angle = np.zeros(nelements, 'float32')\\n max_warp_angle = np.zeros(nelements, 'float32')\\n max_aspect_ratio = np.zeros(nelements, 'float32')\\n area = np.zeros(nelements, 'float32')\\n area_ratio = np.zeros(nelements, 'float32')\\n taper_ratio = np.zeros(nelements, 'float32')\\n min_edge_length = np.zeros(nelements, 'float32')\\n normals = np.full((nelements, 3), np.nan, 'float32')\\n\\n nids_list = []\\n ieid = 0\\n cell_offset = 0\\n\\n dtype = get_numpy_idtype_for_vtk()\\n\\n cell_types_array = np.zeros(nelements, dtype=dtype)\\n cell_offsets_array = np.zeros(nelements, dtype=dtype)\\n\\n cell_type_point = 1 # vtk.vtkVertex().GetCellType()\\n cell_type_line = 3 # vtk.vtkLine().GetCellType()\\n cell_type_tri3 = 5 # vtkTriangle().GetCellType()\\n cell_type_tri6 = 22 # vtkQuadraticTriangle().GetCellType()\\n cell_type_quad4 = 9 # vtkQuad().GetCellType()\\n #cell_type_quad8 = 23 # vtkQuadraticQuad().GetCellType()\\n cell_type_tetra4 = 10 # vtkTetra().GetCellType()\\n cell_type_tetra10 = 24 # vtkQuadraticTetra().GetCellType()\\n cell_type_pyram5 = 14 # vtkPyramid().GetCellType()\\n #cell_type_pyram13 = 27 # vtk.vtkQuadraticPyramid().GetCellType()\\n cell_type_penta6 = 13 # vtkWedge().GetCellType()\\n cell_type_penta15 = 26 # vtkQuadraticWedge().GetCellType()\\n cell_type_hexa8 = 12 # vtkHexahedron().GetCellType()\\n cell_type_hexa20 = 25 # vtkQuadraticHexahedron().GetCellType()\\n\\n # per gui/testing_methods.py/create_vtk_cells_of_constant_element_type\\n #1 = vtk.vtkVertex().GetCellType()\\n #3 = vtkLine().GetCellType()\\n #5 = vtkTriangle().GetCellType()\\n #9 = vtk.vtkQuad().GetCellType()\\n #10 = vtkTetra().GetCellType()\\n #vtkPenta().GetCellType()\\n #vtkHexa().GetCellType()\\n #vtkPyram().GetCellType()\\n\\n skipped_etypes = set()\\n all_nids = nid_cp_cd[:, 0]\\n ieid = 0\\n for eid, elem in sorted(elements.items()):\\n if ieid % 5000 == 0 and ieid > 0:\\n print(' map_elements = %i' % ieid)\\n etype = elem.type\\n nnodes = None\\n nids = None\\n pid = None\\n cell_type = None\\n inids = None\\n\\n dideal_thetai = np.nan\\n min_thetai = np.nan\\n max_thetai = np.nan\\n #max_thetai = np.nan\\n max_skew = np.nan\\n max_warp = np.nan\\n aspect_ratio = np.nan\\n areai = np.nan\\n area_ratioi = np.nan\\n taper_ratioi = np.nan\\n min_edge_lengthi = np.nan\\n normali = np.nan\\n if etype in ['CTRIA3', 'CTRIAR', 'CTRAX3', 'CPLSTN3', 'CPLSTS3']:\\n nids = elem.nodes\\n pid = elem.pid\\n cell_type = cell_type_tri3 # 5\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2, p3 = xyz_cid0[inids, :]\\n out = tri_quality(p1, p2, p3)\\n (areai, max_skew, aspect_ratio,\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi) = out\\n normali = np.cross(p1 - p2, p1 - p3)\\n if isinstance(elem.theta_mcid, float):\\n material_theta_array[ieid] = elem.theta_mcid\\n else:\\n mcid_array[ieid] = elem.theta_mcid\\n nnodes = 3\\n dim = 2\\n\\n elif etype in {'CQUAD4', 'CQUADR', 'CPLSTN4', 'CPLSTS4', 'CQUADX4',\\n 'CQUAD1'}: # nastran95\\n nids = elem.nodes\\n pid = elem.pid\\n cell_type = cell_type_quad4 #9\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2, p3, p4 = xyz_cid0[inids, :]\\n out = quad_quality(elem, p1, p2, p3, p4)\\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\\n normali = np.cross(p1 - p3, p2 - p4)\\n if isinstance(elem.theta_mcid, float):\\n material_theta_array[ieid] = elem.theta_mcid\\n else:\\n mcid_array[ieid] = elem.theta_mcid\\n nnodes = 4\\n dim = 2\\n\\n elif etype in ['CTRIA6']:\\n nids = elem.nodes\\n pid = elem.pid\\n if None in nids:\\n cell_type = cell_type_tri3\\n inids = np.searchsorted(all_nids, nids[:3])\\n nids = nids[:3]\\n p1, p2, p3 = xyz_cid0[inids, :]\\n nnodes = 3\\n else:\\n cell_type = cell_type_tri6\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2, p3, p4, unused_p5, unused_p6 = xyz_cid0[inids, :]\\n nnodes = 6\\n out = tri_quality(p1, p2, p3)\\n (areai, max_skew, aspect_ratio,\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi) = out\\n normali = np.cross(p1 - p2, p1 - p3)\\n if isinstance(elem.theta_mcid, float):\\n material_theta_array[ieid] = elem.theta_mcid\\n else:\\n mcid_array[ieid] = elem.theta_mcid\\n dim = 2\\n elif etype == 'CQUAD8':\\n nids = elem.nodes\\n pid = elem.pid\\n if None in nids:\\n cell_type = cell_type_tri3\\n inids = np.searchsorted(all_nids, nids[:4])\\n nids = nids[:4]\\n p1, p2, p3, p4 = xyz_cid0[inids, :]\\n nnodes = 4\\n else:\\n cell_type = cell_type_tri6\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2, p3, p4 = xyz_cid0[inids[:4], :]\\n nnodes = 8\\n out = quad_quality(elem, p1, p2, p3, p4)\\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\\n normali = np.cross(p1 - p3, p2 - p4)\\n if isinstance(elem.theta_mcid, float):\\n material_theta_array[ieid] = elem.theta_mcid\\n else:\\n mcid_array[ieid] = elem.theta_mcid\\n nnodes = 4\\n dim = 2\\n\\n elif etype == 'CSHEAR':\\n nids = elem.nodes\\n pid = elem.pid\\n cell_type = cell_type_quad4 #9\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2, p3, p4 = xyz_cid0[inids, :]\\n out = quad_quality(elem, p1, p2, p3, p4)\\n (areai, taper_ratioi, area_ratioi, max_skew, aspect_ratio,\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi, max_warp) = out\\n normali = np.cross(p1 - p3, p2 - p4)\\n nnodes = 4\\n dim = 2\\n\\n elif etype == 'CTETRA':\\n nids = elem.nodes\\n pid = elem.pid\\n if None in nids:\\n cell_type = cell_type_tetra4\\n nids = nids[:4]\\n nnodes = 4\\n else:\\n cell_type = cell_type_tetra10\\n nnodes = 10\\n inids = np.searchsorted(all_nids, nids)\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\\n _ctetra_faces, nids, nid_map, xyz_cid0)\\n dim = 3\\n\\n elif etype == 'CHEXA':\\n nids = elem.nodes\\n pid = elem.pid\\n if None in nids:\\n cell_type = cell_type_hexa8\\n nids = nids[:8]\\n nnodes = 8\\n else:\\n cell_type = cell_type_hexa20\\n nnodes = 20\\n inids = np.searchsorted(all_nids, nids)\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\\n _chexa_faces, nids, nid_map, xyz_cid0)\\n dim = 3\\n\\n elif etype == 'CPENTA':\\n nids = elem.nodes\\n pid = elem.pid\\n\\n if None in nids:\\n cell_type = cell_type_penta6\\n nids = nids[:6]\\n nnodes = 6\\n else:\\n cell_type = cell_type_penta15\\n nnodes = 15\\n\\n inids = np.searchsorted(all_nids, nids)\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\\n _cpenta_faces, nids, nid_map, xyz_cid0)\\n dim = 3\\n elif etype == 'CPYRAM':\\n # TODO: assuming 5\\n nids = elem.nodes\\n pid = elem.pid\\n if None in nids:\\n cell_type = cell_type_pyram5\\n nids = nids[:5]\\n nnodes = 5\\n else:\\n cell_type = cell_type_penta15\\n nnodes = 15\\n inids = np.searchsorted(all_nids, nids)\\n min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\\n _cpyram_faces, nids, nid_map, xyz_cid0)\\n dim = 3\\n elif etype in ['CELAS2', 'CELAS4', 'CDAMP4']:\\n # these can have empty nodes and have no property\\n # CELAS1: 1/2 GRID/SPOINT and pid\\n # CELAS2: 1/2 GRID/SPOINT, k, ge, and s\\n # CELAS3: 1/2 SPOINT and pid\\n # CELAS4: 1/2 SPOINT and k\\n nids = elem.nodes\\n assert nids[0] != nids[1]\\n if None in nids:\\n assert nids[0] is not None, nids\\n assert nids[1] is None, nids\\n nids = [nids[0]]\\n cell_type = cell_type_point\\n nnodes = 1\\n else:\\n nids = elem.nodes\\n assert nids[0] != nids[1]\\n cell_type = cell_type_line\\n nnodes = 2\\n inids = np.searchsorted(all_nids, nids)\\n pid = 0\\n dim = 0\\n elif etype in ['CBUSH', 'CBUSH1D', 'CBUSH2D',\\n 'CELAS1', 'CELAS3',\\n 'CDAMP1', 'CDAMP2', 'CDAMP3', 'CDAMP5',\\n 'CFAST', 'CGAP', 'CVISC']:\\n nids = elem.nodes\\n assert nids[0] != nids[1]\\n assert None not in nids, 'nids=%s\\\\n%s' % (nids, elem)\\n pid = elem.pid\\n cell_type = cell_type_line\\n inids = np.searchsorted(all_nids, nids)\\n nnodes = 2\\n dim = 0\\n elif etype in ['CBAR', 'CBEAM']:\\n nids = elem.nodes\\n pid = elem.pid\\n pid_ref = model.Property(pid)\\n areai = pid_ref.Area()\\n cell_type = cell_type_line\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2 = xyz_cid0[inids, :]\\n min_edge_lengthi = norm(p2 - p1)\\n nnodes = 2\\n dim = 1\\n elif etype in ['CROD', 'CTUBE']:\\n nids = elem.nodes\\n pid = elem.pid\\n pid_ref = model.Property(pid)\\n areai = pid_ref.Area()\\n cell_type = cell_type_line\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2 = xyz_cid0[inids, :]\\n min_edge_lengthi = norm(p2 - p1)\\n nnodes = 2\\n dim = 1\\n elif etype == 'CONROD':\\n nids = elem.nodes\\n areai = elem.Area()\\n pid = 0\\n cell_type = cell_type_line\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2 = xyz_cid0[inids, :]\\n min_edge_lengthi = norm(p2 - p1)\\n nnodes = 2\\n dim = 1\\n #------------------------------\\n # rare\\n #elif etype == 'CIHEX1':\\n #nids = elem.nodes\\n #pid = elem.pid\\n #cell_type = cell_type_hexa8\\n #inids = np.searchsorted(all_nids, nids)\\n #min_thetai, max_thetai, dideal_thetai, min_edge_lengthi = get_min_max_theta(\\n #_chexa_faces, nids, nid_map, xyz_cid0)\\n #nnodes = 8\\n #dim = 3\\n elif etype == 'CHBDYE':\\n #self.eid_map[eid] = ieid\\n eid_solid = elem.eid2\\n side = elem.side\\n element_solid = model.elements[eid_solid]\\n\\n mapped_inids = SIDE_MAP[element_solid.type][side]\\n side_inids = [nid - 1 for nid in mapped_inids]\\n nodes = element_solid.node_ids\\n\\n pid = 0\\n nnodes = len(side_inids)\\n nids = [nodes[inid] for inid in side_inids]\\n inids = np.searchsorted(all_nids, nids)\\n\\n if len(side_inids) == 4:\\n cell_type = cell_type_quad4\\n else:\\n msg = 'element_solid:\\\\n%s' % (str(element_solid))\\n msg += 'mapped_inids = %s\\\\n' % mapped_inids\\n msg += 'side_inids = %s\\\\n' % side_inids\\n msg += 'nodes = %s\\\\n' % nodes\\n #msg += 'side_nodes = %s\\\\n' % side_nodes\\n raise NotImplementedError(msg)\\n elif etype == 'GENEL':\\n nids = []\\n if len(elem.ul_nodes):\\n nids.append(elem.ul_nodes)\\n if len(elem.ud_nodes):\\n nids.append(elem.ud_nodes)\\n nids = np.unique(np.hstack(nids))\\n #print(elem.get_stats())\\n nids = nids[:2]\\n\\n areai = np.nan\\n pid = 0\\n cell_type = cell_type_line\\n inids = np.searchsorted(all_nids, nids)\\n p1, p2 = xyz_cid0[inids, :]\\n min_edge_lengthi = norm(p2 - p1)\\n nnodes = len(nids)\\n dim = 1\\n else:\\n #raise NotImplementedError(elem)\\n skipped_etypes.add(etype)\\n nelements -= 1\\n continue\\n #for nid in nids:\\n #assert isinstance(nid, integer_types), 'not an integer. nids=%s\\\\n%s' % (nids, elem)\\n #assert nid != 0, 'not a positive integer. nids=%s\\\\n%s' % (nids, elem)\\n\\n assert inids is not None\\n if not np.array_equal(all_nids[inids], nids):\\n msg = 'all_nids[inids]=%s nids=%s\\\\n%s' % (all_nids[inids], nids, elem)\\n raise RuntimeError(msg)\\n\\n assert cell_type is not None\\n assert cell_offset is not None\\n assert eid is not None\\n assert pid is not None\\n assert dim is not None\\n assert nnodes is not None\\n nids_list.append(nnodes)\\n nids_list.extend(inids)\\n normals[ieid] = normali\\n eids_array[ieid] = eid\\n pids_array[ieid] = pid\\n dim_array[ieid] = dim\\n cell_types_array[ieid] = cell_type\\n cell_offsets_array[ieid] = cell_offset # I assume the problem is here\\n cell_offset += nnodes + 1\\n self.eid_map[eid] = ieid\\n\\n min_interior_angle[ieid] = min_thetai\\n max_interior_angle[ieid] = max_thetai\\n dideal_theta[ieid] = dideal_thetai\\n max_skew_angle[ieid] = max_skew\\n max_warp_angle[ieid] = max_warp\\n max_aspect_ratio[ieid] = aspect_ratio\\n area[ieid] = areai\\n area_ratio[ieid] = area_ratioi\\n taper_ratio[ieid] = taper_ratioi\\n min_edge_length[ieid] = min_edge_lengthi\\n ieid += 1\\n\\n #print('self.eid_map =', self.eid_map)\\n\\n icells_zero = np.where(cell_types_array == 0)[0]\\n # TODO: I'd like to get rid of deep=1, but it'll crash the edges\\n deep = 1\\n if len(icells_zero):\\n icells = np.where(cell_types_array != 0)[0]\\n if len(icells) == 0:\\n self.log.error('skipped_etypes = %s' % skipped_etypes)\\n raise RuntimeError('there are no elements...')\\n eids_array = eids_array[icells]\\n pids_array = pids_array[icells]\\n #dim_array = pids_array[dim_array]\\n cell_types_array = cell_types_array[icells]\\n cell_offsets_array = cell_offsets_array[icells]\\n nnodes_array = nnodes_array[icells]\\n normals = normals[icells, :]\\n #deep = 1\\n #print('deep = %s' % deep)\\n if skipped_etypes:\\n self.log.error('skipped_etypes = %s' % list(skipped_etypes))\\n #print('skipped_etypes = %s' % skipped_etypes)\\n if len(pids_array) != nelements:\\n msg = 'nelements=%s len(pids_array)=%s' % (nelements, len(pids_array))\\n raise RuntimeError(msg)\\n if len(cell_offsets_array) != nelements:\\n msg = 'nelements=%s len(cell_offsets_array)=%s' % (nelements, len(cell_offsets_array))\\n raise RuntimeError(msg)\\n\\n nids_array = np.array(nids_list, dtype=dtype)\\n\\n #-----------------------------------------------------------------\\n # saving some data members\\n self.element_ids = eids_array\\n\\n #print('cell_types_array* = ', cell_types_array.tolist())\\n #print('cell_offsets_array* = ', cell_offsets_array.tolist())\\n\\n #-----------------------------------------------------------------\\n # build the grid\\n\\n #self.log.info('nids_array = %s' % nids_array)\\n #self.log.info('cell_offsets_array = %s' % cell_offsets_array)\\n #self.log.info('cell_types_array = %s' % cell_types_array)\\n\\n # Create the array of cells\\n cells_id_type = numpy_to_vtkIdTypeArray(nids_array, deep=1)\\n vtk_cells = vtk.vtkCellArray()\\n vtk_cells.SetCells(nelements, cells_id_type)\\n\\n # Cell types\\n vtk_cell_types = numpy_to_vtk(\\n cell_types_array, deep=deep,\\n array_type=vtk.vtkUnsignedCharArray().GetDataType())\\n\\n vtk_cell_offsets = numpy_to_vtk(cell_offsets_array, deep=deep,\\n array_type=vtk.VTK_ID_TYPE)\\n\\n grid = self.grid\\n #grid = vtk.vtkUnstructuredGrid()\\n grid.SetCells(vtk_cell_types, vtk_cell_offsets, vtk_cells)\\n\\n #-----------------------------------------------------------------\\n # fill the results\\n nid_to_pid_map = None\\n self.isubcase_name_map = {1: ['Nastran', '']}\\n icase = 0\\n cases = OrderedDict()\\n form = ['Geometry', None, []]\\n form0 = form[2]\\n\\n subcase_id = 0\\n\\n #nids_set = True\\n #if nids_set:\\n # this intentionally makes a deepcopy\\n #nids = np.array(nid_cp_cd[:, 0])\\n\\n # this intentionally makes a deepcopy\\n cds = np.array(nid_cp_cd[:, 2])\\n colormap = settings.colormap\\n nid_res = GuiResult(subcase_id, 'NodeID', 'NodeID', 'node', all_nids,\\n mask_value=0,\\n nlabels=None,\\n labelsize=None,\\n ncolors=None,\\n colormap=colormap,\\n data_format=None,\\n uname='GuiResult')\\n cases[icase] = (nid_res, (0, 'Node ID'))\\n form0.append(('Node ID', icase, []))\\n icase += 1\\n\\n if cds.max() > 0:\\n cd_res = GuiResult(0, header='NodeCd', title='NodeCd',\\n location='node', scalar=cds)\\n cases[icase] = (cd_res, (0, 'NodeCd'))\\n form0.append(('NodeCd', icase, []))\\n icase += 1\\n\\n eid_res = GuiResult(subcase_id, 'ElementID', 'ElementID', 'centroid', eids_array,\\n mask_value=0,\\n nlabels=None,\\n labelsize=None,\\n ncolors=None,\\n colormap=colormap,\\n data_format=None,\\n uname='GuiResult')\\n cases[icase] = (eid_res, (0, 'ElementID'))\\n form0.append(('ElementID', icase, []))\\n icase += 1\\n\\n is_element_dim = True\\n #if len(np.unique(dim_array)) > 1:\\n #dim_res = GuiResult(subcase_id, 'ElementDim', 'ElementDim', 'centroid', dim_array,\\n #mask_value=-1,\\n #nlabels=None,\\n #labelsize=None,\\n #ncolors=None,\\n #colormap=colormap,\\n #data_format=None,\\n #uname='GuiResult')\\n #cases[icase] = (dim_res, (0, 'ElementDim'))\\n #form0.append(('ElementDim', icase, []))\\n #icase += 1\\n\\n if nnodes_array.max() > -1:\\n nnodes_res = GuiResult(subcase_id, 'NNodes/Elem', 'NNodes/Elem',\\n 'centroid', nnodes_array,\\n mask_value=0,\\n nlabels=None,\\n labelsize=None,\\n ncolors=None,\\n colormap=colormap,\\n data_format=None,\\n uname='GuiResult')\\n cases[icase] = (nnodes_res, (0, 'NNodes/Elem'))\\n form0.append(('NNodes/Elem', icase, []))\\n icase += 1\\n\\n #pid_res = GuiResult(subcase_id, 'PropertyID', 'PropertyID', 'centroid', pids_array,\\n #mask_value=0,\\n #nlabels=None,\\n #labelsize=None,\\n #ncolors=None,\\n #colormap=colormap,\\n #data_format=None,\\n #uname='GuiResult')\\n #cases[icase] = (pid_res, (0, 'PropertyID'))\\n #form0.append(('PropertyID', icase, []))\\n #icase += 1\\n\\n if len(model.properties) and nelements and settings.nastran_is_properties:\\n icase, upids, pcomp, pshell, is_pshell_pcomp = self._build_properties(\\n model, nelements, eids_array, pids_array, cases, form0, icase)\\n icase = _build_materials(model, pcomp, pshell, is_pshell_pcomp,\\n cases, form0, icase)\\n try:\\n icase = _build_optimization(model, pids_array, upids,\\n nelements, cases, form0, icase)\\n except Exception:\\n #raise\\n s = StringIO()\\n traceback.print_exc(file=s)\\n sout = s.getvalue()\\n self.gui.log_error(sout)\\n print(sout)\\n\\n #if isgreater_int(mcid_array, -1):\\n #mcid_res = GuiResult(subcase_id, 'Material Coordinate System', 'MaterialCoord',\\n #'centroid', mcid_array,\\n #mask_value=-1,\\n #nlabels=None,\\n #labelsize=None,\\n #ncolors=None,\\n #colormap=colormap,\\n #data_format=None,\\n #uname='GuiResult')\\n #cases[icase] = (mcid_res, (0, 'Material Coordinate System'))\\n #form0.append(('Material Coordinate System', icase, []))\\n #icase += 1\\n\\n #if np.isfinite(theta_array).any():\\n #print('np.nanmax(theta_array) =', np.nanmax(theta_array))\\n #theta_res = GuiResult(subcase_id, 'Theta', 'Theta', 'centroid', theta_array,\\n #mask_value=None,\\n #nlabels=None,\\n #labelsize=None,\\n #ncolors=None,\\n #colormap=colormap,\\n #data_format=None,\\n #uname='GuiResult')\\n #cases[icase] = (theta_res, (0, 'Theta'))\\n #form0.append(('Theta', icase, []))\\n #icase += 1\\n\\n normal_mag = underflow_norm(normals, axis=1)\\n assert len(normal_mag) == nelements\\n normals /= normal_mag.reshape(nelements, 1)\\n i_not_nan = np.isnan(normal_mag)\\n\\n #if self.make_offset_normals_dim and nelements:\\n #material_coord = None\\n #icase, normals = _build_normals_quality(\\n #model, self.gui.eid_map, nelements, cases, form0, icase,\\n #xyz_cid0, material_coord, material_theta,\\n #min_interior_angle, max_interior_angle, dideal_theta,\\n #area, max_skew_angle, taper_ratio,\\n #max_warp_angle, area_ratio, min_edge_length, max_aspect_ratio,\\n #make_offset_normals_dim=self.make_offset_normals_dim)\\n #self.normals = normals\\n\\n #----------------------------------------------------------\\n\\n is_shell = False\\n if False in i_not_nan:\\n #max_normal = np.nanmax(normal_mag[i_not_nan])\\n #is_shell = np.abs(max_normal) > 0.\\n is_shell = True\\n is_solid = isfinite_and_nonzero(max_interior_angle)\\n #print('is_shell=%s is_solid=%s' % (is_shell, is_solid))\\n if is_shell:\\n nx_res = GuiResult(\\n 0, header='NormalX', title='NormalX',\\n location='centroid', scalar=normals[:, 0], data_format='%.2f')\\n ny_res = GuiResult(\\n 0, header='NormalY', title='NormalY',\\n location='centroid', scalar=normals[:, 1], data_format='%.2f')\\n nz_res = GuiResult(\\n 0, header='NormalZ', title='NormalZ',\\n location='centroid', scalar=normals[:, 2], data_format='%.2f')\\n nxyz_res = NormalResult(0, 'Normals', 'Normals',\\n nlabels=2, labelsize=5, ncolors=2,\\n colormap=colormap, data_format='%.1f',\\n uname='NormalResult')\\n\\n\\n area_res = GuiResult(0, header='Area', title='Area',\\n location='centroid', scalar=area)\\n min_edge_length_res = GuiResult(\\n 0, header='Min Edge Length', title='Min Edge Length',\\n location='centroid', scalar=min_edge_length)\\n\\n min_theta_res = GuiResult(\\n 0, header='Min Interior Angle', title='Min Interior Angle',\\n location='centroid', scalar=np.degrees(min_interior_angle))\\n max_theta_res = GuiResult(\\n 0, header='Max Interior Angle', title='Max Interior Angle',\\n location='centroid', scalar=np.degrees(max_interior_angle))\\n dideal_theta_res = GuiResult(\\n 0, header='Delta Ideal Angle', title='Delta Ideal Angle',\\n location='centroid', scalar=np.degrees(dideal_theta))\\n\\n skew = np.degrees(max_skew_angle)\\n skew_res = GuiResult(\\n 0, header='Max Skew Angle', title='MaxSkewAngle',\\n location='centroid', scalar=skew)\\n aspect_res = GuiResult(\\n 0, header='Aspect Ratio', title='AspectRatio',\\n location='centroid', scalar=max_aspect_ratio)\\n\\n form_checks = []\\n form0.append(('Element Checks', None, form_checks))\\n if is_element_dim:\\n form_checks.append(('ElementDim', icase, []))\\n\\n if self.make_offset_normals_dim and self.make_nnodes_result and 0: # pragma: no cover\\n nnodes_res = GuiResult(\\n 0, header='NNodes/Elem', title='NNodes/Elem',\\n location='centroid', scalar=nnodes_array)\\n form_checks.append(('NNodes', icase + 1, []))\\n cases[icase + 1] = (nnodes_res, (0, 'NNodes'))\\n icase += 1\\n\\n if self.make_offset_normals_dim or 1:\\n cases[icase + 1] = (nx_res, (0, 'NormalX'))\\n cases[icase + 2] = (ny_res, (0, 'NormalY'))\\n cases[icase + 3] = (nz_res, (0, 'NormalZ'))\\n cases[icase + 4] = (nxyz_res, (0, 'Normal'))\\n\\n form_checks.append(('NormalX', icase + 1, []))\\n form_checks.append(('NormalY', icase + 2, []))\\n form_checks.append(('NormalZ', icase + 3, []))\\n form_checks.append(('Normal', icase + 4, []))\\n\\n cases[icase + 5] = (area_res, (0, 'Area'))\\n cases[icase + 6] = (min_edge_length_res, (0, 'Min Edge Length'))\\n cases[icase + 7] = (min_theta_res, (0, 'Min Interior Angle'))\\n cases[icase + 8] = (max_theta_res, (0, 'Max Interior Angle'))\\n cases[icase + 9] = (dideal_theta_res, (0, 'Delta Ideal Angle'))\\n cases[icase + 10] = (skew_res, (0, 'Max Skew Angle'))\\n cases[icase + 11] = (aspect_res, (0, 'Aspect Ratio'))\\n\\n form_checks.append(('Area', icase + 5, []))\\n form_checks.append(('Min Edge Length', icase + 6, []))\\n form_checks.append(('Min Interior Angle', icase + 7, []))\\n form_checks.append(('Max Interior Angle', icase + 8, []))\\n form_checks.append(('Delta Ideal Angle', icase + 9, []))\\n form_checks.append(('Max Skew Angle', icase + 10, []))\\n form_checks.append(('Aspect Ratio', icase + 11, []))\\n icase += 12\\n\\n if np.any(np.isfinite(area_ratio)) and np.nanmax(area_ratio) > 1.:\\n arearatio_res = GuiResult(\\n 0, header='Area Ratio', title='Area Ratio',\\n location='centroid', scalar=area_ratio)\\n cases[icase] = (arearatio_res, (0, 'Area Ratio'))\\n form_checks.append(('Area Ratio', icase, []))\\n icase += 1\\n\\n if np.any(np.isfinite(taper_ratio)) and np.nanmax(taper_ratio) > 1.:\\n taperratio_res = GuiResult(\\n 0, header='Taper Ratio', title='Taper Ratio',\\n location='centroid', scalar=taper_ratio)\\n cases[icase] = (taperratio_res, (0, 'Taper Ratio'))\\n form_checks.append(('Taper Ratio', icase, []))\\n icase += 1\\n\\n if isfinite_and_nonzero(max_warp_angle):\\n warp_res = GuiResult(\\n 0, header='Max Warp Angle', title='MaxWarpAngle',\\n location='centroid', scalar=np.degrees(max_warp_angle))\\n cases[icase + 4] = (warp_res, (0, 'Max Warp Angle'))\\n form_checks.append(('Max Warp Angle', icase, []))\\n icase += 1\\n\\n #if (np.abs(xoffset).max() > 0.0 or np.abs(yoffset).max() > 0.0 or\\n #np.abs(zoffset).max() > 0.0):\\n # offsets\\n #offset_res = GuiResult(\\n #0, header='Offset', title='Offset',\\n #location='centroid', scalar=offset, data_format='%g')\\n #offset_x_res = GuiResult(\\n #0, header='OffsetX', title='OffsetX',\\n #location='centroid', scalar=xoffset, data_format='%g')\\n #offset_y_res = GuiResult(\\n #0, header='OffsetY', title='OffsetY',\\n #location='centroid', scalar=yoffset, data_format='%g')\\n #offset_z_res = GuiResult(\\n #0, header='OffsetZ', title='OffsetZ',\\n #location='centroid', scalar=zoffset, data_format='%g')\\n\\n #cases[icase] = (offset_res, (0, 'Offset'))\\n #cases[icase + 1] = (offset_x_res, (0, 'OffsetX'))\\n #cases[icase + 2] = (offset_y_res, (0, 'OffsetY'))\\n #cases[icase + 3] = (offset_z_res, (0, 'OffsetZ'))\\n\\n #form_checks.append(('Offset', icase, []))\\n #form_checks.append(('OffsetX', icase + 1, []))\\n #form_checks.append(('OffsetY', icase + 2, []))\\n #form_checks.append(('OffsetZ', icase + 3, []))\\n #icase += 4\\n\\n if self.make_xyz or IS_TESTING:\\n x_res = GuiResult(\\n 0, header='X', title='X',\\n location='node', scalar=xyz_cid0[:, 0], data_format='%g')\\n y_res = GuiResult(\\n 0, header='Y', title='Y',\\n location='node', scalar=xyz_cid0[:, 1], data_format='%g')\\n z_res = GuiResult(\\n 0, header='Z', title='Z',\\n location='node', scalar=xyz_cid0[:, 2], data_format='%g')\\n cases[icase] = (x_res, (0, 'X'))\\n cases[icase + 1] = (y_res, (0, 'Y'))\\n cases[icase + 2] = (z_res, (0, 'Z'))\\n form_checks.append(('X', icase + 0, []))\\n form_checks.append(('Y', icase + 1, []))\\n form_checks.append(('Z', icase + 2, []))\\n icase += 3\\n\\n elif is_solid:\\n # only solid elements\\n form_checks = []\\n form0.append(('Element Checks', None, form_checks))\\n\\n min_edge_length_res = GuiResult(\\n 0, header='Min Edge Length', title='Min Edge Length',\\n location='centroid', scalar=min_edge_length)\\n min_theta_res = GuiResult(\\n 0, header='Min Interior Angle', title='Min Interior Angle',\\n location='centroid', scalar=np.degrees(min_interior_angle))\\n max_theta_res = GuiResult(\\n 0, header='Max Interior Angle', title='Max Interior Angle',\\n location='centroid', scalar=np.degrees(max_interior_angle))\\n skew = 90. - np.degrees(max_skew_angle)\\n #skew_res = GuiResult(0, header='Max Skew Angle', title='MaxSkewAngle',\\n #location='centroid', scalar=skew)\\n if is_element_dim:\\n form_checks.append(('ElementDim', icase, []))\\n form_checks.append(('Min Edge Length', icase + 1, []))\\n form_checks.append(('Min Interior Angle', icase + 2, []))\\n form_checks.append(('Max Interior Angle', icase + 3, []))\\n form_checks.append(('Max Skew Angle', icase + 4, []))\\n cases[icase + 1] = (min_edge_length_res, (0, 'Min Edge Length'))\\n cases[icase + 2] = (min_theta_res, (0, 'Min Interior Angle'))\\n cases[icase + 3] = (max_theta_res, (0, 'Max Interior Angle'))\\n #cases[icase + 4] = (skew_res, (0, 'Max Skew Angle'))\\n icase += 4\\n\\n else:\\n form0.append(('ElementDim', icase, []))\\n icase += 1\\n\\n if isgreater_int(mcid_array, -1):\\n material_coord_res = GuiResult(\\n 0, header='MaterialCoord', title='MaterialCoord',\\n location='centroid',\\n scalar=mcid_array, mask_value=-1, data_format='%i')\\n cases[icase] = (material_coord_res, (0, 'MaterialCoord'))\\n form0.append(('MaterialCoord', icase, []))\\n icase += 1\\n if isfinite(material_theta_array):\\n material_theta_res = GuiResult(\\n 0, header='MaterialTheta', title='MaterialTheta',\\n location='centroid',\\n scalar=material_theta_array, data_format='%.3f')\\n cases[icase] = (material_theta_res, (0, 'MaterialTheta'))\\n form0.append(('MaterialTheta', icase, []))\\n icase += 1\\n\\n #print(normals)\\n #----------------------------------------------------------\\n # finishing up vtk\\n if nelements and isfinite(min_edge_length):\\n mean_edge_length = np.nanmean(min_edge_length)\\n self.set_glyph_scale_factor(mean_edge_length * 2.5) # was 1.5\\n\\n grid.Modified()\\n #----------------------------------------------------------\\n # finishing up parameters\\n self.node_ids = all_nids\\n self.normals = normals\\n\\n return nid_to_pid_map, icase, cases, form\",\n \"def _gtTSmap(self):\\n if os.path.isfile(self.outtsmap):\\n # Already exists\\n return\\n\\n if self.csys == 'GAL':\\n center_icrs = SkyCoord(ra=self.ra*u.degree, dec=self.dec*u.degree, frame='icrs')\\n self.ra = center_icrs.galactic.l.deg\\n self.dec = center_icrs.galactic.b.deg\\n\\n model = os.path.join(self.workpath, 'TSmapModel.xml') \\n rfil = open(self.outmodel, 'r')\\n wfil = open(model, 'w')\\n isSrc = False\\n isDif = False\\n for line in rfil:\\n if (isSrc) and ('<source name' in line):\\n # Arrived to a new source, restart copying\\n isSrc = False\\n if (isDif) and ('<source name' in line) and ('PointSource' in line):\\n isDif = False\\n if 'TARGET' in line:\\n isSrc = True\\n if ('<source name=\\\"gll_iem_v06\\\"' in line) or ('<source name=\\\"iso_source_v06\\\"' in line): \\n isDif = True\\n \\n if isSrc:\\n # Do not copy the Target model to make it appear in the TS map\\n pass\\n else:\\n if isDif:\\n # Leave Diffuse model normalizations free\\n wfil.write(line)\\n else:\\n # Make sur the gtlike output source model has all source parameters fixed\\n wfil.write(line.replace('free=\\\"1\\\"', 'free=\\\"0\\\"'))\\n rfil.close()\\n wfil.close()\\n\\n # Launch the gttsmap tool \\n if self.mode == 'binned':\\n os.popen(\\\"gttsmap evfile={} scfile={} bexpmap={} expcube={} cmap={} srcmdl={}\\\\\\n outfile={} evtype={} irfs=CALDB optimizer=NewMinuit statistic=BINNED ftol=1e-2\\\\\\n coordsys={} proj=AIT nxpix={} nypix={} binsz={} xref={} yref={}\\\".format(self.outmktime,\\n self.ft2, self.outbinexp, self.outltcube, self.outbincub, model, self.outtsmap, self.evtype,\\n self.csys, self.imwid, self.imwid, self.binsz, self.ra, self.dec))\\n elif self.mode == 'unbinned':\\n os.popen(\\\"gttsmap evfile={} scfile={} expmap={} expcube={} srcmdl={}\\\\\\n outfile={} evtype={} irfs=CALDB optimizer=NewMinuit statistic=UNBINNED ftol=1e-2\\\\\\n coordsys={} proj=AIT nxpix={} nypix={} binsz={} xref={} yref={}\\\".format(self.outmktime,\\n self.ft2, self.outexpmap, self.outltcube, model, self.outtsmap, self.evtype,\\n self.csys, self.imwid, self.imwid, self.binsz, self.ra, self.dec))\\n else:\\n return\\n\\n if self.csys == 'GAL':\\n self.ra = center_icrs.ra.deg\\n self.dec = center_icrs.dec.deg\\n return\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CCLB').get('abstractTypes')\\n exolinks = globalMap.get('CCLB').get('exolinks')\\n\\n # Class AtomLabel\\n currentMap = {}\\n abstractTypes['AtomLabel'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'] = currentMap\\n loadMaps['CCLB.AtomLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'atomLabels'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AtomLabel.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AtomLabel.isotopeCode\\n currentMap = {}\\n contentMap['isotopeCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'] = currentMap\\n loadMaps['CCLB.AtomLabel.isotopeCode'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.isotopeCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'\\n currentMap['name'] = 'isotopeCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AtomLabel.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'] = currentMap\\n loadMaps['CCLB.AtomLabel.name'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AtomLabel.subType\\n currentMap = {}\\n contentMap['subType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'] = currentMap\\n loadMaps['CCLB.AtomLabel.subType'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.subType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'\\n currentMap['name'] = 'subType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['default'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute AtomLabel.weight\\n currentMap = {}\\n contentMap['weight'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'] = currentMap\\n loadMaps['CCLB.AtomLabel.weight'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.weight'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'\\n currentMap['name'] = 'weight'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 1.0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\\n\\n # Role AtomLabel.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of AtomLabel\\n\\n currentMap = abstractTypes.get('AtomLabel')\\n aList = ['isotopeCode', 'name', 'subType', 'weight']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ChemCompLabel\\n currentMap = {}\\n abstractTypes['ChemCompLabel'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'] = currentMap\\n loadMaps['CCLB.ChemCompLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemCompLabels'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemCompLabel.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemCompLabel.ccpCode\\n currentMap = {}\\n contentMap['ccpCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.ccpCode'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.ccpCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'\\n currentMap['name'] = 'ccpCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ChemCompLabel.molType\\n currentMap = {}\\n contentMap['molType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.molType'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.molType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'\\n currentMap['name'] = 'molType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\\n\\n # Role ChemCompLabel.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemCompLabel.isotopomers\\n currentMap = {}\\n contentMap['isotopomers'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.isotopomers'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.isotopomers'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'\\n currentMap['name'] = 'isotopomers'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of ChemCompLabel\\n\\n currentMap = abstractTypes.get('ChemCompLabel')\\n aList = ['ccpCode', 'molType']\\n currentMap['headerAttrs'] = aList\\n aList = ['isotopomers', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['isotopomers']\\n currentMap['children'] = aList\\n\\n # Class Isotopomer\\n currentMap = {}\\n abstractTypes['Isotopomer'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'] = currentMap\\n loadMaps['CCLB.Isotopomer'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'isotopomers'\\n currentMap['objkey'] = 'serial'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Isotopomer.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Isotopomer.serial\\n currentMap = {}\\n contentMap['serial'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'] = currentMap\\n loadMaps['CCLB.Isotopomer.serial'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.serial'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'\\n currentMap['name'] = 'serial'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Isotopomer.weight\\n currentMap = {}\\n contentMap['weight'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'] = currentMap\\n loadMaps['CCLB.Isotopomer.weight'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.weight'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'\\n currentMap['name'] = 'weight'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 1.0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\\n\\n # Role Isotopomer.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role Isotopomer.atomLabels\\n currentMap = {}\\n contentMap['atomLabels'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'] = currentMap\\n loadMaps['CCLB.Isotopomer.atomLabels'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.atomLabels'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'\\n currentMap['name'] = 'atomLabels'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of Isotopomer\\n\\n currentMap = abstractTypes.get('Isotopomer')\\n aList = ['serial', 'weight']\\n currentMap['headerAttrs'] = aList\\n aList = ['atomLabels', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['atomLabels']\\n currentMap['children'] = aList\\n\\n # Class LabelingScheme\\n currentMap = {}\\n abstractTypes['LabelingScheme'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'] = currentMap\\n loadMaps['CCLB.LabelingScheme'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'labelingSchemes'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute LabelingScheme.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute LabelingScheme.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'] = currentMap\\n loadMaps['CCLB.LabelingScheme.details'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute LabelingScheme.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute LabelingScheme.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.longName\\n currentMap = {}\\n contentMap['longName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'] = currentMap\\n loadMaps['CCLB.LabelingScheme.longName'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.longName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'\\n currentMap['name'] = 'longName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute LabelingScheme.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'] = currentMap\\n loadMaps['CCLB.LabelingScheme.name'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role LabelingScheme.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role LabelingScheme.chemCompLabels\\n currentMap = {}\\n contentMap['chemCompLabels'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'] = currentMap\\n loadMaps['CCLB.LabelingScheme.chemCompLabels'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.chemCompLabels'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'\\n currentMap['name'] = 'chemCompLabels'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of LabelingScheme\\n\\n currentMap = abstractTypes.get('LabelingScheme')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy', 'name']\\n currentMap['headerAttrs'] = aList\\n aList = ['details', 'longName']\\n currentMap['simpleAttrs'] = aList\\n aList = ['chemCompLabels', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['chemCompLabels']\\n currentMap['children'] = aList\\n\\n # Out-of-package link to AtomLabel\\n currentMap = {}\\n exolinks['AtomLabel'] = currentMap\\n loadMaps['CCLB.exo-AtomLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-AtomLabel'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\\n currentMap['name'] = 'AtomLabel'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n\\n # Out-of-package link to ChemCompLabel\\n currentMap = {}\\n exolinks['ChemCompLabel'] = currentMap\\n loadMaps['CCLB.exo-ChemCompLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-ChemCompLabel'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\\n currentMap['name'] = 'ChemCompLabel'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n\\n # Out-of-package link to Isotopomer\\n currentMap = {}\\n exolinks['Isotopomer'] = currentMap\\n loadMaps['CCLB.exo-Isotopomer'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-Isotopomer'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\\n currentMap['name'] = 'Isotopomer'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n\\n # Out-of-package link to LabelingScheme\\n currentMap = {}\\n exolinks['LabelingScheme'] = currentMap\\n loadMaps['CCLB.exo-LabelingScheme'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-LabelingScheme'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\\n currentMap['name'] = 'LabelingScheme'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\",\n \"def run(input_f, output_f):\\n with open(input_f) as f:\\n lines = f.readlines()\\n\\n # Collect the array dims\\n PE_defs = []\\n module_start = False\\n is_PE = False \\n PE_indices = []\\n for line_id in range(len(lines)):\\n line = lines[line_id]\\n if line.find('Module Definition') != -1:\\n module_start = not module_start\\n if module_start:\\n module_start_pos = line_id\\n is_PE = False\\n else:\\n module_end_pos = line_id\\n if is_PE:\\n PE_defs.append({'def': lines[module_start_pos : module_end_pos + 1], \\\\\\n 'pos': [module_start_pos, module_end_pos]})\\n if module_start:\\n #print(line_id)\\n nxt_line_id = line_id + 1\\n while nxt_line_id < len(lines): \\n nxt_line = lines[nxt_line_id]\\n if nxt_line.find('kernel void PE') != -1:\\n is_PE = True\\n m = re.search(r'void PE(.+?)\\\\(', nxt_line)\\n #print(nxt_line)\\n if m:\\n PE_index = m.group(1).split('_')[1:]\\n PE_indices.append(PE_index)\\n if is_PE:\\n break\\n if nxt_line.find('Module Definition') != -1:\\n break\\n nxt_line_id += 1\\n\\n #print(PE_indices)\\n PE_dims = [int(d) for d in PE_indices[0]]\\n for ind in PE_indices:\\n for dim in range(len(PE_dims)):\\n PE_dims[dim] = max(PE_dims[dim], int(ind[dim]) + 1)\\n #print(PE_dims)\\n \\n PE_lines = PE_defs[0]['def']\\n # Parse the data transfer information\\n data_trans_info = extract_data_trans_info(PE_lines, PE_dims) \\n\\n # Compose the new PE function\\n PE_lines = compose_PE(data_trans_info, PE_dims, PE_defs)\\n\\n line_offset = 0\\n for PE_def in PE_defs:\\n lines = lines[:PE_def['pos'][0] - line_offset] + lines[PE_def['pos'][1] + 1 - line_offset:]\\n line_offset += (PE_def['pos'][1] - PE_def['pos'][0] + 1)\\n\\n lines = lines + PE_lines\\n\\n # Modify the channels\\n lines = modify_channels(lines, data_trans_info, PE_dims)\\n\\n with open(output_f, 'w') as f:\\n for line in lines:\\n f.write(line)\\n # f.writelines(PE_lines)\",\n \"def load_ftmap(\\n *paths,\\n group=None,\\n max_cs=3,\\n plot=True,\\n plot_annot=True,\\n plot_class=None,\\n plot_method=\\\"overlap\\\",\\n table=True,\\n _self=pm,\\n):\\n if all(ch in \\\"1234567890\\\" for ch in paths[0]):\\n jobid = paths[0]\\n fp, temp = tempfile.mkstemp(suffix=\\\".pdb\\\")\\n open(fp).close()\\n session = requests.Session()\\n session.get(\\\"https://ftmap.bu.edu/nousername.php\\\")\\n with session.get(\\n f\\\"https://ftmap.bu.edu/file.php\\\"\\n f\\\"?jobid={jobid}\\\"\\n f\\\"&coeffi=0&model=0&filetype=model_file\\\",\\n stream=True,\\n ) as ret:\\n with open(temp, \\\"wb\\\") as fp:\\n shutil.copyfileobj(ret.raw, fp)\\n if not ret.content:\\n raise CmdException(f\\\"Invalid response id {jobid}\\\")\\n return process_session(\\n Kozakov2015Ensemble.collect_ftmap,\\n [temp],\\n group,\\n int(max_cs),\\n plot=plot,\\n plot_annot=bool(int(plot_annot)),\\n plot_class=plot_class,\\n table=table,\\n plot_method=plot_method,\\n base_root=\\\"fftmap\\\" + jobid,\\n )\\n return process_session(\\n Kozakov2015Ensemble.collect_ftmap,\\n paths,\\n group,\\n int(max_cs),\\n plot=plot,\\n plot_annot=bool(int(plot_annot)),\\n plot_class=plot_class,\\n table=table,\\n plot_method=plot_method,\\n )\",\n \"def loadSubjActFlowFC_NoHidden(subj,inputtype,fcdir):\\n \\n if inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:\\n h5f = h5py.File(fcdir + inputtype + 'ToOutputLayer_FC_subj' + subj + '.h5','r')\\n fcmapping = h5f['sourceToTargetMapping'][:].copy()\\n eigenvectors_input = h5f['eigenvectors'][:].copy()\\n h5f.close()\\n fc_input2output = fcmapping\\n\\n if inputtype=='12' or inputtype=='fpn' or inputtype=='nounimodal':\\n h5f = h5py.File(fcdir + '12RuleToOutputLayer_FC_subj' + subj + '.h5','r')\\n fcmapping = h5f['sourceToTargetMapping'][:].copy()\\n eigenvectors_input = h5f['eigenvectors'][:].copy()\\n h5f.close()\\n fc_input2output = fcmapping\\n\\n return fc_input2output, eigenvectors_input\",\n \"def initialize_undistortion_maps(self):\\n\\n new_camera_matrix, valid_roi = cv2.getOptimalNewCameraMatrix(\\n self.camera_matrix, self.distortion_coefficients, self.image_size,\\n 0)\\n\\n self.map1, self.map2 = cv2.initUndistortRectifyMap(\\n self.camera_matrix, self.distortion_coefficients, None,\\n new_camera_matrix, self.image_size, cv2.CV_16SC2)\",\n \"def create_dicts(self):\\n \\n # remove this string from filename to make output file names more manageable\\n pre_output1 = self.file1.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n pre_output2 = self.file2.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n \\n # Build the output file name.\\n # if prefix is present add it\\n if self.out_file_prefix is not None:\\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n # if no prefix don't add it!\\n else:\\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n\\n # add temp to end of file name to create a temporary output filename\\n self.tempoutputfilename = self.outputfilename.replace(\\\".txt\\\", '') + \\\"temp.txt\\\"\\n\\n # open temp output file\\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\\n\\n \\n # open FE files\\n file1_open = open(self.chosenfolder + self.file1, 'r')\\n file2_open = open(self.chosenfolder + self.file2, 'r')\\n\\n # open file1 and create a dict of the features.\\n for linenumber, line in enumerate(file1_open):\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file1_dict[int(splitline[1])] = line\\n # get n of rows in file1 (take the linenumber of the last line)\\n self.file1_len = linenumber\\n\\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \\\"header\\\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\\n for linenumber, line in enumerate(file2_open):\\n if linenumber < 10:\\n self.tempoutputfile.write(line)\\n # then add all features to a dictionary, with the unique feature number as a key\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file2_dict[int(splitline[1])] = line\\n # get n of rows in file2\\n self.file2_len = linenumber\\n\\n # close files\\n file1_open.close()\\n file2_open.close()\",\n \"def _update_farness_map(self,ind):\",\n \"def read_flat_map(filename,i_map=0) :\\n hdul=fits.open(filename)\\n w=WCS(hdul[0].header)\\n\\n maps=hdul[i_map].data\\n ny,nx=maps.shape\\n\\n return w,maps\",\n \"def deconv_compute_fusion_para(x, y):\\n input_memory_type = x.op.attrs[\\\"addr_type\\\"].value \\\\\\n if \\\"addr_type\\\" in x.op.attrs else 0\\n valid_shape = x.op.attrs[\\\"valid_shape\\\"] \\\\\\n if \\\"valid_shape\\\" in x.op.attrs else ()\\n slice_offset = x.op.attrs[\\\"slice_offset\\\"] \\\\\\n if \\\"slice_offset\\\" in x.op.attrs else ()\\n output_offset = y.get(\\\"slice_offset\\\") \\\\\\n if \\\"slice_offset\\\" in y else ()\\n l1_fusion_type = x.op.attrs[\\\"L1_fusion_type\\\"].value \\\\\\n if \\\"L1_fusion_type\\\" in x.op.attrs else -1\\n fmap_l1_addr_flag = x.op.attrs[\\\"L1_addr_flag\\\"].value \\\\\\n if \\\"L1_addr_flag\\\" in x.op.attrs else False\\n fmap_l1_valid_size = x.op.attrs[\\\"L1_valid_size\\\"].value\\\\\\n if \\\"L1_valid_size\\\" in x.op.attrs else 0\\n\\n l1_fusion_enable_flag = get_L1_info(\\\"L1_fusion_enabled\\\")\\n\\n if input_memory_type not in (0, 1, 2):\\n args_dict = {\\n \\\"errCode\\\": \\\"E65008\\\",\\n \\\"input_memory_type_range\\\": \\\"(0, 1, 2)\\\",\\n \\\"input_memory_type\\\": str(input_memory_type)\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n\\n if valid_shape and not slice_offset:\\n reason = \\\"valid shape exists, slice shape cannot be []\\\"\\n args_dict = {\\n \\\"errCode\\\": \\\"E60108\\\",\\n \\\"reason\\\": reason\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n if valid_shape and not output_offset:\\n reason = \\\"valid shape exists, output offset cannot be []\\\"\\n args_dict = {\\n \\\"errCode\\\": \\\"E60108\\\",\\n \\\"reason\\\": reason\\n }\\n raise RuntimeError(args_dict,\\n err_man.get_error_message(args_dict))\\n\\n valid_shape = shape_to_list(valid_shape)\\n slice_offset = shape_to_list(slice_offset)\\n output_offset = shape_to_list(output_offset)\\n\\n if not l1_fusion_enable_flag:\\n input_memory_type = 0\\n valid_shape = []\\n slice_offset = []\\n output_offset = []\\n l1_fusion_type = -1\\n fmap_l1_addr_flag = False\\n fmap_l1_valid_size = 0\\n\\n fusion_para = {\\\"input_memory_type\\\": input_memory_type,\\n \\\"output_memory_type\\\": \\\"fuse_flag\\\",\\n \\\"valid_shape\\\": valid_shape,\\n \\\"slice_offset\\\": slice_offset,\\n \\\"output_offset\\\": output_offset,\\n \\\"l1_fusion_type\\\": l1_fusion_type,\\n \\\"fmap_l1_addr_flag\\\": fmap_l1_addr_flag,\\n \\\"fmap_l1_valid_size\\\": fmap_l1_valid_size}\\n\\n return fusion_para\",\n \"def inferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping,\\n sequences_mapping, protein_mapping, verbose=False, throwOnMismatch=False, fileType=None):\\n import csv, os\\n\\n if fileType == \\\"simple\\\":\\n return simpleInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\\n elif fileType == \\\"traml\\\":\\n return tramlInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\\n elif fileType == \\\"sqmass\\\":\\n return sqlInferMapping(rawdata_files, aligned_pg_files, mapping, precursors_mapping, sequences_mapping, protein_mapping, verbose=verbose)\\n\\n nomatch_found = set([])\\n for file_nr, f in enumerate(aligned_pg_files):\\n header_dict = {}\\n if f.endswith('.gz'):\\n import gzip \\n filehandler = gzip.open(f,'rb')\\n else:\\n filehandler = open(f)\\n reader = csv.reader(filehandler, delimiter=\\\"\\\\t\\\")\\n header = next(reader)\\n for i,n in enumerate(header):\\n header_dict[n] = i\\n\\n if not \\\"align_origfilename\\\" in header_dict or not \\\"align_runid\\\" in header_dict:\\n\\n # Check whether we have a single mzML file and a single result\\n # file. If so, simply map these to each other.\\n if len(rawdata_files) == 1 and len(aligned_pg_files) == 1:\\n mapping[\\\"0_0\\\"] = rawdata_files\\n return\\n\\n print (header_dict)\\n raise Exception(\\\"need column header align_origfilename and align_runid\\\")\\n\\n for this_row in reader:\\n\\n if len(this_row) == 0: \\n continue\\n\\n # Get the transition mapping ... \\n mapRow(this_row, header_dict, precursors_mapping, sequences_mapping, protein_mapping)\\n\\n # 1. Get the original filename (find a non-NA entry) and the corresponding run id\\n aligned_fname, aligned_id = getAlignedFilename(this_row, header_dict)\\n\\n if aligned_id is None or aligned_id in mapping:\\n continue \\n\\n # 2. Go through all chromatogram input files and try to find\\n # one that matches the one from align_origfilename\\n for rfile in rawdata_files:\\n\\n # 2.1 remove common file endings from the raw data\\n rfile_base = os.path.basename(rfile)\\n for ending in [\\\".sqMass\\\", \\\".filter\\\", \\\".mzML\\\", \\\".chrom\\\"]:\\n rfile_base = rfile_base.split(ending)[0]\\n\\n # 2.3 Check if we have a match\\n if aligned_fname == rfile_base:\\n if verbose: \\n print(\\\"- Found match:\\\", os.path.basename(rfile), \\\"->\\\", os.path.basename(this_row[ header_dict[\\\"align_origfilename\\\"] ]))\\n mapping[aligned_id] = [rfile]\\n\\n if not aligned_id in mapping:\\n if True:\\n nomatch_found.update( [aligned_fname] )\\n if throwOnMismatch:\\n raise Exception(\\\"Mismatch, alignment filename could not be matched to input chromatogram\\\")\\n\\n if verbose:\\n print(\\\"- No match found for :\\\", list(nomatch_found), \\\"in any of\\\", \\\\\\n [os.path.basename(rfile) for rfile in rawdata_files])\\n print(\\\"- This may be a bad sign if you expected a match here. You might have \\\" +\\\\\\n \\\"to either rename your files to have matching filenames \\\" +\\\\\\n \\\"or provide an input yaml file describing the matching in detail.\\\")\",\n \"def WriteDepMappingFile(translated_source_files,\\n objc_file_path,\\n output_dependency_mapping_file,\\n file_open=open):\\n dep_mapping = dict()\\n input_file_queue = Queue.Queue()\\n output_dep_mapping_queue = Queue.Queue()\\n error_message_queue = Queue.Queue()\\n for output_file in translated_source_files.split(','):\\n input_file_queue.put(output_file)\\n\\n for _ in xrange(multiprocessing.cpu_count()):\\n t = threading.Thread(target=_ReadDepMapping, args=(input_file_queue,\\n output_dep_mapping_queue,\\n error_message_queue,\\n objc_file_path,\\n file_open))\\n t.start()\\n\\n input_file_queue.join()\\n\\n if not error_message_queue.empty():\\n error_messages = [error_message for error_message in\\n error_message_queue.queue]\\n raise RuntimeError('\\\\n'.join(error_messages))\\n\\n while not output_dep_mapping_queue.empty():\\n entry_file, deps = output_dep_mapping_queue.get()\\n dep_mapping[entry_file] = deps\\n\\n f = file_open(output_dependency_mapping_file, 'w')\\n for entry in sorted(dep_mapping):\\n for dep in dep_mapping[entry]:\\n f.write(entry + ':' + dep + '\\\\n')\\n f.close()\",\n \"def main():\\r\\n option_parser, opts, args = parse_command_line_parameters(**script_info)\\r\\n\\r\\n sff_files = opts.sff_fps\\r\\n\\r\\n for f in sff_files:\\r\\n if (not exists(f)):\\r\\n option_parser.error(('Flowgram file path does not exist:\\\\n %s \\\\n' +\\r\\n 'Pass a valid one via -i.') % f)\\r\\n outdir = opts.output_dir\\r\\n\\r\\n create_dir(outdir, fail_on_exist=not opts.force)\\r\\n\\r\\n log_fh = None\\r\\n\\r\\n if (not (opts.primer or opts.map_fname)):\\r\\n raise ApplicationError(\\\"Either mapping file or primer required\\\")\\r\\n # Read primer from Meta data file if not set on command line\\r\\n if not opts.primer:\\r\\n mapping_data, header, comments = \\\\\\r\\n parse_mapping_file(open(opts.map_fname, \\\"U\\\"))\\r\\n\\r\\n index = header.index(\\\"LinkerPrimerSequence\\\")\\r\\n all_primers = set(array(mapping_data)[:, index])\\r\\n\\r\\n if len(all_primers) != 1:\\r\\n raise ValueError(\\\"Currently only data sets with one primer are allowed.\\\\n\\\" +\\r\\n \\\"Make separate mapping files with only one primer, re-run split_libraries and\\\\n\\\"\\r\\n + \\\"denoise with each split_library output separately.\\\")\\r\\n primer = list(all_primers)[0]\\r\\n last_char = primer[-1]\\r\\n if(last_char not in \\\"ACGT\\\"):\\r\\n raise ValueError(\\\"We currently do not support primer with \\\" +\\r\\n \\\"degenerate bases at it's 3' end.\\\")\\r\\n\\r\\n else:\\r\\n primer = opts.primer\\r\\n\\r\\n centroids, cluster_mapping = fast_denoiser(opts.sff_fps, opts.fasta_fp,\\r\\n outdir, opts.num_cpus, primer,\\r\\n titanium=opts.titanium)\\r\\n\\r\\n # store mapping file and centroids\\r\\n result_otu_path = '%s/denoised_clusters.txt' % outdir\\r\\n of = open(result_otu_path, 'w')\\r\\n for i, cluster in cluster_mapping.iteritems():\\r\\n of.write('%s\\\\t%s\\\\n' % (str(i), '\\\\t'.join(cluster)))\\r\\n of.close()\\r\\n\\r\\n result_fasta_path = '%s/denoised_seqs.fasta' % outdir\\r\\n oh = open(result_fasta_path, 'w')\\r\\n write_Fasta_from_name_seq_pairs(centroids, oh)\",\n \"def fusion(inputs, inp_index, out_index):\\n shortcut = inputs[out_index]\\n if data_format == 'channel_first':\\n _, _, out_h, out_w = shortcut.get_shape().as_list()\\n else:\\n _, out_h, out_w, _ = shortcut.get_shape().as_list()\\n \\n for ind in inp_index:\\n input_branch = inputs[ind]\\n with tf.variable_scope('input_{}_output_{}'.format(ind, out_index)):\\n if ind > out_index:\\n input_branch = conv2d_fixed_padding(\\n inputs=input_branch, filters=num_outchannels[out_index],\\n kernel_size=1, strides=1, data_format=data_format)\\n input_branch = batch_norm(input_branch, training, data_format)\\n input_branch = tf.nn.relu(input_branch)\\n if data_format == 'channel_first':\\n input_branch = tf.transpose(input_branch, perm=[0, 2, 3, 1])\\n input_branch = tf.image.resize(input_branch, (out_h, out_w), \\n method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n input_branch = tf.transpose(input_branch, perm=[0, 3, 1, 2])\\n else:\\n input_branch = tf.image.resize(input_branch, (out_h, out_w), \\n method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n elif ind == out_index:\\n continue\\n else:\\n for k in range(out_index - ind):\\n if k == out_index - ind - 1:\\n input_branch = conv2d_fixed_padding(\\n inputs=input_branch, filters=num_outchannels[out_index],\\n kernel_size=3, strides=2, data_format=data_format)\\n input_branch = batch_norm(input_branch, training, data_format)\\n else:\\n input_branch = conv2d_fixed_padding(\\n inputs=input_branch, filters=num_outchannels[out_index],\\n kernel_size=3, strides=2, data_format=data_format)\\n input_branch = batch_norm(input_branch, training, data_format)\\n input_branch = tf.nn.relu(input_branch)\\n\\n shortcut += input_branch\\n shortcut = tf.nn.relu(shortcut)\\n return shortcut\",\n \"def main():\\n print \\\"=\\\" * 78\\n print \\\"%s %s\\\" % (__prog_name__, __version__)\\n debug, input_file_names = check_cli()\\n if not input_file_names:\\n _error(\\\"No input file name found!\\\\n\\\\n%s\\\" % __help__)\\n for input_file_name in input_file_names:\\n print \\\"* Reading\\\", input_file_name\\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\\n file_dir_name = os.path.dirname(input_file_name)\\n sections = {}\\n tex_map = {}\\n with open(input_file_name, 'rU') as in_fd:\\n sections = get_sections(in_fd.read())\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"sec\\\",\\n {\\\"sections\\\": sections})\\n\\n if not sections:\\n _error(\\\"Nothing could be read from '%s'.\\\\nIs this an Oolite .dat file?\\\" \\\\\\n % input_file_name)\\n\\n # Magically call the 'check' functions\\n for name in sections.keys():\\n f_name = \\\"check_%s\\\" % name.lower()\\n if f_name in globals().keys():\\n if not globals()[f_name](sections):\\n _error(\\\"Number of entries in '%s' section is different as declared!\\\" % name)\\n\\n def get_data(name, sections=sections):\\n \\\"\\\"\\\"Returns the 'data' object from the 'name' one found in the\\n 'sections' one.\\n :sections: dictionary: Object returned by 'get_sections'.\\n :name: string: The name of the section to get the 'data'.\\n Returns a list of 'lines'.\\n \\\"\\\"\\\"\\n return sections.get(name, {}).get(\\\"data\\\", [])\\n\\n oti_file_name = build_file_path(file_dir_name, file_base_name, \\\"oti\\\")\\n tex_map = parse_names(get_data(\\\"NAMES\\\"), oti_file_name)\\n\\n tex_refs, tex_lines_out = parse_textures(get_data(\\\"TEXTURES\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"tex\\\",\\n {\\\"tex_refs\\\": tex_refs,\\n \\\"tex_lines_out\\\": tex_lines_out})\\n\\n # Update the tex_map object if textures indexes and names are both\\n # used in 'TEXTURES'.\\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\\\"named\\\").keys()):\\n tex_map = update_tex_map(tex_map,\\n set(tex_refs[\\\"named\\\"].keys()).difference(tex_map.keys()))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"txm\\\",\\n {\\\"tex_map\\\": tex_map})\\n\\n n_verts, vertex_lines_out = parse_vertex(get_data(\\\"VERTEX\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"ver\\\",\\n {\\\"n_verts\\\": n_verts,\\n \\\"vertex_lines_out\\\": vertex_lines_out})\\n\\n n_normals, normals_lines_out = parse_normals(get_data(\\\"NORMALS\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"nor\\\",\\n {\\\"n_normals\\\": n_normals,\\n \\\"normals_lines_out\\\": normals_lines_out})\\n\\n n_faces, faces_groups = parse_faces(get_data(\\\"FACES\\\"), tex_refs,\\n normals_lines_out)\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"fac\\\",\\n {\\\"n_faces\\\": n_faces,\\n \\\"faces_groups\\\": faces_groups})\\n\\n output_file_name = build_file_path(file_dir_name,\\n file_base_name, 'obj')\\n material_file_name = build_file_path(file_dir_name,\\n file_base_name, 'mtl')\\n mtl_lib_file = os.path.basename(material_file_name)\\n\\n write_obj(output_file_name, file_base_name, mtl_lib_file,\\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\\n n_normals, normals_lines_out, n_faces, faces_groups)\\n\\n write_mtl(material_file_name, tex_map)\\n\\n _exit(\\\"* Done\\\")\",\n \"def test_mapping_file_removal(self):\\r\\n # doesn't change in test\\r\\n mf_exp, _ = parse_mapping_file_to_dict(self.MF_IN_2)\\r\\n bt_exp = parse_biom_table(self.BT_OUT_2)\\r\\n mf_obs, bt_obs, nonshared_samples = \\\\\\r\\n sync_biom_and_mf(parse_mapping_file_to_dict(self.MF_IN_2)[0],\\r\\n parse_biom_table(self.BT_IN_1))\\r\\n self.assertEqual(mf_exp, mf_obs)\\r\\n self.assertEqual(bt_exp, bt_obs)\\r\\n self.assertEqual(nonshared_samples, set(['Sample5', 'Sample6']))\",\n \"def __init__(self):\\n\\n self.gm = GradientMapper()\\n self.im = SpringMapper()\\n self.fm = FullMapper(self.im, self.gm)\\n # self.lm = LineMapper(self.fm)\\n self.exit = False\",\n \"def step2(step2_input, step2_output):\\n\\n global graf\\n logger.info(\\\"###Step 2:\\\")\\n graf = defaultdict(dict)\\n start2 = clock()\\n info = []\\n for input_file in step2_input:\\n logger.info(\\\"Reading input file {}\\\".format(input_file))\\n with open(input_file) as csv_file:\\n start_file=clock()\\n rdr = csv.reader(csv_file)\\n header = rdr.next()\\n header_last = len(header) - 1\\n try: \\n for chunk in gen_chunks(rdr, 10000):\\n info.extend([(row[0], row[header_last]) for row in chunk])\\n info = list(set(info))\\n process_info(info)\\n except csv.Error as e:\\n logger.error(\\\"Exception {}: {}\\\".format(type(e), e))\\n logger.error(\\\"Check Problems section in readme for known issues.\\\")\\n return 1\\n check_time(start_file, \\\"Done reading.\\\")\\n check_time(start2, \\\"Done generating full link dict...\\\")\\n start_write = clock()\\n write_to_file(step2_output, graf)\\n check_time(start_write, \\\"Done writing output file.\\\")\\n check_time(start2, \\\"Done with Step 2.\\\")\\n return 0\",\n \"def makeAMixOf2Annotations(inputAnnotPath1, inputAnnotPath2, outputMixPath):\\n # make sure the paths end in a slash\\n if inputAnnotPath1[-1] != u'/':\\n inputAnnotPath1 = u'{0}/'.format(inputAnnotPath1)\\n if inputAnnotPath2[-1] != u'/':\\n inputAnnotPath2 = u'{0}/'.format(inputAnnotPath2)\\n if outputMixPath[-1] != u'/':\\n outputMixPath = u'{0}/'.format(outputMixPath)\\n # for each input open\\n for inPath in [inputAnnotPath1, inputAnnotPath2]:\\n # open the file, read the lines\\n with open(u'{0}sample.en'.format(inPath)) as inEnFile:\\n enLns = inEnFile.readlines()\\n with open(u'{0}sample.fr'.format(inPath)) as inFrFile:\\n frLns = inFrFile.readlines()\\n with open(u'{0}sampleAnnotation.tsv'.format(inPath)) as inAnnotFile:\\n annotLns = inAnnotFile.readlines()\\n with open(u'{0}sampleReference.tsv'.format(inPath)) as inRefFile:\\n refLns = inRefFile.readlines()\\n with open(u'{0}scores.tsv'.format(inPath)) as inScFile:\\n scLns = inScFile.readlines()\\n with open(u'{0}scoresAndMetaData.tsv'.format(inPath)) as inScMetaFile:\\n scMetaLns = inScMetaFile.readlines()\\n # choose and index randomly\\n dejaVus = set([])\\n while len(dejaVus) < int(len(enLns)/2.0):\\n randomInd = randint(0, len(enLns)-1)\\n while randomInd in dejaVus:\\n randomInd = randint(0, len(enLns)-1)\\n # add to dejavus\\n dejaVus.add(randomInd)\\n # dump to output file\\n utilsOs.appendLineToFile(enLns[randomInd], u'{0}sample.en'.format(outputMixPath), addNewLine=False)\\n utilsOs.appendLineToFile(frLns[randomInd], u'{0}sample.fr'.format(outputMixPath), False)\\n utilsOs.appendLineToFile(annotLns[randomInd], u'{0}sampleAnnotation.tsv'.format(outputMixPath), False)\\n utilsOs.appendLineToFile(refLns[randomInd], u'{0}sampleReference.tsv'.format(outputMixPath), False)\\n utilsOs.appendLineToFile(scLns[randomInd], u'{0}scores.tsv'.format(outputMixPath), False)\\n utilsOs.appendLineToFile(scMetaLns[randomInd], u'{0}scoresAndMetaData.tsv'.format(outputMixPath), False)\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('ANAP').get('abstractTypes')\\n exolinks = globalMap.get('ANAP').get('exolinks')\\n\\n # DataType GraphicsHandlerType\\n currentMap = {}\\n abstractTypes['GraphicsHandlerType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'] = currentMap\\n loadMaps['ANAP.GraphicsHandlerType'] = currentMap\\n currentMap['tag'] = 'ANAP.GraphicsHandlerType'\\n currentMap['type'] = 'simple'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'\\n currentMap['toStr'] = 'text'\\n currentMap['cnvrt'] = 'text'\\n\\n # Class AnalysisProfile\\n currentMap = {}\\n abstractTypes['AnalysisProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'] = currentMap\\n loadMaps['ANAP.AnalysisProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'analysisProfiles'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AnalysisProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AnalysisProfile.bgColor\\n currentMap = {}\\n contentMap['bgColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.bgColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.bgColor'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'\\n currentMap['name'] = 'bgColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['default'] = '#FFFFFF'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute AnalysisProfile.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.fgColor\\n currentMap = {}\\n contentMap['fgColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.fgColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.fgColor'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'\\n currentMap['name'] = 'fgColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['default'] = '#000000'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute AnalysisProfile.font\\n currentMap = {}\\n contentMap['font'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.font'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.font'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'\\n currentMap['name'] = 'font'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.graphicsHandler\\n currentMap = {}\\n contentMap['graphicsHandler'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.graphicsHandler'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.graphicsHandler'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'\\n currentMap['name'] = 'graphicsHandler'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'Tk'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001')\\n\\n # Attribute AnalysisProfile.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute AnalysisProfile.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.name'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AnalysisProfile.panView\\n currentMap = {}\\n contentMap['panView'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.panView'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.panView'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'\\n currentMap['name'] = 'panView'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.sendBugReports\\n currentMap = {}\\n contentMap['sendBugReports'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.sendBugReports'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.sendBugReports'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'\\n currentMap['name'] = 'sendBugReports'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'maybe'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2010-11-17-16:21:33_00001')\\n\\n # Attribute AnalysisProfile.transientDialogs\\n currentMap = {}\\n contentMap['transientDialogs'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.transientDialogs'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientDialogs'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'\\n currentMap['name'] = 'transientDialogs'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.transientWindows\\n currentMap = {}\\n contentMap['transientWindows'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.transientWindows'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientWindows'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'\\n currentMap['name'] = 'transientWindows'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.twoCharShortcuts\\n currentMap = {}\\n contentMap['twoCharShortcuts'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.twoCharShortcuts'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.twoCharShortcuts'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'\\n currentMap['name'] = 'twoCharShortcuts'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.useCrosshair\\n currentMap = {}\\n contentMap['useCrosshair'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.useCrosshair'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.useCrosshair'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'\\n currentMap['name'] = 'useCrosshair'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.useGlobalShortcuts\\n currentMap = {}\\n contentMap['useGlobalShortcuts'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.useGlobalShortcuts'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.useGlobalShortcuts'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'\\n currentMap['name'] = 'useGlobalShortcuts'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.userEmail\\n currentMap = {}\\n contentMap['userEmail'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userEmail'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userEmail'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'\\n currentMap['name'] = 'userEmail'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute AnalysisProfile.userName\\n currentMap = {}\\n contentMap['userName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userName'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'\\n currentMap['name'] = 'userName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.userOrganisation\\n currentMap = {}\\n contentMap['userOrganisation'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userOrganisation'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userOrganisation'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'\\n currentMap['name'] = 'userOrganisation'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.webBrowser\\n currentMap = {}\\n contentMap['webBrowser'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.webBrowser'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.webBrowser'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'\\n currentMap['name'] = 'webBrowser'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role AnalysisProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role AnalysisProfile.colorSchemes\\n currentMap = {}\\n contentMap['colorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.colorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.colorSchemes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'\\n currentMap['name'] = 'colorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.macros\\n currentMap = {}\\n contentMap['macros'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.macros'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.macros'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'\\n currentMap['name'] = 'macros'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.marksColor\\n currentMap = {}\\n contentMap['marksColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.marksColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.marksColor'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'\\n currentMap['name'] = 'marksColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['implSkip'] = True\\n currentMap['copyOverride'] = True\\n\\n # Role AnalysisProfile.refExpProfiles\\n currentMap = {}\\n contentMap['refExpProfiles'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.refExpProfiles'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.refExpProfiles'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'\\n currentMap['name'] = 'refExpProfiles'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.residueProfiles\\n currentMap = {}\\n contentMap['residueProfiles'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.residueProfiles'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.residueProfiles'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'\\n currentMap['name'] = 'residueProfiles'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.rulersColor\\n currentMap = {}\\n contentMap['rulersColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.rulersColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.rulersColor'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'\\n currentMap['name'] = 'rulersColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['implSkip'] = True\\n currentMap['copyOverride'] = True\\n # End of AnalysisProfile\\n\\n currentMap = abstractTypes.get('AnalysisProfile')\\n aList = ['createdBy', 'graphicsHandler', 'guid', 'isModifiable', 'lastUnlockedBy', 'name', 'panView', 'sendBugReports', 'transientDialogs', 'transientWindows', 'twoCharShortcuts', 'useCrosshair', 'useGlobalShortcuts', 'userEmail', 'webBrowser']\\n currentMap['headerAttrs'] = aList\\n aList = ['bgColor', 'fgColor', 'font', 'userName', 'userOrganisation', 'marksColor', 'rulersColor']\\n currentMap['simpleAttrs'] = aList\\n aList = ['residueProfiles', 'refExpProfiles', 'macros', 'colorSchemes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['colorSchemes', 'macros', 'refExpProfiles', 'residueProfiles']\\n currentMap['children'] = aList\\n\\n # Class ColorScheme\\n currentMap = {}\\n abstractTypes['ColorScheme'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'] = currentMap\\n loadMaps['ANAP.ColorScheme'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'colorSchemes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ColorScheme.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ColorScheme.colors\\n currentMap = {}\\n contentMap['colors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'] = currentMap\\n loadMaps['ANAP.ColorScheme.colors'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme.colors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'\\n currentMap['name'] = 'colors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute ColorScheme.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'] = currentMap\\n loadMaps['ANAP.ColorScheme.name'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role ColorScheme.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of ColorScheme\\n\\n currentMap = abstractTypes.get('ColorScheme')\\n aList = ['colors', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class Macro\\n currentMap = {}\\n abstractTypes['Macro'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'] = currentMap\\n loadMaps['ANAP.Macro'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'macros'\\n currentMap['objkey'] = 'serial'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Macro.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Macro.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'] = currentMap\\n loadMaps['ANAP.Macro.details'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute Macro.function\\n currentMap = {}\\n contentMap['function'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'] = currentMap\\n loadMaps['ANAP.Macro.function'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.function'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'\\n currentMap['name'] = 'function'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute Macro.isInMenu\\n currentMap = {}\\n contentMap['isInMenu'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'] = currentMap\\n loadMaps['ANAP.Macro.isInMenu'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.isInMenu'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'\\n currentMap['name'] = 'isInMenu'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute Macro.isInMouseMenu\\n currentMap = {}\\n contentMap['isInMouseMenu'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'] = currentMap\\n loadMaps['ANAP.Macro.isInMouseMenu'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.isInMouseMenu'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'\\n currentMap['name'] = 'isInMouseMenu'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute Macro.module\\n currentMap = {}\\n contentMap['module'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'] = currentMap\\n loadMaps['ANAP.Macro.module'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.module'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'\\n currentMap['name'] = 'module'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute Macro.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'] = currentMap\\n loadMaps['ANAP.Macro.name'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute Macro.ordering\\n currentMap = {}\\n contentMap['ordering'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'] = currentMap\\n loadMaps['ANAP.Macro.ordering'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.ordering'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'\\n currentMap['name'] = 'ordering'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['default'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Macro.path\\n currentMap = {}\\n contentMap['path'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'] = currentMap\\n loadMaps['ANAP.Macro.path'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.path'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'\\n currentMap['name'] = 'path'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00003')\\n\\n # Attribute Macro.serial\\n currentMap = {}\\n contentMap['serial'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'] = currentMap\\n loadMaps['ANAP.Macro.serial'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.serial'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'\\n currentMap['name'] = 'serial'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Macro.shortcut\\n currentMap = {}\\n contentMap['shortcut'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'] = currentMap\\n loadMaps['ANAP.Macro.shortcut'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.shortcut'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'\\n currentMap['name'] = 'shortcut'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role Macro.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of Macro\\n\\n currentMap = abstractTypes.get('Macro')\\n aList = ['function', 'isInMenu', 'isInMouseMenu', 'module', 'ordering', 'serial', 'shortcut']\\n currentMap['headerAttrs'] = aList\\n aList = ['details', 'name', 'path']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class RefExpProfile\\n currentMap = {}\\n abstractTypes['RefExpProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'] = currentMap\\n loadMaps['ANAP.RefExpProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'refExpProfiles'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute RefExpProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute RefExpProfile.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'] = currentMap\\n loadMaps['ANAP.RefExpProfile.name'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute RefExpProfile.peakSymbolColors\\n currentMap = {}\\n contentMap['peakSymbolColors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'] = currentMap\\n loadMaps['ANAP.RefExpProfile.peakSymbolColors'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.peakSymbolColors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'\\n currentMap['name'] = 'peakSymbolColors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute RefExpProfile.peakTextColors\\n currentMap = {}\\n contentMap['peakTextColors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'] = currentMap\\n loadMaps['ANAP.RefExpProfile.peakTextColors'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.peakTextColors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'\\n currentMap['name'] = 'peakTextColors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute RefExpProfile.refExpNames\\n currentMap = {}\\n contentMap['refExpNames'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'] = currentMap\\n loadMaps['ANAP.RefExpProfile.refExpNames'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.refExpNames'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'\\n currentMap['name'] = 'refExpNames'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role RefExpProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role RefExpProfile.negColorSchemes\\n currentMap = {}\\n contentMap['negColorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'] = currentMap\\n loadMaps['ANAP.RefExpProfile.negColorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.negColorSchemes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'\\n currentMap['name'] = 'negColorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n\\n # Role RefExpProfile.posColorSchemes\\n currentMap = {}\\n contentMap['posColorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'] = currentMap\\n loadMaps['ANAP.RefExpProfile.posColorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.posColorSchemes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'\\n currentMap['name'] = 'posColorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of RefExpProfile\\n\\n currentMap = abstractTypes.get('RefExpProfile')\\n aList = ['name']\\n currentMap['headerAttrs'] = aList\\n aList = ['peakSymbolColors', 'peakTextColors', 'refExpNames', 'negColorSchemes', 'posColorSchemes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ResidueProfile\\n currentMap = {}\\n abstractTypes['ResidueProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'] = currentMap\\n loadMaps['ANAP.ResidueProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'residueProfiles'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ResidueProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ResidueProfile.ccpCode\\n currentMap = {}\\n contentMap['ccpCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'] = currentMap\\n loadMaps['ANAP.ResidueProfile.ccpCode'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.ccpCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'\\n currentMap['name'] = 'ccpCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ResidueProfile.guiName\\n currentMap = {}\\n contentMap['guiName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'] = currentMap\\n loadMaps['ANAP.ResidueProfile.guiName'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.guiName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'\\n currentMap['name'] = 'guiName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ResidueProfile.molType\\n currentMap = {}\\n contentMap['molType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'] = currentMap\\n loadMaps['ANAP.ResidueProfile.molType'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.molType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'\\n currentMap['name'] = 'molType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\\n\\n # Role ResidueProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of ResidueProfile\\n\\n currentMap = abstractTypes.get('ResidueProfile')\\n aList = ['ccpCode', 'guiName', 'molType']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to AnalysisProfile\\n currentMap = {}\\n exolinks['AnalysisProfile'] = currentMap\\n loadMaps['ANAP.exo-AnalysisProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-AnalysisProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\\n currentMap['name'] = 'AnalysisProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to ColorScheme\\n currentMap = {}\\n exolinks['ColorScheme'] = currentMap\\n loadMaps['ANAP.exo-ColorScheme'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-ColorScheme'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\\n currentMap['name'] = 'ColorScheme'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to Macro\\n currentMap = {}\\n exolinks['Macro'] = currentMap\\n loadMaps['ANAP.exo-Macro'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-Macro'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\\n currentMap['name'] = 'Macro'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n\\n # Out-of-package link to RefExpProfile\\n currentMap = {}\\n exolinks['RefExpProfile'] = currentMap\\n loadMaps['ANAP.exo-RefExpProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-RefExpProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\\n currentMap['name'] = 'RefExpProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n\\n # Out-of-package link to ResidueProfile\\n currentMap = {}\\n exolinks['ResidueProfile'] = currentMap\\n loadMaps['ANAP.exo-ResidueProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-ResidueProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\\n currentMap['name'] = 'ResidueProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\",\n \"def _fp_setup2(self):\\n # TODO: right now it's hard to implement this required stage\",\n \"def main(input_filepath, output_filepath):\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\",\n \"def main(input_filepath, output_filepath):\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\",\n \"def visualize_saliency_of_output(FLAGS, model, input_images=[]):\\n if len(input_images) == 0:\\n # use predefined images\\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\\n\\n print(\\\"[tools.py]: extracting saliency maps of {0} in {1}\\\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\\n \\n \\n inputs = load_images(input_images, model.input_size[1:])\\n\\n print 'shape: ',inputs.shape\\n\\n if 'nfc' in FLAGS.network:\\n inputs = np.concatenate([inputs]*FLAGS.n_frames, axis=-1)\\n \\n # extract deconvolution\\n import tf_cnnvis\\n\\n # layers = ['c']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D','MobilenetV1_1/AvgPool_1a/AvgPool']\\n\\n # layers = [str(i.name) for i in model.sess.graph.get_operations() if 'outputs' in i.name and not 'activations' in i.name and not 'gradients' in i.name]\\n layers = [model.endpoints['eval']['outputs'].name[:-2]] #cut out :0 in the end to change name from tensor to operation name\\n # layers = ['outputs']\\n \\n # results = tf_cnnvis.activation_visualization(sess_graph_path = model.sess, \\n # value_feed_dict = {model.inputs : inputs}, \\n # layers=layers)\\n results = tf_cnnvis.deconv_visualization(sess_graph_path = model.sess, \\n value_feed_dict = {model.inputs : inputs}, \\n layers=layers)\\n\\n # Normalize deconvolution within 0:1 range\\n num_rows=0\\n clean_results={} \\n # Loop over layers\\n for k in results.keys():\\n clean_results[k]=[]\\n # Loop over channels\\n for c in range(len(results[k])):\\n num_rows+=1\\n clean_results[k].append(np.zeros((results[k][c].shape[0:3])))\\n # Loop over images\\n for i in range(results[k][c].shape[0]):\\n clean_results[k][c][i]=deprocess_image(results[k][c][i],one_channel=True)\\n if num_rows > 6:\\n print(\\\"[tools.py]: There are too many columns to create a proper image.\\\")\\n return\\n\\n # create one combined image with each input image on each column\\n fig, axes = plt.subplots(num_rows+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # fig, axes = plt.subplots(num_columns+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # add original images in first row\\n for i in range(axes.shape[1]):\\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\\n axes[0, i].axis('off')\\n \\n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\\n\\n # add deconvolutions over the columns\\n row_index = 1\\n for k in results.keys(): # go over layers\\n for c in range(len(results[k])): # add each channel in 2 new column\\n for i in range(axes.shape[1]): # fill row going over input images\\n # axes[row_index, i].set_title(k.split('/')[1]+'/'+k.split('/')[2]+'_'+str(c))\\n axes[row_index, i].set_title(k+'_'+str(c))\\n # axes[row_index, i].set_title(experts[c])\\n \\n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[k][c][i],axis=2)), axis=2))\\n axes[row_index, i].axis('off')\\n # row_index+=2\\n row_index+=1\\n # plt.show()\\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/saliency_maps.jpg',bbox_inches='tight')\",\n \"def __init__(self, model_source = None, train_log_dir = None, name = \\\"DNN2\\\", auto_reload = False, only_final=False, denorm_out=True): \\n super().__init__(name = name)\\n self.model_source = model_source\\n self.train_log_dir = train_log_dir\\n \\n self.feat_in_pipe_out, self.feat_in_pipe_in = multiprocessing.Pipe(False)\\n self.mapping_process = None\\n self.run_map = multiprocessing.Value('b', False)\\n self.auto_reload = auto_reload\\n self.observer = None\\n self.only_final = only_final\\n self.denorm_out = denorm_out\",\n \"def preprocess(self):\\n inputMatrix = pd.read_csv(self.input, index_col = 0)\\n\\n original_filename = self.input.split(\\\"/\\\")[-1]\\n mapped_filename = \\\"mapped_\\\" + self.desiredFormat + \\\"_\\\" + original_filename\\n output = self.input\\n output_filepath = \\\"/\\\".join(self.input.split(\\\"/\\\")[0:-1])\\n #as the DataFormatter always transposes the data before any further processing, we can expect all genes to be in the columns\\n genesInColumn = \\\"true\\\"\\n #only map genes if the current format is not the desired format\\n if (self.currentFormat != self.desiredFormat):\\n output = output_filepath + \\\"/\\\" + mapped_filename\\n benchutils.mapDataMatrix(inputMatrix, genesInColumn, self.currentFormat, self.desiredFormat, output, self.labeled)\\n\\n return output\",\n \"def infer():\\n\\n # Create StreamManagerApi object\\n stream_manager_api = StreamManagerApi()\\n # Use InitManager method init StreamManagerApi\\n ret = stream_manager_api.InitManager()\\n if ret != 0:\\n print(\\\"Failed to init Stream manager, ret=%s\\\" % str(ret))\\n exit()\\n\\n # create streams by pipeline config file\\n with open(args.pipeline_path, \\\"rb\\\") as f:\\n pipeline_str = f.read()\\n\\n # Configuring a stream\\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\\n if ret != 0:\\n print(\\\"Failed to create Stream, ret=%s\\\" % str(ret))\\n exit()\\n\\n # Construct the input of the stream\\n data_input = MxDataInput()\\n # Stream_name encoded in UTF-8\\n stream_name = args.stream_name.encode()\\n print(stream_name)\\n predictions = []\\n with open(args.label_path, 'rt') as f:\\n val_cls = f.read().rstrip(\\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(args.instances_path)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n for file_name in os.listdir(args.img_path):\\n pred_data = []\\n # Gets the Address of each image\\n img_id = int(file_name.split('.')[0])\\n file_path = args.img_path + file_name\\n size = (cv2.imread(file_path)).shape\\n\\n # Read each photo in turn\\n with open(file_path, \\\"rb\\\") as f:\\n img_data = f.read()\\n if not img_data:\\n print(f\\\"read empty data from img:{file_name}\\\")\\n continue\\n # The element value img_data\\n data_input.data = img_data\\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\\n pred_data.append({\\\"boxes\\\": boxes_output,\\n \\\"box_scores\\\": scores_output,\\n \\\"img_id\\\": img_id,\\n \\\"image_shape\\\": size})\\n\\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\\n print(f\\\"Inferred image:{file_name} success!\\\")\\n\\n # Save the result in JSON format\\n if not os.path.exists(args.res_path):\\n os.makedirs(args.res_path)\\n with open(args.res_path + 'predictions_test.json', 'w') as f:\\n json.dump(predictions, f)\\n stream_manager_api.DestroyAllStreams()\",\n \"def nominal_map(options):\\n pass\",\n \"def analysis_dFF_map(self):\\r\\n\\r\\n \\r\\n\\r\\n print ('Starting dF/F analysis:')\\r\\n\\r\\n self.print_image_info()\\r\\n\\r\\n # smoothwin = int(self.imageData.shape[1]/8.)\\r\\n\\r\\n # get the average image and the average of the whole image over time\\r\\n\\r\\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\\r\\n\\r\\n \\r\\n\\r\\n mpl.figure(99)\\r\\n\\r\\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\\r\\n\\r\\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\\r\\n\\r\\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\\r\\n\\r\\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\\r\\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\\r\\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\\r\\n\\r\\n mpl.figure(98)\\r\\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\\r\\n mpl.figure(97)\\r\\n mpl.imshow(np.mean(imgdatasm,axis=0))\\r\\n self.n_times = self.timebase\\r\\n\\r\\n periodsize = int(self.period*self.framerate)\\r\\n print('periodsize: ',periodsize)\\r\\n\\r\\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\\r\\n\\r\\n # r = range(0, self.imageData.shape[0], windowsize)\\r\\n\\r\\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \\r\\n\\r\\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\\r\\n\\r\\n delresp=np.zeros([19,256,256])\\r\\n repback = np.mean(sig[:,1:4,:,:],axis=1)\\r\\n resp = np.mean(sig[:,5:9,:,:],axis=1)\\r\\n for counter in range(19):\\r\\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\\r\\n quot=np.mean(delresp,axis=0)\\r\\n quot=-quot\\r\\n print ('shape of quot: ', np.shape(quot))\\r\\n # quot=(resp-repback)/repback\\r\\n # quot[quot>0]=0\\r\\n # quot=-1000*quot\\r\\n\\r\\n mpl.figure(7)\\r\\n mpl.imshow(quot,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n\\r\\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n mpl.figure(8)\\r\\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n \\r\\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\\r\\n\\r\\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n\\r\\n\\r\\n # print (' windowsize: ', windowsize)\\r\\n\\r\\n # print (' periodsize: ', periodsize)\\r\\n # mc = matplotlib.cm\\r\\n\\r\\n # only use sequential maps here\\r\\n\\r\\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\\r\\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\\r\\n\\r\\n cs = {}\\r\\n\\r\\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\\r\\n# \\r\\n # localmax = {}\\r\\n\\r\\n # sigmax = 0.\\r\\n# \\r\\n # kernel = np.ones((5, 5))\\r\\n\\r\\n # psf = kernel / np.sum(kernel)\\r\\n\\r\\n # compute dF/F, and get maximum over all frequencies\\r\\n\\r\\n print (' sig shape: ', sig.shape)\\r\\n\\r\\n # print (' bl shape: ', bl.shape)\\r\\n\\r\\n # smax = np.zeros(bl.shape[0])\\r\\n\\r\\n # for i in range(bl.shape[0]):\\r\\n\\r\\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\\r\\n\\r\\n # sigd[i] = sigd[i]**2.0\\r\\n\\r\\n # smooth\\r\\n\\r\\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # deconvolve\\r\\n\\r\\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\\r\\n\\r\\n# sm = sigd[i].max().max()\\r\\n\\r\\n# if sm > sigmax:\\r\\n\\r\\n# sigmax = sm\\r\\n\\r\\n# smax[i] = sm\\r\\n\\r\\n# print( ' i, sm: ', i, sm)\\r\\n\\r\\n# # now process for display\\r\\n\\r\\n# print (' sigd shape: ', sigd.shape)\\r\\n\\r\\n# wdat = np.mean(sig, axis=0)\\r\\n\\r\\n# wds = wdat.shape\\r\\n\\r\\n# print('wdat shape: ', wds)\\r\\n\\r\\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\\r\\n\\r\\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\\r\\n\\r\\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\\r\\n\\r\\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\\r\\n\\r\\n# mpl.figure(1)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\\r\\n\\r\\n\\r\\n\\r\\n# mpl.figure(2)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\\r\\n\\r\\n# # find center of mass of areas above threshold\\r\\n\\r\\n# # mass = sigd[i].copy()\\r\\n\\r\\n# # mass[sigd[i] > 0.] = 1.\\r\\n\\r\\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\\r\\n\\r\\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\\r\\n\\r\\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\\r\\n\\r\\n# # xcoords = np.array([x[1] for x in coords])\\r\\n\\r\\n# # ycoords = np.array([x[0] for x in coords])\\r\\n\\r\\n# # cs[i] = (xcoords, ycoords)\\r\\n\\r\\n\\r\\n\\r\\n# # Calculating local maxima\\r\\n\\r\\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \\r\\n\\r\\n# indices=True, num_peaks=10, footprint=None, labels=None)\\r\\n\\r\\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\\r\\n\\r\\n# # print ('i, local max: ',i, localmax)\\r\\n\\r\\n# mpl.subplot(5,5,i+1)\\r\\n# print ('shape of sigd: ',[np.shape(sigd),i])\\r\\n\\r\\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\\r\\n\\r\\n# if len(localmax[i]) > 0:\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# else:\\r\\n\\r\\n# continue\\r\\n\\r\\n# scattersize = 30.\\r\\n\\r\\n# for k, lm in enumerate(localmax[i]):\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\\r\\n\\r\\n# mpl.subplot(6,5,i+15+1)\\r\\n\\r\\n# wr = range(i*windowsize, i*windowsize+windowsize)\\r\\n\\r\\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\\r\\n\\r\\n# wmax = 0.\\r\\n\\r\\n# for lmax in localmax[i]: # was xcoords\\r\\n\\r\\n# wave = wdat[wr, lmax[0],lmax[1]]\\r\\n\\r\\n# wdff = (wave-wave[0])/wave[0]\\r\\n\\r\\n# if np.max(wdff) > wmax:\\r\\n\\r\\n# wmax = np.max(wdff)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\\r\\n\\r\\n# wdff, color=clist2[i])\\r\\n\\r\\n# mpl.ylim(-0.1*wmax, wmax)\\r\\n\\r\\n# fig = mpl.figure(3)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# if len(localmax[i]) == 0:\\r\\n\\r\\n# continue\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# for lm in localmax[i]:\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\\r\\n\\r\\n# mpl.ylim(0, sigd.shape[2])\\r\\n\\r\\n# mpl.xlim(0, sigd.shape[1])\\r\\n\\r\\n# mpl.axis('equal')\\r\\n\\r\\n mpl.show()\\r\\n\\r\\n print (' DF/F analysis finished.\\\\n')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5958182","0.5901442","0.58976465","0.5824817","0.57437664","0.5723222","0.56925786","0.5678178","0.5666717","0.5651474","0.5641801","0.56411237","0.5631734","0.5607848","0.5584844","0.5577562","0.556734","0.5566151","0.55564994","0.55500746","0.5506336","0.5506106","0.5499676","0.5496993","0.54944056","0.5477993","0.54719365","0.546853","0.54555947","0.5438957","0.54378337","0.5429204","0.54250026","0.5413153","0.5400939","0.5377995","0.53099835","0.53027594","0.5282418","0.52805704","0.5272015","0.5264046","0.525754","0.52553695","0.5255109","0.5231665","0.5220456","0.5215562","0.5214885","0.5211323","0.52072805","0.5201386","0.520122","0.519687","0.51900196","0.51828283","0.5181327","0.5178426","0.51737106","0.5171859","0.5171553","0.51601785","0.515803","0.51558167","0.5151351","0.5143562","0.5138246","0.5138149","0.51291096","0.5127923","0.5126541","0.51250005","0.5124198","0.5123981","0.51046395","0.51020205","0.51011574","0.5099815","0.50989264","0.50932324","0.50925165","0.50891614","0.5087213","0.5081455","0.5080258","0.50802416","0.5076174","0.5073045","0.5071579","0.5070656","0.50694245","0.5061168","0.5059715","0.5059715","0.50592417","0.505801","0.5057387","0.5057017","0.50541866","0.5041918"],"string":"[\n \"0.5958182\",\n \"0.5901442\",\n \"0.58976465\",\n \"0.5824817\",\n \"0.57437664\",\n \"0.5723222\",\n \"0.56925786\",\n \"0.5678178\",\n \"0.5666717\",\n \"0.5651474\",\n \"0.5641801\",\n \"0.56411237\",\n \"0.5631734\",\n \"0.5607848\",\n \"0.5584844\",\n \"0.5577562\",\n \"0.556734\",\n \"0.5566151\",\n \"0.55564994\",\n \"0.55500746\",\n \"0.5506336\",\n \"0.5506106\",\n \"0.5499676\",\n \"0.5496993\",\n \"0.54944056\",\n \"0.5477993\",\n \"0.54719365\",\n \"0.546853\",\n \"0.54555947\",\n \"0.5438957\",\n \"0.54378337\",\n \"0.5429204\",\n \"0.54250026\",\n \"0.5413153\",\n \"0.5400939\",\n \"0.5377995\",\n \"0.53099835\",\n \"0.53027594\",\n \"0.5282418\",\n \"0.52805704\",\n \"0.5272015\",\n \"0.5264046\",\n \"0.525754\",\n \"0.52553695\",\n \"0.5255109\",\n \"0.5231665\",\n \"0.5220456\",\n \"0.5215562\",\n \"0.5214885\",\n \"0.5211323\",\n \"0.52072805\",\n \"0.5201386\",\n \"0.520122\",\n \"0.519687\",\n \"0.51900196\",\n \"0.51828283\",\n \"0.5181327\",\n \"0.5178426\",\n \"0.51737106\",\n \"0.5171859\",\n \"0.5171553\",\n \"0.51601785\",\n \"0.515803\",\n \"0.51558167\",\n \"0.5151351\",\n \"0.5143562\",\n \"0.5138246\",\n \"0.5138149\",\n \"0.51291096\",\n \"0.5127923\",\n \"0.5126541\",\n \"0.51250005\",\n \"0.5124198\",\n \"0.5123981\",\n \"0.51046395\",\n \"0.51020205\",\n \"0.51011574\",\n \"0.5099815\",\n \"0.50989264\",\n \"0.50932324\",\n \"0.50925165\",\n \"0.50891614\",\n \"0.5087213\",\n \"0.5081455\",\n \"0.5080258\",\n \"0.50802416\",\n \"0.5076174\",\n \"0.5073045\",\n \"0.5071579\",\n \"0.5070656\",\n \"0.50694245\",\n \"0.5061168\",\n \"0.5059715\",\n \"0.5059715\",\n \"0.50592417\",\n \"0.505801\",\n \"0.5057387\",\n \"0.5057017\",\n \"0.50541866\",\n \"0.5041918\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50639737"},"document_rank":{"kind":"string","value":"91"}}},{"rowIdx":20271,"cells":{"query":{"kind":"string","value":"array can either be 360 array or ~59k array. If 360, will automatically map back to ~59k"},"document":{"kind":"string","value":"def mapBackToSurface(array,filename):\n #### Map back to surface\n if array.shape[0]==360:\n out_array = np.zeros((glasser2.shape[0],3))\n\n roicount = 0\n for roi in range(360):\n for col in range(array.shape[1]):\n vertex_ind = np.where(glasser2==roi+1)[0]\n out_array[vertex_ind,col] = array[roicount,col]\n\n roicount += 1\n\n else:\n out_array = array\n\n #### \n # Write file to csv and run wb_command\n np.savetxt(filename + '.csv', out_array,fmt='%s')\n wb_file = filename + '.dscalar.nii'\n wb_command = 'wb_command -cifti-convert -from-text ' + filename + '.csv ' + glasserfile2 + ' ' + wb_file + ' -reset-scalars'\n os.system(wb_command)\n os.remove(filename + '.csv')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def changeArray(array):\r\n\r\n return [[float(array[j][i]) for j in range(len(array))] for i in range(len(array[0]))]","def solution(array):\n array1 = np.array(array)\n array2 = array1.astype(float)\n return array2","def mapping(array, map):\r\n n = map.shape[0] \r\n if array.dtype == np.complex :\r\n arrayout = np.zeros((2*n),dtype=array.real.dtype)\r\n for ii in range(n):\r\n i = map[ii,0]\r\n j = map[ii,1]\r\n arrayout[ii] = array[i,j].real\r\n arrayout[ii+n] = array[i,j].imag\r\n else :\r\n arrayout = np.zeros((n),dtype=array.dtype)\r\n for ii in range(n):\r\n i = map[ii,0]\r\n j = map[ii,1]\r\n arrayout[ii] = array[i,j]\r\n return arrayout","def rescale_toa(arr, dtype=np.float32):\n # First look at raw value dists along bands\n\n arr_trans = np.subtract(arr, arr.min(axis=(1, 2))[:, np.newaxis, np.newaxis])\n arr_rs = np.divide(arr_trans, arr_trans.max(axis=(1, 2))[:, np.newaxis, np.newaxis])\n if dtype == np.uint8:\n arr_rs = np.array(arr_rs*255, dtype=np.uint8)\n return arr_rs","def array(self):","def unmapping(array, map, N):\r\n n = map.shape[0] \r\n if (array.shape[0] / 2) == N**2 :\r\n arrayout = np.zeros((N,N),dtype=np.complex128)\r\n for ii in range(n):\r\n i = map[ii,0]\r\n j = map[ii,1]\r\n arrayout[i,j] = array[ii] + 1.0J * array[ii+n]\r\n elif array.shape[0] == N**2 :\r\n arrayout = np.zeros((N,N),dtype=array.dtype)\r\n for ii in range(n):\r\n i = map[ii,0]\r\n j = map[ii,1]\r\n arrayout[i,j] = array[ii] \r\n return arrayout","def array_to_raster_noTi(x_pix,y_pix,pixSize,x_min,y_max,proj,array,outFile):\n \n\n driver = gdal.GetDriverByName('GTiff')\n\n outDataset = driver.Create(\n outFile,\n x_pix,\n y_pix,\n 1,\n gdal.GDT_Float32, )\n\n outDataset.SetGeoTransform((\n x_min, # 0 * top left border of pixel\n pixSize, # 1\n 0, # 2\n y_max, # 3 top left border of pixel\n 0, # 4\n -pixSize)) \n\n projx = osr.SpatialReference()\n projx.SetWellKnownGeogCS( proj ) #Get the long coordinate system name\n wkt_projection = projx.ExportToWkt()\n\n outDataset.SetProjection(wkt_projection)\n outDataset.GetRasterBand(1).WriteArray(array)\n outDataset.FlushCache() # Write to disk.\n return outDataset, outDataset.GetRasterBand(1) #If you need to return, remenber to return also the dataset because the band don`t live without dataset.","def adapt_array(self,array):\n import io\n import array,numpy\n out = io.BytesIO()\n numpy.save(out, array)\n out.seek(0)\n \n return out.read()","def map_reshaper(map):\n a = [[map[int(i / 2), int(j / 2)] for j in range(50)] for i in range(50)]\n return np.array(a)","def test_array_factory(self):\n\n colors = array([[0.0,0.0,0.0], [1.0,1.0,1.0]])\n cm = ColorMapper.from_palette_array(colors)\n cm.range = DataRange1D()\n\n ar = ArrayDataSource(array([0.0, 0.5, 1.0]))\n cm.range.add(ar)\n b = cm.map_screen(ar.get_data())\n cm.range.remove(ar)\n\n expected = array([0.0, 0.5, 1.0])\n\n self.assertTrue(allclose(ravel(b[:,:1]), expected, atol=0.02),\n \"Array factory failed. Expected %s. Got %s\" % (expected, b[:,:1]))\n\n return","def de_project(np_arr):\n item = (np_arr +1)*255 / 2\n return item.astype(np.int32, copy=True)","def fromarray(self, array):\n\n raise NotImplementedError","def clean_data(array):\n ret = np.zeros(len(array))\n for i in range(len(array)):\n drop_id = len(str(i+1)) + 1\n array[i, 0] = array[i, 0][int(drop_id):]\n return array","def array2img(array):\n if len(array.shape) == 2:\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='L')\n elif len(array.shape) == 3:\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='RGB')\n else:\n print('Income array is not at appropriate shape!')","def convertToLongArray(booleanArray: typing.List[bool]) -> typing.List[int]:\n ...","def basic_array_ejection():\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\n\n srs: pd.Series = arr.to_pandas() # NOTE: Requires pandas installation\n nparr: np.ndarray = arr.to_numpy()\n list_: List[dict] = arr.to_pylist()\n str_: str = arr.to_string()\n\n results = {\n 'to_pandas > to_list': srs.to_list(),\n 'to_numpy > tolist': nparr.tolist(),\n 'to_pylist': list_,\n 'to_string': str_,\n }\n\n pretty_print_result_map(results)","def reduce_array(\n array: np.ndarray,\n components: typing.Optional[typing.Collection[int]] = None,\n max_val: typing.Optional[int] = None,\n dtype=None,\n) -> np.ndarray:\n # this function minimal dtype is np.uint8 so there is no need to do calculation.\n if components is None:\n components = np.unique(array.flat)\n if max_val is None:\n max_val = np.max(components)\n\n if max_val is None:\n max_val = np.max(array)\n\n translate = np.zeros(max_val + 1, dtype=dtype or minimal_dtype(len(components) + 1))\n\n for i, val in enumerate(sorted(components), start=0 if 0 in components else 1):\n translate[val] = i\n\n return translate[array]","def writeArray(self, array, mapping=None):\n offset = self.scanOffset\n shape = self.scanShape\n nf, ny, nx = shape\n stride = self.scanStride\n \n dx = self.colVector\n dy = self.rowVector\n\n # Make grid of indexes\n r = np.mgrid[0:ny, 0:nx]\n if self.bidirectional:\n r[:, 1::2] = r[:, 1::2, ::-1]\n \n # Convert indexes to global coordinates.\n v = np.array([dy, dx]).reshape(2,1,1,2) \n r = r[...,np.newaxis]\n q = (v*r).sum(axis=0) # order is now (row, column, xy)\n q += self.scanOrigin.reshape(1,1,2)\n \n # Convert via mapping (usually to mirror voltages)\n # xy = q.reshape(q.shape[0]*q.shape[1], 2)\n # pg.plot(xy[:,0], xy[:,1])\n if mapping is None:\n qm = q\n else:\n x,y = mapping(q[...,0], q[...,1])\n qm = np.empty(q.shape, x.dtype)\n qm[...,0] = x\n qm[...,1] = y\n \n ### select target array based on offset, shape, and stride. \n # first check that this array is long enough\n if array.shape[0] < offset + shape[0] * stride[0]:\n print(self)\n raise Exception(\"Array is too small to contain the specified rectangle scan. Available: %d Required: %d\" % (array.shape[0], shape[0] * stride[0]))\n \n # select the target sub-array\n target = pg.subArray(array, offset, shape, stride)\n \n # copy data into array (one copy per frame)\n target[:] = qm[np.newaxis, ...]","def conver1D(array):\n l = array.shape\n total = np.zeros((0, l[1] * l[2]), dtype=np.float32)\n i = 0\n for i in range(24):\n tempData = array[i]\n array1D = []\n for x in tempData:\n for s in x:\n array1D.append(s)\n total = np.insert(total, i, array1D, axis=0)\n return total","def process_array(arr, session):\n img = Image.fromarray(arr)\n cim_resized = img.resize((40,40), resample=Image.LANCZOS)\n n = cim_resized.convert('L')\n cropped = np.array(n).astype(np.float64)\n normalized_cropped_image = cropped - np.mean(cropped)\n normalized_cropped_image = normalized_cropped_image.reshape((-1, image_size, image_size, num_channels)).astype(np.float32)\n predicted_arr = predict_live(normalized_cropped_image, session)\n label = ''.join(['' if int(x[0]) == 10 else str(x[0]) for x in list(predicted_arr)])\n print 'NUMBER IS : ' + label","def __call__(self, mp_array, PYT_array):\n valid_mask = mp_array != _INDEX_NODATA\n result = numpy.empty_like(mp_array)\n result[:] = _INDEX_NODATA\n result[valid_mask] = PYT_array[valid_mask]-mp_array[valid_mask]\n max_mask = valid_mask & (result < 0.0)\n result[max_mask] = 0.0\n return result","def geotrans_array_deterministic(data, num_aug):\n rot_list = [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)]\n rot_flip_list = [[rdata] + [np.flip(rdata, axis=2)] for rdata in rot_list]\n\n return_list = []\n for sublist in rot_flip_list:\n for item in sublist:\n return_list.append(item)\n\n return np.concatenate(return_list[:num_aug], axis=0)","def Array2PIL(a,lut=None,minvalue=None,maxvalue=None,width=None,height=None,\n flip=None):\n import Image # we only need it here ...\n\n if flip==\"ud\": #up-down exchange\n a=a[::-1,:]\n h,w=Numeric.shape(a)\n## a_min=Numeric.minimum.reduce((Numeric.ravel(a)))\n## a_max=Numeric.maximum.reduce((Numeric.ravel(a)))\n a_min=min(Numeric.ravel(a))\n a_max=max(Numeric.ravel(a))\n\n # allow for an user-specified maximal value:\n if maxvalue!=None and maxvalue>a_max:\n a_max=maxvalue\n # allows for an user-specified minimal value:\n if minvalue!=None and minvalue<a_min:\n a_min=minvalue\n\n if lut is not None:\n if len(lut[0]) == 256:\n \n a=(Numeric.ravel(255.0*(a-a_min)/\n (a_max-a_min))).astype(Numeric.UInt8)\n\n rgb=Numeric.zeros( (len(a),3),typecode=Numeric.UInt8)\n\n\n lut_=Numeric.zeros( (3,len(lut[0])),Numeric.UInt8)\n lut_[0]=lut[0].astype(Numeric.UInt8)\n lut_[1]=lut[1].astype(Numeric.UInt8)\n lut_[2]=lut[2].astype(Numeric.UInt8)\n\n # This is much faster than the original zip/ravel variant ...\n rgb[:,0]=Numeric.take(lut_[0],a)\n #print \"rtake\"\n rgb[:,1]=Numeric.take(lut_[1],a)\n #print \"gtake\"\n rgb[:,2]=Numeric.take(lut_[2],a)\n #print \"btake\"\n #rgb=Numeric.ravel(((Numeric.array(zip(r,g,b),\n # typecode=Numeric.UInt8))))\n\n #print \"rgb done\"\n else:\n N = len(lut[0])\n print \"LUT with N=%d entries\" % N\n if N>=256*256:\n print \"UUPS, more than uint16 colors??\", N\n raise ValueError(\"N too large\")\n \n a = (Numeric.ravel((N-1)*(a-a_min)/\n (a_max-a_min))).astype(Numeric.UInt16)\n\n rgb = Numeric.zeros( (len(a), 3), typecode=Numeric.UInt16)\n\n lut_ = Numeric.zeros( (3,len(lut[0])), Numeric.UInt16)\n lut_[0] = lut[0].astype(Numeric.UInt16)\n lut_[1] = lut[1].astype(Numeric.UInt16)\n lut_[2] = lut[2].astype(Numeric.UInt16)\n\n # This is much faster than the original zip/ravel variant ...\n rgb[:,0] = Numeric.take(lut_[0],a)\n rgb[:,1] = Numeric.take(lut_[1],a)\n rgb[:,2] = Numeric.take(lut_[2],a)\n\n rgb = (rgb*256.0/N).astype(Numeric.UInt8)\n\n else: # simple grey scale ramp...\n a=(Numeric.ravel(255.0*(a-a_min)/\n (a_max-a_min))).astype(Numeric.UInt8)\n # convert to (r_0,g_0,b_0,r_1,g_1,b_1,....)\n rgb=Numeric.ravel(Numeric.array(zip(a,a,a)))\n\n # create a PIL RGB image\n #print \"w/h\",w,h\n im=Image.new(\"RGB\",(w,h))\n #print \"imfromstring:\"\n im.fromstring(rgb.tostring())\n #print \"done ...\"\n \n # scale image ?\n if height!=None and width==None:\n im=im.resize(w/h*height,height)\n elif height==None and width!=None:\n im=im.resize(width,h/w*width)\n elif height!=None and width!=None:\n im=im.resize(width,height)\n\n return(im)","def __init__(self):\n self.array = [None] * 1543","def __init__(self):\n self.arr = [-1] * 1000001","def test_reference_to_array(self):\n arr = numpy.arange(0.0, 10.0, 0.1)\n arr = numpy.reshape(arr, (25, 4))\n vtk_arr = array_handler.array2vtk(arr)\n arr1 = array_handler.vtk2array(vtk_arr)\n # Now make sure these are using the same memory.\n arr[0][0] = 100.0\n self.assertEqual(arr[0][0], arr1[0][0])\n self.assertEqual(arr.shape, arr1.shape)","def sanitize_array(array):\n a = np.ravel(array)\n maxi = np.nanmax(a[np.isfinite(a)])\n mini = np.nanmin(a[np.isfinite(a)])\n array[array == float('inf')] = maxi\n array[array == float('-inf')] = mini\n mid = (maxi + mini) / 2\n array[np.isnan(array)] = mid\n return array","def plume_location_multiple_realizations(t_target_array, folder, prefix, n_realization, attrib='x_array', start=0):\n #first stich together all the arrays\n #read in he first one\n\n file_name = prefix + '_' + str(start) + \".pkl\"\n file_address = os.path.join(folder, file_name)\n with open(file_address, 'rb') as input:\n dataHolder = pickle.load(input)\n x_big = getattr(dataHolder, attrib)\n t_big = dataHolder.t_array\n print 'making large array from realizations...'\n for i in range(start+1, start+n_realization):\n file_name = prefix + \"_\" + str(i) + \".pkl\"\n file_address = os.path.join(folder, file_name)\n with open(file_address, 'rb') as input:\n dataHolder = pickle.load(input)\n x_mat = getattr(dataHolder, attrib)\n t_mat = dataHolder.t_array\n x_big = np.vstack((x_big, x_mat))\n t_big = np.vstack((t_big, t_mat))\n print 'done'\n n_given_times = len(t_target_array)\n n_particles = t_big.shape[0]\n out_put_array = np.zeros((n_given_times, n_particles))\n for i in range(n_given_times):\n t = t_target_array[i]\n out_put_array[i, :] = plume_location_at_given_time(t, x_big, t_big)\n return out_put_array","def victorylap(array):\n for i in range(0, array.len()):\n array.peek(i, False, True, 0.01) # Run it slower","def _as_u64_array(array):\n return ffi.cast(\"unsigned long int*\", array.ctypes.data)","def time_scheme2_ne(array):\n\n bins = 1000\n num_fft = 123 #the reduced number of frequency bins\n\n # reshape into two axis: axis zero is time, axis 1 is frequency\n # then take the transpose, so that axis zero is frequency\n raw = array.reshape((-1,num_fft)).T\n\n # create new array\n new = np.zeros(raw.shape)\n\n # don't time average in frequency bins 0 to 54\n new[0:54,...] = raw[0:54,...]\n\n # time average in frequency bins 54 to 66\n factor1 = 5\n a = 54\n while a <= 66:\n # b = a + 1\n compress = raw[a,...]\n new[a,:200] = binning(compress, factor1, expand=False)\n a += 1\n del a\n\n # don't time average in frequency bins 66 to 116\n new[66:116,...] = raw[66:116,...]\n\n # time average in frequency bins 116 to 123\n factor2 = 5\n a = 116\n while a <= 122:\n compress = raw[a,...]\n new[a,:200] = binning(compress, factor2, expand=False)\n a += 1\n del a\n\n # transpose back to the original array shape\n new1 = new.T\n\n # ensure that the array is the correct shape\n if new1.shape == (bins, num_fft):\n # make array one dimensional again\n new2 = new1.reshape((1,-1))\n new3 = new2[new2 != 0]\n return new3\n else:\n raise RuntimeError('Output array is the wrong shape, something went wrong.')","def data(self, arr):\n self.bitmap(arr, 1)","def __init__(self):\n self.size = 1000\n self.mapArray = [None] * self.size","def recursive_index_decode(int_array, max=32767, min=-32768):\n out_arr = []\n decoded_val = 0\n for item in int_array.tolist():\n if item==max or item==min:\n decoded_val += item\n else:\n decoded_val += item\n out_arr.append(decoded_val)\n decoded_val = 0\n return numpy.asarray(out_arr,dtype=numpy.int32)","def unlock_array(a):\n safe_call(backend.get().af_unlock_array(a.arr))","def regular_to_ragged(array):\n array_list = []\n for i in range(array.shape[0]):\n array_list.append(trim_zeros(array[i]))\n return array_list","def __array_wrap__(self, out_arr, context=None): #pylint: disable=no-self-use, unused-argument\n if out_arr.shape != (3,):\n out_arr = out_arr.view(np.ndarray)\n return out_arr","def _solve(self) -> CasADiArrayType:\n pass","def normalize(array):\n\treturn array/np.max(array)","def test_degrade_map_recarray(self):\n random.seed(seed=12345)\n\n nside_coverage = 32\n nside_map = 1024\n nside_new = 256\n\n dtype = [('col1', 'f8'), ('col2', 'f8'), ('col3', 'i4')]\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage, nside_map, dtype, primary='col1')\n pixel = np.arange(20000)\n values = np.zeros_like(pixel, dtype=dtype)\n values['col1'] = random.random(size=pixel.size)\n values['col2'] = random.random(size=pixel.size)\n values['col3'] = random.poisson(size=pixel.size, lam=2)\n sparse_map.update_values_pix(pixel, values)\n\n ra, dec = hpg.pixel_to_angle(nside_map, pixel)\n\n # Make the test values\n hpmap_col1 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n hpmap_col2 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n hpmap_col3 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\n hpmap_col1[pixel] = values['col1']\n hpmap_col2[pixel] = values['col2']\n hpmap_col3[pixel] = values['col3']\n\n # Degrade healpix maps\n hpmap_col1 = hp.ud_grade(hpmap_col1, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\n hpmap_col2 = hp.ud_grade(hpmap_col2, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\n hpmap_col3 = hp.ud_grade(hpmap_col3, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\n ipnest_test = hpg.angle_to_pixel(nside_new, ra, dec)\n\n # Degrade the old map\n new_map = sparse_map.degrade(nside_out=nside_new)\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col1'],\n hpmap_col1[ipnest_test])\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col2'],\n hpmap_col2[ipnest_test])\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col3'],\n hpmap_col3[ipnest_test])\n\n # Test degrade-on-read\n self.test_dir = tempfile.mkdtemp(dir='./', prefix='TestHealSparse-')\n\n fname = os.path.join(self.test_dir, 'test_recarray_degrade.hs')\n sparse_map.write(fname)\n\n new_map2 = healsparse.HealSparseMap.read(fname, degrade_nside=nside_new)\n\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col1'],\n hpmap_col1[ipnest_test])\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col2'],\n hpmap_col2[ipnest_test])\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col3'],\n hpmap_col3[ipnest_test])","def lookup_array(self, *args, **kwargs): # real signature unknown\n pass","def lookup_array(self, *args, **kwargs): # real signature unknown\n pass","def detect_min_max(arr):\n\n max_value = max(np.absolute(np.reshape(arr, -1)))\n peaks_max = []\n peaks_min = []\n x_max = []\n y_max = []\n z_max = []\n x_min = []\n y_min = []\n z_min = []\n\n for j1 in range(10, arr.shape[0]-10):\n for j2 in range(10, arr.shape[1]-10):\n for j3 in range(10, arr.shape[2]-10):\n if (np.absolute(arr[j1, j2, j3]) > 0.3*max_value):\n\n aaaa = [\n arr[j1, j2, j3 + 1], arr[j1, j2 + 1, j3],\n arr[j1 + 1, j2, j3], arr[j1, j2, j3 - 1],\n arr[j1, j2 - 1, j3], arr[j1 - 1, j2, j3],\n arr[j1 + 1, j2 + 1, j3 + 1],\n arr[j1 - 1, j2 - 1, j3 - 1],\n arr[j1 - 1, j2 + 1, j3 + 1], arr[j1, j2 + 1, j3 + 1],\n arr[j1, j2 - 1, j3 - 1], arr[j1, j2 - 1, j3 + 1],\n arr[j1, j2 + 1, j3 - 1], arr[j1 + 1, j2, j3 + 1],\n arr[j1 - 1, j2, j3 - 1], arr[j1 - 1, j2, j3 + 1],\n arr[j1 + 1, j2, j3 - 1], arr[j1 + 1, j2 + 1, j3],\n arr[j1 - 1, j2 - 1, j3], arr[j1 + 1, j2 - 1, j3],\n arr[j1 - 1, j2 + 1, j3], arr\n [j1 + 1, j2 - 1, j3 + 1], arr\n [j1 + 1, j2 + 1, j3 - 1], arr\n [j1 - 1, j2 - 1, j3 + 1], arr\n [j1 + 1, j2 - 1, j3 - 1], arr\n [j1 - 1, j2 + 1, j3 - 1]]\n bbbb = [\n arr[j1, j2, j3 + 9], arr[j1, j2 + 9, j3],\n arr[j1 + 9, j2, j3], arr[j1, j2, j3 - 9],\n arr[j1, j2 - 9, j3], arr[j1 - 9, j2, j3]]\n\n if ((arr[j1, j2, j3] > max(aaaa)) and (max(aaaa) > max(bbbb))):\n peaks_max = np.append(peaks_max, arr[j1, j2, j3])\n x_max = np.append(x_max, j1)\n y_max = np.append(y_max, j2)\n z_max = np.append(z_max, j3)\n\n if ((arr[j1, j2, j3] < min(aaaa)) and (min(aaaa) < min(bbbb))):\n peaks_min = np.append(peaks_min, arr[j1, j2, j3])\n x_min = np.append(x_min, j1)\n y_min = np.append(y_min, j2)\n z_min = np.append(z_min, j3)\n\n return peaks_min, np.vstack(\n (x_min, y_min, z_min)), peaks_max, np.vstack(\n (x_max, y_max, z_max))","def unwrap_array(array, mask, algorithm='py_gold', additional=False,\n **keyargs):\n if algorithm not in ['py_gold', 'c_gold', 'quality_guided', 'mask_cut']:\n raise AttributeError('No algorithm named {}'.format(algorithm))\n\n if array.shape != mask.shape:\n raise ValueError(\"Mask does not fit to array!\")\n\n if isinstance(array, MRRArray):\n array = array['phase'].view(np.ndarray)\n\n # test if array wrapped to 0..1\n if array.min() < 0.0 or array.max() > 1.0:\n print '''Warning: Array should be normalized to contain data ranging\n from 0.0 to 1.0. Data renormalized, check results!'''\n normalize_array(array)\n\n# if algorithm == 'c_gold':\n# if not goldstein_available:\n# print 'c_gold is not available, using py_gold instead'\n# algorithm = 'py_gold'\n# else:\n# unwr, data = c_gold(array.astype(np.float32), mask, **keyargs)\n\n if algorithm == 'py_gold':\n unwr, flags, num = unwrap_py_gold(array, mask, **keyargs)\n data = (flags, num)\n\n if algorithm == 'quality_guided':\n qual = 1./(DerivativeVariance(array) + 1e-3) # avoid division by zero\n unwr = unwrap_quality_guided(array, qual, mask, **keyargs)\n data = qual\n\n if algorithm == 'mask_cut':\n qual = 1./(DerivativeVariance(array) + 1e-3) # avoid division by zero\n unwr, flags, num = unwrap_mask_cut(array, qual, mask=mask, **keyargs)\n data = (qual, flags, num)\n\n if additional:\n return unwr, data\n else:\n return unwr","def geo_m_v2(data_array):\n r = 6378.137 #promien ziemi w km\n delta = np.zeros(data_array.size//7-1)\n alo = data_array[0][1]\n ala = data_array[0][2]\n count = 0\n for row in data_array[1:]:\n dLat = (row[2] - ala) * math.pi/180.0\n dLon = (row[1] - alo) * math.pi/180.0\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\n * math.sin(dLon/2.0)**2\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\n count += 1\n alo = row[1]\n ala = row[2]\n return delta","def pack_unpack_hard():\n # Array is apprx. 1.5 GB large\n # should make apprx 1536 chunks\n pack_unpack(100, chunk_size=reverse_pretty('1M'), progress=simple_progress)","def solution(array):\n result = np.array(array)\n return result[::-1]","def rearrange(self, an_array):\n\tnew_array = an_array*0\n\tn=new_array.size()\n\tnew_array[n/2:] = an_array[:n/2]\n\tnew_array[:n/2] = an_array[n/2:]\n\treturn new_array","def translate(data):\n\t######## REALLY SLOW CODE!!!! OPTIMIZE!!! ########\n\t\"\"\"make the given array a continous set of numbers\n\t ex - translate([1,1,1,33,33,55,55]) -> [1,1,1,2,2,3,3] \"\"\"\n\t# Make the data into a set. Then make a hashmap and then use the map function to pull out the \n\t# new value from the hashmap\n\tout = []\n\t# lens = [data.count(k) for k in sorted(set(data))]\n\t# nested = map(lambda indx:[indx for i in range(lens[indx-1])],range(1, len(lens)+1))\n\t# return [item for sublist in nested for item in sublist]\n\thsh = {j: data.count(j) for j in set(data)}\n\tcnt = 0\n\tfor k in sorted(hsh.keys()):\n\t\tout += [cnt for i in range(hsh[k])]\n\t\tcnt += 1\n\t# ctr = 0\n\t# prev = data[0]\n\t# for point in data:\n\t# \tif point != prev:\n\t# \t\tprev = point\n\t# \t\tctr += 1\n\t# \tout.append(ctr)\n\treturn out","def array(self, array):\n\n self._array = array","def test_isarray_gtiff(self):\n self.assertIsInstance(_test_array(landsat_gtiff), np.ndarray)","def test_array_uplift(parser):\n doc = parser.parse(b'[0, 1, 2, 3, 4, 5]')\n assert isinstance(doc, simdjson.Array)\n\n assert doc.as_list() == [0, 1, 2, 3, 4, 5]\n assert isinstance(doc.as_list(), list)","def _align_np_datatype_for_array(array):\n return np.asarray(array, _numpy_datatype_from_nd4j_context())","def ndarray_to_rotation(array: np.ndarray) -> carla.Rotation: # pylint: disable=no-member\n return carla.Rotation(*list(map(float, array))) # pylint: disable=no-member","def fits_to_nparray(file):\n hdu_list = fits.open(file)\n image_data = hdu_list[0].data\n image_data=image_data.astype(np.uint16)\n \n gdal_array.SaveArray(image_data, file[:-5]+\".tif\")\n \n return image_data","def initArrayWithNumbers(self, array):\n for i in range(array.shape[0]):\n array[i][0] = 1\n for j in range(array.shape[1]):\n array[0][j] = 1\n return array","def convert_to_compact_array(data, label):\n indices = np.arange(230 * 230).reshape(230, 230)\n t1, t2, pd, dn = label\n m = np.ma.masked_equal(pd, 0)\n t1_masked, t2_masked, pd_masked, indices_masked, dn_masked = \\\n np.ma.masked_array(t1, m.mask), np.ma.masked_array(t2, m.mask), \\\n np.ma.masked_array(pd, m.mask), np.ma.masked_array(indices, m.mask), \\\n np.ma.masked_array(dn, m.mask)\n t1_compressed, t2_compressed, pd_compressed, indices_compressed, dn_compressed = \\\n np.ma.compressed(t1_masked), np.ma.compressed(t2_masked), \\\n np.ma.compressed(pd_masked), np.ma.compressed(indices_masked), \\\n np.ma.compressed(dn_masked)\n\n fp_compressed = []\n for index in indices_compressed:\n x = int(index // 230)\n y = int(index % 230)\n fp_compressed.append(data[x][y])\n fp_compressed = np.asarray(fp_compressed)\n # recon = np.zeros((230, 230))\n # x = indices_compressed // 230\n # y = indices_compressed % 230\n # recon[x, y] = t1_compressed[np.arange(len(indices_compressed))]\n\n label = np.asarray([t1_compressed, t2_compressed, pd_compressed, indices_compressed, dn_compressed])\n label = np.transpose(label)\n data = fp_compressed\n return data, label","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def __array__(self):\n return self.array","def decode(self, spikes: np.ndarray) -> np.ndarray:\n pass","def getarray(str_array):\n if ':' in str_array:\n s=str_array.split(':')\n if 'm' in s[0]:\n s2=[cu.convlen(x) for x in s]\n else: \n s2=[float(x) for x in s]\n ns=round((s2[2]-s2[0])/s2[1])+1\n s3=np.linspace(s2[0],s2[2],ns)\n else:\n s3=cu.convlen(str_array)\n \n return s3","def scaleto11(val,check=True):\n if type(val) is not list and type(val) is not np.ndarray:\n val = [val]\n if type(val) is list:\n val = np.array(val)\n assert type(val) is np.ndarray\n assert not check or np.all((val==0) + (val==1))\n return val*2-1","def change_altitude_cm_m(data_array):\n data_array[:, 3] = data_array[:, 3]*0.3048\n return data_array","def check_array(arr: Arrayable) -> np.ndarray:\n if isinstance(arr, np.ndarray):\n return arr\n return np.array(arr)","def export_array(in_array, output_path):\n global proj, geotrans, row, col\n proj = band.GetProjection()\n geotrans = band.GetGeoTransform()\n row = band.RasterYSize\n col = band.RasterXSize\n driver = gdal.GetDriverByName(\"GTiff\")\n outdata = driver.Create(output_path, col, row, 1)\n outband = outdata.GetRasterBand(1)\n outband.SetNoDataValue(-9999)\n outband.WriteArray(in_array)\n # Georeference the image\n outdata.SetGeoTransform(geotrans)\n # Write projection information\n outdata.SetProjection(proj)\n outdata.FlushCache()\n outdata = None","def rotate_array_deterministic(data):\n return np.concatenate(\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)","def _share_array(arr_np, typecode_or_type):\n\n arr = mp.RawArray(typecode_or_type, arr_np.ravel())\n return arr, arr_np.shape","def corrected_rotation(x_arr, mu):\n if x_arr < (mu-180):\n x_arr += 360\n elif x_arr > mu+180:\n x_arr -= 360\n\n return x_arr","def highpass(arrayin, rad=0.5):\r\n circ = circle(arrayin.shape[0], arrayin.shape[1], radius = rad/2.0)\r\n arrayout = fft2(ifft2(arrayin) * (1.0 - circ))\r\n arrayout = np.array(arrayout, dtype=arrayin.dtype)\r\n return arrayout","def backconvert_units(array, out_units):\n if out_units == \"None\" or out_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def DARP2016_MicArray():\n\n M = 36 # number of mics\n array_height = -0.49 # [m] (ref. to airfoil height at z=0)\n\n # mic coordinates (corrected for DARP2016 configuration)\n XYZ_array = np.array([[0., 0.025, 0.08477, 0.12044, 0.18311, 0.19394,\n 0.01559, 0.08549, 0.16173, 0.19659, 0.24426, -0.00556,\n 0.02184, 0.08124, 0.06203, 0.11065, -0.02252, -0.05825,\n -0.06043, -0.11924, -0.10628, -0.02252, -0.09449, -0.15659,\n -0.21072, -0.24318, -0.00556, -0.05957, -0.13484, -0.14352,\n -0.19696, 0.01559, 0.02021, -0.01155, 0.03174, -0.00242],\n [-0., -0., 0.04175, 0.11082, 0.10542, 0.15776,\n -0.01955, -0.04024, -0.02507, -0.07743, -0.05327, -0.02437,\n -0.09193, -0.14208, -0.20198, -0.22418, -0.01085, -0.0744,\n -0.1521, -0.17443, -0.22628, 0.01085, -0.00084, -0.04759,\n -0.01553, -0.05799, 0.02437, 0.07335, 0.09276, 0.15506,\n 0.15397, 0.01955, 0.09231, 0.16326, 0.20889, 0.24999],\n array_height*np.ones(M)])\n\n # calibration factors\n array_cal = np.array([73.92182641429085, 96.84446743391487, 85.48777846463159,\n 85.24410968090712, 83.63917149322562, 68.94090765134432,\n 79.2385037527723, 112.77357210746612, 84.8483307868491,\n 87.18956628936178, 97.75046920293282, 89.2829545690508,\n 79.51644155562396, 90.39403884030057, 80.71754629014218,\n 89.4418210091059, 98.33634233056068, 79.2212022850229,\n 91.25543447201031, 89.55040012572815, 85.77495667666254,\n 82.74418222820202, 84.63061055646973, 77.01568014644964,\n 95.52764533324982, 92.16734812591154, 95.27123074600838,\n 87.93335310521428, 96.65066131188675, 93.58564782091074,\n 78.1446818728945, 101.3047738767648, 83.68569643491034,\n 84.7981031520437, 94.40796508430756, 83.52266614867919])\n\n return XYZ_array, array_cal","def checkio(numbers_array):\n \n return sorted(numbers_array, key=abs)","def data_filter(input_array, step):\n mod = input_array.shape[0] % step\n rows = input_array.shape[0] // step\n factor = np.arange(rows)\n if mod:\n in_mat = np.reshape(input_array[:-mod], (rows, -1))\n min_array = np.r_[in_mat.min(axis=1), min(input_array[-mod:])]\n max_array = np.r_[in_mat.max(axis=1), max(input_array[-mod:])]\n median = np.median(in_mat, axis=1)\n median_rest = np.median(input_array[-mod:])\n median_array = np.r_[median, median_rest]\n\n # get min, max and average value indices\n min_ind = in_mat.argmin(axis=1)\n min_ind += factor * step\n min_ind = np.append(min_ind, input_array[-mod:].argmin() + rows * step)\n\n max_ind = in_mat.argmax(axis=1)\n max_ind += factor * step\n max_ind = np.append(max_ind, input_array[-mod:].argmax() + rows * step)\n\n median_trans = np.reshape(median, (rows, -1))\n median_ind = abs(in_mat - median_trans).argmin(axis=1)\n median_ind += factor * step\n median_ind = np.append(median_ind, abs(\n input_array[-mod:] - median_rest).argmin() + rows * step)\n\n else:\n in_mat = np.reshape(input_array, (input_array.shape[0] // step, -1))\n min_array = in_mat.min(axis=1)\n max_array = in_mat.max(axis=1)\n median_array = np.median(in_mat, axis=1)\n\n # get min, max and average value indices\n min_ind = in_mat.argmin(axis=1)\n min_ind += factor * step\n\n max_ind = in_mat.argmax(axis=1)\n max_ind += factor * step\n\n median_trans = np.reshape(median_array, (rows, -1))\n median_ind = abs(in_mat - median_trans).argmin(axis=1)\n median_ind += factor * step\n\n return min_array, median_array, max_array, min_ind, median_ind, max_ind","def normalize(self,arr):\n arr = arr/(arr.max()/255.0)\n return arr","def make_float(array):\n finial_array = []\n\n for number in array:\n finial_array.append(float(number))\n return finial_array","def test_TimeArray_convert_unit():","def create_array( n ):","def normalize_array(image_array):\n\n array = image_array.astype(np.float)\n array /= 255.0\n return array","def convertToPrimitiveArray(objectArray: typing.List[typing.Any]) -> typing.Any:\n ...","def map_read(array, read, res=1.0):\n start, stop = read\n array[int(ceil(start/res)):int(ceil(stop/res))] += 1","def double(arr):\n newarr = np.array([(xx,xx) for xx in arr]).ravel()\n return newarr","def coerced_shape(array):\n if array.shape is not None:\n return array.shape\n\n r = array.eval().dimensions().project('low', 'high').toarray()\n shp = tuple(np.maximum(r['high'] - r['low'] + 1, 0))\n return shp","def __init__(self):\n self.array = [None for i in range(10000)]","def __cut_arrays(data_array, maximum_time, arrays_to_cut):\n\n try:\n begin_time = data_array[arrays_to_cut[0]][0][0]\n end_time = data_array[arrays_to_cut[0]][0][-1]\n delta_time = (\n data_array[arrays_to_cut[0]][0][1]\n - data_array[arrays_to_cut[0]][0][0]\n )\n total_time = end_time - begin_time\n if total_time > maximum_time:\n over_time = total_time - maximum_time\n array_elm_to_drop = int(over_time / delta_time)\n for arrays in arrays_to_cut:\n data_array[arrays][0] = data_array[arrays][0][\n array_elm_to_drop:\n ]\n data_array[arrays][1] = data_array[arrays][1][\n array_elm_to_drop:\n ]\n except:\n pass","def normalize(data):\n\n\t#return [float(x) / pow(2, 15) for x in data]\n\n\tl = [float(x) / pow(2, 15) for x in data]\n\treturn np.asarray(l)","def floatArrayToPrt(float_array):\n\n util = OpenMaya.MScriptUtil() \n util.createFromList(float_array, len(float_array))\n\n return util.asFloatPtr()","def wrap(array):\n\t\t\t\n\t\t\tassert array.ndim == 2, ('works on 2D arrays only; expecting '\n\t\t\t\t\t\t\t\t\t 'self.cond_tuning, which should be 2D')\n\t\t\t\t\t\t\t\t\t\t\t\n\t\t\treturn np.column_stack((array, array[..., 0]))","def array_fractional_reducer(array, fraction, axis=0):\r\n number_of_total_elements = np.shape(array)[axis]\r\n number_of_kept_elements = round(number_of_total_elements * fraction)\r\n index = np.round(np.linspace(0, np.shape(array)[axis] - 1, number_of_kept_elements)).astype(int)\r\n return np.take(array, index, axis)","def padArray(ori_array, pad_size):\n if (pad_size > 0):\n [x_size, y_size] = ori_array.shape\n lg_array = numpy.ones((x_size+2*pad_size,y_size+2*pad_size))\n lg_array[pad_size:(x_size+pad_size),pad_size:(y_size+pad_size)] = ori_array.astype(numpy.float64)\n lg_array[0:pad_size,:] = numpy.flipud(lg_array[pad_size:2*pad_size,:])\n lg_array[(x_size+pad_size):(x_size+2*pad_size),:] = numpy.flipud(lg_array[x_size:(x_size+pad_size),:])\n lg_array[:,0:pad_size] = numpy.fliplr(lg_array[:,pad_size:2*pad_size])\n lg_array[:,(y_size+pad_size):(y_size+2*pad_size)] = numpy.fliplr(lg_array[:,y_size:(y_size+pad_size)])\n return lg_array\n \n else:\n return ori_array","def segment_array(a):\n\n l = [array(a.typecode) for chaff in range(16)]\n index = 0\n\n for i in range(0, len(a), 16):\n l[index].extend(a[i:i + 16])\n index = (index + 1) % 16\n\n return l","def com_msd_multiple_realizations(t_target_array, folder, prefix, n_realization, attrib = 'x_array'):\n #first stich together all the arrays\n #read in he first one\n file_name = prefix + \"_0\" + \".pkl\"\n file_address = os.path.join(folder, file_name)\n with open(file_address, 'rb') as input:\n dataHolder = pickle.load(input)\n x_big = getattr(dataHolder, attrib)\n t_big = dataHolder.t_array\n for i in range(1,n_realization):\n file_name = prefix + \"_\" + str(i) + \".pkl\"\n file_address = os.path.join(folder, file_name)\n with open(file_address, 'rb') as input:\n dataHolder = pickle.load(input)\n x_mat = getattr(dataHolder, attrib)\n t_mat = dataHolder.t_array\n x_big = np.vstack((x_big, x_mat))\n t_big = np.vstack((t_big, t_mat))\n out_put_size = len(t_target_array)\n com_array = np.zeros(out_put_size)\n msd_array = np.zeros(out_put_size)\n for i in range(out_put_size):\n t = t_target_array[i]\n com_array[i], msd_array[i] = com_msd_at_given_time(t, x_big, t_big)\n return com_array, msd_array","def GPy_reformat_3D(array):\r\n n_timesteps = np.shape(array)[-1]\r\n if len(np.shape(array)) == 1:\r\n array = array.reshape(n_timesteps, 1)\r\n return [array, array, array]\r\n elif len(np.shape(array)) == 2:\r\n array = array.T\r\n array1 = array[:, 0, None]\r\n array2 = array[:, 1, None]\r\n array3 = array[:, 2, None]\r\n return [array1, array2, array3]\r\n else:\r\n return print(\"Error in GPy_reformat, input array is wrong shape.\")","def traj_rfft(array):\r\n return Trajectory(my_rfft(array))","def ravel(arrayin):\r\n if arrayin.dtype == complex :\r\n arrayout = np.concatenate((np.ravel(np.real(arrayin)), np.ravel(np.imag(arrayin))), axis = 0)\r\n else :\r\n arrayout = np.ravel(arrayin)\r\n return arrayout","def type_array():\n return []","def __init__(self,array):\n self.arr = array\n # self.result = []","def clean_arrays_dict(arrays_dict):\n for k in arrays_dict.keys():\n volumes_list = arrays_dict[k]\n arrays_dict[k] = [convert_Volume_to_slices(v) for v in volumes_list]","def _apply_array_spin12_lowfilling(self, h1e: 'Nparray',\n h2e: 'Nparray') -> 'Nparray':\n if fqe.settings.use_accelerated_code:\n return self._apply_array_spin12_lowfilling_fast(h1e, h2e)\n else:\n return self._apply_array_spin12_lowfilling_python(h1e, h2e)","def ragged_to_regular(array_list):\n join_length = len(array_list)\n # the weird line below is faster than allocating numpy arrays\n dims = list(zip(*[array.shape for array in array_list]))\n max_dims = tuple(max(dim) for dim in dims)\n dtype = array_list[0].dtype\n padded_hypercube = np.zeros((join_length,) + max_dims, dtype=dtype)\n for i in range(join_length):\n multislice = (slice(i, i+1, 1),) + tuple(slice(0, dim[i], 1)\n for dim in dims)\n padded_hypercube[multislice] = array_list[i]\n return padded_hypercube","def rescale_array(array, old_range, new_range, dtype):\n if not HAS_NUMPY:\n LOGGER.error(\"The Python library numpy is required for this operation\")\n return\n\n old_min, old_max = old_range\n if array.min() < old_min or array.max() > old_max:\n ## truncate:\n array = numpy.clip(array, old_min, old_max)\n new_min, new_max = new_range\n old_delta = float(old_max - old_min)\n new_delta = float(new_max - new_min)\n if old_delta == 0:\n return ((array - old_min) + (new_min + new_max) / 2).astype(dtype)\n else:\n return (new_min + (array - old_min) * new_delta / old_delta).astype(dtype)"],"string":"[\n \"def changeArray(array):\\r\\n\\r\\n return [[float(array[j][i]) for j in range(len(array))] for i in range(len(array[0]))]\",\n \"def solution(array):\\n array1 = np.array(array)\\n array2 = array1.astype(float)\\n return array2\",\n \"def mapping(array, map):\\r\\n n = map.shape[0] \\r\\n if array.dtype == np.complex :\\r\\n arrayout = np.zeros((2*n),dtype=array.real.dtype)\\r\\n for ii in range(n):\\r\\n i = map[ii,0]\\r\\n j = map[ii,1]\\r\\n arrayout[ii] = array[i,j].real\\r\\n arrayout[ii+n] = array[i,j].imag\\r\\n else :\\r\\n arrayout = np.zeros((n),dtype=array.dtype)\\r\\n for ii in range(n):\\r\\n i = map[ii,0]\\r\\n j = map[ii,1]\\r\\n arrayout[ii] = array[i,j]\\r\\n return arrayout\",\n \"def rescale_toa(arr, dtype=np.float32):\\n # First look at raw value dists along bands\\n\\n arr_trans = np.subtract(arr, arr.min(axis=(1, 2))[:, np.newaxis, np.newaxis])\\n arr_rs = np.divide(arr_trans, arr_trans.max(axis=(1, 2))[:, np.newaxis, np.newaxis])\\n if dtype == np.uint8:\\n arr_rs = np.array(arr_rs*255, dtype=np.uint8)\\n return arr_rs\",\n \"def array(self):\",\n \"def unmapping(array, map, N):\\r\\n n = map.shape[0] \\r\\n if (array.shape[0] / 2) == N**2 :\\r\\n arrayout = np.zeros((N,N),dtype=np.complex128)\\r\\n for ii in range(n):\\r\\n i = map[ii,0]\\r\\n j = map[ii,1]\\r\\n arrayout[i,j] = array[ii] + 1.0J * array[ii+n]\\r\\n elif array.shape[0] == N**2 :\\r\\n arrayout = np.zeros((N,N),dtype=array.dtype)\\r\\n for ii in range(n):\\r\\n i = map[ii,0]\\r\\n j = map[ii,1]\\r\\n arrayout[i,j] = array[ii] \\r\\n return arrayout\",\n \"def array_to_raster_noTi(x_pix,y_pix,pixSize,x_min,y_max,proj,array,outFile):\\n \\n\\n driver = gdal.GetDriverByName('GTiff')\\n\\n outDataset = driver.Create(\\n outFile,\\n x_pix,\\n y_pix,\\n 1,\\n gdal.GDT_Float32, )\\n\\n outDataset.SetGeoTransform((\\n x_min, # 0 * top left border of pixel\\n pixSize, # 1\\n 0, # 2\\n y_max, # 3 top left border of pixel\\n 0, # 4\\n -pixSize)) \\n\\n projx = osr.SpatialReference()\\n projx.SetWellKnownGeogCS( proj ) #Get the long coordinate system name\\n wkt_projection = projx.ExportToWkt()\\n\\n outDataset.SetProjection(wkt_projection)\\n outDataset.GetRasterBand(1).WriteArray(array)\\n outDataset.FlushCache() # Write to disk.\\n return outDataset, outDataset.GetRasterBand(1) #If you need to return, remenber to return also the dataset because the band don`t live without dataset.\",\n \"def adapt_array(self,array):\\n import io\\n import array,numpy\\n out = io.BytesIO()\\n numpy.save(out, array)\\n out.seek(0)\\n \\n return out.read()\",\n \"def map_reshaper(map):\\n a = [[map[int(i / 2), int(j / 2)] for j in range(50)] for i in range(50)]\\n return np.array(a)\",\n \"def test_array_factory(self):\\n\\n colors = array([[0.0,0.0,0.0], [1.0,1.0,1.0]])\\n cm = ColorMapper.from_palette_array(colors)\\n cm.range = DataRange1D()\\n\\n ar = ArrayDataSource(array([0.0, 0.5, 1.0]))\\n cm.range.add(ar)\\n b = cm.map_screen(ar.get_data())\\n cm.range.remove(ar)\\n\\n expected = array([0.0, 0.5, 1.0])\\n\\n self.assertTrue(allclose(ravel(b[:,:1]), expected, atol=0.02),\\n \\\"Array factory failed. Expected %s. Got %s\\\" % (expected, b[:,:1]))\\n\\n return\",\n \"def de_project(np_arr):\\n item = (np_arr +1)*255 / 2\\n return item.astype(np.int32, copy=True)\",\n \"def fromarray(self, array):\\n\\n raise NotImplementedError\",\n \"def clean_data(array):\\n ret = np.zeros(len(array))\\n for i in range(len(array)):\\n drop_id = len(str(i+1)) + 1\\n array[i, 0] = array[i, 0][int(drop_id):]\\n return array\",\n \"def array2img(array):\\n if len(array.shape) == 2:\\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='L')\\n elif len(array.shape) == 3:\\n return Image.fromarray(np.clip(array, 0, 255).astype('uint8'), mode='RGB')\\n else:\\n print('Income array is not at appropriate shape!')\",\n \"def convertToLongArray(booleanArray: typing.List[bool]) -> typing.List[int]:\\n ...\",\n \"def basic_array_ejection():\\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\\n\\n srs: pd.Series = arr.to_pandas() # NOTE: Requires pandas installation\\n nparr: np.ndarray = arr.to_numpy()\\n list_: List[dict] = arr.to_pylist()\\n str_: str = arr.to_string()\\n\\n results = {\\n 'to_pandas > to_list': srs.to_list(),\\n 'to_numpy > tolist': nparr.tolist(),\\n 'to_pylist': list_,\\n 'to_string': str_,\\n }\\n\\n pretty_print_result_map(results)\",\n \"def reduce_array(\\n array: np.ndarray,\\n components: typing.Optional[typing.Collection[int]] = None,\\n max_val: typing.Optional[int] = None,\\n dtype=None,\\n) -> np.ndarray:\\n # this function minimal dtype is np.uint8 so there is no need to do calculation.\\n if components is None:\\n components = np.unique(array.flat)\\n if max_val is None:\\n max_val = np.max(components)\\n\\n if max_val is None:\\n max_val = np.max(array)\\n\\n translate = np.zeros(max_val + 1, dtype=dtype or minimal_dtype(len(components) + 1))\\n\\n for i, val in enumerate(sorted(components), start=0 if 0 in components else 1):\\n translate[val] = i\\n\\n return translate[array]\",\n \"def writeArray(self, array, mapping=None):\\n offset = self.scanOffset\\n shape = self.scanShape\\n nf, ny, nx = shape\\n stride = self.scanStride\\n \\n dx = self.colVector\\n dy = self.rowVector\\n\\n # Make grid of indexes\\n r = np.mgrid[0:ny, 0:nx]\\n if self.bidirectional:\\n r[:, 1::2] = r[:, 1::2, ::-1]\\n \\n # Convert indexes to global coordinates.\\n v = np.array([dy, dx]).reshape(2,1,1,2) \\n r = r[...,np.newaxis]\\n q = (v*r).sum(axis=0) # order is now (row, column, xy)\\n q += self.scanOrigin.reshape(1,1,2)\\n \\n # Convert via mapping (usually to mirror voltages)\\n # xy = q.reshape(q.shape[0]*q.shape[1], 2)\\n # pg.plot(xy[:,0], xy[:,1])\\n if mapping is None:\\n qm = q\\n else:\\n x,y = mapping(q[...,0], q[...,1])\\n qm = np.empty(q.shape, x.dtype)\\n qm[...,0] = x\\n qm[...,1] = y\\n \\n ### select target array based on offset, shape, and stride. \\n # first check that this array is long enough\\n if array.shape[0] < offset + shape[0] * stride[0]:\\n print(self)\\n raise Exception(\\\"Array is too small to contain the specified rectangle scan. Available: %d Required: %d\\\" % (array.shape[0], shape[0] * stride[0]))\\n \\n # select the target sub-array\\n target = pg.subArray(array, offset, shape, stride)\\n \\n # copy data into array (one copy per frame)\\n target[:] = qm[np.newaxis, ...]\",\n \"def conver1D(array):\\n l = array.shape\\n total = np.zeros((0, l[1] * l[2]), dtype=np.float32)\\n i = 0\\n for i in range(24):\\n tempData = array[i]\\n array1D = []\\n for x in tempData:\\n for s in x:\\n array1D.append(s)\\n total = np.insert(total, i, array1D, axis=0)\\n return total\",\n \"def process_array(arr, session):\\n img = Image.fromarray(arr)\\n cim_resized = img.resize((40,40), resample=Image.LANCZOS)\\n n = cim_resized.convert('L')\\n cropped = np.array(n).astype(np.float64)\\n normalized_cropped_image = cropped - np.mean(cropped)\\n normalized_cropped_image = normalized_cropped_image.reshape((-1, image_size, image_size, num_channels)).astype(np.float32)\\n predicted_arr = predict_live(normalized_cropped_image, session)\\n label = ''.join(['' if int(x[0]) == 10 else str(x[0]) for x in list(predicted_arr)])\\n print 'NUMBER IS : ' + label\",\n \"def __call__(self, mp_array, PYT_array):\\n valid_mask = mp_array != _INDEX_NODATA\\n result = numpy.empty_like(mp_array)\\n result[:] = _INDEX_NODATA\\n result[valid_mask] = PYT_array[valid_mask]-mp_array[valid_mask]\\n max_mask = valid_mask & (result < 0.0)\\n result[max_mask] = 0.0\\n return result\",\n \"def geotrans_array_deterministic(data, num_aug):\\n rot_list = [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)]\\n rot_flip_list = [[rdata] + [np.flip(rdata, axis=2)] for rdata in rot_list]\\n\\n return_list = []\\n for sublist in rot_flip_list:\\n for item in sublist:\\n return_list.append(item)\\n\\n return np.concatenate(return_list[:num_aug], axis=0)\",\n \"def Array2PIL(a,lut=None,minvalue=None,maxvalue=None,width=None,height=None,\\n flip=None):\\n import Image # we only need it here ...\\n\\n if flip==\\\"ud\\\": #up-down exchange\\n a=a[::-1,:]\\n h,w=Numeric.shape(a)\\n## a_min=Numeric.minimum.reduce((Numeric.ravel(a)))\\n## a_max=Numeric.maximum.reduce((Numeric.ravel(a)))\\n a_min=min(Numeric.ravel(a))\\n a_max=max(Numeric.ravel(a))\\n\\n # allow for an user-specified maximal value:\\n if maxvalue!=None and maxvalue>a_max:\\n a_max=maxvalue\\n # allows for an user-specified minimal value:\\n if minvalue!=None and minvalue<a_min:\\n a_min=minvalue\\n\\n if lut is not None:\\n if len(lut[0]) == 256:\\n \\n a=(Numeric.ravel(255.0*(a-a_min)/\\n (a_max-a_min))).astype(Numeric.UInt8)\\n\\n rgb=Numeric.zeros( (len(a),3),typecode=Numeric.UInt8)\\n\\n\\n lut_=Numeric.zeros( (3,len(lut[0])),Numeric.UInt8)\\n lut_[0]=lut[0].astype(Numeric.UInt8)\\n lut_[1]=lut[1].astype(Numeric.UInt8)\\n lut_[2]=lut[2].astype(Numeric.UInt8)\\n\\n # This is much faster than the original zip/ravel variant ...\\n rgb[:,0]=Numeric.take(lut_[0],a)\\n #print \\\"rtake\\\"\\n rgb[:,1]=Numeric.take(lut_[1],a)\\n #print \\\"gtake\\\"\\n rgb[:,2]=Numeric.take(lut_[2],a)\\n #print \\\"btake\\\"\\n #rgb=Numeric.ravel(((Numeric.array(zip(r,g,b),\\n # typecode=Numeric.UInt8))))\\n\\n #print \\\"rgb done\\\"\\n else:\\n N = len(lut[0])\\n print \\\"LUT with N=%d entries\\\" % N\\n if N>=256*256:\\n print \\\"UUPS, more than uint16 colors??\\\", N\\n raise ValueError(\\\"N too large\\\")\\n \\n a = (Numeric.ravel((N-1)*(a-a_min)/\\n (a_max-a_min))).astype(Numeric.UInt16)\\n\\n rgb = Numeric.zeros( (len(a), 3), typecode=Numeric.UInt16)\\n\\n lut_ = Numeric.zeros( (3,len(lut[0])), Numeric.UInt16)\\n lut_[0] = lut[0].astype(Numeric.UInt16)\\n lut_[1] = lut[1].astype(Numeric.UInt16)\\n lut_[2] = lut[2].astype(Numeric.UInt16)\\n\\n # This is much faster than the original zip/ravel variant ...\\n rgb[:,0] = Numeric.take(lut_[0],a)\\n rgb[:,1] = Numeric.take(lut_[1],a)\\n rgb[:,2] = Numeric.take(lut_[2],a)\\n\\n rgb = (rgb*256.0/N).astype(Numeric.UInt8)\\n\\n else: # simple grey scale ramp...\\n a=(Numeric.ravel(255.0*(a-a_min)/\\n (a_max-a_min))).astype(Numeric.UInt8)\\n # convert to (r_0,g_0,b_0,r_1,g_1,b_1,....)\\n rgb=Numeric.ravel(Numeric.array(zip(a,a,a)))\\n\\n # create a PIL RGB image\\n #print \\\"w/h\\\",w,h\\n im=Image.new(\\\"RGB\\\",(w,h))\\n #print \\\"imfromstring:\\\"\\n im.fromstring(rgb.tostring())\\n #print \\\"done ...\\\"\\n \\n # scale image ?\\n if height!=None and width==None:\\n im=im.resize(w/h*height,height)\\n elif height==None and width!=None:\\n im=im.resize(width,h/w*width)\\n elif height!=None and width!=None:\\n im=im.resize(width,height)\\n\\n return(im)\",\n \"def __init__(self):\\n self.array = [None] * 1543\",\n \"def __init__(self):\\n self.arr = [-1] * 1000001\",\n \"def test_reference_to_array(self):\\n arr = numpy.arange(0.0, 10.0, 0.1)\\n arr = numpy.reshape(arr, (25, 4))\\n vtk_arr = array_handler.array2vtk(arr)\\n arr1 = array_handler.vtk2array(vtk_arr)\\n # Now make sure these are using the same memory.\\n arr[0][0] = 100.0\\n self.assertEqual(arr[0][0], arr1[0][0])\\n self.assertEqual(arr.shape, arr1.shape)\",\n \"def sanitize_array(array):\\n a = np.ravel(array)\\n maxi = np.nanmax(a[np.isfinite(a)])\\n mini = np.nanmin(a[np.isfinite(a)])\\n array[array == float('inf')] = maxi\\n array[array == float('-inf')] = mini\\n mid = (maxi + mini) / 2\\n array[np.isnan(array)] = mid\\n return array\",\n \"def plume_location_multiple_realizations(t_target_array, folder, prefix, n_realization, attrib='x_array', start=0):\\n #first stich together all the arrays\\n #read in he first one\\n\\n file_name = prefix + '_' + str(start) + \\\".pkl\\\"\\n file_address = os.path.join(folder, file_name)\\n with open(file_address, 'rb') as input:\\n dataHolder = pickle.load(input)\\n x_big = getattr(dataHolder, attrib)\\n t_big = dataHolder.t_array\\n print 'making large array from realizations...'\\n for i in range(start+1, start+n_realization):\\n file_name = prefix + \\\"_\\\" + str(i) + \\\".pkl\\\"\\n file_address = os.path.join(folder, file_name)\\n with open(file_address, 'rb') as input:\\n dataHolder = pickle.load(input)\\n x_mat = getattr(dataHolder, attrib)\\n t_mat = dataHolder.t_array\\n x_big = np.vstack((x_big, x_mat))\\n t_big = np.vstack((t_big, t_mat))\\n print 'done'\\n n_given_times = len(t_target_array)\\n n_particles = t_big.shape[0]\\n out_put_array = np.zeros((n_given_times, n_particles))\\n for i in range(n_given_times):\\n t = t_target_array[i]\\n out_put_array[i, :] = plume_location_at_given_time(t, x_big, t_big)\\n return out_put_array\",\n \"def victorylap(array):\\n for i in range(0, array.len()):\\n array.peek(i, False, True, 0.01) # Run it slower\",\n \"def _as_u64_array(array):\\n return ffi.cast(\\\"unsigned long int*\\\", array.ctypes.data)\",\n \"def time_scheme2_ne(array):\\n\\n bins = 1000\\n num_fft = 123 #the reduced number of frequency bins\\n\\n # reshape into two axis: axis zero is time, axis 1 is frequency\\n # then take the transpose, so that axis zero is frequency\\n raw = array.reshape((-1,num_fft)).T\\n\\n # create new array\\n new = np.zeros(raw.shape)\\n\\n # don't time average in frequency bins 0 to 54\\n new[0:54,...] = raw[0:54,...]\\n\\n # time average in frequency bins 54 to 66\\n factor1 = 5\\n a = 54\\n while a <= 66:\\n # b = a + 1\\n compress = raw[a,...]\\n new[a,:200] = binning(compress, factor1, expand=False)\\n a += 1\\n del a\\n\\n # don't time average in frequency bins 66 to 116\\n new[66:116,...] = raw[66:116,...]\\n\\n # time average in frequency bins 116 to 123\\n factor2 = 5\\n a = 116\\n while a <= 122:\\n compress = raw[a,...]\\n new[a,:200] = binning(compress, factor2, expand=False)\\n a += 1\\n del a\\n\\n # transpose back to the original array shape\\n new1 = new.T\\n\\n # ensure that the array is the correct shape\\n if new1.shape == (bins, num_fft):\\n # make array one dimensional again\\n new2 = new1.reshape((1,-1))\\n new3 = new2[new2 != 0]\\n return new3\\n else:\\n raise RuntimeError('Output array is the wrong shape, something went wrong.')\",\n \"def data(self, arr):\\n self.bitmap(arr, 1)\",\n \"def __init__(self):\\n self.size = 1000\\n self.mapArray = [None] * self.size\",\n \"def recursive_index_decode(int_array, max=32767, min=-32768):\\n out_arr = []\\n decoded_val = 0\\n for item in int_array.tolist():\\n if item==max or item==min:\\n decoded_val += item\\n else:\\n decoded_val += item\\n out_arr.append(decoded_val)\\n decoded_val = 0\\n return numpy.asarray(out_arr,dtype=numpy.int32)\",\n \"def unlock_array(a):\\n safe_call(backend.get().af_unlock_array(a.arr))\",\n \"def regular_to_ragged(array):\\n array_list = []\\n for i in range(array.shape[0]):\\n array_list.append(trim_zeros(array[i]))\\n return array_list\",\n \"def __array_wrap__(self, out_arr, context=None): #pylint: disable=no-self-use, unused-argument\\n if out_arr.shape != (3,):\\n out_arr = out_arr.view(np.ndarray)\\n return out_arr\",\n \"def _solve(self) -> CasADiArrayType:\\n pass\",\n \"def normalize(array):\\n\\treturn array/np.max(array)\",\n \"def test_degrade_map_recarray(self):\\n random.seed(seed=12345)\\n\\n nside_coverage = 32\\n nside_map = 1024\\n nside_new = 256\\n\\n dtype = [('col1', 'f8'), ('col2', 'f8'), ('col3', 'i4')]\\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage, nside_map, dtype, primary='col1')\\n pixel = np.arange(20000)\\n values = np.zeros_like(pixel, dtype=dtype)\\n values['col1'] = random.random(size=pixel.size)\\n values['col2'] = random.random(size=pixel.size)\\n values['col3'] = random.poisson(size=pixel.size, lam=2)\\n sparse_map.update_values_pix(pixel, values)\\n\\n ra, dec = hpg.pixel_to_angle(nside_map, pixel)\\n\\n # Make the test values\\n hpmap_col1 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n hpmap_col2 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n hpmap_col3 = np.zeros(hpg.nside_to_npixel(nside_map)) + hpg.UNSEEN\\n hpmap_col1[pixel] = values['col1']\\n hpmap_col2[pixel] = values['col2']\\n hpmap_col3[pixel] = values['col3']\\n\\n # Degrade healpix maps\\n hpmap_col1 = hp.ud_grade(hpmap_col1, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\\n hpmap_col2 = hp.ud_grade(hpmap_col2, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\\n hpmap_col3 = hp.ud_grade(hpmap_col3, nside_out=nside_new, order_in='NESTED', order_out='NESTED')\\n ipnest_test = hpg.angle_to_pixel(nside_new, ra, dec)\\n\\n # Degrade the old map\\n new_map = sparse_map.degrade(nside_out=nside_new)\\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col1'],\\n hpmap_col1[ipnest_test])\\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col2'],\\n hpmap_col2[ipnest_test])\\n testing.assert_almost_equal(new_map.get_values_pos(ra, dec, lonlat=True)['col3'],\\n hpmap_col3[ipnest_test])\\n\\n # Test degrade-on-read\\n self.test_dir = tempfile.mkdtemp(dir='./', prefix='TestHealSparse-')\\n\\n fname = os.path.join(self.test_dir, 'test_recarray_degrade.hs')\\n sparse_map.write(fname)\\n\\n new_map2 = healsparse.HealSparseMap.read(fname, degrade_nside=nside_new)\\n\\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col1'],\\n hpmap_col1[ipnest_test])\\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col2'],\\n hpmap_col2[ipnest_test])\\n testing.assert_almost_equal(new_map2.get_values_pos(ra, dec, lonlat=True)['col3'],\\n hpmap_col3[ipnest_test])\",\n \"def lookup_array(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def lookup_array(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def detect_min_max(arr):\\n\\n max_value = max(np.absolute(np.reshape(arr, -1)))\\n peaks_max = []\\n peaks_min = []\\n x_max = []\\n y_max = []\\n z_max = []\\n x_min = []\\n y_min = []\\n z_min = []\\n\\n for j1 in range(10, arr.shape[0]-10):\\n for j2 in range(10, arr.shape[1]-10):\\n for j3 in range(10, arr.shape[2]-10):\\n if (np.absolute(arr[j1, j2, j3]) > 0.3*max_value):\\n\\n aaaa = [\\n arr[j1, j2, j3 + 1], arr[j1, j2 + 1, j3],\\n arr[j1 + 1, j2, j3], arr[j1, j2, j3 - 1],\\n arr[j1, j2 - 1, j3], arr[j1 - 1, j2, j3],\\n arr[j1 + 1, j2 + 1, j3 + 1],\\n arr[j1 - 1, j2 - 1, j3 - 1],\\n arr[j1 - 1, j2 + 1, j3 + 1], arr[j1, j2 + 1, j3 + 1],\\n arr[j1, j2 - 1, j3 - 1], arr[j1, j2 - 1, j3 + 1],\\n arr[j1, j2 + 1, j3 - 1], arr[j1 + 1, j2, j3 + 1],\\n arr[j1 - 1, j2, j3 - 1], arr[j1 - 1, j2, j3 + 1],\\n arr[j1 + 1, j2, j3 - 1], arr[j1 + 1, j2 + 1, j3],\\n arr[j1 - 1, j2 - 1, j3], arr[j1 + 1, j2 - 1, j3],\\n arr[j1 - 1, j2 + 1, j3], arr\\n [j1 + 1, j2 - 1, j3 + 1], arr\\n [j1 + 1, j2 + 1, j3 - 1], arr\\n [j1 - 1, j2 - 1, j3 + 1], arr\\n [j1 + 1, j2 - 1, j3 - 1], arr\\n [j1 - 1, j2 + 1, j3 - 1]]\\n bbbb = [\\n arr[j1, j2, j3 + 9], arr[j1, j2 + 9, j3],\\n arr[j1 + 9, j2, j3], arr[j1, j2, j3 - 9],\\n arr[j1, j2 - 9, j3], arr[j1 - 9, j2, j3]]\\n\\n if ((arr[j1, j2, j3] > max(aaaa)) and (max(aaaa) > max(bbbb))):\\n peaks_max = np.append(peaks_max, arr[j1, j2, j3])\\n x_max = np.append(x_max, j1)\\n y_max = np.append(y_max, j2)\\n z_max = np.append(z_max, j3)\\n\\n if ((arr[j1, j2, j3] < min(aaaa)) and (min(aaaa) < min(bbbb))):\\n peaks_min = np.append(peaks_min, arr[j1, j2, j3])\\n x_min = np.append(x_min, j1)\\n y_min = np.append(y_min, j2)\\n z_min = np.append(z_min, j3)\\n\\n return peaks_min, np.vstack(\\n (x_min, y_min, z_min)), peaks_max, np.vstack(\\n (x_max, y_max, z_max))\",\n \"def unwrap_array(array, mask, algorithm='py_gold', additional=False,\\n **keyargs):\\n if algorithm not in ['py_gold', 'c_gold', 'quality_guided', 'mask_cut']:\\n raise AttributeError('No algorithm named {}'.format(algorithm))\\n\\n if array.shape != mask.shape:\\n raise ValueError(\\\"Mask does not fit to array!\\\")\\n\\n if isinstance(array, MRRArray):\\n array = array['phase'].view(np.ndarray)\\n\\n # test if array wrapped to 0..1\\n if array.min() < 0.0 or array.max() > 1.0:\\n print '''Warning: Array should be normalized to contain data ranging\\n from 0.0 to 1.0. Data renormalized, check results!'''\\n normalize_array(array)\\n\\n# if algorithm == 'c_gold':\\n# if not goldstein_available:\\n# print 'c_gold is not available, using py_gold instead'\\n# algorithm = 'py_gold'\\n# else:\\n# unwr, data = c_gold(array.astype(np.float32), mask, **keyargs)\\n\\n if algorithm == 'py_gold':\\n unwr, flags, num = unwrap_py_gold(array, mask, **keyargs)\\n data = (flags, num)\\n\\n if algorithm == 'quality_guided':\\n qual = 1./(DerivativeVariance(array) + 1e-3) # avoid division by zero\\n unwr = unwrap_quality_guided(array, qual, mask, **keyargs)\\n data = qual\\n\\n if algorithm == 'mask_cut':\\n qual = 1./(DerivativeVariance(array) + 1e-3) # avoid division by zero\\n unwr, flags, num = unwrap_mask_cut(array, qual, mask=mask, **keyargs)\\n data = (qual, flags, num)\\n\\n if additional:\\n return unwr, data\\n else:\\n return unwr\",\n \"def geo_m_v2(data_array):\\n r = 6378.137 #promien ziemi w km\\n delta = np.zeros(data_array.size//7-1)\\n alo = data_array[0][1]\\n ala = data_array[0][2]\\n count = 0\\n for row in data_array[1:]:\\n dLat = (row[2] - ala) * math.pi/180.0\\n dLon = (row[1] - alo) * math.pi/180.0\\n a = math.sin(dLat/2.0)**2 + math.cos(ala * math.pi/180.0) * math.cos(row[2] * math.pi/180.0)\\\\\\n * math.sin(dLon/2.0)**2\\n delta[count] = r * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))#w km\\n count += 1\\n alo = row[1]\\n ala = row[2]\\n return delta\",\n \"def pack_unpack_hard():\\n # Array is apprx. 1.5 GB large\\n # should make apprx 1536 chunks\\n pack_unpack(100, chunk_size=reverse_pretty('1M'), progress=simple_progress)\",\n \"def solution(array):\\n result = np.array(array)\\n return result[::-1]\",\n \"def rearrange(self, an_array):\\n\\tnew_array = an_array*0\\n\\tn=new_array.size()\\n\\tnew_array[n/2:] = an_array[:n/2]\\n\\tnew_array[:n/2] = an_array[n/2:]\\n\\treturn new_array\",\n \"def translate(data):\\n\\t######## REALLY SLOW CODE!!!! OPTIMIZE!!! ########\\n\\t\\\"\\\"\\\"make the given array a continous set of numbers\\n\\t ex - translate([1,1,1,33,33,55,55]) -> [1,1,1,2,2,3,3] \\\"\\\"\\\"\\n\\t# Make the data into a set. Then make a hashmap and then use the map function to pull out the \\n\\t# new value from the hashmap\\n\\tout = []\\n\\t# lens = [data.count(k) for k in sorted(set(data))]\\n\\t# nested = map(lambda indx:[indx for i in range(lens[indx-1])],range(1, len(lens)+1))\\n\\t# return [item for sublist in nested for item in sublist]\\n\\thsh = {j: data.count(j) for j in set(data)}\\n\\tcnt = 0\\n\\tfor k in sorted(hsh.keys()):\\n\\t\\tout += [cnt for i in range(hsh[k])]\\n\\t\\tcnt += 1\\n\\t# ctr = 0\\n\\t# prev = data[0]\\n\\t# for point in data:\\n\\t# \\tif point != prev:\\n\\t# \\t\\tprev = point\\n\\t# \\t\\tctr += 1\\n\\t# \\tout.append(ctr)\\n\\treturn out\",\n \"def array(self, array):\\n\\n self._array = array\",\n \"def test_isarray_gtiff(self):\\n self.assertIsInstance(_test_array(landsat_gtiff), np.ndarray)\",\n \"def test_array_uplift(parser):\\n doc = parser.parse(b'[0, 1, 2, 3, 4, 5]')\\n assert isinstance(doc, simdjson.Array)\\n\\n assert doc.as_list() == [0, 1, 2, 3, 4, 5]\\n assert isinstance(doc.as_list(), list)\",\n \"def _align_np_datatype_for_array(array):\\n return np.asarray(array, _numpy_datatype_from_nd4j_context())\",\n \"def ndarray_to_rotation(array: np.ndarray) -> carla.Rotation: # pylint: disable=no-member\\n return carla.Rotation(*list(map(float, array))) # pylint: disable=no-member\",\n \"def fits_to_nparray(file):\\n hdu_list = fits.open(file)\\n image_data = hdu_list[0].data\\n image_data=image_data.astype(np.uint16)\\n \\n gdal_array.SaveArray(image_data, file[:-5]+\\\".tif\\\")\\n \\n return image_data\",\n \"def initArrayWithNumbers(self, array):\\n for i in range(array.shape[0]):\\n array[i][0] = 1\\n for j in range(array.shape[1]):\\n array[0][j] = 1\\n return array\",\n \"def convert_to_compact_array(data, label):\\n indices = np.arange(230 * 230).reshape(230, 230)\\n t1, t2, pd, dn = label\\n m = np.ma.masked_equal(pd, 0)\\n t1_masked, t2_masked, pd_masked, indices_masked, dn_masked = \\\\\\n np.ma.masked_array(t1, m.mask), np.ma.masked_array(t2, m.mask), \\\\\\n np.ma.masked_array(pd, m.mask), np.ma.masked_array(indices, m.mask), \\\\\\n np.ma.masked_array(dn, m.mask)\\n t1_compressed, t2_compressed, pd_compressed, indices_compressed, dn_compressed = \\\\\\n np.ma.compressed(t1_masked), np.ma.compressed(t2_masked), \\\\\\n np.ma.compressed(pd_masked), np.ma.compressed(indices_masked), \\\\\\n np.ma.compressed(dn_masked)\\n\\n fp_compressed = []\\n for index in indices_compressed:\\n x = int(index // 230)\\n y = int(index % 230)\\n fp_compressed.append(data[x][y])\\n fp_compressed = np.asarray(fp_compressed)\\n # recon = np.zeros((230, 230))\\n # x = indices_compressed // 230\\n # y = indices_compressed % 230\\n # recon[x, y] = t1_compressed[np.arange(len(indices_compressed))]\\n\\n label = np.asarray([t1_compressed, t2_compressed, pd_compressed, indices_compressed, dn_compressed])\\n label = np.transpose(label)\\n data = fp_compressed\\n return data, label\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def __array__(self):\\n return self.array\",\n \"def decode(self, spikes: np.ndarray) -> np.ndarray:\\n pass\",\n \"def getarray(str_array):\\n if ':' in str_array:\\n s=str_array.split(':')\\n if 'm' in s[0]:\\n s2=[cu.convlen(x) for x in s]\\n else: \\n s2=[float(x) for x in s]\\n ns=round((s2[2]-s2[0])/s2[1])+1\\n s3=np.linspace(s2[0],s2[2],ns)\\n else:\\n s3=cu.convlen(str_array)\\n \\n return s3\",\n \"def scaleto11(val,check=True):\\n if type(val) is not list and type(val) is not np.ndarray:\\n val = [val]\\n if type(val) is list:\\n val = np.array(val)\\n assert type(val) is np.ndarray\\n assert not check or np.all((val==0) + (val==1))\\n return val*2-1\",\n \"def change_altitude_cm_m(data_array):\\n data_array[:, 3] = data_array[:, 3]*0.3048\\n return data_array\",\n \"def check_array(arr: Arrayable) -> np.ndarray:\\n if isinstance(arr, np.ndarray):\\n return arr\\n return np.array(arr)\",\n \"def export_array(in_array, output_path):\\n global proj, geotrans, row, col\\n proj = band.GetProjection()\\n geotrans = band.GetGeoTransform()\\n row = band.RasterYSize\\n col = band.RasterXSize\\n driver = gdal.GetDriverByName(\\\"GTiff\\\")\\n outdata = driver.Create(output_path, col, row, 1)\\n outband = outdata.GetRasterBand(1)\\n outband.SetNoDataValue(-9999)\\n outband.WriteArray(in_array)\\n # Georeference the image\\n outdata.SetGeoTransform(geotrans)\\n # Write projection information\\n outdata.SetProjection(proj)\\n outdata.FlushCache()\\n outdata = None\",\n \"def rotate_array_deterministic(data):\\n return np.concatenate(\\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)\",\n \"def _share_array(arr_np, typecode_or_type):\\n\\n arr = mp.RawArray(typecode_or_type, arr_np.ravel())\\n return arr, arr_np.shape\",\n \"def corrected_rotation(x_arr, mu):\\n if x_arr < (mu-180):\\n x_arr += 360\\n elif x_arr > mu+180:\\n x_arr -= 360\\n\\n return x_arr\",\n \"def highpass(arrayin, rad=0.5):\\r\\n circ = circle(arrayin.shape[0], arrayin.shape[1], radius = rad/2.0)\\r\\n arrayout = fft2(ifft2(arrayin) * (1.0 - circ))\\r\\n arrayout = np.array(arrayout, dtype=arrayin.dtype)\\r\\n return arrayout\",\n \"def backconvert_units(array, out_units):\\n if out_units == \\\"None\\\" or out_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def DARP2016_MicArray():\\n\\n M = 36 # number of mics\\n array_height = -0.49 # [m] (ref. to airfoil height at z=0)\\n\\n # mic coordinates (corrected for DARP2016 configuration)\\n XYZ_array = np.array([[0., 0.025, 0.08477, 0.12044, 0.18311, 0.19394,\\n 0.01559, 0.08549, 0.16173, 0.19659, 0.24426, -0.00556,\\n 0.02184, 0.08124, 0.06203, 0.11065, -0.02252, -0.05825,\\n -0.06043, -0.11924, -0.10628, -0.02252, -0.09449, -0.15659,\\n -0.21072, -0.24318, -0.00556, -0.05957, -0.13484, -0.14352,\\n -0.19696, 0.01559, 0.02021, -0.01155, 0.03174, -0.00242],\\n [-0., -0., 0.04175, 0.11082, 0.10542, 0.15776,\\n -0.01955, -0.04024, -0.02507, -0.07743, -0.05327, -0.02437,\\n -0.09193, -0.14208, -0.20198, -0.22418, -0.01085, -0.0744,\\n -0.1521, -0.17443, -0.22628, 0.01085, -0.00084, -0.04759,\\n -0.01553, -0.05799, 0.02437, 0.07335, 0.09276, 0.15506,\\n 0.15397, 0.01955, 0.09231, 0.16326, 0.20889, 0.24999],\\n array_height*np.ones(M)])\\n\\n # calibration factors\\n array_cal = np.array([73.92182641429085, 96.84446743391487, 85.48777846463159,\\n 85.24410968090712, 83.63917149322562, 68.94090765134432,\\n 79.2385037527723, 112.77357210746612, 84.8483307868491,\\n 87.18956628936178, 97.75046920293282, 89.2829545690508,\\n 79.51644155562396, 90.39403884030057, 80.71754629014218,\\n 89.4418210091059, 98.33634233056068, 79.2212022850229,\\n 91.25543447201031, 89.55040012572815, 85.77495667666254,\\n 82.74418222820202, 84.63061055646973, 77.01568014644964,\\n 95.52764533324982, 92.16734812591154, 95.27123074600838,\\n 87.93335310521428, 96.65066131188675, 93.58564782091074,\\n 78.1446818728945, 101.3047738767648, 83.68569643491034,\\n 84.7981031520437, 94.40796508430756, 83.52266614867919])\\n\\n return XYZ_array, array_cal\",\n \"def checkio(numbers_array):\\n \\n return sorted(numbers_array, key=abs)\",\n \"def data_filter(input_array, step):\\n mod = input_array.shape[0] % step\\n rows = input_array.shape[0] // step\\n factor = np.arange(rows)\\n if mod:\\n in_mat = np.reshape(input_array[:-mod], (rows, -1))\\n min_array = np.r_[in_mat.min(axis=1), min(input_array[-mod:])]\\n max_array = np.r_[in_mat.max(axis=1), max(input_array[-mod:])]\\n median = np.median(in_mat, axis=1)\\n median_rest = np.median(input_array[-mod:])\\n median_array = np.r_[median, median_rest]\\n\\n # get min, max and average value indices\\n min_ind = in_mat.argmin(axis=1)\\n min_ind += factor * step\\n min_ind = np.append(min_ind, input_array[-mod:].argmin() + rows * step)\\n\\n max_ind = in_mat.argmax(axis=1)\\n max_ind += factor * step\\n max_ind = np.append(max_ind, input_array[-mod:].argmax() + rows * step)\\n\\n median_trans = np.reshape(median, (rows, -1))\\n median_ind = abs(in_mat - median_trans).argmin(axis=1)\\n median_ind += factor * step\\n median_ind = np.append(median_ind, abs(\\n input_array[-mod:] - median_rest).argmin() + rows * step)\\n\\n else:\\n in_mat = np.reshape(input_array, (input_array.shape[0] // step, -1))\\n min_array = in_mat.min(axis=1)\\n max_array = in_mat.max(axis=1)\\n median_array = np.median(in_mat, axis=1)\\n\\n # get min, max and average value indices\\n min_ind = in_mat.argmin(axis=1)\\n min_ind += factor * step\\n\\n max_ind = in_mat.argmax(axis=1)\\n max_ind += factor * step\\n\\n median_trans = np.reshape(median_array, (rows, -1))\\n median_ind = abs(in_mat - median_trans).argmin(axis=1)\\n median_ind += factor * step\\n\\n return min_array, median_array, max_array, min_ind, median_ind, max_ind\",\n \"def normalize(self,arr):\\n arr = arr/(arr.max()/255.0)\\n return arr\",\n \"def make_float(array):\\n finial_array = []\\n\\n for number in array:\\n finial_array.append(float(number))\\n return finial_array\",\n \"def test_TimeArray_convert_unit():\",\n \"def create_array( n ):\",\n \"def normalize_array(image_array):\\n\\n array = image_array.astype(np.float)\\n array /= 255.0\\n return array\",\n \"def convertToPrimitiveArray(objectArray: typing.List[typing.Any]) -> typing.Any:\\n ...\",\n \"def map_read(array, read, res=1.0):\\n start, stop = read\\n array[int(ceil(start/res)):int(ceil(stop/res))] += 1\",\n \"def double(arr):\\n newarr = np.array([(xx,xx) for xx in arr]).ravel()\\n return newarr\",\n \"def coerced_shape(array):\\n if array.shape is not None:\\n return array.shape\\n\\n r = array.eval().dimensions().project('low', 'high').toarray()\\n shp = tuple(np.maximum(r['high'] - r['low'] + 1, 0))\\n return shp\",\n \"def __init__(self):\\n self.array = [None for i in range(10000)]\",\n \"def __cut_arrays(data_array, maximum_time, arrays_to_cut):\\n\\n try:\\n begin_time = data_array[arrays_to_cut[0]][0][0]\\n end_time = data_array[arrays_to_cut[0]][0][-1]\\n delta_time = (\\n data_array[arrays_to_cut[0]][0][1]\\n - data_array[arrays_to_cut[0]][0][0]\\n )\\n total_time = end_time - begin_time\\n if total_time > maximum_time:\\n over_time = total_time - maximum_time\\n array_elm_to_drop = int(over_time / delta_time)\\n for arrays in arrays_to_cut:\\n data_array[arrays][0] = data_array[arrays][0][\\n array_elm_to_drop:\\n ]\\n data_array[arrays][1] = data_array[arrays][1][\\n array_elm_to_drop:\\n ]\\n except:\\n pass\",\n \"def normalize(data):\\n\\n\\t#return [float(x) / pow(2, 15) for x in data]\\n\\n\\tl = [float(x) / pow(2, 15) for x in data]\\n\\treturn np.asarray(l)\",\n \"def floatArrayToPrt(float_array):\\n\\n util = OpenMaya.MScriptUtil() \\n util.createFromList(float_array, len(float_array))\\n\\n return util.asFloatPtr()\",\n \"def wrap(array):\\n\\t\\t\\t\\n\\t\\t\\tassert array.ndim == 2, ('works on 2D arrays only; expecting '\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t 'self.cond_tuning, which should be 2D')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\treturn np.column_stack((array, array[..., 0]))\",\n \"def array_fractional_reducer(array, fraction, axis=0):\\r\\n number_of_total_elements = np.shape(array)[axis]\\r\\n number_of_kept_elements = round(number_of_total_elements * fraction)\\r\\n index = np.round(np.linspace(0, np.shape(array)[axis] - 1, number_of_kept_elements)).astype(int)\\r\\n return np.take(array, index, axis)\",\n \"def padArray(ori_array, pad_size):\\n if (pad_size > 0):\\n [x_size, y_size] = ori_array.shape\\n lg_array = numpy.ones((x_size+2*pad_size,y_size+2*pad_size))\\n lg_array[pad_size:(x_size+pad_size),pad_size:(y_size+pad_size)] = ori_array.astype(numpy.float64)\\n lg_array[0:pad_size,:] = numpy.flipud(lg_array[pad_size:2*pad_size,:])\\n lg_array[(x_size+pad_size):(x_size+2*pad_size),:] = numpy.flipud(lg_array[x_size:(x_size+pad_size),:])\\n lg_array[:,0:pad_size] = numpy.fliplr(lg_array[:,pad_size:2*pad_size])\\n lg_array[:,(y_size+pad_size):(y_size+2*pad_size)] = numpy.fliplr(lg_array[:,y_size:(y_size+pad_size)])\\n return lg_array\\n \\n else:\\n return ori_array\",\n \"def segment_array(a):\\n\\n l = [array(a.typecode) for chaff in range(16)]\\n index = 0\\n\\n for i in range(0, len(a), 16):\\n l[index].extend(a[i:i + 16])\\n index = (index + 1) % 16\\n\\n return l\",\n \"def com_msd_multiple_realizations(t_target_array, folder, prefix, n_realization, attrib = 'x_array'):\\n #first stich together all the arrays\\n #read in he first one\\n file_name = prefix + \\\"_0\\\" + \\\".pkl\\\"\\n file_address = os.path.join(folder, file_name)\\n with open(file_address, 'rb') as input:\\n dataHolder = pickle.load(input)\\n x_big = getattr(dataHolder, attrib)\\n t_big = dataHolder.t_array\\n for i in range(1,n_realization):\\n file_name = prefix + \\\"_\\\" + str(i) + \\\".pkl\\\"\\n file_address = os.path.join(folder, file_name)\\n with open(file_address, 'rb') as input:\\n dataHolder = pickle.load(input)\\n x_mat = getattr(dataHolder, attrib)\\n t_mat = dataHolder.t_array\\n x_big = np.vstack((x_big, x_mat))\\n t_big = np.vstack((t_big, t_mat))\\n out_put_size = len(t_target_array)\\n com_array = np.zeros(out_put_size)\\n msd_array = np.zeros(out_put_size)\\n for i in range(out_put_size):\\n t = t_target_array[i]\\n com_array[i], msd_array[i] = com_msd_at_given_time(t, x_big, t_big)\\n return com_array, msd_array\",\n \"def GPy_reformat_3D(array):\\r\\n n_timesteps = np.shape(array)[-1]\\r\\n if len(np.shape(array)) == 1:\\r\\n array = array.reshape(n_timesteps, 1)\\r\\n return [array, array, array]\\r\\n elif len(np.shape(array)) == 2:\\r\\n array = array.T\\r\\n array1 = array[:, 0, None]\\r\\n array2 = array[:, 1, None]\\r\\n array3 = array[:, 2, None]\\r\\n return [array1, array2, array3]\\r\\n else:\\r\\n return print(\\\"Error in GPy_reformat, input array is wrong shape.\\\")\",\n \"def traj_rfft(array):\\r\\n return Trajectory(my_rfft(array))\",\n \"def ravel(arrayin):\\r\\n if arrayin.dtype == complex :\\r\\n arrayout = np.concatenate((np.ravel(np.real(arrayin)), np.ravel(np.imag(arrayin))), axis = 0)\\r\\n else :\\r\\n arrayout = np.ravel(arrayin)\\r\\n return arrayout\",\n \"def type_array():\\n return []\",\n \"def __init__(self,array):\\n self.arr = array\\n # self.result = []\",\n \"def clean_arrays_dict(arrays_dict):\\n for k in arrays_dict.keys():\\n volumes_list = arrays_dict[k]\\n arrays_dict[k] = [convert_Volume_to_slices(v) for v in volumes_list]\",\n \"def _apply_array_spin12_lowfilling(self, h1e: 'Nparray',\\n h2e: 'Nparray') -> 'Nparray':\\n if fqe.settings.use_accelerated_code:\\n return self._apply_array_spin12_lowfilling_fast(h1e, h2e)\\n else:\\n return self._apply_array_spin12_lowfilling_python(h1e, h2e)\",\n \"def ragged_to_regular(array_list):\\n join_length = len(array_list)\\n # the weird line below is faster than allocating numpy arrays\\n dims = list(zip(*[array.shape for array in array_list]))\\n max_dims = tuple(max(dim) for dim in dims)\\n dtype = array_list[0].dtype\\n padded_hypercube = np.zeros((join_length,) + max_dims, dtype=dtype)\\n for i in range(join_length):\\n multislice = (slice(i, i+1, 1),) + tuple(slice(0, dim[i], 1)\\n for dim in dims)\\n padded_hypercube[multislice] = array_list[i]\\n return padded_hypercube\",\n \"def rescale_array(array, old_range, new_range, dtype):\\n if not HAS_NUMPY:\\n LOGGER.error(\\\"The Python library numpy is required for this operation\\\")\\n return\\n\\n old_min, old_max = old_range\\n if array.min() < old_min or array.max() > old_max:\\n ## truncate:\\n array = numpy.clip(array, old_min, old_max)\\n new_min, new_max = new_range\\n old_delta = float(old_max - old_min)\\n new_delta = float(new_max - new_min)\\n if old_delta == 0:\\n return ((array - old_min) + (new_min + new_max) / 2).astype(dtype)\\n else:\\n return (new_min + (array - old_min) * new_delta / old_delta).astype(dtype)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5801872","0.5736414","0.5607404","0.54848576","0.5462905","0.53815883","0.53789145","0.5347712","0.534731","0.5346173","0.5330794","0.53048295","0.53041655","0.5290421","0.52872","0.5281134","0.5254639","0.5245278","0.5217675","0.5208273","0.5203374","0.52031237","0.5195591","0.5192283","0.51651263","0.5163994","0.5161466","0.51594925","0.5158688","0.51393485","0.5138308","0.5137557","0.51300484","0.511079","0.5102302","0.50686556","0.5065685","0.50540894","0.505043","0.50357527","0.50188357","0.50188357","0.5013785","0.5009769","0.5006577","0.500492","0.500384","0.50011384","0.49834234","0.49826425","0.49764615","0.4971303","0.49642846","0.49440983","0.49424708","0.4937744","0.49345872","0.49342507","0.49303004","0.49237832","0.49199638","0.49138495","0.49120072","0.49107632","0.48973185","0.48830578","0.48805046","0.4879637","0.48787197","0.48784873","0.486857","0.48679474","0.48652247","0.48640805","0.48629332","0.48620838","0.48591185","0.48562884","0.48533043","0.4852058","0.48517564","0.48490155","0.48481363","0.48412037","0.48403555","0.4839484","0.48363572","0.4834494","0.48279774","0.48246062","0.48117062","0.4808061","0.48061484","0.48042575","0.48031786","0.47990182","0.47988564","0.4794603","0.47940323","0.47939807"],"string":"[\n \"0.5801872\",\n \"0.5736414\",\n \"0.5607404\",\n \"0.54848576\",\n \"0.5462905\",\n \"0.53815883\",\n \"0.53789145\",\n \"0.5347712\",\n \"0.534731\",\n \"0.5346173\",\n \"0.5330794\",\n \"0.53048295\",\n \"0.53041655\",\n \"0.5290421\",\n \"0.52872\",\n \"0.5281134\",\n \"0.5254639\",\n \"0.5245278\",\n \"0.5217675\",\n \"0.5208273\",\n \"0.5203374\",\n \"0.52031237\",\n \"0.5195591\",\n \"0.5192283\",\n \"0.51651263\",\n \"0.5163994\",\n \"0.5161466\",\n \"0.51594925\",\n \"0.5158688\",\n \"0.51393485\",\n \"0.5138308\",\n \"0.5137557\",\n \"0.51300484\",\n \"0.511079\",\n \"0.5102302\",\n \"0.50686556\",\n \"0.5065685\",\n \"0.50540894\",\n \"0.505043\",\n \"0.50357527\",\n \"0.50188357\",\n \"0.50188357\",\n \"0.5013785\",\n \"0.5009769\",\n \"0.5006577\",\n \"0.500492\",\n \"0.500384\",\n \"0.50011384\",\n \"0.49834234\",\n \"0.49826425\",\n \"0.49764615\",\n \"0.4971303\",\n \"0.49642846\",\n \"0.49440983\",\n \"0.49424708\",\n \"0.4937744\",\n \"0.49345872\",\n \"0.49342507\",\n \"0.49303004\",\n \"0.49237832\",\n \"0.49199638\",\n \"0.49138495\",\n \"0.49120072\",\n \"0.49107632\",\n \"0.48973185\",\n \"0.48830578\",\n \"0.48805046\",\n \"0.4879637\",\n \"0.48787197\",\n \"0.48784873\",\n \"0.486857\",\n \"0.48679474\",\n \"0.48652247\",\n \"0.48640805\",\n \"0.48629332\",\n \"0.48620838\",\n \"0.48591185\",\n \"0.48562884\",\n \"0.48533043\",\n \"0.4852058\",\n \"0.48517564\",\n \"0.48490155\",\n \"0.48481363\",\n \"0.48412037\",\n \"0.48403555\",\n \"0.4839484\",\n \"0.48363572\",\n \"0.4834494\",\n \"0.48279774\",\n \"0.48246062\",\n \"0.48117062\",\n \"0.4808061\",\n \"0.48061484\",\n \"0.48042575\",\n \"0.48031786\",\n \"0.47990182\",\n \"0.47988564\",\n \"0.4794603\",\n \"0.47940323\",\n \"0.47939807\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5695677"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":20272,"cells":{"query":{"kind":"string","value":"Run an acrosssubject classification Decode responses on each hand separately from CPRO data"},"document":{"kind":"string","value":"def compositionalActflowDecodings(data, nov_actflow_data, prac_actflow_data, effects=False, featsel=True, ncvs=1, nproc=5):\n\n nSubjs = data.shape[2]\n stats = np.zeros((1,))\n \n ncond = data.shape[1]\n\n nsamples = nSubjs * ncond\n nfeatures = data.shape[0]\n\n # Label array for supervised learning\n labels = np.tile(range(ncond),nSubjs)\n subjarray = np.repeat(range(nSubjs),ncond)\n\n svm_mat = np.zeros((nsamples,nfeatures))\n nov_svm_mat = np.zeros((nsamples,nfeatures))\n prc_svm_mat = np.zeros((nsamples,nfeatures))\n samplecount = 0\n scount = 0\n for subj in range(nSubjs):\n origdata = data[:,:,scount]\n nov_data = nov_actflow_data[:,:,scount]\n prc_data = prac_actflow_data[:,:,scount]\n svm_mat[samplecount:(samplecount+ncond),:] = origdata.T\n nov_svm_mat[samplecount:(samplecount+ncond),:] = nov_data.T\n prc_svm_mat[samplecount:(samplecount+ncond),:] = prc_data.T\n\n scount += 1\n samplecount += ncond\n\n # Spatially demean matrix across features\n# samplemean = np.mean(svm_mat,axis=1)\n# samplemean.shape = (len(samplemean),1)\n# svm_mat = svm_mat - samplemean\n#\n# samplemean = np.mean(actflow_svm_mat,axis=1)\n# samplemean.shape = (len(samplemean),1)\n# actflow_svm_mat = actflow_svm_mat - samplemean\n\n scores, rmatch, rmismatch = compositionalActflowRandomSplitLOOBaselineCV(ncvs, svm_mat, nov_svm_mat, prc_svm_mat, labels, subjarray, featsel=featsel, nproc=nproc)\n# stats = np.mean(scores)\n stats = scores \n if effects: \n return stats, rmatch,rmismatch\n else:\n return stats"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\n \n ncond = data.shape[1] # two motor outputs\n nSubjs = data.shape[2]\n\n nsamples = nSubjs * ncond\n stats = np.zeros((len(rois),nsamples))\n rmatches = np.zeros((len(rois),))\n rmismatches = np.zeros((len(rois),))\n\n # Label array for supervised learning\n labels = np.tile(range(ncond),nSubjs)\n subjarray = np.repeat(range(nSubjs),ncond)\n\n # Run SVM classifications on network-level activation patterns across subjects\n confusion_mats = []\n roicount = 0\n for roi in rois:\n roi_ind = np.where(glasser2==roi+1)[0]\n nfeatures = len(roi_ind)\n roi_ind.shape = (len(roi_ind),1) \n\n svm_mat = np.zeros((nsamples,roi_ind.shape[0]))\n samplecount = 0\n for scount in range(nSubjs):\n roidata = np.squeeze(data[roi_ind,:,scount])\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\n\n samplecount += ncond\n\n # Spatially demean matrix across features\n# samplemean = np.mean(svm_mat,axis=1)\n# samplemean.shape = (len(samplemean),1)\n# svm_mat = svm_mat - samplemean\n \n scores, rmatch, rmismatch, confusion_mat = randomSplitLOOBaselineCV(ncvs, svm_mat, labels, subjarray, \n motorOutput=motorOutput, decoder=decoder, nproc=nproc)\n stats[roicount,:] = scores\n rmatches[roicount] = np.mean(rmatch)\n rmismatches[roicount] = np.mean(rmismatch)\n confusion_mats.append(confusion_mat)\n roicount += 1\n \n if effects and confusion:\n return stats, rmatch, rmismatch, confusion_mats\n if effects and not confusion:\n return stats, rmatch, rmismatch\n if confusion and not effects:\n return stats, confusion_mats\n else:\n return stats","def forward(self, *args): # noqa: R0914\r\n encoder_out, (hn, cn) = self.unified_encoder(*args)\r\n device = hn.device\r\n non_sequential_cont_decoded = self.mlp_non_seq_cont(hn)\r\n non_sequential_cat_decoded = []\r\n for mlp_non_seq_cat in self.mlp_non_seq_cat_list:\r\n non_sequential_cat_decoded.append(mlp_non_seq_cat(hn))\r\n\r\n hn = torch.unsqueeze(hn, 0)\r\n cn = torch.unsqueeze(cn, 0)\r\n # decoded is the output prediction of timestep i-1 of the decoder\r\n decoded = torch.zeros(encoder_out.shape[0], int(\r\n self.unified_encoder.seq_cont_count + self.unified_encoder.no_of_embs_seq), device=device)\r\n seq_cont_decoded = torch.Tensor(device=device)\r\n seq_cat_decoded = []\r\n for _ in range(self.unified_encoder.seq_cat_count):\r\n seq_cat_decoded.append(torch.Tensor(device=device))\r\n\r\n for _ in range(encoder_out.shape[1]):\r\n decoded, (hn, cn), out_cont, out_cat = self.decoder(decoded, (hn, cn))\r\n # Predict all categorical columns\r\n out_cat_onehot = []\r\n if self.unified_encoder.seq_cat_count != 0:\r\n for idx, out in enumerate(out_cat):\r\n out_cat_onehot.append(torch.argmax(out, dim=1).unsqueeze(-1))\r\n seq_cat_decoded[idx] = torch.cat(\r\n [seq_cat_decoded[idx], out.view(out.shape[0], 1, -1)], dim=1)\r\n out_cat_onehot = torch.cat(out_cat_onehot, -1)\r\n out_cat_embedding = self.unified_encoder.seq_emb_layers(out_cat_onehot)\r\n decoded = torch.cat([out_cat_embedding, out_cont], dim=-1)\r\n else:\r\n decoded = out_cont\r\n seq_cont_decoded = torch.cat(\r\n [seq_cont_decoded, out_cont.view(out_cont.shape[0], 1, -1)], dim=1)\r\n\r\n return non_sequential_cont_decoded, non_sequential_cat_decoded, seq_cont_decoded, seq_cat_decoded","def apply_classifier(self):\n for detected_object in self.detected_objects:\n detected_object.predict_class(self.original_image)","def compute_classifications2(depc, gid_list, config=None):\n logger.info('[ibs] Process Image Classifications2')\n logger.info('config = {!r}'.format(config))\n # Get controller\n ibs = depc.controller\n depc = ibs.depc_image\n if config['classifier_two_algo'] in ['cnn']:\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (192, 192),\n }\n # depc.delete_property('thumbnails', gid_list, config=config_)\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\n result_list = ibs.generate_thumbnail_class2_list(thumbnail_list, **config)\n elif config['classifier_two_algo'] in ['rf']:\n from wbia.algo.detect.rf import classify\n\n config_ = {'algo': 'resnet'}\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\n classifier_weight_filepath = config['classifier_weight_filepath']\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\n elif config['classifier_two_algo'] in ['densenet']:\n from wbia.algo.detect import densenet\n\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\n }\n thumbpath_list = ibs.depc_image.get(\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\n )\n config_ = {\n 'classifier_weight_filepath': config['classifier_two_weight_filepath'],\n }\n result_list = densenet.test(\n thumbpath_list,\n ibs=ibs,\n gid_list=gid_list,\n return_dict=True,\n multiclass=True,\n **config_,\n )\n result_list = list(result_list)\n for index in range(len(result_list)):\n best_score, best_key, scores = result_list[index]\n classes = [best_key]\n result_list[index] = (\n scores,\n classes,\n )\n else:\n raise ValueError(\n 'specified classifier_two algo is not supported in config = {!r}'.format(\n config\n )\n )\n\n # yield detections\n for result in result_list:\n yield result","def test_service_api_predict_multiple_raw_classified(service_app):\n response = service_app.post('/predict',\n data=json.dumps(data),\n content_type='application/json')\n response_data = json.loads(response.data)\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 200\n assert response_data['message'] == 'Records successfully classified'\n assert len(response_data['prediction'].keys()) == 102\n assert response_data['prediction']['business_outcome'] == [4, 5]\n assert response_data['prediction']['phat'] == [0.8228085289874678, 0.753958838418463]\n assert all(len(value) == 2 for value in response_data['prediction'].values())","def classify_encapsulated(audio_summary, track_info, pickle_file):\n\tf = open(pickle_file, 'r')\n\tfit = pickle.load(f)\n\tf.close()\n\trv = {}\n\t#print track_info.keys()\n\t#print track_info[audio_summary]['title'].keys()\n\trv[\"speechiness\"] = [audio_summary['audio_summary']['speechiness']]\n\trv[\"time_sig\"] = [audio_summary['audio_summary']['time_signature']]\n\trv[\"bpm\"] = [audio_summary['audio_summary']['tempo']]\n\trv[\"key\"] = [audio_summary['audio_summary']['key']]\n\trv[\"duration\"] = [audio_summary['audio_summary']['duration']]\n\trv[\"loudness\"] = [audio_summary['audio_summary']['loudness']]\n\trv[\"end_of_fade_in\"] = [track_info['track']['end_of_fade_in']]\n\trv[\"start_of_fade_out\"] = [track_info['track']['start_of_fade_out']]\n\trv[\"bpm_range\"] = [proc.bpm_range(track_info['beats'])]\n\trv[\"max_bpm_spike\"] = [proc.max_bpm_spike(track_info['beats'])]\n\ttry:\n\t\trv[\"num_keys\"] = [proc.num_keys(track_info['sections'])]\n\texcept:\n\t\trv[\"num_keys\"] = [1]\n\trv[\"sections\"] = [proc.num_sections(track_info['sections'])]\n\tnew_df = build_data_frame([rv],[\"Unknown\"])\n\tp = prob_category(new_df,fit)\n\trobjects.globalenv[\"pred\"] = p\n\tedm_prob = robjects.default_ri2py(p.rx(1))[0]\n\tfolk_prob = robjects.default_ri2py(p.rx(2))[0]\n\trap_prob = robjects.default_ri2py(p.rx(3))[0]\n\tcls = classify(new_df,fit)\n\treturn [(edm_prob,folk_prob,rap_prob),cls[0]]","def execute(self, requests):\n responses = []\n for request in requests:\n infer_outputs = pb_utils.get_input_tensor_by_name(\n request, self.input_names[0])\n im_infos = pb_utils.get_input_tensor_by_name(request,\n self.input_names[1])\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\n self.input_names[2])\n\n infer_outputs = infer_outputs.as_numpy()\n im_infos = im_infos.as_numpy()\n ori_imgs = ori_imgs.as_numpy()\n\n results = self.postprocessor.run([infer_outputs], im_infos)\n batch_rec_texts = []\n batch_rec_scores = []\n batch_box_list = []\n for i_batch in range(len(results)):\n\n cls_labels = []\n cls_scores = []\n rec_texts = []\n rec_scores = []\n\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\n image_list = []\n if len(box_list) == 0:\n image_list.append(ori_imgs[i_batch])\n else:\n for box in box_list:\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\n image_list.append(crop_img)\n\n batch_box_list.append(box_list)\n\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", cls_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='cls_pp',\n requested_output_names=['cls_labels', 'cls_scores'],\n inputs=[cls_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n cls_labels = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_labels')\n cls_labels = cls_labels.as_numpy()\n\n cls_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_scores')\n cls_scores = cls_scores.as_numpy()\n\n for index in range(len(image_list)):\n if cls_labels[index] == 1 and cls_scores[\n index] > self.cls_threshold:\n image_list[index] = cv2.rotate(\n image_list[index].astype(np.float32), 1)\n image_list[index] = np.astype(np.uint8)\n\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", rec_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='rec_pp',\n requested_output_names=['rec_texts', 'rec_scores'],\n inputs=[rec_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n rec_texts = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_texts')\n rec_texts = rec_texts.as_numpy()\n\n rec_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_scores')\n rec_scores = rec_scores.as_numpy()\n\n batch_rec_texts.append(rec_texts)\n batch_rec_scores.append(rec_scores)\n\n out_tensor_0 = pb_utils.Tensor(\n self.output_names[0],\n np.array(\n batch_rec_texts, dtype=np.object_))\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\n np.array(batch_rec_scores))\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\n np.array(batch_box_list))\n inference_response = pb_utils.InferenceResponse(\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\n responses.append(inference_response)\n return responses","def do_predict(self):\n answer = []\n response = []\n\n for it_predictions in json.loads(request.data.decode('UTF-8')):\n prediction = it_predictions['score']\n for ite_clf in g_list_of_classifier:\n answer.append(ite_clf.predict(prediction))\n if answer.count(True) > answer.count(False):\n response.append({'answer' : True})\n else:\n response.append({'answer' : False})\n return json.dumps(response, indent=4)","def _ctc_decoder_prediction(prediction, labels):\n blank_id = len(labels)\n hypotheses = []\n # CTC decoding procedure\n for batch_elem in prediction:\n decoded_prediction = []\n previous = blank_id\n for p in batch_elem:\n if previous != p != blank_id:\n decoded_prediction.append(labels[p])\n previous = p\n hypotheses.append(''.join(decoded_prediction))\n return hypotheses","def classification(self,a_train,a_test,c_train,c_test,classifier):\n le =LabelEncoder()\n le.fit(c_train)\n c_train = le.transform(c_train)\n c_test = le.transform(c_test)\n if classifier==\"GNB\": #Gaussian Naive Bayes\n gnb = GaussianNB()\n gnb.fit(a_train, c_train)\n c_pred = gnb.predict(a_test)\n elif classifier==\"DT\": #Decision Tree\n dt=DecisionTreeClassifier()\n dt.fit(a_train, c_train)\n c_pred = dt.predict(a_test)\n elif classifier==\"KNN\": #K-Next-Neighbors\n kn=KNeighborsClassifier(n_neighbors=5)\n kn.fit(a_train, c_train)\n c_pred = kn.predict(a_test)\n elif classifier==\"RF\": #Random Forest\n rf=RandomForestClassifier()\n rf.fit(a_train, c_train)\n c_pred = rf.predict(a_test)\n elif classifier==\"SVC\": # Support Vector Classifier\n \"\"\"\n SVC needs normalisation of Feature Values to scale of [-1,1] or [0,1] depending on sign of them\n \"\"\"\n if a_train.min()<0:\n mms = MinMaxScaler(feature_range=(-1,1))\n else:\n mms = MinMaxScaler()\n mms.fit(a_train)\n a_train = mms.transform(a_train)\n a_test = mms.transform(a_test)\n svc=SVC(cache_size=2000,C=1, probability=True,kernel='rbf')\n svc.fit(a_train,c_train)\n #c_pred = svc.predict(a_test) did not work, that's why it is predicted manual\n new_prob = svc.predict_proba(a_test)\n samples=new_prob.shape[0]\n c_pred= np.array\n for k in range(samples):\n c_pred=np.append(c_pred,new_prob[k].argmax())\n c_pred = c_pred[1:samples+1]\n elif classifier==\"DC\": #Dummy Classifier\n dc=DummyClassifier(strategy=\"uniform\")\n dc.fit(a_train, c_train)\n c_pred = dc.predict(a_test)\n elif classifier==\"GMM\": #Gaussian Mixture Modell\n #number of existing classes get passed to the GMM (n_classes)\n n_classes_train = len(np.unique(c_train))\n n_classes_test = len(np.unique(c_test))\n if n_classes_train>n_classes_test:\n n_classes = n_classes_train\n else:\n n_classes = n_classes_test\n #init_params='', because initial values get calculated manual\n gmm = GMM(n_components=n_classes,init_params='')\n #array of feature values of class i get extracted for further process\n gmm.means_=np.array([a_train[c_train==i,:].mean(axis=0) for i in xrange(n_classes)])\n gmm.weights_=np.array([a_train[c_train==i,:].shape[0]/float(c_train.shape[0]) for i in xrange(n_classes)])\n \n gmm_covars = np.zeros((a_train.shape[1]))\n for i in xrange(n_classes):\n valuesOfClassi = a_train[c_train==i,:]\n valuesOfClassi = np.asarray(valuesOfClassi).T\n matrixOfCov = np.cov(valuesOfClassi)+gmm.min_covar*np.eye(valuesOfClassi.shape[0])\n variance = np.array([matrixOfCov[j,j] for j in xrange(matrixOfCov.shape[0])])\n gmm_covars=np.vstack((gmm_covars,variance))\n gmm_covars=gmm_covars[1:,:] #deletes initial row with zeros\n \n gmm.covars_=gmm_covars\n c_pred = gmm.predict(a_test)\n \n c_pred=le.inverse_transform(c_pred)\n return c_pred","def decode_results(self, outputs):\n ...","def makepredictions(self):\n data, sampling_rate = librosa.load(self.file)\n mfccs = np.mean(librosa.feature.mfcc(y=data, sr=sampling_rate, n_mfcc=40).T, axis=0)\n x = np.expand_dims(mfccs, axis=1)\n x = np.expand_dims(x, axis=0)\n predictions = self.loaded_model.predict_classes(x)\n predict = self.convertclasstoemotion(predictions)\n print(\"Prediction is\", \" \", self.convertclasstoemotion(predictions))\n return predict","def chainercv_postprocess_change_labels(results):\n bboxes, labels, scores = results\n # loop over the results and add them to the list of\n # returned predictions\n classes = []\n boxes = []\n confs = []\n for index, bbox in enumerate(bboxes[0]):\n classes.append(str(voc_bbox_label_names[int(labels[0][index])]))\n boxes.append([bbox[0], bbox[1], bbox[2], bbox[3]])\n confs.append(scores[0][index])\n\n return (boxes, classes, confs)","def chainercv_postprocess_pack_each_item(results):\n bboxes, labels, scores = results\n\n # loop over the results and add them to the list of\n # returned predictions\n predictions = []\n for index, bbox in enumerate(bboxes[0]):\n r = {\"class\": str(voc_bbox_label_names[int(labels[0][index])]),\n \"bbox\": {\n \"ymin\": str(bbox[0]),\n \"xmin\": str(bbox[1]),\n \"ymax\": str(bbox[2]),\n \"xmax\": str(bbox[3])\n },\n \"probability\": str(scores[0][index])\n }\n predictions.append(r)\n\n return predictions","def compute_classifications(depc, gid_list, config=None):\n logger.info('[ibs] Process Image Classifications')\n logger.info('config = {!r}'.format(config))\n # Get controller\n ibs = depc.controller\n depc = ibs.depc_image\n if config['classifier_algo'] in ['cnn']:\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (192, 192),\n }\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\n result_list = ibs.generate_thumbnail_class_list(thumbnail_list, **config)\n elif config['classifier_algo'] in ['svm']:\n from wbia.algo.detect.svm import classify\n\n config_ = {'algo': 'resnet'}\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\n classifier_weight_filepath = config['classifier_weight_filepath']\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\n elif config['classifier_algo'] in ['densenet']:\n from wbia.algo.detect import densenet\n\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\n }\n thumbpath_list = ibs.depc_image.get(\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\n )\n result_list = densenet.test(thumbpath_list, ibs=ibs, gid_list=gid_list, **config)\n elif config['classifier_algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\n classifier_weight_filepath = config['classifier_weight_filepath']\n classifier_weight_filepath = classifier_weight_filepath.strip().split(';')\n\n assert len(classifier_weight_filepath) == 2\n classifier_algo_, model_tag_ = classifier_weight_filepath\n\n include_grid2 = config['classifier_algo'] in ['tile_aggregation']\n tid_list = ibs.scout_get_valid_tile_rowids(\n gid_list=gid_list, include_grid2=include_grid2\n )\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\n confidence_list = ibs.scout_wic_test(\n tid_list, classifier_algo=classifier_algo_, model_tag=model_tag_\n )\n\n gid_dict = {}\n for ancestor_gid, tid, confidence in zip(\n ancestor_gid_list, tid_list, confidence_list\n ):\n if ancestor_gid not in gid_dict:\n gid_dict[ancestor_gid] = []\n gid_dict[ancestor_gid].append(confidence)\n\n result_list = []\n for gid in tqdm.tqdm(gid_list):\n gid_confidence_list = gid_dict.get(gid, None)\n assert gid_confidence_list is not None\n best_score = np.max(gid_confidence_list)\n\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in ['densenet+neighbors']:\n raise NotImplementedError\n # ut.embed()\n # classifier_weight_filepath = config['classifier_weight_filepath']\n\n # all_bbox_list = ibs.get_image_bboxes(gid_list)\n # wic_confidence_list = ibs.scout_wic_test(gid_list, classifier_algo='densenet',\n # model_tag=classifier_weight_filepath)\n #\n # ancestor_gid_list = list(set(ibs.get_tile_ancestor_gids(gid_list)))\n # all_tile_list = list(set(ibs.scout_get_valid_tile_rowids(gid_list=ancestor_gid_list)))\n # all_bbox_list = ibs.get_image_bboxes(all_tile_list)\n # all_confidence_list = ibs.scout_wic_test(all_tile_list, classifier_algo='densenet',\n # model_tag=classifier_weight_filepath)\n #\n # TODO: USE THRESHOLDED AVERAGE, NOT MAX\n # result_list = []\n # for gid, wic_confidence in zip(gid_list, wic_confidence_list):\n # best_score = wic_confidence\n # for aid in aid_list:\n # wic_confidence_ = aid_conf_dict.get(aid, None)\n # assert wic_confidence_ is not None\n # best_score = max(best_score, wic_confidence_)\n #\n # if wic_confidence < 0.5:\n # best_key = 'negative'\n # best_score = 1.0 - best_score\n # else:\n # best_key = 'positive'\n # if best_score > wic_confidence:\n # recovered += 1\n # result = (best_score, best_key, )\n # result_list.append(result)\n elif config['classifier_algo'] in ['scout_detectnet']:\n import json\n\n json_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\n assert exists(json_filepath)\n with open(json_filepath, 'r') as json_file:\n values = json.load(json_file)\n annotations = values.get('annotations', {})\n\n gpath_list = ibs.get_image_paths(gid_list)\n gname_list = [split(gpath)[1] for gpath in gpath_list]\n\n result_list = []\n for gname in gname_list:\n annotation = annotations.get(gname, None)\n assert annotation is not None\n\n best_score = 1.0\n if len(annotation) == 0:\n best_key = 'negative'\n else:\n best_key = 'positive'\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in ['scout_detectnet_csv', 'scout_faster_rcnn_csv']:\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\n\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\n csv_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\n\n assert exists(manifest_filepath)\n assert exists(csv_filepath)\n\n manifest_dict = {}\n with open(manifest_filepath, 'r') as manifest_file:\n manifest_file.readline() # Discard column header row\n manifest_line_list = manifest_file.readlines()\n for manifest_line in manifest_line_list:\n manifest = manifest_line.strip().split(',')\n assert len(manifest) == 2\n manifest_filename, manifest_uuid = manifest\n manifest_dict[manifest_filename] = manifest_uuid\n\n csv_dict = {}\n with open(csv_filepath, 'r') as csv_file:\n csv_file.readline() # Discard column header row\n csv_line_list = csv_file.readlines()\n for csv_line in csv_line_list:\n csv = csv_line.strip().split(',')\n assert len(csv) == 2\n csv_filename, csv_score = csv\n csv_uuid = manifest_dict.get(csv_filename, None)\n assert (\n csv_uuid is not None\n ), 'Test image {!r} is not in the manifest'.format(\n csv,\n )\n csv_dict[csv_uuid] = csv_score\n\n result_list = []\n for uuid_str in uuid_str_list:\n best_score = csv_dict.get(uuid_str, None)\n assert best_score is not None\n\n if config['classifier_algo'] in ['scout_detectnet_csv']:\n assert best_score in ['yes', 'no']\n best_key = 'positive' if best_score == 'yes' else 'negative'\n best_score = 1.0\n elif config['classifier_algo'] in ['scout_faster_rcnn_csv']:\n best_score = float(best_score)\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n else:\n raise ValueError\n\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n elif config['classifier_algo'] in [\n 'lightnet',\n 'densenet+lightnet',\n 'densenet+lightnet!',\n ]:\n min_area = 10\n\n classifier_weight_filepath = config['classifier_weight_filepath']\n classifier_weight_filepath = classifier_weight_filepath.strip().split(',')\n\n if config['classifier_algo'] in ['lightnet']:\n assert len(classifier_weight_filepath) == 2\n weight_filepath, nms_thresh = classifier_weight_filepath\n wic_thresh = 0.0\n nms_thresh = float(nms_thresh)\n wic_confidence_list = [np.inf] * len(gid_list)\n wic_filter = False\n elif config['classifier_algo'] in ['densenet+lightnet', 'densenet+lightnet!']:\n assert len(classifier_weight_filepath) == 4\n (\n wic_model_tag,\n wic_thresh,\n weight_filepath,\n nms_thresh,\n ) = classifier_weight_filepath\n wic_thresh = float(wic_thresh)\n nms_thresh = float(nms_thresh)\n wic_confidence_list = ibs.scout_wic_test(\n gid_list, classifier_algo='densenet', model_tag=wic_model_tag\n )\n wic_filter = config['classifier_algo'] in ['densenet+lightnet']\n else:\n raise ValueError\n\n flag_list = [\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\n ]\n if wic_filter:\n gid_list_ = ut.compress(gid_list, flag_list)\n else:\n gid_list_ = gid_list[:]\n config = {\n 'grid': False,\n 'algo': 'lightnet',\n 'config_filepath': weight_filepath,\n 'weight_filepath': weight_filepath,\n 'nms': True,\n 'nms_thresh': nms_thresh,\n 'sensitivity': 0.0,\n }\n prediction_list = depc.get_property(\n 'localizations', gid_list_, None, config=config\n )\n prediction_dict = dict(zip(gid_list_, prediction_list))\n\n result_list = []\n for gid, wic_confidence, flag in zip(gid_list, wic_confidence_list, flag_list):\n if not flag:\n best_key = 'negative'\n best_score = 1.0 - wic_confidence\n else:\n prediction = prediction_dict.get(gid, None)\n assert prediction is not None\n\n best_score = 0.0\n if prediction is not None:\n score, bboxes, thetas, confs, classes = prediction\n for bbox, conf in zip(bboxes, confs):\n xtl, ytl, w, h = bbox\n area = w * h\n if area >= min_area:\n best_score = max(best_score, conf)\n\n if best_score >= 0.5:\n best_key = 'positive'\n else:\n best_key = 'negative'\n best_score = 1.0 - best_score\n result = (\n best_score,\n best_key,\n )\n result_list.append(result)\n else:\n raise ValueError(\n 'specified classifier algo is not supported in config = {!r}'.format(config)\n )\n\n # yield detections\n for result in result_list:\n yield result","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_classifier.predict(data)","def voc_pred_process(pred_data, val_cls, recs):\n num_classes = config.num_classes\n cls_img_ids = {}\n cls_bboxes = {}\n cls_scores = {}\n classes = {}\n cls_npos = {}\n for cls in val_cls:\n if cls == 'background':\n continue\n class_recs = {}\n npos = 0\n for imagename in imagenames:\n R = [obj for obj in recs[imagename] if obj['name'] == cls]\n bbox = np.array([x['bbox'] for x in R])\n difficult = np.array([x['difficult'] for x in R]).astype(np.bool)\n det = [False] * len(R)\n npos = npos + sum(~difficult)\n class_recs[imagename] = {'bbox': bbox,\n 'difficult': difficult,\n 'det': det}\n cls_npos[cls] = npos\n classes[cls] = class_recs\n cls_img_ids[cls] = []\n cls_bboxes[cls] = []\n cls_scores[cls] = []\n\n for sample in pred_data:\n pred_boxes = sample['boxes']\n box_scores = sample['box_scores']\n img_id = sample['img_id']\n h, w = sample['image_shape']\n\n final_boxes = []\n final_label = []\n final_score = []\n\n for c in range(1, num_classes):\n class_box_scores = box_scores[:, c]\n score_mask = class_box_scores > config.min_score\n class_box_scores = class_box_scores[score_mask]\n class_boxes = pred_boxes[score_mask] * [h, w, h, w]\n\n if score_mask.any():\n nms_index = apply_nms(class_boxes, class_box_scores, config.nms_threshold, config.max_boxes)\n class_boxes = class_boxes[nms_index]\n class_box_scores = class_box_scores[nms_index]\n\n final_boxes += class_boxes.tolist()\n final_score += class_box_scores.tolist()\n final_label += [c] * len(class_box_scores)\n\n for loc, label, score in zip(final_boxes, final_label, final_score):\n cls_img_ids[val_cls[label]].append(img_id)\n cls_bboxes[val_cls[label]].append([loc[1], loc[0], loc[3], loc[2]])\n cls_scores[val_cls[label]].append(score)\n return classes, cls_img_ids, cls_bboxes, cls_scores, cls_npos","def _eval_predictions(self, tasks, predictions):\n self._logger.info(\"Preparing results for COCO format ...\")\n coco_results = list(itertools.chain(*[x[\"instances\"] for x in predictions]))\n\n # unmap the category ids for COCO\n if hasattr(self._metadata, \"thing_dataset_id_to_contiguous_id\"):\n reverse_id_mapping = {\n v: k for k, v in self._metadata.thing_dataset_id_to_contiguous_id.items()\n }\n for result in coco_results:\n category_id = result[\"category_id\"]\n assert (\n category_id in reverse_id_mapping\n ), \"A prediction has category_id={}, which is not available in the dataset.\".format(\n category_id\n )\n result[\"category_id\"] = reverse_id_mapping[category_id]\n\n if self._output_dir:\n file_path = os.path.join(self._output_dir, \"coco_instances_results.json\")\n self._logger.info(\"Saving results to {}\".format(file_path))\n with PathManager.open(file_path, \"w\") as f:\n f.write(json.dumps(coco_results))\n f.flush()\n\n if not self._do_evaluation:\n self._logger.info(\"Annotations are not available for evaluation.\")\n return\n\n self._logger.info(\"Evaluating predictions ...\")\n for i, task in enumerate(list(sorted(tasks)) + ['segm_voc', 'segm_nvoc']):\n\n if task in ['segm_voc', 'segm_nvoc']:\n iou_type, ps_mode = task.split('_')\n else:\n iou_type = task\n ps_mode = None\n\n print('psmode', ps_mode, iou_type)\n coco_eval = (\n _evaluate_predictions_on_coco_ps(\n self._coco_api, coco_results, iou_type, ps_mode, kpt_oks_sigmas=self._kpt_oks_sigmas\n )\n if len(coco_results) > 0\n else None # cocoapi does not handle empty results very well\n )\n\n if ps_mode == 'voc':\n class_names = list(np.asarray(self._metadata.get(\"thing_classes\"))[VOC_INDICES])\n elif ps_mode == 'nvoc':\n class_names = list(np.asarray(self._metadata.get(\"thing_classes\"))[NON_VOC_INDICES])\n else:\n class_names = self._metadata.get(\"thing_classes\")\n\n res = self._derive_coco_results(\n coco_eval, iou_type, class_names=class_names\n )\n self._results[task] = res","def handle_decode(self, encoded_data):\n \n config.COD_PROMPT = config.DEC_PROMPT\n print config.DEC_PROMPT + \" decoding...\"\n \n # while there is another decoder, run each item through the next decoder\n data = encoded_data\n success = False\n for decoder in self.decoder_list:\n current_decoder = decoder()\n success, data = self.recursive_decoder(current_decoder.decode, data)\n if not success:\n break\n print config.DEC_PROMPT + \"%s decoded to '%s'\" % ( current_decoder.name(),data)\n return success, data","def coco_metrics(pred_data, anno_json, config):\n from pycocotools.coco import COCO\n from pycocotools.cocoeval import COCOeval\n num_classes = config.num_classes\n\n #Classes need to train or test.\n val_cls = config.classes\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(anno_json)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n predictions = []\n img_ids = []\n\n for sample in pred_data:\n pred_boxes = sample['boxes']\n box_scores = sample['box_scores']\n img_id = sample['img_id']\n h, w = sample['image_shape']\n\n final_boxes = []\n final_label = []\n final_score = []\n img_ids.append(img_id)\n\n for c in range(1, num_classes):\n class_box_scores = box_scores[:, c]\n score_mask = class_box_scores > config.min_score\n class_box_scores = class_box_scores[score_mask]\n class_boxes = pred_boxes[score_mask] * [h, w, h, w]\n\n if score_mask.any():\n nms_index = apply_nms(class_boxes, class_box_scores, config.nms_threshold, config.max_boxes)\n class_boxes = class_boxes[nms_index]\n class_box_scores = class_box_scores[nms_index]\n\n final_boxes += class_boxes.tolist()\n final_score += class_box_scores.tolist()\n final_label += [classs_dict[val_cls_dict[c]]] * len(class_box_scores)\n\n for loc, label, score in zip(final_boxes, final_label, final_score):\n res = {}\n res['image_id'] = img_id\n res['bbox'] = [loc[1], loc[0], loc[3] - loc[1], loc[2] - loc[0]]\n res['score'] = score\n res['category_id'] = label\n predictions.append(res)\n if not os.path.exists('./eval_out'):\n os.makedirs('./eval_out')\n with open('./eval_out/predictions.json', 'w') as f:\n json.dump(predictions, f)\n\n coco_dt = coco_gt.loadRes('./eval_out/predictions.json')\n E = COCOeval(coco_gt, coco_dt, iouType='bbox')\n E.params.imgIds = img_ids\n E.evaluate()\n E.accumulate()\n E.summarize()\n return E.stats[0]","def algo(self):\n audio = np.array([self.audio.popleft() for _ in range(self.count)])\n # Run Classifier\n wav_data = np.abs(np.fft.rfft(audio.flatten()))\n if len(wav_data) > 0:\n pred = self.clf.predict(np.expand_dims(wav_data, 0))\n if self.verbose > 1:\n print('The prediction is : ' + str(pred))\n self.finished.emit(int(pred[-1]))\n else:\n self.finished.emit(0)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)\n #track.du_doan(self.kf_test)","def actflowDecodings(data, actflow_data, effects=False, featsel=True, ncvs=1, permutation=False, confusion=False, nproc=5):\n\n nSubjs = data.shape[2]\n stats = np.zeros((1,))\n \n ncond = data.shape[1]\n\n nsamples = nSubjs * ncond\n nfeatures = data.shape[0]\n\n # Label array for supervised learning\n labels = np.tile(range(ncond),nSubjs)\n subjarray = np.repeat(range(nSubjs),ncond)\n\n svm_mat = np.zeros((nsamples,nfeatures))\n actflow_svm_mat = np.zeros((nsamples,nfeatures))\n samplecount = 0\n scount = 0\n for subj in range(nSubjs):\n roidata = data[:,:,scount]\n actflow_roidata = actflow_data[:,:,scount]\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\n actflow_svm_mat[samplecount:(samplecount+ncond),:] = actflow_roidata.T\n\n scount += 1\n samplecount += ncond\n\n # Spatially demean matrix across features\n# samplemean = np.mean(svm_mat,axis=1)\n# samplemean.shape = (len(samplemean),1)\n# svm_mat = svm_mat - samplemean\n#\n# samplemean = np.mean(actflow_svm_mat,axis=1)\n# samplemean.shape = (len(samplemean),1)\n# actflow_svm_mat = actflow_svm_mat - samplemean\n\n scores, rmatch, rmismatch, confusion_mat = actflowRandomSplitLOOBaselineCV(ncvs, svm_mat, actflow_svm_mat, labels, subjarray, featsel=featsel, permutation=permutation, nproc=nproc)\n# stats = np.mean(scores)\n stats = scores \n\n if effects and confusion:\n return stats, rmatch, rmismatch, confusion_mat\n if effects and not confusion:\n return stats, rmatch, rmismatch\n if confusion and not effects:\n return stats, confusion_mat\n else:\n return stats","def predict_multiple():\n req = request.json\n values = pd.DataFrame(data=req['data'])\n pred = clf2.predict(values)\n responses = {}\n for i, rep in enumerate(pred):\n if rep:\n responses[f\"Customer {i + 1}\"] = f\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is likely to churn\"\n\n else:\n responses[f\"Customer {i + 1}\"] = f\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is a loyal customer\"\n\n return make_response(jsonify(responses))","def process_data(df, encoders, process_target=True):\n\n # Pclass\n pclass_enc = df['Pclass'].values\n pclass_enc = encoders['pclass_encoder'].transform(pclass_enc)\n\n # Sex\n sex_enc = df['Sex'].values\n sex_enc = encoders['sex_encoder'].transform(sex_enc)\n\n # Age\n age_enc = pd.cut(df['Age'].values, encoders['age_bins'],\n labels=False, include_lowest=True)\n age_enc = encoders['age_encoder'].transform(age_enc)\n\n # Siblings/Spouses Aboard\n siblings_spouses_aboard_enc = df['Siblings/Spouses Aboard'].values\n siblings_spouses_aboard_enc = encoders['siblings_spouses_aboard_encoder'].transform(\n siblings_spouses_aboard_enc)\n\n # Parents/Children Aboard\n parents_children_aboard_enc = df['Parents/Children Aboard'].values\n parents_children_aboard_enc = encoders['parents_children_aboard_encoder'].transform(\n parents_children_aboard_enc)\n\n # Fare\n fare_enc = pd.cut(df['Fare'].values, encoders['fare_bins'],\n labels=False, include_lowest=True)\n fare_enc = encoders['fare_encoder'].transform(fare_enc)\n\n data_enc = [pclass_enc,\n sex_enc,\n age_enc,\n siblings_spouses_aboard_enc,\n parents_children_aboard_enc,\n fare_enc\n ]\n\n if process_target:\n # Target Field: Survived\n survived_enc = df['Survived'].values\n\n survived_enc = encoders['survived_encoder'].transform(survived_enc)\n\n return (data_enc, survived_enc)\n\n return data_enc","def main(self, data):\n\t\ttokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\", do_lower_case=True)\n\t\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\n\t\tlabel, prob = self.predict(eval_features)\n\t\treturn label, prob","def main() -> Dict[int, int]:\n # DOCUMENTS DIRECTORY\n # Path of the directory that contains the .txt documents. One .txt document by company. IT NEEDS TO BE \"/data\" when you upload it in data challenge platform. For test in local, you can modifiy to match your data path.\n if dev:\n documents_directory = \"../example_dataset/data\"\n else: \n documents_directory = \"/data\"\n\n path_to_files: List[str] = [os.path.join(documents_directory, file) for file in os.listdir(documents_directory)]\n assert len(path_to_files) == 10 # 10 files in documents directory\n path_to_files.sort() # Sort list of path file by alphabetical order to match ground truth annotations order : IT IS ESSENTIAL.\n\n # INITIALIZATION OF YOUR OBJECTS\n data_model = FormDataModel.from_json_file(\n os.path.join(os.path.dirname(__file__), \"resources\", \"data-model.json\")\n )\n country_referential = CountryReferential.from_csv(\n os.path.join(os.path.dirname(__file__), \"resources\", \"countries_code.csv\")\n )\n form_company_filling = FormCompanyFilling([\n BasicExtractor(\n question_ids=NOT_COUNTRY_QUESTIONS_NUMBERS,\n form_data_model=data_model,\n ),\n BasicCountryExtractor(\n question_ids=COUNTRY_QUESTIONS_NUMBERS,\n form_data_model=data_model,\n country_code_referential=country_referential,\n\n )\n ])\n\n # COMPUTE PREDICTION BY FILE (ie company)\n print(\"##################################\")\n print(\"RUNNING PREDICTION\")\n results: Dict[int, int] = {}\n start_time = time.time()\n for i, path in enumerate(path_to_files):\n start = time.time()\n print(f\"File : {path}\")\n with open(path, \"r\") as input_file:\n text = input_file.read()\n print(\"... Encoding ...\")\n start_encoding = time.time()\n embeddings = model.encode(prepare_sentences(text))\n # embeddings = []\n print(\"Successfully encoded\")\n print(\"Encoding time : \", time.time() - start_encoding)\n\n form_company_response = form_company_filling.fill(text, embeddings, model)\n form_company_response.sort_by_question_id() # ESSENTIAL : Sort the response by question number for each company\n for answer in form_company_response.answers:\n question_number = answer.question_id + i * 22 # ESSENTIAL : each company has 22 questions. Each question_number in results should be unique\n results[question_number] = answer.answer_id\n # gc.collect()\n print(\"File time :\", time.time()-start, '\\n')\n # CHECK FORMAT RESULTS IS DATACHALLENGE PLATFORM COMPATIBLE\n assert len(results) == len(path_to_files) * (len(COUNTRY_QUESTIONS_NUMBERS) + len(NOT_COUNTRY_QUESTIONS_NUMBERS))\n assert set(list(results.keys())) == {i for i in range(1,221)}\n print(\"Full Time\", time.time()-start_time)\n return results","def yield_prediction():\n ## input code here\n if request.method == \"POST\":\n re = request.get_json()\n city = re[\"city\"]\n state = re[\"state\"]\n ## convert into lower case\n state = state.lower()\n city = city.lower()\n model_crop = re[\"crop\"]\n model_crop = model_crop.lower()\n model_season = re[\"season\"]\n model_season = model_season.lower()\n model_area = re[\"area\"]\n model_area = int(model_area)\n\n ## store name of crop for the graph\n crop = model_crop\n ## preprocesss the code\n\n try:\n state_le = load(\"static/labelencoder/state_le.joblib\")\n district_le = load(\"static/labelencoder/district_le.joblib\")\n season_le = load(\"static/labelencoder/season_le.joblib\")\n crop_le = load(\"static/labelencoder/crop_le.joblib\")\n model_crop = crop_le.transform([model_crop])[0]\n model_season = season_le.transform([model_season])[0]\n model_state = state_le.transform([state])[0]\n model_city = district_le.transform([city])[0]\n except:\n response_dict = {\n \"status\": False,\n \"message\": \"Enter Valid Data\"\n }\n return jsonify(response_dict)\n\n model_city = int(model_city)\n model_state = int(model_state)\n model_crop = int(model_crop)\n model_season = int(model_season)\n model_para = [model_state, model_city, model_season, model_crop, model_area]\n\n ## prediction code here\n\n import requests\n # NOTE: you must manually set API_KEY below using information retrieved from your IBM Cloud account.\n API_KEY = \"S30qFHkYTHMDO81ijSRiGSiE1jOfnlt01Vtn9UBU2KqL\"\n token_response = requests.post('https://iam.cloud.ibm.com/identity/token',\n data={\"apikey\": API_KEY, \"grant_type\": 'urn:ibm:params:oauth:grant-type:apikey'})\n mltoken = token_response.json()[\"access_token\"]\n\n header = {'Content-Type': 'application/json', 'Authorization': 'Bearer ' + mltoken}\n\n # NOTE: manually define and pass the array(s) of values to be scored in the next line\n payload_scoring = {\"input_data\": [\n {\"fields\": [\"State_Name\", \"District_Name\", \"Season\", \"Crop\", \"Area\"], \"values\": [model_para]}]}\n\n response_scoring = requests.post(\n 'https://us-south.ml.cloud.ibm.com/ml/v4/deployments/180fe5c1-a652-4e59-8b33-781326790706/predictions?version=2021-07-16',\n json=payload_scoring, headers={'Authorization': 'Bearer ' + mltoken})\n\n output = response_scoring.json()\n\n ## retrive the output\n\n pred_yield = output[\"predictions\"][0]['values'][0][0]\n pred_production = pred_yield * model_area\n\n ## PIE CHART\n try:\n kharif_value = kharif_yield.query.filter_by(crop_name=crop).first()\n kharif_values = kharif_value.yield_value\n except:\n kharif_values = 0\n try:\n rabi_value = rabi_yield.query.filter_by(crop_name=crop).first()\n rabi_values = rabi_value.yield_value\n except:\n rabi_values = 0\n\n try:\n summer_value = summer_yield.query.filter_by(crop_name=crop).first()\n summer_values = summer_value.yield_value\n except:\n summer_values = 0\n\n try:\n winter_value = winter_yield.query.filter_by(crop_name=crop).first()\n winter_values = winter_value.yield_value\n except:\n winter_values = 0\n\n try:\n autumn_value = autumn_yield.query.filter_by(crop_name=crop).first()\n autumn_values = autumn_value.yield_value\n except:\n autumn_values = 0\n\n try:\n whole_year_value = whole_year_yield.query.filter_by(crop_name=crop).first()\n whole_year_values = whole_year_value.yield_value\n except:\n whole_year_values = 0\n\n season_name = ['kharif', 'rabi', 'summer', 'winter', 'autumn', 'whole year']\n yield_list = [kharif_values, rabi_values, summer_values, winter_values, autumn_values, whole_year_values]\n\n season_yield_dict = dict()\n pie_list = list()\n for season, value in zip(season_name, yield_list):\n if value == 0:\n pass\n else:\n season_yield_dict[season] = round(value, 2)\n pie_list.append(round(value, 2))\n bar_graph_label = list(season_yield_dict.keys())\n pie_final_list = list()\n sum_list = sum(pie_list)\n for val in pie_list:\n suceess = val / sum_list\n suceess = round(suceess, 2)\n pie_final_list.append(suceess * 100)\n\n ## reponse dict here\n response_dict = {\n \"predYield\": pred_yield,\n \"predProduction\": pred_production,\n \"barGraphLabel\": bar_graph_label,\n \"barGraphvalue\": yield_list,\n \"pieChartLabel\": bar_graph_label,\n \"pieChartValue\": pie_final_list\n }\n return jsonify(response_dict)","def predict(self, x):\n\n x_ = self.scaler_s1.transform(x)\n s1_df = self.basemodel.decision_function(x_)\n s2_df = self.confidencemodel.decision_function(x_)\n\n '''\n hc_df = np.max(dfs, 1)\n\n # high confidence vector\n hc_df[(dfs > 0).sum(1) > 1] = np.min(dfs, 1)[(dfs > 0).sum(1) > 1]\n '''\n\n hc_df = -np.ones((s2_df.shape[0], 1))\n y_pred1 = self.basemodel.predict(x_)\n\n unique_labels = range(s2_df.shape[1])\n for label in unique_labels:\n hc_df[y_pred1 == label, :] = s2_df[y_pred1 == label, label][:, np.newaxis]\n\n '''\n # TODO modif this to be compatible with multilabel classifiers (currently only binary classifier)\n xor_mask = np.logical_xor(s2_df[:, 0] > 0, s2_df[:, 1] > 0)\n\n if xor_mask.sum() > 0:\n hc_df[xor_mask, 0] = np.max(s2_df, 1)[xor_mask]\n hc_df[~xor_mask, 0] = -np.abs(np.max(s2_df, 1)[~xor_mask])\n #hc_labels = np.greater(s2_df[:, 1], s2_df[:, 0]).astype(int)\n '''\n\n hit_proba_estimate = self.hitproba.predict(x_)\n joint_hc = self.joint_class_hc.predict(x_)\n\n data_array = []\n dict_array = []\n if len(joint_hc.shape):\n\n dict_array = {'s1_df': s1_df[:, np.newaxis],\n 'hcdf': hc_df,\n 's2_df': s2_df,\n 'hitproba': hit_proba_estimate[:, np.newaxis],\n 'hcjoint': joint_hc[:, np.newaxis],\n 's1_hat': self.ohe.transform((s1_df[:, np.newaxis]>0).astype(int)),\n 's2_hat': ((self.ohe.transform((s1_df.reshape(-1, 1)>0).astype(int))>0) & (s2_df>0)).astype(int),\n }\n data_array = np.hstack(\n [s1_df[:, np.newaxis], hc_df, s2_df, hit_proba_estimate[:, np.newaxis], joint_hc[:, np.newaxis]])\n else:\n # multiclass\n data_array = np.hstack([s1_df, hc_df, s2_df, hit_proba_estimate, joint_hc])\n dict_array = {'s1_df': s1_df,\n 'hc_df': hc_df,\n 's2_df': s2_df,\n 'hitproba': hit_proba_estimate,\n 'hcjoint': joint_hc,\n 's1_hat': self.ohe.transform((s1_df > 0).astype(int)),\n 's2_hat': ((self.ohe.transform((s1_df > 0).astype(int)) > 0) & (s2_df > 0)).astype(int)\n }\n\n return data_array, dict_array","def predict_and_sample(inference_model,x_initializer,a_initializer,c_initializer):\n # Step 1: Use your inference model to predict an output sequence given x_initializer, a_initializer and c_initializer.\n pred = inference_model.predict([x_initializer,a_initializer,c_initializer])\n \n # Step 2: Convert \"pred\" into an np.array() of indices with the maximum probabilities\n indices = np.argmax(pred,axis=-1)\n \n # Step 3: Convert indices to one-hot vectors, the shape of the results should be (1, )\n results = to_categorical(indices,num_classes=x_initializer.shape[-1])\n \n return results,indices","def post_handler(_dev_idx, raw_res, _captured_frames_path):\n global CUR_IMAGE\n if CUR_IMAGE % 2:\n print(\"\\nFox classification\")\n else:\n print(\"\\nCat classification\")\n\n scores, _labels = postprocess(raw_res[0])\n top_indices(scores[0], 3)\n\n CUR_IMAGE += 1","def postprocess(self, data):\n if self.error is not None:\n return [self.error]\n\n # Iterating over inference results to render the normalized probabilities\n response = []\n for inference_result in data:\n softmax_result = inference_result.softmax().asnumpy()\n for idx, label in enumerate(self.labels):\n response.append({label: float(softmax_result[0][idx])})\n return [response]","def make_predictions(self):\n if is_classification(self.model):\n if self.ct == None:\n prediction = self.model.predict(self.input_data.to_numpy())\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\n return prediction, probabilities\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n probabilities = self.model.predict_proba(self.data_into_model())\n return prediction, probabilities\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.model))\n \n else:\n if self.ct == None:\n prediction = self.model.predict(self.input_data)\n return prediction\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n return prediction\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.self.model))","def Prediction(self):\n # converts first 19 chunks of audio bytes into 16 bit int values\n in_data = np.fromstring(np.array(self.frames[:19]), 'Int16')\n\n # extract MFCCs from the 19 chunks of audio\n audio_sig = np.array([mfcc(in_data, self.rate, self.window,\n self.stride, self.mfcc, self.filter_banks,\n self.fft_num, 0, None, True)])\n\n # makes predictions\n prediction = self.ww_model.model.predict(audio_sig)\n\n if(self.print_pred):\n print(prediction)\n\n return prediction","def test_service_api_predict_single_raw_classified(service_app):\n response = service_app.post('/predict',\n data=json.dumps(data[1:2]),\n content_type='application/json')\n\n response_data = json.loads(response.data)\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 200\n assert response_data['message'] == 'Records successfully classified'\n assert len(response_data['prediction'].keys()) == 102\n assert response_data['prediction']['business_outcome'] == [4]\n assert response_data['prediction']['phat'] == [0.8228085289874678]\n assert all(len(value) == 1 for value in response_data['prediction'].values())","def do_decode(decoder, \n output_handlers, \n src_sentences,\n trgt_sentences=None,\n estimator=None,\n iterations=1,\n num_log=1):\n if not decoder.has_predictor():\n logging.fatal(\"Terminated due to an error in the \"\n \"predictor configuration.\")\n return\n all_hypos = []\n text_output_handler = _get_text_output_handler(output_handlers)\n if text_output_handler:\n text_output_handler.open_file()\n score_output_handler = _get_score_output_handler(output_handlers)\n\n start_time = time.time()\n logging.info(\"Start time: %s\" % start_time)\n sen_indices = []\n diversity_metrics = []\n not_full = 0\n num_iterations = iterations if estimator and not decoder.is_deterministic() else 1\n \n estimates = []\n\n for sen_idx in get_sentence_indices(args.range, src_sentences):\n decoder.set_current_sen_id(sen_idx)\n try:\n src = \"0\" if src_sentences is False else src_sentences[sen_idx]\n if len(src.split()) > 1000:\n print(\"Skipping ID\", str(sen_idx), \". Too long...\")\n continue\n src_print = io_utils.src_sentence(src)\n logging.info(\"Next sentence (ID: %d): %s\" % (sen_idx + 1, src_print))\n src = io_utils.encode(src)\n sen_estimates = []\n\n for i in range(num_iterations):\n start_hypo_time = time.time()\n decoder.apply_predictor_count = 0\n decoder.seed=i\n if decoder.name == \"reference\":\n hypos = decoder.decode(src, io_utils.encode_trg(trgt_sentences[sen_idx]))\n else:\n hypos = decoder.decode(src)\n if not hypos:\n logging.error(\"No translation found for ID %d!\" % (sen_idx+1))\n logging.info(\"Stats (ID: %d): score=<not-found> \"\n \"num_expansions=%d \"\n \"time=%.2f\" % (sen_idx+1,\n decoder.apply_predictor_count,\n time.time() - start_hypo_time))\n hypos = [_generate_dummy_hypo()]\n \n hypos = _postprocess_complete_hypos(hypos)\n for logged_hypo in hypos[:num_log]:\n logging.info(\"Decoded (ID: %d): %s\" % (\n sen_idx+1,\n io_utils.decode(logged_hypo.trgt_sentence)))\n logging.info(\"Stats (ID: %d): score=%f \"\n \"num_expansions=%d \"\n \"time=%.2f \" \n \"perplexity=%.2f\"% (sen_idx+1,\n logged_hypo.total_score,\n #logged_hypo.base_score if logged_hypo.base_score else logged_hypo.total_score,\n decoder.apply_predictor_count,\n time.time() - start_hypo_time,\n utils.perplexity(logged_hypo.score_breakdown)))\n if estimator:\n container = []\n kau = min(hypos).total_score if decoder.gumbel else None\n for h in hypos:\n if kau and h.total_score <= kau:\n continue\n inc_prob = decoder.get_inclusion_prob_estimate(src, h, kau=kau)\n model_prob = h.base_score if h.base_score else h.total_score\n val = estimator.add_value(h, model_prob - inc_prob, \n ref=trgt_sentences[sen_idx] if trgt_sentences else None)\n container.append((model_prob - inc_prob, val))\n logging.info(\"Estimator value: %.5f\" % (estimator.estimate()))\n estimator.reset()\n sen_estimates.append(container)\n\n\n if score_output_handler:\n try:\n score_output_handler.write_score(logged_hypo.score_breakdown)\n except IOError as e:\n logging.error(\"I/O error %d occurred when creating output files: %s\"\n % (sys.exc_info()[0], e))\n\n if decoder.nbest > 1:\n diversity_score = utils.ngram_diversity([io_utils.decode(h.trgt_sentence) for h in hypos])\n logging.info(\"Diversity: score=%f \"\n % (diversity_score))\n diversity_metrics.append(diversity_score)\n\n if len(hypos) < decoder.nbest:\n not_full += 1\n\n \n all_hypos.append(hypos)\n sen_indices.append(sen_idx)\n estimates.append(sen_estimates)\n try:\n # Write text output as we go\n if text_output_handler:\n text_output_handler.write_hypos([hypos])\n except IOError as e:\n logging.error(\"I/O error %d occurred when creating output files: %s\"\n % (sys.exc_info()[0], e))\n except ValueError as e:\n logging.error(\"Number format error at sentence id %d: %s, \"\n \"Stack trace: %s\" % (sen_idx+1, \n e,\n traceback.format_exc()))\n except AttributeError as e:\n logging.fatal(\"Attribute error at sentence id %d: %s. This often \"\n \"indicates an error in the predictor configuration \"\n \"which could not be detected in initialisation. \"\n \"Stack trace: %s\" \n % (sen_idx+1, e, traceback.format_exc()))\n except Exception as e:\n logging.error(\"An unexpected %s error has occurred at sentence id \"\n \"%d: %s, Stack trace: %s\" % (sys.exc_info()[0],\n sen_idx+1,\n e,\n traceback.format_exc()))\n try:\n # Write text output as we go\n if text_output_handler:\n hypos = [_generate_dummy_hypo()]\n text_output_handler.write_hypos([hypos])\n except IOError as e:\n logging.error(\"I/O error %d occurred when creating output files: %s\"\n % (sys.exc_info()[0], e))\n if estimator:\n file_name = decoder.name + '_' + args.fairseq_lang_pair + '_' + estimator.name + '_' +str(args.range) + '_' + str(args.nbest)\n if hasattr(args, 'inc_prob_estimate_rounds'):\n file_name += '_' + str(args.inc_prob_estimate_rounds)\n file_name += '.out'\n with open(file_name, 'w') as f:\n f.write('\\n'.join([str(x) for x in estimates]))\n\n logging.info(\"Decoding finished. Time: %.2f\" % (time.time() - start_time))\n if decoder.nbest > 1:\n print(diversity_metrics)\n print(\"Total not full:\", str(not_full))\n try:\n for output_handler in output_handlers:\n if output_handler == text_output_handler:\n output_handler.close_file()\n else:\n output_handler.write_hypos(all_hypos, sen_indices)\n except IOError as e:\n logging.error(\"I/O error %s occurred when creating output files: %s\"\n % (sys.exc_info()[0], e))","def inference(self, inputs):\n\n input_ids = torch.tensor([inputs[\"head_ids\"]], dtype=torch.long).to(self.device)\n attention_masks = torch.tensor([inputs[\"attention_masks\"]], dtype=torch.bool).to(self.device)\n \n # Handling inference for sequence_classification.\n with torch.no_grad():\n output = self.model(input_ids, attention_masks)\n predict_label = output[0].argmax(dim=2)\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\n\n logger.info(\"Model predicted: '%s'\", predict_string)\n return [{'predict': predict_string}]","def _predict(self, probabilities):\n child_categories = []\n for i in range(0, self.category_level):\n child_categories.append({})\n for category_label in self.classifiers[i].classes_:\n main_category = self._get_categories(category_label)[0]\n if main_category not in child_categories[i]:\n child_categories[i][main_category] = []\n child_categories[i][main_category].append(category_label)\n\n # find the primary category\n max_score = -1\n primary_category_label = None\n\n for i in range(0, self.category_level):\n for category_label in self.classifiers[i].classes_:\n if probabilities[category_label] < 1e-9:\n continue\n total_score = 0\n main_category = self._get_categories(category_label)[0]\n candidates = child_categories[i][main_category]\n for actual_label in candidates:\n probability = probabilities[actual_label]\n if probability < 1e-9:\n continue\n score = self._cal_score(category_label, None, actual_label, i)\n total_score += score * probability\n if total_score > max_score:\n max_score = total_score\n primary_category_label = category_label\n\n # find the secondary category\n max_score = -1\n secondary_category_label = None\n for i in range(0, self.category_level):\n for category_label in self.classifiers[i].classes_:\n if probabilities[category_label] < 1e-9 and secondary_category_label:\n continue\n if category_label == primary_category_label:\n continue\n total_score = 0\n main_category = self._get_categories(category_label)[0]\n main_category2 = self._get_categories(primary_category_label)[0]\n candidates = list(set(child_categories[i][main_category] + child_categories[i][main_category2]))\n for actual_label in candidates:\n probability = probabilities[actual_label]\n if probability < 1e-9:\n continue\n score = self._cal_score(primary_category_label, category_label, actual_label, i)\n total_score += score * probability\n if total_score > max_score:\n max_score = total_score\n secondary_category_label = category_label\n\n return [self._get_categories(primary_category_label), self._get_categories(secondary_category_label)]","def predict(image_path, wrapper):\n \"\"\"\n #Don't forget to store your prediction into ImgPred\n img_prediction = ImgPred(...)\n \"\"\"\n\n #This is where all of our code will probably go. Here are the steps to success\n\n \n #Step One: Make a list which will contain the locations of every character in our source Image.\n SymPredList = []\n\n #Step Two: Go down that list we just made and use the code from PA4 in conjunction with our new Model to analyze each character. George made this part.\n #This is the find a character part of the code. Max and George worked it out.\n im = cv2.imread(image_path,0)\n (thresh, imbw) = cv2.threshold(im,20,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU)\n #cv2.imwrite('clapfuck.jpg', imbw)\n im3,contours,hierarchy = cv2.findContours(imbw,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\n idx = 0\n for cnt in contours:\n idx += 1\n x1,y1,w,h = cv2.boundingRect(cnt)\n roi=imbw[y1:y1+h,x1:x1+w]\n\n #Step Two.1: Make a Numpy Array of all the pixels starting from the top left corner of an identified character to the bottom right corner of the identified character.\n height, width = roi.shape\n if height >= width:\n padded = cv2.copyMakeBorder(roi,0,0,(height-width)//2,(height-width)//2,cv2.BORDER_CONSTANT,value=[0,0,0])\n else:\n padded = cv2.copyMakeBorder(roi,(width-height)//2,(width-height)//2,0,0,cv2.BORDER_CONSTANT,value=[0,0,0])\n Smol = cv2.resize(padded, (28, 28))\n (thresh, evaluateMe) = cv2.threshold(Smol, 20, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\n #scipy.misc.imsave(os.path.basename(file), ree)\n #Step Two.2: Feed that numpy into our PA4 image analyzer converter thing but using our new trained model\n evaluateMeMe = numpy.reshape(evaluateMe, (1, 28, 28, 1))\n prediction = tf.argmax(y_conv,1)\n final_number = prediction.eval(feed_dict={x:evaluateMeMe,y_:numpy.zeros((1,40)), keep_prob:1.0})\n #Step Two.3: Record what we think it is as the prediction field of the SymPred we are currently on\n final_guess = wrapper.label_types[int(final_number)]\n DisSymPred = SymPred(final_guess,x1,y1,x1+w,y1-h)\n SymPredList.append(DisSymPred)\n\n #Step Three: Wrap that now complete SymPred list, in an ImgPred, fill out all the fields of that ImgPred, and then return that shit.\n img_prediction = ImgPred(os.path.basename(image_path), SymPredList)\n\n #Step Four: Were Donezo\n return img_prediction","def do_training(self):\n json_data = request.data\n global g_list_of_classifier\n\n datas = json.loads(json_data.decode('UTF-8')) #datas = liste\n\n for ite_clf in g_list_of_classifier:\n for data in datas:\n ite_clf.add_data(data['score'], data['answer'])\n print(ite_clf.get_info())\n return ''","def get_mc_pred(output,eng,frame,nImg):\n preds_2d = [];\n preds_3d = [];\n \n c,s = ut.calc_cent_scale(frame);\n \n center = matlab.double([list(c)],(1,2));\n scale = matlab.double([s],(1,1));\n \n for i in tqdm(range(0,nImg)):\n preds_2d.append(eng.transformMPII(output[\"W_final\"][2*i:2*(i+1)],center,scale,matlab.double([64,64],(1,2)),1));\n preds_3d.append(output[\"S_final\"][3*i:3*i + 3]);\n \n print(\"Converting estimates to Python format...\");\n preds_2d = np.array(preds_2d);\n preds_3d = np.array(preds_3d);\n \n preds_2d = preds_2d.swapaxes(1, 2);\n preds_3d = preds_3d.swapaxes(1, 2);\n \n return preds_2d, preds_3d;","def evaluate(self, model, data):\n model.eval()\n\n loss = self.loss\n loss.reset()\n match = 0\n total = 0\n correct_spk = 0\n total_response = 0\n y_true = np.array([])\n y_pred = np.array([])\n\n device = None if torch.cuda.is_available() else -1\n batch_iterator = torchtext.data.BucketIterator(\n dataset=data, batch_size=self.batch_size,\n sort=True, sort_key=lambda x: len(x.src),\n device=device, train=False)\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\n\n for batch in batch_iterator:\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\n\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs)\n\n # Predict Speaker:\n target_spk = spk_inputs[-1]\n target_lengths = target_lengths.cpu().numpy()\n prob_per_spk = []\n for i in range(self.args.num_spk):\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\n spk_inputs_.append(spk_inputs_predict)\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs_)\n prob_per_responce = []\n target = target_variables.transpose(0,1)\n for word, prob in zip(target[1:], decoder_outputs):\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\n indices = zip(np.arange(len(word)), word)\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\n prob_per_responce.append(prob_per_word)\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\n\n predicts = np.argmax(prob_per_spk, axis=1)\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\n total_response += len(batch.tgt[0])\n\n # Evaluation\n seqlist = other['sequence']\n for step, step_output in enumerate(decoder_outputs):\n target = target_variables[:, step + 1]\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\n\n non_padding = target.ne(pad)\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\n match += correct\n total += non_padding.sum().data[0]\n\n y_pred = np.append(y_pred, predicts)\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\n\n print(y_pred.shape)\n\n print(accuracy_score(y_true, y_pred))\n print(confusion_matrix(y_true, y_pred))\n\n if total == 0:\n accuracy = float('nan')\n else:\n accuracy = match / total\n\n if total_response == 0:\n accuracy_spk = float('nan')\n else:\n accuracy_spk = correct_spk / total_response\n\n return loss.get_loss(), accuracy, accuracy_spk","def decode(self, probs, embedded_inputs, selections, decode_type):\n batch_size = self.shape(probs)[0]\n idxs = mindspore.ops.multinomial(probs, 1)\n squeeze = mindspore.ops.Squeeze(1)\n idxs = squeeze(idxs)\n\n sels = embedded_inputs[idxs.item(), [i for i in range(batch_size)], :]\n return sels, idxs","def mite_2m(train_df, test_df, features, outcome, treatment, exposure, clf_t, clf_c, clf_er):\n np.random.seed(0)\n\n train_exposed_df, train_not_exposed_df = split_treatment_control(train_df, exposure)\n train_t_df, _ = split_treatment_control(train_df, treatment)\n\n clf_t_trained = clf_t.fit(train_exposed_df[features], train_exposed_df[outcome])\n clf_c_trained = clf_c.fit(train_not_exposed_df[features], train_not_exposed_df[outcome])\n clf_er_trained = clf_er.fit(train_t_df[features], train_t_df[exposure])\n\n test_f_df = test_df[features]\n return clf_er_trained.predict_proba(test_f_df)[:, 1] * \\\n (clf_t_trained.predict_proba(test_f_df)[:, 1] - clf_c_trained.predict_proba(test_f_df)[:, 1])","def CardiacDiagnosisModelTester(clf, final_test_path, name, scaler, save_dir='./', label_available=False, prediction_csv=None):\n class_names = [MINF, DCM]\n df = load_dataframe(final_test_path, column='GROUP')\n features = list(df.columns[np.r_[START_COL:END_COL]])\n X_df = df[features]\n X_scaled = scaler.transform(X_df) \n y_pred = clf.predict(X_scaled)\n print (\"Writing predictions to file\", name)\n target = open(save_dir+'/'+ name+'predictions_{}.txt'.format(time.strftime(\"%Y%m%d_%H%M%S\")), 'w')\n classes = {MINF:0, DCM:0}\n for pid, pred in zip(df['Name'], y_pred):\n classes[class_names[pred]] +=1\n line = '{} {}'.format(pid, class_names[pred])\n target.write(line)\n target.write(\"\\n\")\n target.close()\n print (classes)\n if label_available:\n y_true,_ = encode_target(df, 'GROUP', heart_disease_label_map)\n accuracy = accuracy_score(y_true['GROUP'], y_pred)\n print(\"Accuracy: %.2f%%\" % (accuracy * 100.0))\n else:\n if prediction_csv:\n pdf = pd.read_csv(test_on_prediction)\n for pid, pred in zip(df['Name'], y_pred):\n #https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/\n pdf.loc[pdf['Name']== pid, 'GROUP'] = class_names[pred]\n pdf.to_csv(prediction_csv, index=False)\n # Upload file\n with open(os.path.join(os.path.dirname(prediction_csv), 'ACDC_Predictions.txt'),'w') as outfile:\n pdf.to_string(outfile, columns=['Name','GROUP'], index=False, header=False)","def _postprocess(self, responses):\n for idx, response in enumerate(responses):\n responses[idx] = {'id': response[0],\n 'text': self.target_test[response[0]]}\n\n for jdx, score in enumerate(response[1:]):\n responses[idx]['score_' + str(jdx)] = response[1:][jdx]\n\n return responses","def decode(self, tgt, encoder_out):\n tgt_mask = get_lookahead_mask(tgt)\n tgt = self.emb(tgt)\n tgt = self.phn_lin(tgt)\n if self.attention_type == \"RelPosMHAXL\":\n # we use fixed positional encodings in the decoder\n tgt = tgt + self.positional_encoding_decoder(tgt)\n encoder_out = encoder_out + self.positional_encoding_decoder(\n encoder_out\n )\n elif self.positional_encoding_type == \"fixed_abs_sine\":\n tgt = tgt + self.positional_encoding(tgt) # add the encodings here\n prediction, self_attns, multihead_attns = self.decoder(\n tgt,\n encoder_out,\n tgt_mask=tgt_mask,\n pos_embs_tgt=None,\n pos_embs_src=None,\n )\n attention = multihead_attns[-1]\n return prediction, attention","def predict_note_authentication(totalyearlycompensation,safety,classifier):\n \n prediction=classifier.predict([[totalyearlycompensation,safety]])\n print(prediction)\n return prediction","def test_predict(self):\n\n classifier = BertCCAMClassifier()\n classifier.load_model(\"models\")\n prediction = classifier.predict([\"bartosz\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}])\n\n # with multiple labels\n prediction = classifier.predict([\"ala bert\"])\n self.assertEqual(prediction, [{\"labels\": (\"A\", \"B\")}])\n\n # in a batch\n prediction = classifier.predict([\"bartosz\", \"adam\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}, {\"labels\": (\"A\",)}])","def decode(self, img_metas, output, **kwargs):\n batch_size = len(img_metas)\n if 'bbox_id' in img_metas[0]:\n bbox_ids = []\n else:\n bbox_ids = None\n c = np.zeros((batch_size, 2), dtype=np.float32)\n s = np.zeros((batch_size, 2), dtype=np.float32)\n image_paths = []\n score = np.ones(batch_size)\n for i in range(batch_size):\n c[i, :] = img_metas[i]['center']\n s[i, :] = img_metas[i]['scale']\n image_paths.append(img_metas[i]['image_file'])\n if 'bbox_score' in img_metas[i]:\n score[i] = np.array(img_metas[i]['bbox_score']).reshape(-1)\n if bbox_ids is not None:\n bbox_ids.append(img_metas[i]['bbox_id'])\n preds, maxvals = keypoints_from_heatmaps(output, c, s, unbiased=self.test_cfg.get('unbiased_decoding', False), post_process=self.test_cfg.get('post_process', 'default'), kernel=self.test_cfg.get('modulate_kernel', 11), valid_radius_factor=self.test_cfg.get('valid_radius_factor', 0.0546875), use_udp=self.test_cfg.get('use_udp', False), target_type=self.test_cfg.get('target_type', 'GaussianHeatmap'))\n all_preds = np.zeros((batch_size, preds.shape[1], 3), dtype=np.float32)\n all_boxes = np.zeros((batch_size, 6), dtype=np.float32)\n all_preds[:, :, 0:2] = preds[:, :, 0:2]\n all_preds[:, :, 2:3] = maxvals\n all_boxes[:, 0:2] = c[:, 0:2]\n all_boxes[:, 2:4] = s[:, 0:2]\n all_boxes[:, 4] = np.prod(s * 200.0, axis=1)\n all_boxes[:, 5] = score\n result = {}\n result['preds'] = all_preds\n result['boxes'] = all_boxes\n result['image_paths'] = image_paths\n result['bbox_ids'] = bbox_ids\n return result","def Preprocess_MR(path=\"datasets/raw/rt10662\"):\n\n output_path = \"datasets/preprocessed/MR_Data\"\n\n # load positive and negative data\n with io.open(os.path.join(path, \"rt-polarity.pos\"), encoding='latin-1') as f:\n pos_data = f.readlines()\n pos_data = [sentence.strip() for sentence in pos_data]\n with io.open(os.path.join(path, \"rt-polarity.neg\"), encoding='latin-1') as f:\n neg_data = f.readlines()\n neg_data = [sentence.strip() for sentence in neg_data]\n\n labels = compute_labels(pos_data, neg_data)\n text, labels = shuffle_data(pos_data + neg_data, labels)\n\n # split data in 70%/20%/10% train/test/dev split\n train_len = ((len(text) / 10) * 7) + (len(text) % 10)\n test_len = (len(text) / 10) * 2\n dev_len = len(text) / 10\n\n trX = text[0:train_len]\n teX = text[train_len:train_len + test_len]\n vaX = text[train_len + test_len: train_len + test_len + dev_len]\n\n trY = labels[0:train_len]\n teY = labels[train_len:train_len + test_len]\n vaY = labels[train_len + test_len: train_len + test_len + dev_len]\n\n if not os.path.exists(output_path):\n os.makedirs(output_path)\n\n dat1 = pd.DataFrame({'label': trY})\n dat2 = pd.DataFrame({'sentence': trX})\n df = dat1.join(dat2)\n df.to_csv(os.path.join(output_path, \"train_binary_sent.csv\"), encoding='utf-8', index=False)\n\n\n dat1 = pd.DataFrame({'label': teY})\n dat2 = pd.DataFrame({'sentence': teX})\n df = dat1.join(dat2)\n df.to_csv(os.path.join(output_path, \"test_binary_sent.csv\"), encoding='utf-8', index=False)\n\n dat1 = pd.DataFrame({'label': vaY})\n dat2 = pd.DataFrame({'sentence': vaX})\n df = dat1.join(dat2)\n df.to_csv(os.path.join(output_path, \"dev_binary_sent.csv\"), encoding='utf-8', index=False)","def classify_subjects_parallel(sub, feature_spaces, model, cv):\n scores, preds, coefs = [], [], dict()\n for fs in feature_spaces:\n \n if not isinstance(fs, (tuple, list)):\n fs = (fs,)\n \n fs_name = '+'.join(fs)\n\n dl = DataLoader(sub=sub, log_level=30)\n dl.load_y(strategy_doubles='hard')\n dl.load_X(feature_set=fs, n_comp=100)\n X, y = dl.return_Xy()\n\n preds_, scores_, coefs_, model_ = cross_val_predict_and_score(\n estimator=model,\n X=X, y=y,\n cv=cv,\n scoring=tjur_score,\n between_sub=False,\n soft=True\n )\n joblib.dump(model_, f'models/sub-{sub}_analysis-within_split-train_fs-{fs_name}_model.jl')\n\n dl.log.warning(f\"sub-{sub} scores: {np.round(scores_, 2)} (fs = {fs_name})\")\n scores_df = pd.DataFrame(scores_, columns=['score'])\n scores_df['feature_set'] = fs_name\n scores_df['emotion'] = dl.le.classes_\n scores_df['sub'] = sub\n scores.append(scores_df)\n\n for i in range(len(preds_)):\n preds_[i]['feature_set'] = fs_name\n preds_[i]['sub'] = sub\n preds_[i]['rep'] = i\n \n preds.append(pd.concat(preds_, axis=0))\n\n coefs_df = pd.DataFrame(data=coefs_, columns=X.columns)\n coefs_df['feature_set'] = fs_name\n coefs_df['emotion'] = dl.le.classes_\n coefs_df['sub'] = sub\n coefs[fs_name] = coefs_df\n\n scores = pd.concat(scores, axis=0)\n preds = pd.concat(preds, axis=0)\n return preds, scores, coefs","def test_BrainMapDecoder(testdata_laird):\n ids = testdata_laird.ids[:5]\n labels = testdata_laird.get_labels(ids=testdata_laird.ids)\n decoder = discrete.BrainMapDecoder(features=labels)\n decoder.fit(testdata_laird)\n decoded_df = decoder.transform(ids=ids)\n assert isinstance(decoded_df, pd.DataFrame)\n assert decoded_df.shape == (len(labels), 6)","def ite_2m(train_df, test_df, features, outcome, treatment, clf_t, clf_c):\n np.random.seed(0)\n\n train_t_df, train_c_df = split_treatment_control(train_df, treatment)\n\n clf_t_trained = clf_t.fit(train_t_df[features], train_t_df[outcome])\n clf_c_trained = clf_c.fit(train_c_df[features], train_c_df[outcome])\n\n test_f_df = test_df[features]\n return clf_t_trained.predict_proba(test_f_df)[:, 1] - clf_c_trained.predict_proba(test_f_df)[:, 1]","def results_corr_clsfied_imgs(org_pred_probs_full_data, org_pred_probs_clscorr, perturbed_pred_probs,\n class_index_json_path, y, y_, img_names, root_folder_to_save_images, threshold,\n method_type, experiments_file_path):\n\n original_image_predicted_classes_full_data = []\n\n original_image_predicted_classes = []\n\n perturbed_image_predicted_classes = []\n\n with open(class_index_json_path) as index_class_mapping_file:\n mapping_dictionary = json.load(index_class_mapping_file)\n\n for org_preds, perturbed_preds in zip(org_pred_probs_clscorr, perturbed_pred_probs):\n org_top_predicted_label_index = org_preds.argsort()[-1]\n\n perturbed_top_predicted_label_index = perturbed_preds.argsort()[-1]\n original_image_predicted_classes.append(mapping_dictionary[str(org_top_predicted_label_index)])\n perturbed_image_predicted_classes.append(mapping_dictionary[str(perturbed_top_predicted_label_index)])\n\n for org_preds_full_data in org_pred_probs_full_data:\n top_predicted_label_index = org_preds_full_data.argsort()[-1]\n original_image_predicted_classes_full_data.append(mapping_dictionary[str(top_predicted_label_index)])\n\n with open(os.path.join(root_folder_to_save_images, \"output.csv\"), 'w', newline='') as output_file:\n output_writer = csv.writer(output_file, delimiter=',')\n output_writer.writerow(\n ['IMAGE Name', 'Original Class Name', 'Predictions On Original Images', 'Predictions On Perturbed Images'])\n for i in zip(img_names, y_, original_image_predicted_classes, perturbed_image_predicted_classes):\n output_writer.writerow(i)\n print(\"output.csv has been generated..\")\n\n # Classwise metrics\n\n num_samples_per_class = defaultdict(int)\n for a_label in y:\n num_samples_per_class[a_label] += 1 # Example : { 'classA': 100 , 'classB': 99,...., 'classN': 89 }\n\n num_adv_samples_per_class = defaultdict(int)\n for label in y_:\n num_adv_samples_per_class[label] += 1\n\n # num of adversarial examples found for each class\n # num_of_adv_examples_found = list(num_adv_samples_per_class.values())\n\n unique_labels = list(num_adv_samples_per_class.keys())\n\n # Y_ ==> only labels for classes where correctly classified.Y==>Overall Data.\n # We need report only for correctly classified. Hence 'labels' argument has been assigned with classes where\n # samples have been correctly classified by the model.\n metrics_org_examples = precision_recall_fscore_support(\n y, original_image_predicted_classes_full_data, labels=unique_labels)\n # recall_org_examples = metrics_org_examples[1]\n support_org_examples = metrics_org_examples[3]\n\n # To get true positives on perturbed examples\n conf_matrix_perturbed_imgs = confusion_matrix(y_, perturbed_image_predicted_classes, labels=unique_labels)\n conf_matrix_overall_imgs = confusion_matrix(y, original_image_predicted_classes_full_data, labels=unique_labels)\n\n # Get diagonal elements from the matrix to get true positives\n perturbed_ex_correctly_classified_per_class = []\n for i in range(conf_matrix_perturbed_imgs.shape[0]):\n perturbed_ex_correctly_classified_per_class.append(conf_matrix_perturbed_imgs[i][i])\n\n test_data_correctly_classified_per_class = []\n for j in range(conf_matrix_overall_imgs.shape[0]):\n test_data_correctly_classified_per_class.append(conf_matrix_overall_imgs[j][j])\n\n # perturbed examples correctly classified divided by original number of examples in each class\n percent_of_adv_exmpls_classified_correctly = [j / i for i, j in zip(support_org_examples,\n perturbed_ex_correctly_classified_per_class)]\n # test data examples correctly classified divided by original number of samples in each class\n percent_of_test_data_classified_correctly = [n / m for m, n in zip(support_org_examples,\n test_data_correctly_classified_per_class)]\n\n diff_bool = []\n for m, n in zip(percent_of_test_data_classified_correctly, percent_of_adv_exmpls_classified_correctly):\n if n == 0:\n diff_bool.append('TRUE')\n else:\n diff_bool.append((m - n) > threshold)\n with open(os.path.join(root_folder_to_save_images, 'classmetrics.csv'), 'w', newline='') as classmetrics_file:\n classmetrics_writer = csv.writer(classmetrics_file, delimiter=',')\n classmetrics_writer.writerow(\n ['ClassNames', 'Number Of Examples In Each Class(Overall Test Data)',\n 'Number Of Test Data Correctly Classified(Overall)', 'Perturbed Examples Correctly Classified',\n 'Accuracy-TestData', 'Accuracy-PerturbedExamples', 'Diff-Accuracy'])\n for row in zip(unique_labels, support_org_examples, test_data_correctly_classified_per_class,\n perturbed_ex_correctly_classified_per_class, percent_of_test_data_classified_correctly,\n percent_of_adv_exmpls_classified_correctly, diff_bool):\n classmetrics_writer.writerow(row)\n\n print(\"classwisemetrics.csv has been generated..\")\n\n # Overall Metrics\n # calculate overall true positives\n conf_matrix_full_testdata = confusion_matrix(y, original_image_predicted_classes_full_data, labels=list(set(y)))\n true_positives_overall_testdata = 0\n for d in range(conf_matrix_full_testdata.shape[0]):\n true_positives_overall_testdata += conf_matrix_full_testdata[d][d]\n\n accuracy_overall_testdata = true_positives_overall_testdata / len(y)\n accuracy_perturbed_examples = sum(perturbed_ex_correctly_classified_per_class) / len(y)\n with open(os.path.join(root_folder_to_save_images, 'overallmetrics.csv'), 'w', newline='') as overall_metrics_file:\n overall_metrics_writer = csv.writer(overall_metrics_file, delimiter=',')\n overall_metrics_writer.writerow(['Metrics', 'OnOriginalExamples', 'OnPerturbedExamples', 'Diff-Accuracy'])\n overall_metrics_writer.writerow(['Accuracy', accuracy_overall_testdata, accuracy_perturbed_examples,\n accuracy_overall_testdata - accuracy_perturbed_examples > threshold])\n\n print(\"overallmetrics.csv has been generated..\")\n\n # Generate experiments.csv file.\n generate_experiments(experiments_file_path, method_type)\n\n # Check if the result files have been generated and the return a message\n\n return result_message(root_folder_to_save_images)","def prep_metrics(ap_data, dets, img, gt, gt_masks, h, w, num_crowd, image_id, detections: Detections = None):\n if not args.output_coco_json:\n with timer.env('Prepare gt'):\n gt_boxes = torch.Tensor(gt[:, :4])\n gt_boxes[:, [0, 2]] *= w\n gt_boxes[:, [1, 3]] *= h\n gt_classes = list(gt[:, 4].astype(int))\n gt_masks = torch.Tensor(gt_masks).view(-1, h * w)\n\n if num_crowd > 0:\n split = lambda x: (x[-num_crowd:], x[:-num_crowd])\n crowd_boxes, gt_boxes = split(gt_boxes)\n crowd_masks, gt_masks = split(gt_masks)\n crowd_classes, gt_classes = split(gt_classes)\n\n with timer.env('Postprocess'):\n classes, scores, boxes, masks = postprocess(dets, w, h, crop_masks=args.crop,\n score_threshold=args.score_threshold)\n\n if classes.size(0) == 0:\n return\n\n classes = list(classes.cpu().numpy().astype(int))\n if isinstance(scores, list):\n box_scores = list(scores[0].cpu().numpy().astype(float))\n mask_scores = list(scores[1].cpu().numpy().astype(float))\n else:\n scores = list(scores.cpu().numpy().astype(float))\n box_scores = scores\n mask_scores = scores\n masks = masks.view(-1, h * w).cuda()\n boxes = boxes.cuda()\n\n if args.output_coco_json:\n with timer.env('JSON Output'):\n boxes = boxes.cpu().numpy()\n masks = masks.view(-1, h, w).cpu().numpy()\n for i in range(masks.shape[0]):\n # Make sure that the bounding box actually makes sense and a mask was produced\n if (boxes[i, 3] - boxes[i, 1]) * (boxes[i, 2] - boxes[i, 0]) > 0:\n detections.add_bbox(image_id, classes[i], boxes[i, :], box_scores[i])\n detections.add_mask(image_id, classes[i], masks[i, :, :], mask_scores[i])\n return\n\n with timer.env('Eval Setup'):\n num_pred = len(classes)\n num_gt = len(gt_classes)\n\n mask_iou_cache = _mask_iou(masks, gt_masks)\n bbox_iou_cache = _bbox_iou(boxes.float(), gt_boxes.float())\n\n if num_crowd > 0:\n crowd_mask_iou_cache = _mask_iou(masks, crowd_masks, iscrowd=True)\n crowd_bbox_iou_cache = _bbox_iou(boxes.float(), crowd_boxes.float(), iscrowd=True)\n else:\n crowd_mask_iou_cache = None\n crowd_bbox_iou_cache = None\n\n box_indices = sorted(range(num_pred), key=lambda i: -box_scores[i])\n mask_indices = sorted(box_indices, key=lambda i: -mask_scores[i])\n\n iou_types = [\n ('box', lambda i, j: bbox_iou_cache[i, j].item(),\n lambda i, j: crowd_bbox_iou_cache[i, j].item(),\n lambda i: box_scores[i], box_indices),\n ('mask', lambda i, j: mask_iou_cache[i, j].item(),\n lambda i, j: crowd_mask_iou_cache[i, j].item(),\n lambda i: mask_scores[i], mask_indices)\n ]\n\n timer.start('Main loop')\n for _class in set(classes + gt_classes):\n ap_per_iou = []\n num_gt_for_class = sum([1 for x in gt_classes if x == _class])\n\n for iouIdx in range(len(iou_thresholds)):\n iou_threshold = iou_thresholds[iouIdx]\n\n for iou_type, iou_func, crowd_func, score_func, indices in iou_types:\n gt_used = [False] * len(gt_classes)\n\n ap_obj = ap_data[iou_type][iouIdx][_class]\n ap_obj.add_gt_positives(num_gt_for_class)\n\n for i in indices:\n if classes[i] != _class:\n continue\n\n max_iou_found = iou_threshold\n max_match_idx = -1\n for j in range(num_gt):\n if gt_used[j] or gt_classes[j] != _class:\n continue\n\n iou = iou_func(i, j)\n\n if iou > max_iou_found:\n max_iou_found = iou\n max_match_idx = j\n\n if max_match_idx >= 0:\n gt_used[max_match_idx] = True\n ap_obj.push(score_func(i), True)\n else:\n # If the detection matches a crowd, we can just ignore it\n matched_crowd = False\n\n if num_crowd > 0:\n for j in range(len(crowd_classes)):\n if crowd_classes[j] != _class:\n continue\n\n iou = crowd_func(i, j)\n\n if iou > iou_threshold:\n matched_crowd = True\n break\n\n # All this crowd code so that we can make sure that our eval code gives the\n # same result as COCOEval. There aren't even that many crowd annotations to\n # begin with, but accuracy is of the utmost importance.\n if not matched_crowd:\n ap_obj.push(score_func(i), False)\n timer.stop('Main loop')","def main(domain):\n\n filepath_train1 = '../../Non_covid_data_15oct/train_data_batch1_disregard_removed.pkl'\n filepath_test1 = '../../Non_covid_data_15oct/test_data_batch1_disregard_removed.pkl'\n filepath_train2 = '../../Covid_data_11nov/traindata_covidbatch.pkl'\n filepath_test2 = '../../Covid_data_11nov/testdata_covidbatch.pkl'\n\n df_train_nc, df_test_nc = createDataframe(filepath_train1, filepath_test1, domain, 'noncovid')\n df_train_c, df_test_c = createDataframe(filepath_train2, filepath_test2, domain, 'covid')\n #print(df_train)\n sen_reps_tr_nc, labels_tr_nc, sen_reps_te_nc, labels_te_nc = prepro(df_train_nc, df_test_nc)\n sen_reps_tr_c, labels_tr_c, sen_reps_te_c, labels_te_c = prepro(df_train_c, df_test_c)\n #print(labels_te)\n\n #Uncomment to combine training datasets \n #sen_reps_tr_c += sen_reps_tr_nc\n #labels_tr_c += labels_tr_nc\n\n #Uncomment to combine test datasets and test labels if necessary (if you do so, also combine test df's)\n #sen_reps_te_c += sen_reps_te_nc\n #labels_te_c += labels_te_nc\n #df_test = pd.concat([df_test_c, df_test_nc])\n\n #Feed selected train and test data to regression model\n predictions = get_predictions(sen_reps_tr_c, labels_tr_c, sen_reps_te_c)\n\n #Make dataframes of note id's and labels\n df_ann = make_note_df(df_test_c, labels_te_c)\n df_pred = make_note_df(df_test_c, predictions)\n\n #Evaluate on sentence level\n MSE, MAE, RMSE = evaluation(labels_te_c, predictions)\n\n print(\"MSE \"+domain, MSE)\n print(\"MAE \"+domain, MAE)\n print(\"RMSE \"+domain, RMSE)\n\n #Aggregate per note\n means_ann = means(df_ann)\n means_pred = means(df_pred)\n\n #Evaluate on note level\n MSE, MAE, RMSE = evaluation(means_ann, means_pred)\n\n print(\"MSE agg\"+domain, MSE)\n print(\"MAE agg\"+domain, MAE)\n print(\"RMSE agg\"+domain, RMSE)","def decode(self, output_dict):\n top_spans_batch = output_dict[\"top_spans\"].detach().cpu()\n predicted_relations_batch = output_dict[\"predicted_relations\"].detach().cpu()\n num_spans_to_keep_batch = output_dict[\"num_spans_to_keep\"].detach().cpu()\n res_dict = []\n res_list = []\n\n # Collect predictions for each sentence in minibatch.\n zipped = zip(top_spans_batch, predicted_relations_batch, num_spans_to_keep_batch)\n for top_spans, predicted_relations, num_spans_to_keep in zipped:\n entry_dict, entry_list = self._decode_sentence(\n top_spans, predicted_relations, num_spans_to_keep)\n res_dict.append(entry_dict)\n res_list.append(entry_list)\n\n output_dict[\"decoded_relations_dict\"] = res_dict\n output_dict[\"decoded_relations\"] = res_list\n return output_dict","def prep_metrics(ap_data, dets, gt, gt_masks, h, w, num_crowd):\n gt_boxes = torch.Tensor(gt[:, :4])\n gt_boxes[:, [0, 2]] *= w\n gt_boxes[:, [1, 3]] *= h\n gt_classes = list(gt[:, 4].astype(int))\n gt_masks = torch.Tensor(gt_masks).view(-1, h*w)\n\n if num_crowd > 0:\n split = lambda x: (x[-num_crowd:], x[:-num_crowd])\n crowd_boxes , gt_boxes = split(gt_boxes)\n crowd_masks , gt_masks = split(gt_masks)\n crowd_classes, gt_classes = split(gt_classes)\n\n classes, scores, boxes, masks = postprocess(dets, w, h, crop_masks=True, score_threshold=0)\n\n classes = list(classes.cpu().numpy().astype(int))\n scores = list(scores.cpu().numpy().astype(float))\n masks = masks.view(-1, h*w)\n \n num_pred = len(classes)\n num_gt = len(gt_classes)\n\n mask_iou_cache = mask_iou(masks, gt_masks)\n bbox_iou_cache = bbox_iou(boxes.float(), gt_boxes.float())\n\n if num_crowd > 0:\n crowd_mask_iou_cache = mask_iou(masks, crowd_masks, iscrowd=True)\n crowd_bbox_iou_cache = bbox_iou(boxes.float(), crowd_boxes.float(), iscrowd=True)\n else:\n crowd_mask_iou_cache = None\n crowd_bbox_iou_cache = None\n\n iou_types = [\n ('box', lambda i,j: bbox_iou_cache[i, j].item(), lambda i,j: crowd_bbox_iou_cache[i,j].item()),\n ('mask', lambda i,j: mask_iou_cache[i, j].item(), lambda i,j: crowd_mask_iou_cache[i,j].item())\n ]\n\n for _class in set(classes + gt_classes):\n ap_per_iou = []\n num_gt_for_class = sum([1 for x in gt_classes if x == _class])\n \n for iouIdx in range(len(iou_thresholds)):\n iou_threshold = iou_thresholds[iouIdx]\n\n for iou_type, iou_func, crowd_func in iou_types:\n gt_used = [False] * len(gt_classes)\n\n ap_obj = ap_data[iou_type][iouIdx][_class]\n ap_obj.add_gt_positives(num_gt_for_class)\n\n for i in range(num_pred):\n if classes[i] != _class:\n continue\n \n max_iou_found = iou_threshold\n max_match_idx = -1\n for j in range(num_gt):\n if gt_used[j] or gt_classes[j] != _class:\n continue\n \n iou = iou_func(i, j)\n\n if iou > max_iou_found:\n max_iou_found = iou\n max_match_idx = j\n \n if max_match_idx >= 0:\n gt_used[max_match_idx] = True\n ap_obj.push(scores[i], True)\n else:\n # If the detection matches a crowd, we can just ignore it\n matched_crowd = False\n\n if num_crowd > 0:\n for j in range(len(crowd_classes)):\n if crowd_classes[j] != _class:\n continue\n \n iou = crowd_func(i, j)\n\n if iou > iou_threshold:\n matched_crowd = True\n break\n\n # All this crowd code so that we can make sure that our eval code gives the\n # same result as COCOEval. There aren't even that many crowd annotations to\n # begin with, but accuracy is of the utmost importance.\n if not matched_crowd:\n ap_obj.push(scores[i], False)","def main(args):\r\n # Parse inputs\r\n parser = _argparse()\r\n argp = parser.parse_args(args[1:])\r\n # Read training data\r\n sparse_training = sp.sparse.load_npz( argp.training_data )\r\n training_data = np.array( sparse_training.todense() )\r\n training_labels = np.array(pd.read_csv(argp.training_labels,index_col = 0 ))\r\n\r\n # Train classifier \r\n classifier = train_classifier.train_LR( training_data, training_labels, num_genes = argp.num_genes, pct_var = argp.pca_variance/100, save_results = False )\r\n\r\n training_predictions, training_probabilities = predict_cell_types( training_data, classifier )\r\n confusion_mat = pd.DataFrame(confusion_matrix( training_labels, training_predictions ),\r\n index = np.unique(training_labels), columns = np.unique(training_labels)).to_csv(\r\n \"results/classification/confusion_matrix.csv\")\r\n # Make predictions for all cells\r\n sparse_scRNA_expression = sp.sparse.load_npz( argp.test_data )\r\n scRNA_expression = np.array( sparse_scRNA_expression.todense() )\r\n predicted_cell_types, prediction_probabilities = predict_cell_types( scRNA_expression, classifier ) \r\n \r\n sequencing_metrics = pd.read_csv(\"data/combined/processed_metrics.csv\",index_col = 0)\r\n # Save outputs\r\n pd.DataFrame(prediction_probabilities, \r\n index = sequencing_metrics.index.values,\r\n columns = np.unique(predicted_cell_types) ).to_csv(\"results/classification/prediction_probabilities.csv\")\r\n pd.DataFrame(predicted_cell_types, \r\n index = sequencing_metrics.index.values,\r\n columns = [\"predicted_cell_type\"] ).to_csv(\"results/classification/predicted_cell_types.csv\")","def prob_category(new_music, fit):\n\tr = robjects.r\n\t#Be careful not to include the word 'data' in the function call below, although data is a keyword\n\tpredictions = r.predict(fit,new_music,type=\"prob\")\n\treturn predictions","def process(self, classifications, detections):\n det_len = len(detections)\n if len(classifications) != len(detections):\n raise Exception(\"Classifications / Detections difer in length!\")\n\n sequence_length = self.sequenceSize()\n sequence_count = math.ceil(det_len / sequence_length)\n overall_keyframes = []\n\n sequences=[] # The sequence of features to run the network on\n seq_class=[] # the underlying classifictions for each sequence\n # Iterate over each sequence to generate a batch request\n for sequence_idx in range(sequence_count):\n start_idx = sequence_idx*sequence_length\n end_idx = max((sequence_idx+1)*sequence_length,len(detections))\n classification_sublist=classifications[start_idx:end_idx]\n detections_sublist=detections[start_idx:end_idx]\n sequences.append(self._generateSequence(classification_sublist,\n detections_sublist))\n seq_class.append(classification_sublist)\n\n # Now that each sequence is setup, run the network on all of them\n # TODO: May have practical limitations here if we have a huge\n # video\n return self._processSequences(sequences, seq_class)","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_svm.predict(data)","def doContPopEvaluation(self, is_train):\n if is_train:\n my_type = \"TRAINING\"\n else:\n my_type = \"TESTING\"\n no_match = 0 #How often does the population fail to have a classifier that matches an instance in the data.\n cons.env.resetDataRef(is_train) #Go to first instance in data set\n accuracy_estimate_sum = 0\n\n if is_train:\n instances = cons.env.format_data.numb_train_instances\n else:\n instances = cons.env.format_data.numb_test_instances\n #----------------------------------------------------------------------------------------------\n for _ in range(instances):\n if is_train:\n state_action = cons.env.getTrainInstance()\n else:\n state_action = cons.env.getTestInstance()\n #-----------------------------------------------------------------------------\n self.population.makeEvalMatchSet(state_action[0])\n prediction = Prediction(self.population)\n selected_action = prediction.getDecision()\n #-----------------------------------------------------------------------------\n if selected_action == None:\n no_match += 1\n else: #Instances which failed to be covered are excluded from the initial accuracy calculation\n prediction_err = math.fabs(float(selected_action) - float(state_action[1]))\n action_range = cons.env.format_data.action_list[1] - cons.env.format_data.action_list[0]\n accuracy_estimate_sum += 1.0 - (prediction_err / float(action_range))\n\n self.population.clearSets()\n #----------------------------------------------------------------------------------------------\n #Accuracy Estimate\n if instances == no_match:\n accuracy_estimate = 0\n else:\n accuracy_estimate = accuracy_estimate_sum / float(instances - no_match)\n\n #Adjustment for uncovered instances - to avoid positive or negative bias we incorporate the probability of guessing a phenotype by chance (e.g. 50% if two phenotypes)\n covered_instances = 1.0 - (float(no_match)/float(instances))\n adjusted_accuracy_estimate = accuracy_estimate_sum / float(instances) #no_matchs are treated as incorrect predictions (can see no other fair way to do this)\n\n print(\"-----------------------------------------------\")\n print(str(my_type)+\" Accuracy Results:-------------\")\n print(\"Instance Coverage = \"+ str(covered_instances*100.0)+ '%')\n print(\"Estimated Prediction Accuracy (Ignore uncovered) = \" + str(accuracy_estimate))\n print(\"Estimated Prediction Accuracy (Penalty uncovered) = \" + str(adjusted_accuracy_estimate))\n #Balanced and Standard Accuracies will only be the same when there are equal instances representative of each phenotype AND there is 100% covering.\n result_list = [adjusted_accuracy_estimate, covered_instances]\n return result_list","def decode(self, encoded_train, encoded_dev):\n decoded_train_A = self.decoder_A.predict(encoded_train)\n decoded_dev_A = self.decoder_A.predict(encoded_dev)\n self.save_reconstruction(decoded_train_A, decoded_dev_A, modality=True, no_modality=0)\n decoded_train_V = self.decoder_V.predict(encoded_train)\n decoded_dev_V = self.decoder_V.predict(encoded_dev)\n self.save_reconstruction(decoded_train_V, decoded_dev_V, modality=True, no_modality=1)","def decode(dummy_y,encoder):\n # from dummy back to class names\n encoded_y = np.zeros(len(dummy_y))\n for i in range(len(dummy_y)):\n encoded_y[i] = int(np.argmax(dummy_y[i]))\n classes_y = encoder.inverse_transform(encoded_y.astype(int))\n \n return classes_y,encoded_y","def decode(dummy_y,encoder):\n # from dummy back to class names\n encoded_y = np.zeros(len(dummy_y))\n for i in range(len(dummy_y)):\n encoded_y[i] = int(np.argmax(dummy_y[i]))\n classes_y = encoder.inverse_transform(encoded_y.astype(int))\n \n return classes_y,encoded_y","def predict_results_for_tweets(X_test, pipeline_dicts):\r\n results_dict = {}\r\n for emotion, pipeline in pipeline_dicts.items():\r\n print('Predicting for emotion: ' + emotion)\r\n if X_test[emotion].empty == False:\r\n y_pred = pipeline.predict(X_test[emotion])\r\n results_dict[emotion] = y_pred\r\n else:\r\n #Create array of None values with same length as that of X_test\r\n results_dict[emotion] = [None] * len(X_test)\r\n return results_dict","def get_cae_outputs(self, seq, traj_n, pred_h):\r\n st_seq, cond_seq = seq\r\n # reshape to fit model\r\n st_seq.shape = (1, st_seq.shape[0], st_seq.shape[1])\r\n\r\n for n in range(5):\r\n cond_seq[n].shape = (1, 1, 1)\r\n cond_seq[n] = np.repeat(cond_seq[n], traj_n, axis=0)\r\n\r\n st_seq = np.repeat(st_seq, traj_n, axis=0)\r\n # get enc_h state\r\n enc_state = self.enc_model(st_seq)\r\n\r\n self.skip_n = 2 # done for a smoother trajectory\r\n self.step_len = round(self.skip_n*self.data_obj.step_size*0.1, 1) # [s]\r\n steps_n = int(np.ceil(np.ceil(pred_h/self.step_len)*self.step_len/ \\\r\n (self.data_obj.step_size*0.1)))\r\n print('steps_n: ', steps_n)\r\n self.dec_model.steps_n = steps_n\r\n self.dec_model.traj_n = traj_n\r\n t0 = time.time()\r\n\r\n sampled_actions, gmm_mlon, gmm_mlat, prob_mlon, prob_mlat = self.dec_model(\\\r\n [cond_seq, enc_state])\r\n print(time.time() - t0)\r\n prob_mlon = prob_mlon.numpy()\r\n prob_mlat = prob_mlat.numpy()\r\n return sampled_actions, gmm_mlon, gmm_mlat, prob_mlon, prob_mlat","def predict(video_generators, audio_generator, subject):\n prediction = [random.randint(0, 4)]\n\n # TODO: implement prediction method\n # video_frame_subject = next(video_generators[int(subject[-1]) - 1])\n # audio_value = next(audio_generator)\n\n return prediction","def do_subjects_preproc(subjects,\n output_dir=None,\n subject_callback=None,\n dataset_id=\"UNNAMED DATASET!\",\n do_deleteorient=False,\n do_report=True,\n do_export_report=False,\n dataset_description=None,\n report_filename=None,\n do_shutdown_reloaders=True,\n fwhm=0,\n do_bet=False,\n do_slicetiming=False,\n TR=None,\n do_realign=True,\n do_coreg=True,\n do_segment=True,\n do_normalize=True,\n do_dartel=False,\n do_cv_tc=True,\n ignore_exception=True,\n n_jobs=N_JOBS,\n ):\n\n # sanitize input\n subjects = list(subjects)\n\n if do_dartel:\n do_segment = False\n do_normalize = False\n\n # if do_report and report_filename is None:\n # raise RuntimeError(\n # (\"You asked for reporting (do_report=True) but specified\"\n # \" an invalid report_filename (None)\"))\n\n kwargs = {'do_deleteorient': do_deleteorient,\n 'do_bet': do_bet,\n 'do_report': do_report,\n 'do_slicetiming': do_slicetiming,\n 'do_realign': do_realign, 'do_coreg': do_coreg,\n 'do_segment': do_segment, 'do_normalize': do_normalize,\n 'do_cv_tc': do_cv_tc,\n 'fwhm': fwhm,\n 'TR': TR,\n 'ignore_exception': ignore_exception,\n 'last_stage': not do_dartel,\n }\n\n if output_dir is None:\n output_dir = os.path.abspath(\"/tmp/runs_XYZ\")\n print \"Output directory set to: %s\" % output_dir\n\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n additional_preproc_undergone = \"\"\n if do_dartel:\n additional_preproc_undergone += (\n \"<li>\"\n \"Group/Inter-subject Normalization has been done using the \"\n \"SPM8 <a href='%s'>DARTEL</a> to warp subject brains into \"\n \"MNI space. \"\n \"The idea is to register images by computing a “flow\"\n \" field” which can then be “exponentiated\"\n \"” to generate both forward and backward deformation\"\n \"s. Processing begins with the “import” \"\n \"step. This involves taking the parameter files \"\n \"produced by the segmentation (NewSegment), and writing \"\n \"out rigidly \"\n \"transformed versions of the tissue class images, \"\n \"such that they are in as close alignment as possible with\"\n \" the tissue probability maps. \"\n \"The next step is the registration itself. This involves \"\n \"the simultaneous registration of e.g. GM with GM, \"\n \"WM with WM and 1-(GM+WM) with 1-(GM+WM) (when needed, the\"\n \" 1- (GM+WM) class is generated implicitly, so there \"\n \"is no need to include this class yourself). This \"\n \"procedure begins by creating a mean of all the images, \"\n \"which is used as an initial template. Deformations \"\n \"from this template to each of the individual images \"\n \"are computed, and the template is then re-generated\"\n \" by applying the inverses of the deformations to \"\n \"the images and averaging. This procedure is repeated a \"\n \"number of times. Finally, warped \"\n \"versions of the images (or other images that are in \"\n \"alignment with them) can be generated. \"\n \"</li>\") % DARTEL_URL\n\n # get caller module handle from stack-frame\n user_script_name = sys.argv[0]\n user_source_code = base_reporter.get_module_source_code(\n user_script_name)\n\n preproc_undergone = \"\"\"\\\n <p>All preprocessing has been done using the <i>%s</i> script of\n <a href=\"%s\">pypreprocess</a>, which is powered by\n <a href=\"%s\">nipype</a>, and <a href=\"%s\">SPM8</a>.\n </p>\"\"\" % (user_script_name, PYPREPROCESS_URL,\n NIPYPE_URL, SPM8_URL)\n\n preproc_undergone += \"<ul>\"\n\n preproc_undergone += additional_preproc_undergone + \"</ul>\"\n\n kwargs['additional_preproc_undergone'] = additional_preproc_undergone\n\n # generate html report (for QA) as desired\n parent_results_gallery = None\n if do_report:\n # copy css and js stuff to output dir\n for js_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\n \"js/*.js\")):\n shutil.copy(js_file, output_dir)\n for css_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\n \"css/*.css\")):\n shutil.copy(css_file, output_dir)\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\n \"icons/*.gif\")):\n shutil.copy(icon_file, output_dir)\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\n \"images/*.png\")):\n shutil.copy(icon_file, output_dir)\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\n \"images/*.jpeg\")):\n shutil.copy(icon_file, output_dir)\n\n report_log_filename = os.path.join(\n output_dir, 'report_log.html')\n report_preproc_filename = os.path.join(\n output_dir, 'report_preproc.html')\n report_filename = os.path.join(\n output_dir, 'report.html')\n\n # scrape this function's arguments\n preproc_params = \"\"\n frame = inspect.currentframe()\n args, _, _, values = inspect.getargvalues(frame)\n preproc_func_name = inspect.getframeinfo(frame)[2]\n preproc_params += (\"Function <i>%s(...)</i> was invoked by the script\"\n \" <i>%s</i> with the following arguments:\"\n ) % (preproc_func_name,\n user_script_name)\n preproc_params += base_reporter.dict_to_html_ul(\n dict((arg, values[arg]) for arg in args if not arg in [\n \"dataset_description\",\n \"report_filename\",\n \"do_report\",\n \"do_cv_tc\",\n \"do_export_report\",\n \"do_shutdown_reloaders\",\n \"subjects\",\n # add other args to exclude below\n ]\n ))\n\n # initialize results gallery\n loader_filename = os.path.join(\n output_dir, \"results_loader.php\")\n parent_results_gallery = base_reporter.ResultsGallery(\n loader_filename=loader_filename,\n refresh_timeout=30,\n )\n\n # initialize progress bar\n progress_logger = base_reporter.ProgressReport(\n report_log_filename,\n other_watched_files=[report_filename,\n report_preproc_filename])\n\n # html markup\n log = base_reporter.get_dataset_report_log_html_template(\n ).substitute(\n start_time=time.ctime(),\n )\n\n preproc = base_reporter.get_dataset_report_preproc_html_template(\n ).substitute(\n results=parent_results_gallery,\n start_time=time.ctime(),\n preproc_undergone=preproc_undergone,\n dataset_description=dataset_description,\n source_code=user_source_code,\n source_script_name=user_script_name,\n preproc_params=preproc_params,\n )\n\n main_html = base_reporter.get_dataset_report_html_template(\n ).substitute(\n results=parent_results_gallery,\n start_time=time.ctime(),\n dataset_id=dataset_id,\n )\n\n with open(report_log_filename, 'w') as fd:\n fd.write(str(log))\n fd.close()\n with open(report_preproc_filename, 'w') as fd:\n fd.write(str(preproc))\n fd.close()\n with open(report_filename, 'w') as fd:\n fd.write(str(main_html))\n fd.close()\n\n def finalize_report():\n progress_logger.finish(report_preproc_filename)\n\n if do_shutdown_reloaders:\n progress_logger.finish_all()\n\n kwargs['parent_results_gallery'] = parent_results_gallery\n\n results = joblib.Parallel(\n n_jobs=n_jobs,\n pre_dispatch='1.5*n_jobs', # for scalability over RAM\n verbose=100)(joblib.delayed(\n _do_subject_preproc)(\n subject_data, **kwargs) for subject_data in subjects)\n\n if do_dartel:\n # collect subject_ids and session_ids\n subject_ids = [output['subject_id'] for _, output in results]\n session_ids = [output['session_id'] for _, output in results]\n _preproc_undergone = dict((output['subject_id'],\n output['preproc_undergone'])\n for _, output in results)\n # collect estimated motion\n if do_realign:\n estimated_motion = dict((output[\"subject_id\"],\n output['estimated_motion'])\n for _, output in results)\n\n # collect structural files for DARTEL pipeline\n if do_coreg:\n structural_files = [\n output['coreg_result'].outputs.coregistered_source\n for _, output in results]\n else:\n structural_files = [\n subject_data.anat for subject_data, _ in results]\n\n # collect functional files for DARTEL pipeline\n if do_realign:\n functional_files = [\n output['realign_result'].outputs.realigned_files\n for _, output in results]\n else:\n functional_files = [output['func'] for _, output in results]\n\n # collect subject output dirs\n subject_output_dirs = [output['output_dir'] for _, output in results]\n\n # collect gallery related subject-specific stuff\n subject_final_thumbs = None\n subject_results_galleries = None\n subject_progress_loggers = None\n\n if do_report:\n subject_final_thumbs = [output['final_thumbnail']\n for _, output in results]\n subject_results_galleries = [output['results_gallery']\n for _, output in results]\n subject_progress_loggers = [output['progress_logger']\n for _, output in results]\n if do_realign:\n estimated_motion = dict((output[\"subject_id\"],\n output['estimated_motion'])\n for _, output in results)\n\n # normalize brains to their own template space (DARTEL)\n results, newsegment_result = do_group_DARTEL(\n output_dir,\n subject_ids,\n session_ids,\n structural_files,\n functional_files,\n fwhm=fwhm,\n subject_output_dirs=subject_output_dirs,\n do_report=do_report,\n do_cv_tc=do_cv_tc,\n subject_final_thumbs=subject_final_thumbs,\n subject_results_galleries=subject_results_galleries,\n subject_progress_loggers=subject_progress_loggers,\n parent_results_gallery=parent_results_gallery,\n ignore_exception=ignore_exception,\n )\n\n # collect results\n _results = []\n\n if results:\n for item in results:\n if item:\n subject_result = {}\n subject_result['preproc_undergone'] = _preproc_undergone[\n item['subject_id']]\n subject_result['subject_id'] = item['subject_id']\n\n # output final fmri and anat image filenames\n subject_result['func'] = item['func']\n subject_result['anat'] = item['anat']\n\n # output segmented GM compartment\n subject_result['gm'] = item['gm']\n\n # output segmented WM compartment\n subject_result['wm'] = item['wm']\n\n # output motion parameters\n if do_realign:\n subject_result['estimated_motion'] = estimated_motion[\n item['subject_id']]\n subject_result['output_dir'] = item['output_dir']\n\n json_output_filename = os.path.join(\n subject_result['output_dir'], 'infos_DARTEL.json')\n json.dump(subject_result, open(json_output_filename, 'wb'))\n\n if do_report:\n subject_result['progress_logger'] = item[\n 'progress_logger']\n\n if do_shutdown_reloaders:\n subject_result['progress_logger'].finish_all()\n\n _results.append(subject_result)\n\n results = _results\n else:\n # collect results\n _results = []\n\n if results:\n for x in results:\n if x is None:\n continue\n else:\n item = x[1]\n subject_result = {}\n subject_result['preproc_undergone'] = item['preproc_undergone']\n subject_result['subject_id'] = item['subject_id']\n subject_result['func'] = item['func']\n if 'anat' in item.keys():\n subject_result['anat'] = item['anat']\n if do_coreg:\n subject_result['coregistered_anat'] = item[\n 'coregistered_anat']\n if do_realign:\n subject_result['estimated_motion'] = item[\n 'estimated_motion']\n subject_result['realigned_func'] = item['realigned_func']\n\n subject_result['output_dir'] = item['output_dir']\n\n json_output_filename = os.path.join(\n subject_result['output_dir'], 'infos.json')\n json.dump(subject_result, open(json_output_filename, 'wb'))\n\n if do_report:\n subject_result['progress_logger'] = item['progress_logger']\n\n if do_shutdown_reloaders:\n subject_result['progress_logger'].finish_all()\n\n _results.append(subject_result)\n\n results = _results\n\n if do_report:\n finalize_report()\n\n print \"HTML report (dynamic) written to %s\" % report_filename\n\n # export report (so it can be emailed and QA'ed offline, for example)\n if do_report:\n if do_export_report:\n if do_dartel:\n tag = \"DARTEL_workflow\"\n else:\n tag = \"standard_workflow\"\n preproc_reporter.export_report(os.path.dirname(report_filename),\n tag=tag)\n\n return results","def loadMotorResponses(subj,hand='Right'):\n \n hands = {'Left':[0,1],'Right':[2,3]}\n\n x = tgp.loadTaskTiming(subj,'ALL')\n stimIndex = np.asarray(x['stimIndex'])\n ind = np.where(stimIndex=='motorResponse')[0]\n \n datadir = projectdir + 'data/postProcessing/hcpPostProcCiric/'\n h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')\n data = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()\n data = data[:,ind].copy()\n h5f.close()\n \n # Isolate hand responses\n hand_ind = hands[hand]\n tmpdat = np.zeros((data.shape[0],2))\n if hand=='Right':\n #tmpdat[:,0] = data[:,3] #rmid -- need to flip this once glm is re-run -- check the new reffunc\n tmpdat[:,0] = np.real(data[:,2]) \n tmpdat[:,1] = np.real(data[:,3]) \n elif hand=='Left':\n tmpdat[:,0] = np.real(data[:,0]) #lmid\n tmpdat[:,1] = np.real(data[:,1]) #lind\n data = tmpdat.copy()\n\n return data","def infer():\n\n # Create StreamManagerApi object\n stream_manager_api = StreamManagerApi()\n # Use InitManager method init StreamManagerApi\n ret = stream_manager_api.InitManager()\n if ret != 0:\n print(\"Failed to init Stream manager, ret=%s\" % str(ret))\n exit()\n\n # create streams by pipeline config file\n with open(args.pipeline_path, \"rb\") as f:\n pipeline_str = f.read()\n\n # Configuring a stream\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\n if ret != 0:\n print(\"Failed to create Stream, ret=%s\" % str(ret))\n exit()\n\n # Construct the input of the stream\n data_input = MxDataInput()\n # Stream_name encoded in UTF-8\n stream_name = args.stream_name.encode()\n print(stream_name)\n predictions = []\n with open(args.label_path, 'rt') as f:\n val_cls = f.read().rstrip(\"\\n\").split(\"\\n\")\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(args.instances_path)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n for file_name in os.listdir(args.img_path):\n pred_data = []\n # Gets the Address of each image\n img_id = int(file_name.split('.')[0])\n file_path = args.img_path + file_name\n size = (cv2.imread(file_path)).shape\n\n # Read each photo in turn\n with open(file_path, \"rb\") as f:\n img_data = f.read()\n if not img_data:\n print(f\"read empty data from img:{file_name}\")\n continue\n # The element value img_data\n data_input.data = img_data\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\n pred_data.append({\"boxes\": boxes_output,\n \"box_scores\": scores_output,\n \"img_id\": img_id,\n \"image_shape\": size})\n\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\n print(f\"Inferred image:{file_name} success!\")\n\n # Save the result in JSON format\n if not os.path.exists(args.res_path):\n os.makedirs(args.res_path)\n with open(args.res_path + 'predictions_test.json', 'w') as f:\n json.dump(predictions, f)\n stream_manager_api.DestroyAllStreams()","def apply_manual_codes(cls, user, data, coda_input_dir):\n for plan in PipelineConfiguration.TEST_SHOWS_CODING_PLANS:\n test_pipeline_messages = [td for td in data if plan.raw_field in td]\n coda_input_path = path.join(coda_input_dir, plan.coda_filename)\n\n f = None\n try:\n if path.exists(coda_input_path):\n f = open(coda_input_path, 'r')\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable_multi_coded(\n user, test_pipeline_messages, plan.id_field, {plan.coded_field: plan.code_scheme}, f)\n\n if plan.binary_code_scheme is not None:\n if f is not None:\n f.seek(0)\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable(\n user, test_pipeline_messages, plan.id_field, {plan.binary_coded_field:plan.binary_code_scheme}, f)\n finally:\n if f is not None:\n f.close()\n\n # Merge manually coded survey files into cleaned dataset\n for plan in PipelineConfiguration.SURVEY_CODING_PLANS:\n f = None\n try:\n coda_input_path = path.join(coda_input_dir, plan.coda_filename)\n if path.exists(coda_input_path):\n f = open(coda_input_path, 'r')\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable(\n user, data, plan.id_field, {plan.coded_field: plan.code_scheme}, f)\n finally:\n if f is not None:\n f.close()\n \n return data","def bio_classification_report(y_true, y_pred):\n lb = LabelBinarizer()\n y_true_combined = lb.fit_transform(list(chain.from_iterable(y_true)))\n y_pred_combined = lb.transform(list(chain.from_iterable(y_pred)))\n \n tagset = set(lb.classes_) #- {'O'}\n tagset = sorted(tagset, key=lambda tag: tag.split('-', 1)[::-1])\n class_indices = {cls: idx for idx, cls in enumerate(lb.classes_)}\n \n return classification_report(\n y_true_combined,\n y_pred_combined,\n labels = [class_indices[cls] for cls in tagset],\n target_names = tagset,\n )","def perform_Surrogate_Prediction(next_gen_conc,\n conc_array_actual,\n spectra_array_actual):\n gpr = GaussianProcessRegressor().fit(\n conc_array_actual, spectra_array_actual)\n score = gpr.score(conc_array_actual,\n spectra_array_actual)\n spectra_prediction = gpr.predict(next_gen_conc)\n return spectra_prediction, score","def _decode_step(self, states: List[ModelState]) -> Tuple[mx.nd.NDArray, mx.nd.NDArray, List[ModelState]]:\n model_probs, model_attention_probs, model_states = [], [], []\n for model, state in zip(self.models, states):\n probs, attention_probs, state = model.run_decoder(state)\n model_probs.append(probs)\n model_attention_probs.append(attention_probs)\n model_states.append(state)\n probs, attention_probs = self._combine_predictions(model_probs, model_attention_probs)\n return probs, attention_probs, model_states","def test_decoding_batch(self):\r\n\r\n # Data path\r\n cur_dir = os.path.abspath(os.path.join(os.path.realpath(__file__), '..'))\r\n img_path = os.path.join(cur_dir, 'resources', 'input_decode')\r\n img_names = os.listdir(img_path)\r\n for img_name in img_names:\r\n\r\n img_qr_patch = cv2.imread(img_path+'/'+img_name)\r\n\r\n displays1((img_qr_patch,))\r\n decode_result = decode_one(img_qr_patch)\r\n print(decode_result)","def decode(self, output_dict: Dict[str, Any]) -> Dict[str, Any]:\n\n # If the predictions are already decoded, skip the step\n if 'relex_predictions' in output_dict:\n return output_dict\n\n output_dict: Dict[str, Any] = super().decode(output_dict)\n batch_relex_predictions = self._decode_relex_predictions(output_dict)\n output_dict['relex_predictions'] = batch_relex_predictions\n\n batch_clusters: List[List[List[Tuple[int, int]]]] = output_dict['clusters']\n batch_flat_tokens: List[List[Token]] = output_dict['flat_tokens']\n batch_flat_text: List[str] = output_dict['flat_text']\n\n batch_updates = defaultdict(list)\n for (clusters, relations,\n flat_tokens, flat_text) in zip(batch_clusters, batch_relex_predictions,\n batch_flat_tokens, batch_flat_text):\n updates = self._decode_sample(clusters, relations,\n flat_tokens, flat_text)\n for key, value in updates.items():\n batch_updates[key].append(value)\n\n output_dict.update(batch_updates)\n return output_dict","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def test_dict():\n print(\"DictClassifier\")\n print(\"---\" * 45)\n\n from spa.classifiers import DictClassifier\n\n ds = DictClassifier()\n\n # 对一个单句进行情感分析\n #a_sentence = \"剁椒鸡蛋好咸,土豆丝很好吃\" # result值: 修改前(1)/修改后(1)\n #a_sentence = \"要是米饭再多点儿就好了\" # result值: 修改前(1)/修改后(0)\n #a_sentence = \"要是米饭再多点儿就更好了\" # result值: 修改前(0)/修改后(0)\n # a_sentence = \"不太好吃，相当难吃，要是米饭再多点儿就好了\" # result值: 修改前(1)/修改后(0)\n #result = ds.analyse_sentence(a_sentence)\n #print(result)\n\n # 对一个文件内语料进行情感分析\n count = 6001\n flag = 0\n corpus_filepath = \"fileInput/jdnew1.txt\"\n for i in range(0,3000):\n count += 1\n if count%300 == 0:\n print(count)\n flag += 1\n runout_filepath_ = \"f_runout/relsultAppleMac%s.txt\" % flag\n pos_results = ds.analysis_file(corpus_filepath, runout_filepath_, start=count, end=count+300)\n #\n # corpus_filepath = \"D:/My Data/NLP/SA/waimai/negative_corpus_v1.txt\"\n # runout_filepath_ = \"f_runout/f_dict-negative_test.txt\"\n # neg_results = ds.analysis_file(corpus_filepath, runout_filepath_, start=3000, end=4000-1)\n #\n # origin_labels = [1] * 1000 + [0] * 1000\n # classify_labels = pos_results + neg_results\n #\n # print(len(classify_labels))\n #\n # filepath = \"f_runout/Dict-waimai-%s.xls\" % (\n # datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n # results = get_accuracy(origin_labels, classify_labels, [1000, 1000, 0])\n #\n # Write2File.write_contents(filepath, results)","def classify(self, data):\n abstract","def inference(self, data_loader):\n\n # Handling inference for Multiclass classification\n outputs_list = []\n with torch.no_grad():\n for bi, d in enumerate(data_loader):\n ids = d['ids']\n mask = d['mask']\n\n # send them to the cpu\n ids = ids.to(self.device, dtype=torch.long)\n mask = mask.to(self.device, dtype=torch.long)\n\n outputs = self.model(\n input_ids=ids,\n attention_mask=mask\n )\n outputs_list.extend(torch.softmax(outputs, dim=1).cpu().detach().numpy().tolist())\n\n print(\"This the output from the Multiclass classification model\", outputs_list[0])\n\n inferences = np.argmax(outputs_list, axis=1)\n inferences = [self.mapping[str(pred)] for pred in inferences]\n\n return inferences","def decode_center(self,\n pred_dict, img_metas,\n K=50, score_threshold=0.25):\n\n fmap = pred_dict['cls_preds']\n\n dim_pred = pred_dict['dim_preds']\n xy_pred = pred_dict['xy_preds']\n z_pred = pred_dict['z_preds']\n dir_pred = pred_dict['dir_preds']\n batch, channel, height, width = fmap.shape\n\n # assert batch == 1, \"only batch size 1 is supported\"\n\n # image_ids = example['image_idx']\n\n fmap = self.pseudo_nms(fmap)\n\n scores, index, clses, ys, xs = self.topk_score(fmap, K=K)\n\n xy_pred = gather_feature(xy_pred, index, use_transform=True)\n xy_pred = xy_pred.reshape(batch, K, 2)\n xs = xs.view(batch, K, 1) + xy_pred[:, :, 0:1]\n ys = ys.view(batch, K, 1) + xy_pred[:, :, 1:2]\n xs = xs * self.downsample_ratio * self.voxel_size[0] + self.pc_range[0]\n ys = ys * self.downsample_ratio* self.voxel_size[1] + self.pc_range[1]\n\n z_pred = gather_feature(z_pred, index, use_transform=True)\n zs = z_pred\n\n dim_pred = gather_feature(dim_pred, index, use_transform=True)\n dim_pred = dim_pred.reshape(batch, K, 3)\n\n clses_batch = clses.reshape(batch, K).float().detach()\n scores_batch = scores.reshape(batch, K).detach()\n\n dir_pred = gather_feature(dir_pred, index, use_transform=True)\n if self.num_rad_bin<=0:\n dir_pred = torch.atan2(dir_pred[:, :, 0], dir_pred[:, :, 1])\n dir_pred = dir_pred.reshape(batch, K, 1)\n\n else:\n dir_bin = torch.argmax(dir_pred[:, :, :self.num_rad_bin], dim=-1)\n dir_res_norm = torch.gather(dir_pred[:, :, self.num_rad_bin:], dim=-1,\n index=dir_bin.unsqueeze(dim=-1)).squeeze(dim=-1)\n angle_per_class = (2 * np.pi) / self.num_rad_bin\n dir_res = dir_res_norm * (angle_per_class / 2)\n dir_pred = (dir_bin.float() * angle_per_class + dir_res)% (2 * np.pi)\n dir_pred[dir_pred > np.pi] -= 2 * np.pi\n dir_pred+=np.pi\n dir_pred = dir_pred.reshape(batch, K, 1)\n\n bboxes_batch = torch.cat([xs, ys, zs, dim_pred, dir_pred], dim=-1).detach()\n\n detections=[]\n for clses,scores, bboxes,img_meta in zip(clses_batch,scores_batch, bboxes_batch,img_metas):\n keep = scores > score_threshold\n scores = scores[keep]\n clses = clses[keep]\n bboxes = bboxes[keep]\n bboxes = img_meta['box_type_3d'](bboxes, box_dim=7)\n detection = (bboxes, scores, clses, img_meta)\n detections.append(detection)\n\n return detections","def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n elif (self.type_camf == 'CAMF_CU'):\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = cu.fit()\n elif (self.type_camf == 'CAMF_C'):\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = c.fit()\n\n dummy_pred = np.zeros((predictions.shape))\n for r, pred_array in enumerate(predictions):\n for c, pred in enumerate(pred_array):\n dummy_pred[r][c] = self.__check_ratings__(pred)\n predictions = dummy_pred\n #save a plot with a loss function\n plots = prs.PlotRSData()\n #print(losses)\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\"_loop\"+str(self.loop))\n pd.DataFrame(losses).to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ +\"losses_loop\"+str(self.loop)+\".csv\")\n print('Saving the feature matrix...')\n # set predictions back to the pivot table\n self.__utility_saved_training__(predictions) \n # save results\n self.utility_predictions.to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ + \"_SGD_predictions_loop\"+str(self.loop)+\".csv\")","def bio_classification_report(y_true, y_pred):\n lb = LabelBinarizer()\n y_true_combined = lb.fit_transform(list(chain.from_iterable(y_true)))\n y_pred_combined = lb.transform(list(chain.from_iterable(y_pred)))\n\n tagset = set(lb.classes_) - {'O'}\n #tagset = set(lb.classes_)\n tagset = sorted(tagset, key=lambda tag: tag.split('-', 1)[::-1])\n class_indices = {cls: idx for idx, cls in enumerate(lb.classes_)}\n\n return classification_report(\n y_true_combined,\n y_pred_combined,\n labels = [class_indices[cls] for cls in tagset],\n target_names = tagset,\n )","def fetch_compas_df(preprocess=False):\n (train_X, train_y), (test_X, test_y) = lale.datasets.openml.fetch(\n \"compas\", \"classification\", astype=\"pandas\", preprocess=False\n )\n orig_X = pd.concat([train_X, test_X]).sort_index().astype(np.float64)\n orig_y = pd.concat([train_y, test_y]).sort_index().astype(np.float64)\n if preprocess:\n race = pd.Series(orig_X[\"race_caucasian\"] == 1, dtype=np.float64)\n dropped_X = orig_X.drop(\n labels=[\"race_african-american\", \"race_caucasian\"], axis=1\n )\n encoded_X = dropped_X.assign(race=race)\n fairness_info = {\n \"favorable_labels\": [1],\n \"protected_attributes\": [\n {\"feature\": \"sex\", \"reference_group\": [1]},\n {\"feature\": \"race\", \"reference_group\": [1]},\n ],\n }\n return encoded_X, orig_y, fairness_info\n else:\n fairness_info = {\n \"favorable_labels\": [1],\n \"protected_attributes\": [\n {\"feature\": \"sex\", \"reference_group\": [1]},\n {\"feature\": \"race_caucasian\", \"reference_group\": [1]},\n ],\n }\n return orig_X, orig_y, fairness_info","def _classification(text_path_list, id_list, label_list):\n textnum = len(text_path_list)\n batched_num = ((textnum - 1) // classify.BATCH_SIZE + 1) * classify.BATCH_SIZE\n for i in range(batched_num - textnum):\n text_path_list.append(text_path_list[0])\n id_list.append(id_list[0])\n annotations = classify_obj.inference(text_path_list, id_list, label_list) #\n return annotations[0:textnum]","def model(self, conjectures, axioms):\n with self.graph.as_default():\n conjecture_embeddings = self.conjecture_embedding(conjectures)\n axiom_embeddings = self.axiom_embedding(axioms)\n predictions = self.classifier(conjecture_embeddings, axiom_embeddings)\n return predictions","def predict():\n\n\n json_payload = request.json\n #LOG.info(f\"JSON payload: %s\" %json_payload)\n inference_payload = pd.DataFrame(json_payload)\n #LOG.info(\"inference payload DataFrame: %s\" %inference_payload)\n scaled_payload = scale(inference_payload)\n prediction = list(clf.predict(scaled_payload))\n return jsonify({'prediction': prediction})","def extract_features_cue(sentence_dicts, cue_lexicon, affixal_cue_lexicon, mode='training'):\n instances = []\n for sent in sentence_dicts:\n # print(sent)\n for key, value in sent.items():\n features = {}\n if isinstance(key, int):\n if not_known_cue_word(value[3].lower(), cue_lexicon, affixal_cue_lexicon):\n sent[key]['not-pred-cue'] = True\n continue\n\n features['token'] = value[3].lower()\n features['lemma'] = value[4].lower()\n features['pos'] = value[5]\n\n if key == 0:\n features['bw-bigram1'] = 'null'\n else:\n features['bw-bigram1'] = \"%s_*\" %sent[key-1][4].lower()\n if not (key+1) in sent:\n features['fw-bigram1'] = 'null'\n else:\n features['fw-bigram1'] = \"*_%s\" %sent[key+1][4].lower()\n \n affix = get_affix_cue(value[3].lower(), affixal_cue_lexicon)\n if affix != None:\n base = value[3].lower().replace(affix, \"\")\n features['char-5gram1'], features['char-5gram2'] = get_character_ngrams(base, affix, 5)\n features['char-4gram1'], features['char-4gram2'] = get_character_ngrams(base, affix, 4)\n features['char-3gram1'], features['char-3gram2'] = get_character_ngrams(base, affix, 3)\n features['char-2gram1'], features['char-2gram2'] = get_character_ngrams(base, affix, 2)\n features['char-1gram1'], features['char-1gram2'] = get_character_ngrams(base, affix, 1)\n features['affix'] = affix\n else:\n features['char-5gram1'], features['char-5gram2'] = 'null','null'\n features['char-4gram1'], features['char-4gram2'] = 'null','null'\n features['char-3gram1'], features['char-3gram2'] = 'null','null'\n features['char-2gram1'], features['char-2gram2'] = 'null','null'\n features['char-1gram1'], features['char-1gram2'] = 'null','null'\n features['affix'] = 'null'\n \n instances.append(features)\n if mode == 'training':\n labels = extract_labels_cue(sentence_dicts, cue_lexicon, affixal_cue_lexicon)\n return sentence_dicts, instances, labels\n return sentence_dicts, instances","def _run_unlabelled_extraction(self, dataset_type: DatasetType, device: str) -> None:\n dataset = self.image_datasets.get_dataset(dataset_type)\n self.extractor_model = self.extractor_model.to(device)\n\n for image, file_id in tqdm(\n dataset, desc=\"Extracting features - competition\",\n ):\n feature_tensor = self.extractor_model(image.unsqueeze(0).to(device))\n self._save_tensor(DatasetType.Competition, feature_tensor, file_id)","def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\n assert step in ['train', 'test']\n binary = False \n undersample_majority = False\n\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\n if data_type == 'ct':\n data_r = pd.read_excel(paths[0])\n else:\n data_r = pd.read_excel(paths[1])\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\n\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \n\n if data_subtype == 'primary':\n data = data_p\n y = y_p -1\n else:\n data = data_n\n y = y_n -1\n\n if binary:\n y[y<2]=0\n y[y>0]=1\n\n y_dist = [np.sum(y==x) for x in np.unique(y)]\n print(\"Distribution of all labels: \", y_dist, \"\\n\\n\")\n\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\n\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels: \", y_dist, \"\\n\\n\")\n\n if step =='train':\n if use_syntetic_data:\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\n\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\n train_text = np.concatenate((train_text,test_text))\n y_train = np.concatenate((y_train,y_test))\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels after inserting syntetic data: \", y_dist, \"\\n\\n\")\n\n if not undersample_majority:\n data_to_use = train_text.copy()\n y_to_use = y_train.copy()\n else:\n max_label1 = 1000\n data_to_use = []\n y_to_use = []\n y1=0\n for x in range(len(y_train)):\n if y_train[x] !=1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n else:\n if y1 <max_label1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n y1+=1\n\n else:\n data_to_use = test_text.copy()\n y_to_use = y_test.copy()\n\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\n examples = []\n\n for i, tokens in tqdm(enumerate(data_to_use)):\n label = y_to_use[i]\n examples.append(\n ClassificationExample(\n id=i,\n tokens_a=basic_tokenizer.tokenize(tokens),\n tokens_b=None,\n label=label,\n )\n )\n logging.info('Number of `%s` examples: %d', step, len(examples))\n \n return examples","def test_http_classifier(self):\n \n msg = \"\"\n \n files = 0\n tp = 0\n fp = 0\n tn = 0\n fn = 0\n\n self.addr = \"http://\" + self.Helpers.confs[\"cnn\"][\"api\"][\"server\"] + \\\n ':'+str(self.Helpers.confs[\"cnn\"][\"api\"][\"port\"]) + '/Inference'\n self.headers = {'content-type': 'image/jpeg'}\n\n for data in os.listdir(self.testing_dir):\n if os.path.splitext(data)[1] in self.valid:\n \n response = self.send_request(self.testing_dir + \"/\" + data)\n\n msg = \"\"\n if response[\"Diagnosis\"] == \"Positive\" and \"_1.\" in data:\n tp += 1\n msg = \"Acute Lymphoblastic Leukemia correctly detected (True Positive)\"\n elif response[\"Diagnosis\"] == \"Positive\" and \"_0.\" in data:\n fp += 1\n msg = \"Acute Lymphoblastic Leukemia incorrectly detected (False Positive)\"\n elif response[\"Diagnosis\"] == \"Negative\" and \"_0.\" in data:\n tn += 1\n msg = \"Acute Lymphoblastic Leukemia correctly not detected (True Negative)\"\n elif response[\"Diagnosis\"] == \"Negative\" and \"_1.\" in data:\n fn += 1\n msg = \"Acute Lymphoblastic Leukemia incorrectly not detected (False Negative)\" \n \n files += 1\n \n self.Helpers.logger.info(msg)\n print()\n time.sleep(7)\n \n self.Helpers.logger.info(\"Images Classifier: \" + str(files))\n self.Helpers.logger.info(\"True Positives: \" + str(tp))\n self.Helpers.logger.info(\"False Positives: \" + str(fp))\n self.Helpers.logger.info(\"True Negatives: \" + str(tn))\n self.Helpers.logger.info(\"False Negatives: \" + str(fn))","def launch(self, data, classifiers, output_dir, plot, cv):\n\t\tself.logger.info('Encoding data...')\n\t\tencode_data, labels, classes, predicted_labels, le = ML.encode(data)\n\t\tresults_proba, dict_y_test, classifiers = self.stratifier(\n\t\t\tencode_data, labels, classifiers, cv, output_dir)\n\t\tself.logger.info('Saving outputs...')\n\t\tML.dump_models(classifiers, output_dir)\n\t\tif plot is True:\n\t\t\tutils.mkdir(output_dir + \"/Plots\")\n\t\t\tself.logger.info('Saving plots and results...')\n\t\t\tvisualization.plot_roc_curve_training(\n\t\t\t\tdict_y_test, results_proba, output_dir)","def resp_to_pc(rec, pc_idx=None, resp_sig='resp', pc_sig='pca',\n pc_count=None, pc_source='all', overwrite_resp=True,\n compute_power='no',\n whiten=True, **context):\n rec0 = rec.copy()\n resp = rec0[resp_sig]\n\n # compute duration of spont period\n d = resp.get_epoch_bounds('PreStimSilence')\n if len(d):\n PreStimSilence = np.mean(np.diff(d))\n else:\n PreStimSilence = 0\n prestimbins = int(PreStimSilence * resp.fs)\n\n # compute PCs only on valid (masked) times\n rec0[resp_sig] = rec0[resp_sig].rasterize()\n rec_masked = generate_psth_from_resp(rec0, resp_sig=resp_sig)\n\n if 'mask' in rec0.signals:\n rec_masked = rec_masked.apply_mask()\n\n if pc_source=='all':\n D_ref = rec_masked[resp_sig].as_continuous().T\n elif pc_source=='psth':\n D_ref = rec_masked['psth'].as_continuous().T\n elif pc_source=='noise':\n D_psth = rec_masked['psth'].as_continuous().T\n D_raw = rec_masked[resp_sig].as_continuous().T\n D_ref = D_raw - D_psth\n else:\n raise ValueError('pc_source {} not supported'.format(pc_source))\n\n # project full response dataset to preserve time\n D = rec0[resp_sig].as_continuous().T\n\n if pc_count is None:\n pc_count = D_ref.shape[1]\n if pc_idx is None:\n pc_idx=list(np.arange(pc_count))\n elif type(pc_idx) is int:\n pc_idx = [pc_idx]\n\n log.info(f\"PCA: inputs={D_ref.shape[1]}, source={pc_source}, pc_idx(es): {pc_idx}, whiten: {whiten}\")\n\n if False:\n # use sklearn. maybe someday\n pca = PCA(n_components=pc_count)\n pca.fit(D_ref)\n\n X = pca.transform(D)\n else:\n # each row(??) of v is a PC --weights to project into PC domain\n m = np.nanmean(D_ref, axis=0, keepdims=True)\n if whiten:\n sd = np.nanstd(D_ref, axis=0, keepdims=True)\n else:\n sd = np.ones(m.shape)\n D_ref = D_ref[np.sum(np.isfinite(D_ref),axis=1)>0,:]\n sd[sd==0]=1\n D_ = (D_ref-m)/sd\n\n #import pdb;\n #pdb.set_trace()\n\n # A = u @ np.diag(s) @ vh = (u * s) @ vh\n u, s, v = np.linalg.svd(D_.T @ D_, full_matrices=False)\n X = ((D-m) / sd) @ u\n\n rec0[pc_sig] = rec0[resp_sig]._modified_copy(X.T)\n\n r = rec0[pc_sig].extract_epoch('REFERENCE', mask=rec0['mask'])\n mr = np.nanmean(r, axis=0)\n if prestimbins>0:\n spont = np.mean(mr[:,:prestimbins],axis=1,keepdims=True)\n mr -= spont\n vs = np.sign(np.sum(mr[:, prestimbins:(prestimbins+10)], axis=1, keepdims=True))\n u *= vs\n X = ((D-m) / sd) @ u\n\n if compute_power == 'single_trial':\n smwin = 5\n X = smooth(np.abs(X), smwin, axis=0)\n X = X - X.mean(axis=0, keepdims=True)\n\n pc_chans = [f'PC{i}' for i in range(pc_count)]\n rec0[pc_sig] = rec0[resp_sig]._modified_copy(X.T[np.arange(pc_count),:], chans=pc_chans)\n\n# r = rec0[pc_sig].extract_epoch('REFERENCE')\n# mr=np.mean(r,axis=0)\n# spont=np.mean(mr[:,:50],axis=1,keepdims=True)\n# mr-=spont\n# plt.figure()\n# plt.plot(mr[:5,:].T)\n# plt.legend(('1','2','3','4','5'))\n\n rec0.meta['pc_weights'] = u\n rec0.meta['pc_mag'] = s\n if overwrite_resp:\n rec0[resp_sig] = rec0[resp_sig]._modified_copy(X[:, pc_idx].T, \n chans=[pc_chans[c] for c in pc_idx])\n rec0.meta['pc_idx'] = pc_idx\n\n return {'rec': rec0}","def StageSubjects(self,X_test, Y_test, Xrange):\r\n\r\n # subject prediction\r\n pred_sub = []\r\n expectation_sub = []\r\n\r\n # distribution of trajectory samples\r\n sampling_dist = []\r\n\r\n for biomarker in range(self.nrBiomk):\r\n sampling_dist.append([])\r\n for i in range(500):\r\n s_omega, m_omega, s, m, sigma, l, eps = self.unpack_parameters(self.parameters[biomarker])\r\n perturbation_zero_W = np.random.randn(int(2 * self.N_rnd_features)).reshape(\r\n [2 * self.N_rnd_features, 1])\r\n perturbation_zero_Omega = np.random.randn(int(self.N_rnd_features))\r\n Omega = 1 / np.sqrt(np.exp(l)) * self.perturbation_Omega\r\n W = np.multiply(perturbation_zero_W, np.sqrt(np.exp(s))) + m\r\n output = self.basis(Xrange, np.exp(sigma), Omega)\r\n sampling_dist[biomarker].append(np.dot(output, W))\r\n\r\n for sub in range(len(X_test[0])):\r\n print(\"predicting sub: \", sub, \"out of \", len(X_test[0]))\r\n pred_sub.append([])\r\n expectation_sub.append([])\r\n for pos_index,position in enumerate(Xrange):\r\n pred_sub[sub].append(0)\r\n for biomarker in range(self.nrBiomk):\r\n Y_test_biom = np.array(Y_test[biomarker][sub]).reshape([len(Y_test[biomarker][sub]),1])\r\n X_test_biom = np.array(X_test[biomarker][sub]).reshape([len(X_test[biomarker][sub]),1])\r\n\r\n X_test_biom = (X_test_biom - self.mean_std_X[biomarker][0]) / self.mean_std_X[biomarker][1]\r\n X_test_biom = X_test_biom / self.max_X[biomarker]\r\n\r\n Y_test_biom = (Y_test_biom - self.mean_std_Y[biomarker][0]) / self.mean_std_Y[biomarker][1]\r\n Y_test_biom = Y_test_biom / self.max_Y[biomarker]\r\n\r\n if len(X_test_biom > 0):\r\n X_to_test = position + X_test_biom\r\n for i in range(500):\r\n current_sample = sampling_dist[biomarker][i][pos_index:(pos_index + len(Y_test_biom))]\r\n if (len(Y_test_biom) == len(current_sample)):\r\n pred_sub[sub][pos_index] = pred_sub[sub][pos_index] \\\r\n + np.sum((Y_test_biom - current_sample) ** 2)\r\n # - 0.5 * (np.log(2 * np.pi * np.exp(eps)) \\\r\n\r\n final_pred = []\r\n for sub in range(len(pred_sub)):\r\n invalid_indices = np.where(np.array(pred_sub[sub])==0)[0]\r\n # pred_sub[sub][pred_sub[sub] == 0] = 1e10\r\n # print('valid_indices', valid_indices, np.array(pred_sub[sub]).shape)\r\n # invalid_indices = np.logical_not(np.in1d(np.array(range(Xrange.shape[0])), valid_indices))\r\n # print(asds)\r\n # predictions = np.array(pred_sub[sub])[valid_indices]\r\n predictions = np.array(pred_sub[sub])\r\n final_pred.append([])\r\n final_pred[sub] = np.exp(-predictions/500)/ np.sum(np.exp(-predictions/500))\r\n final_pred[sub][invalid_indices] = 0\r\n final_pred[sub] /= np.sum(final_pred[sub])\r\n scaling = self.mean_std_X[biomarker][1]*self.max_X[biomarker]\r\n #expectation_sub[sub] = np.sum(final_pred[sub] * Xrange.flatten()[valid_indices]) * scaling + self.mean_std_X[biomarker][0]\r\n # expectation_sub[sub] = np.sum(final_pred[sub] * (Xrange.flatten()[valid_indices] * scaling + self.mean_std_X[biomarker][0]))\r\n expectation_sub[sub] = np.sum(final_pred[sub] * (Xrange.flatten() * scaling + self.mean_std_X[biomarker][0]))\r\n return final_pred, expectation_sub","def predict(data, samples, classifier='SVM',\r\n classification='combined', selectFeatures=('CUK', 10)):\r\n if (classification == \"trained\"):\r\n classifyTrained = True\r\n classifySurface = False\r\n elif (classification == 'surface'):\r\n classifyTrained = False\r\n classifySurface = True\r\n else:\r\n classifyTrained = True\r\n classifySurface = True\r\n if (classifier == \"SVM\"):\r\n clf = cl.classifyDataSVM(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"DT\"):\r\n clf = cl.classifyDataDT(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"KNN\"):\r\n clf = cl.classifyDataKNN(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"LogReg\"):\r\n clf = cl.classifyDataLR(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n else:\r\n print (str(classifier) + \" is not a valid option\")\r\n \r\n [samples, _,_,_] = clf.extractData(samples,scaling=False)\r\n \r\n predictions = [clf.predict(s) for s in samples]\r\n return predictions"],"string":"[\n \"def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\\n \\n ncond = data.shape[1] # two motor outputs\\n nSubjs = data.shape[2]\\n\\n nsamples = nSubjs * ncond\\n stats = np.zeros((len(rois),nsamples))\\n rmatches = np.zeros((len(rois),))\\n rmismatches = np.zeros((len(rois),))\\n\\n # Label array for supervised learning\\n labels = np.tile(range(ncond),nSubjs)\\n subjarray = np.repeat(range(nSubjs),ncond)\\n\\n # Run SVM classifications on network-level activation patterns across subjects\\n confusion_mats = []\\n roicount = 0\\n for roi in rois:\\n roi_ind = np.where(glasser2==roi+1)[0]\\n nfeatures = len(roi_ind)\\n roi_ind.shape = (len(roi_ind),1) \\n\\n svm_mat = np.zeros((nsamples,roi_ind.shape[0]))\\n samplecount = 0\\n for scount in range(nSubjs):\\n roidata = np.squeeze(data[roi_ind,:,scount])\\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\\n\\n samplecount += ncond\\n\\n # Spatially demean matrix across features\\n# samplemean = np.mean(svm_mat,axis=1)\\n# samplemean.shape = (len(samplemean),1)\\n# svm_mat = svm_mat - samplemean\\n \\n scores, rmatch, rmismatch, confusion_mat = randomSplitLOOBaselineCV(ncvs, svm_mat, labels, subjarray, \\n motorOutput=motorOutput, decoder=decoder, nproc=nproc)\\n stats[roicount,:] = scores\\n rmatches[roicount] = np.mean(rmatch)\\n rmismatches[roicount] = np.mean(rmismatch)\\n confusion_mats.append(confusion_mat)\\n roicount += 1\\n \\n if effects and confusion:\\n return stats, rmatch, rmismatch, confusion_mats\\n if effects and not confusion:\\n return stats, rmatch, rmismatch\\n if confusion and not effects:\\n return stats, confusion_mats\\n else:\\n return stats\",\n \"def forward(self, *args): # noqa: R0914\\r\\n encoder_out, (hn, cn) = self.unified_encoder(*args)\\r\\n device = hn.device\\r\\n non_sequential_cont_decoded = self.mlp_non_seq_cont(hn)\\r\\n non_sequential_cat_decoded = []\\r\\n for mlp_non_seq_cat in self.mlp_non_seq_cat_list:\\r\\n non_sequential_cat_decoded.append(mlp_non_seq_cat(hn))\\r\\n\\r\\n hn = torch.unsqueeze(hn, 0)\\r\\n cn = torch.unsqueeze(cn, 0)\\r\\n # decoded is the output prediction of timestep i-1 of the decoder\\r\\n decoded = torch.zeros(encoder_out.shape[0], int(\\r\\n self.unified_encoder.seq_cont_count + self.unified_encoder.no_of_embs_seq), device=device)\\r\\n seq_cont_decoded = torch.Tensor(device=device)\\r\\n seq_cat_decoded = []\\r\\n for _ in range(self.unified_encoder.seq_cat_count):\\r\\n seq_cat_decoded.append(torch.Tensor(device=device))\\r\\n\\r\\n for _ in range(encoder_out.shape[1]):\\r\\n decoded, (hn, cn), out_cont, out_cat = self.decoder(decoded, (hn, cn))\\r\\n # Predict all categorical columns\\r\\n out_cat_onehot = []\\r\\n if self.unified_encoder.seq_cat_count != 0:\\r\\n for idx, out in enumerate(out_cat):\\r\\n out_cat_onehot.append(torch.argmax(out, dim=1).unsqueeze(-1))\\r\\n seq_cat_decoded[idx] = torch.cat(\\r\\n [seq_cat_decoded[idx], out.view(out.shape[0], 1, -1)], dim=1)\\r\\n out_cat_onehot = torch.cat(out_cat_onehot, -1)\\r\\n out_cat_embedding = self.unified_encoder.seq_emb_layers(out_cat_onehot)\\r\\n decoded = torch.cat([out_cat_embedding, out_cont], dim=-1)\\r\\n else:\\r\\n decoded = out_cont\\r\\n seq_cont_decoded = torch.cat(\\r\\n [seq_cont_decoded, out_cont.view(out_cont.shape[0], 1, -1)], dim=1)\\r\\n\\r\\n return non_sequential_cont_decoded, non_sequential_cat_decoded, seq_cont_decoded, seq_cat_decoded\",\n \"def apply_classifier(self):\\n for detected_object in self.detected_objects:\\n detected_object.predict_class(self.original_image)\",\n \"def compute_classifications2(depc, gid_list, config=None):\\n logger.info('[ibs] Process Image Classifications2')\\n logger.info('config = {!r}'.format(config))\\n # Get controller\\n ibs = depc.controller\\n depc = ibs.depc_image\\n if config['classifier_two_algo'] in ['cnn']:\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (192, 192),\\n }\\n # depc.delete_property('thumbnails', gid_list, config=config_)\\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\\n result_list = ibs.generate_thumbnail_class2_list(thumbnail_list, **config)\\n elif config['classifier_two_algo'] in ['rf']:\\n from wbia.algo.detect.rf import classify\\n\\n config_ = {'algo': 'resnet'}\\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\\n elif config['classifier_two_algo'] in ['densenet']:\\n from wbia.algo.detect import densenet\\n\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\\n }\\n thumbpath_list = ibs.depc_image.get(\\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\\n )\\n config_ = {\\n 'classifier_weight_filepath': config['classifier_two_weight_filepath'],\\n }\\n result_list = densenet.test(\\n thumbpath_list,\\n ibs=ibs,\\n gid_list=gid_list,\\n return_dict=True,\\n multiclass=True,\\n **config_,\\n )\\n result_list = list(result_list)\\n for index in range(len(result_list)):\\n best_score, best_key, scores = result_list[index]\\n classes = [best_key]\\n result_list[index] = (\\n scores,\\n classes,\\n )\\n else:\\n raise ValueError(\\n 'specified classifier_two algo is not supported in config = {!r}'.format(\\n config\\n )\\n )\\n\\n # yield detections\\n for result in result_list:\\n yield result\",\n \"def test_service_api_predict_multiple_raw_classified(service_app):\\n response = service_app.post('/predict',\\n data=json.dumps(data),\\n content_type='application/json')\\n response_data = json.loads(response.data)\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 200\\n assert response_data['message'] == 'Records successfully classified'\\n assert len(response_data['prediction'].keys()) == 102\\n assert response_data['prediction']['business_outcome'] == [4, 5]\\n assert response_data['prediction']['phat'] == [0.8228085289874678, 0.753958838418463]\\n assert all(len(value) == 2 for value in response_data['prediction'].values())\",\n \"def classify_encapsulated(audio_summary, track_info, pickle_file):\\n\\tf = open(pickle_file, 'r')\\n\\tfit = pickle.load(f)\\n\\tf.close()\\n\\trv = {}\\n\\t#print track_info.keys()\\n\\t#print track_info[audio_summary]['title'].keys()\\n\\trv[\\\"speechiness\\\"] = [audio_summary['audio_summary']['speechiness']]\\n\\trv[\\\"time_sig\\\"] = [audio_summary['audio_summary']['time_signature']]\\n\\trv[\\\"bpm\\\"] = [audio_summary['audio_summary']['tempo']]\\n\\trv[\\\"key\\\"] = [audio_summary['audio_summary']['key']]\\n\\trv[\\\"duration\\\"] = [audio_summary['audio_summary']['duration']]\\n\\trv[\\\"loudness\\\"] = [audio_summary['audio_summary']['loudness']]\\n\\trv[\\\"end_of_fade_in\\\"] = [track_info['track']['end_of_fade_in']]\\n\\trv[\\\"start_of_fade_out\\\"] = [track_info['track']['start_of_fade_out']]\\n\\trv[\\\"bpm_range\\\"] = [proc.bpm_range(track_info['beats'])]\\n\\trv[\\\"max_bpm_spike\\\"] = [proc.max_bpm_spike(track_info['beats'])]\\n\\ttry:\\n\\t\\trv[\\\"num_keys\\\"] = [proc.num_keys(track_info['sections'])]\\n\\texcept:\\n\\t\\trv[\\\"num_keys\\\"] = [1]\\n\\trv[\\\"sections\\\"] = [proc.num_sections(track_info['sections'])]\\n\\tnew_df = build_data_frame([rv],[\\\"Unknown\\\"])\\n\\tp = prob_category(new_df,fit)\\n\\trobjects.globalenv[\\\"pred\\\"] = p\\n\\tedm_prob = robjects.default_ri2py(p.rx(1))[0]\\n\\tfolk_prob = robjects.default_ri2py(p.rx(2))[0]\\n\\trap_prob = robjects.default_ri2py(p.rx(3))[0]\\n\\tcls = classify(new_df,fit)\\n\\treturn [(edm_prob,folk_prob,rap_prob),cls[0]]\",\n \"def execute(self, requests):\\n responses = []\\n for request in requests:\\n infer_outputs = pb_utils.get_input_tensor_by_name(\\n request, self.input_names[0])\\n im_infos = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[1])\\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[2])\\n\\n infer_outputs = infer_outputs.as_numpy()\\n im_infos = im_infos.as_numpy()\\n ori_imgs = ori_imgs.as_numpy()\\n\\n results = self.postprocessor.run([infer_outputs], im_infos)\\n batch_rec_texts = []\\n batch_rec_scores = []\\n batch_box_list = []\\n for i_batch in range(len(results)):\\n\\n cls_labels = []\\n cls_scores = []\\n rec_texts = []\\n rec_scores = []\\n\\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\\n image_list = []\\n if len(box_list) == 0:\\n image_list.append(ori_imgs[i_batch])\\n else:\\n for box in box_list:\\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\\n image_list.append(crop_img)\\n\\n batch_box_list.append(box_list)\\n\\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", cls_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='cls_pp',\\n requested_output_names=['cls_labels', 'cls_scores'],\\n inputs=[cls_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n cls_labels = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_labels')\\n cls_labels = cls_labels.as_numpy()\\n\\n cls_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_scores')\\n cls_scores = cls_scores.as_numpy()\\n\\n for index in range(len(image_list)):\\n if cls_labels[index] == 1 and cls_scores[\\n index] > self.cls_threshold:\\n image_list[index] = cv2.rotate(\\n image_list[index].astype(np.float32), 1)\\n image_list[index] = np.astype(np.uint8)\\n\\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", rec_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='rec_pp',\\n requested_output_names=['rec_texts', 'rec_scores'],\\n inputs=[rec_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n rec_texts = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_texts')\\n rec_texts = rec_texts.as_numpy()\\n\\n rec_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_scores')\\n rec_scores = rec_scores.as_numpy()\\n\\n batch_rec_texts.append(rec_texts)\\n batch_rec_scores.append(rec_scores)\\n\\n out_tensor_0 = pb_utils.Tensor(\\n self.output_names[0],\\n np.array(\\n batch_rec_texts, dtype=np.object_))\\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\\n np.array(batch_rec_scores))\\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\\n np.array(batch_box_list))\\n inference_response = pb_utils.InferenceResponse(\\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\\n responses.append(inference_response)\\n return responses\",\n \"def do_predict(self):\\n answer = []\\n response = []\\n\\n for it_predictions in json.loads(request.data.decode('UTF-8')):\\n prediction = it_predictions['score']\\n for ite_clf in g_list_of_classifier:\\n answer.append(ite_clf.predict(prediction))\\n if answer.count(True) > answer.count(False):\\n response.append({'answer' : True})\\n else:\\n response.append({'answer' : False})\\n return json.dumps(response, indent=4)\",\n \"def _ctc_decoder_prediction(prediction, labels):\\n blank_id = len(labels)\\n hypotheses = []\\n # CTC decoding procedure\\n for batch_elem in prediction:\\n decoded_prediction = []\\n previous = blank_id\\n for p in batch_elem:\\n if previous != p != blank_id:\\n decoded_prediction.append(labels[p])\\n previous = p\\n hypotheses.append(''.join(decoded_prediction))\\n return hypotheses\",\n \"def classification(self,a_train,a_test,c_train,c_test,classifier):\\n le =LabelEncoder()\\n le.fit(c_train)\\n c_train = le.transform(c_train)\\n c_test = le.transform(c_test)\\n if classifier==\\\"GNB\\\": #Gaussian Naive Bayes\\n gnb = GaussianNB()\\n gnb.fit(a_train, c_train)\\n c_pred = gnb.predict(a_test)\\n elif classifier==\\\"DT\\\": #Decision Tree\\n dt=DecisionTreeClassifier()\\n dt.fit(a_train, c_train)\\n c_pred = dt.predict(a_test)\\n elif classifier==\\\"KNN\\\": #K-Next-Neighbors\\n kn=KNeighborsClassifier(n_neighbors=5)\\n kn.fit(a_train, c_train)\\n c_pred = kn.predict(a_test)\\n elif classifier==\\\"RF\\\": #Random Forest\\n rf=RandomForestClassifier()\\n rf.fit(a_train, c_train)\\n c_pred = rf.predict(a_test)\\n elif classifier==\\\"SVC\\\": # Support Vector Classifier\\n \\\"\\\"\\\"\\n SVC needs normalisation of Feature Values to scale of [-1,1] or [0,1] depending on sign of them\\n \\\"\\\"\\\"\\n if a_train.min()<0:\\n mms = MinMaxScaler(feature_range=(-1,1))\\n else:\\n mms = MinMaxScaler()\\n mms.fit(a_train)\\n a_train = mms.transform(a_train)\\n a_test = mms.transform(a_test)\\n svc=SVC(cache_size=2000,C=1, probability=True,kernel='rbf')\\n svc.fit(a_train,c_train)\\n #c_pred = svc.predict(a_test) did not work, that's why it is predicted manual\\n new_prob = svc.predict_proba(a_test)\\n samples=new_prob.shape[0]\\n c_pred= np.array\\n for k in range(samples):\\n c_pred=np.append(c_pred,new_prob[k].argmax())\\n c_pred = c_pred[1:samples+1]\\n elif classifier==\\\"DC\\\": #Dummy Classifier\\n dc=DummyClassifier(strategy=\\\"uniform\\\")\\n dc.fit(a_train, c_train)\\n c_pred = dc.predict(a_test)\\n elif classifier==\\\"GMM\\\": #Gaussian Mixture Modell\\n #number of existing classes get passed to the GMM (n_classes)\\n n_classes_train = len(np.unique(c_train))\\n n_classes_test = len(np.unique(c_test))\\n if n_classes_train>n_classes_test:\\n n_classes = n_classes_train\\n else:\\n n_classes = n_classes_test\\n #init_params='', because initial values get calculated manual\\n gmm = GMM(n_components=n_classes,init_params='')\\n #array of feature values of class i get extracted for further process\\n gmm.means_=np.array([a_train[c_train==i,:].mean(axis=0) for i in xrange(n_classes)])\\n gmm.weights_=np.array([a_train[c_train==i,:].shape[0]/float(c_train.shape[0]) for i in xrange(n_classes)])\\n \\n gmm_covars = np.zeros((a_train.shape[1]))\\n for i in xrange(n_classes):\\n valuesOfClassi = a_train[c_train==i,:]\\n valuesOfClassi = np.asarray(valuesOfClassi).T\\n matrixOfCov = np.cov(valuesOfClassi)+gmm.min_covar*np.eye(valuesOfClassi.shape[0])\\n variance = np.array([matrixOfCov[j,j] for j in xrange(matrixOfCov.shape[0])])\\n gmm_covars=np.vstack((gmm_covars,variance))\\n gmm_covars=gmm_covars[1:,:] #deletes initial row with zeros\\n \\n gmm.covars_=gmm_covars\\n c_pred = gmm.predict(a_test)\\n \\n c_pred=le.inverse_transform(c_pred)\\n return c_pred\",\n \"def decode_results(self, outputs):\\n ...\",\n \"def makepredictions(self):\\n data, sampling_rate = librosa.load(self.file)\\n mfccs = np.mean(librosa.feature.mfcc(y=data, sr=sampling_rate, n_mfcc=40).T, axis=0)\\n x = np.expand_dims(mfccs, axis=1)\\n x = np.expand_dims(x, axis=0)\\n predictions = self.loaded_model.predict_classes(x)\\n predict = self.convertclasstoemotion(predictions)\\n print(\\\"Prediction is\\\", \\\" \\\", self.convertclasstoemotion(predictions))\\n return predict\",\n \"def chainercv_postprocess_change_labels(results):\\n bboxes, labels, scores = results\\n # loop over the results and add them to the list of\\n # returned predictions\\n classes = []\\n boxes = []\\n confs = []\\n for index, bbox in enumerate(bboxes[0]):\\n classes.append(str(voc_bbox_label_names[int(labels[0][index])]))\\n boxes.append([bbox[0], bbox[1], bbox[2], bbox[3]])\\n confs.append(scores[0][index])\\n\\n return (boxes, classes, confs)\",\n \"def chainercv_postprocess_pack_each_item(results):\\n bboxes, labels, scores = results\\n\\n # loop over the results and add them to the list of\\n # returned predictions\\n predictions = []\\n for index, bbox in enumerate(bboxes[0]):\\n r = {\\\"class\\\": str(voc_bbox_label_names[int(labels[0][index])]),\\n \\\"bbox\\\": {\\n \\\"ymin\\\": str(bbox[0]),\\n \\\"xmin\\\": str(bbox[1]),\\n \\\"ymax\\\": str(bbox[2]),\\n \\\"xmax\\\": str(bbox[3])\\n },\\n \\\"probability\\\": str(scores[0][index])\\n }\\n predictions.append(r)\\n\\n return predictions\",\n \"def compute_classifications(depc, gid_list, config=None):\\n logger.info('[ibs] Process Image Classifications')\\n logger.info('config = {!r}'.format(config))\\n # Get controller\\n ibs = depc.controller\\n depc = ibs.depc_image\\n if config['classifier_algo'] in ['cnn']:\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (192, 192),\\n }\\n thumbnail_list = depc.get_property('thumbnails', gid_list, 'img', config=config_)\\n result_list = ibs.generate_thumbnail_class_list(thumbnail_list, **config)\\n elif config['classifier_algo'] in ['svm']:\\n from wbia.algo.detect.svm import classify\\n\\n config_ = {'algo': 'resnet'}\\n vector_list = depc.get_property('features', gid_list, 'vector', config=config_)\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n result_list = classify(vector_list, weight_filepath=classifier_weight_filepath)\\n elif config['classifier_algo'] in ['densenet']:\\n from wbia.algo.detect import densenet\\n\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\\n }\\n thumbpath_list = ibs.depc_image.get(\\n 'thumbnails', gid_list, 'img', config=config_, read_extern=False, ensure=True\\n )\\n result_list = densenet.test(thumbpath_list, ibs=ibs, gid_list=gid_list, **config)\\n elif config['classifier_algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n classifier_weight_filepath = classifier_weight_filepath.strip().split(';')\\n\\n assert len(classifier_weight_filepath) == 2\\n classifier_algo_, model_tag_ = classifier_weight_filepath\\n\\n include_grid2 = config['classifier_algo'] in ['tile_aggregation']\\n tid_list = ibs.scout_get_valid_tile_rowids(\\n gid_list=gid_list, include_grid2=include_grid2\\n )\\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\\n confidence_list = ibs.scout_wic_test(\\n tid_list, classifier_algo=classifier_algo_, model_tag=model_tag_\\n )\\n\\n gid_dict = {}\\n for ancestor_gid, tid, confidence in zip(\\n ancestor_gid_list, tid_list, confidence_list\\n ):\\n if ancestor_gid not in gid_dict:\\n gid_dict[ancestor_gid] = []\\n gid_dict[ancestor_gid].append(confidence)\\n\\n result_list = []\\n for gid in tqdm.tqdm(gid_list):\\n gid_confidence_list = gid_dict.get(gid, None)\\n assert gid_confidence_list is not None\\n best_score = np.max(gid_confidence_list)\\n\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in ['densenet+neighbors']:\\n raise NotImplementedError\\n # ut.embed()\\n # classifier_weight_filepath = config['classifier_weight_filepath']\\n\\n # all_bbox_list = ibs.get_image_bboxes(gid_list)\\n # wic_confidence_list = ibs.scout_wic_test(gid_list, classifier_algo='densenet',\\n # model_tag=classifier_weight_filepath)\\n #\\n # ancestor_gid_list = list(set(ibs.get_tile_ancestor_gids(gid_list)))\\n # all_tile_list = list(set(ibs.scout_get_valid_tile_rowids(gid_list=ancestor_gid_list)))\\n # all_bbox_list = ibs.get_image_bboxes(all_tile_list)\\n # all_confidence_list = ibs.scout_wic_test(all_tile_list, classifier_algo='densenet',\\n # model_tag=classifier_weight_filepath)\\n #\\n # TODO: USE THRESHOLDED AVERAGE, NOT MAX\\n # result_list = []\\n # for gid, wic_confidence in zip(gid_list, wic_confidence_list):\\n # best_score = wic_confidence\\n # for aid in aid_list:\\n # wic_confidence_ = aid_conf_dict.get(aid, None)\\n # assert wic_confidence_ is not None\\n # best_score = max(best_score, wic_confidence_)\\n #\\n # if wic_confidence < 0.5:\\n # best_key = 'negative'\\n # best_score = 1.0 - best_score\\n # else:\\n # best_key = 'positive'\\n # if best_score > wic_confidence:\\n # recovered += 1\\n # result = (best_score, best_key, )\\n # result_list.append(result)\\n elif config['classifier_algo'] in ['scout_detectnet']:\\n import json\\n\\n json_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\\n assert exists(json_filepath)\\n with open(json_filepath, 'r') as json_file:\\n values = json.load(json_file)\\n annotations = values.get('annotations', {})\\n\\n gpath_list = ibs.get_image_paths(gid_list)\\n gname_list = [split(gpath)[1] for gpath in gpath_list]\\n\\n result_list = []\\n for gname in gname_list:\\n annotation = annotations.get(gname, None)\\n assert annotation is not None\\n\\n best_score = 1.0\\n if len(annotation) == 0:\\n best_key = 'negative'\\n else:\\n best_key = 'positive'\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in ['scout_detectnet_csv', 'scout_faster_rcnn_csv']:\\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\\n\\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\\n csv_filepath = join(ibs.dbdir, config['classifier_weight_filepath'])\\n\\n assert exists(manifest_filepath)\\n assert exists(csv_filepath)\\n\\n manifest_dict = {}\\n with open(manifest_filepath, 'r') as manifest_file:\\n manifest_file.readline() # Discard column header row\\n manifest_line_list = manifest_file.readlines()\\n for manifest_line in manifest_line_list:\\n manifest = manifest_line.strip().split(',')\\n assert len(manifest) == 2\\n manifest_filename, manifest_uuid = manifest\\n manifest_dict[manifest_filename] = manifest_uuid\\n\\n csv_dict = {}\\n with open(csv_filepath, 'r') as csv_file:\\n csv_file.readline() # Discard column header row\\n csv_line_list = csv_file.readlines()\\n for csv_line in csv_line_list:\\n csv = csv_line.strip().split(',')\\n assert len(csv) == 2\\n csv_filename, csv_score = csv\\n csv_uuid = manifest_dict.get(csv_filename, None)\\n assert (\\n csv_uuid is not None\\n ), 'Test image {!r} is not in the manifest'.format(\\n csv,\\n )\\n csv_dict[csv_uuid] = csv_score\\n\\n result_list = []\\n for uuid_str in uuid_str_list:\\n best_score = csv_dict.get(uuid_str, None)\\n assert best_score is not None\\n\\n if config['classifier_algo'] in ['scout_detectnet_csv']:\\n assert best_score in ['yes', 'no']\\n best_key = 'positive' if best_score == 'yes' else 'negative'\\n best_score = 1.0\\n elif config['classifier_algo'] in ['scout_faster_rcnn_csv']:\\n best_score = float(best_score)\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n else:\\n raise ValueError\\n\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n elif config['classifier_algo'] in [\\n 'lightnet',\\n 'densenet+lightnet',\\n 'densenet+lightnet!',\\n ]:\\n min_area = 10\\n\\n classifier_weight_filepath = config['classifier_weight_filepath']\\n classifier_weight_filepath = classifier_weight_filepath.strip().split(',')\\n\\n if config['classifier_algo'] in ['lightnet']:\\n assert len(classifier_weight_filepath) == 2\\n weight_filepath, nms_thresh = classifier_weight_filepath\\n wic_thresh = 0.0\\n nms_thresh = float(nms_thresh)\\n wic_confidence_list = [np.inf] * len(gid_list)\\n wic_filter = False\\n elif config['classifier_algo'] in ['densenet+lightnet', 'densenet+lightnet!']:\\n assert len(classifier_weight_filepath) == 4\\n (\\n wic_model_tag,\\n wic_thresh,\\n weight_filepath,\\n nms_thresh,\\n ) = classifier_weight_filepath\\n wic_thresh = float(wic_thresh)\\n nms_thresh = float(nms_thresh)\\n wic_confidence_list = ibs.scout_wic_test(\\n gid_list, classifier_algo='densenet', model_tag=wic_model_tag\\n )\\n wic_filter = config['classifier_algo'] in ['densenet+lightnet']\\n else:\\n raise ValueError\\n\\n flag_list = [\\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\\n ]\\n if wic_filter:\\n gid_list_ = ut.compress(gid_list, flag_list)\\n else:\\n gid_list_ = gid_list[:]\\n config = {\\n 'grid': False,\\n 'algo': 'lightnet',\\n 'config_filepath': weight_filepath,\\n 'weight_filepath': weight_filepath,\\n 'nms': True,\\n 'nms_thresh': nms_thresh,\\n 'sensitivity': 0.0,\\n }\\n prediction_list = depc.get_property(\\n 'localizations', gid_list_, None, config=config\\n )\\n prediction_dict = dict(zip(gid_list_, prediction_list))\\n\\n result_list = []\\n for gid, wic_confidence, flag in zip(gid_list, wic_confidence_list, flag_list):\\n if not flag:\\n best_key = 'negative'\\n best_score = 1.0 - wic_confidence\\n else:\\n prediction = prediction_dict.get(gid, None)\\n assert prediction is not None\\n\\n best_score = 0.0\\n if prediction is not None:\\n score, bboxes, thetas, confs, classes = prediction\\n for bbox, conf in zip(bboxes, confs):\\n xtl, ytl, w, h = bbox\\n area = w * h\\n if area >= min_area:\\n best_score = max(best_score, conf)\\n\\n if best_score >= 0.5:\\n best_key = 'positive'\\n else:\\n best_key = 'negative'\\n best_score = 1.0 - best_score\\n result = (\\n best_score,\\n best_key,\\n )\\n result_list.append(result)\\n else:\\n raise ValueError(\\n 'specified classifier algo is not supported in config = {!r}'.format(config)\\n )\\n\\n # yield detections\\n for result in result_list:\\n yield result\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_classifier.predict(data)\",\n \"def voc_pred_process(pred_data, val_cls, recs):\\n num_classes = config.num_classes\\n cls_img_ids = {}\\n cls_bboxes = {}\\n cls_scores = {}\\n classes = {}\\n cls_npos = {}\\n for cls in val_cls:\\n if cls == 'background':\\n continue\\n class_recs = {}\\n npos = 0\\n for imagename in imagenames:\\n R = [obj for obj in recs[imagename] if obj['name'] == cls]\\n bbox = np.array([x['bbox'] for x in R])\\n difficult = np.array([x['difficult'] for x in R]).astype(np.bool)\\n det = [False] * len(R)\\n npos = npos + sum(~difficult)\\n class_recs[imagename] = {'bbox': bbox,\\n 'difficult': difficult,\\n 'det': det}\\n cls_npos[cls] = npos\\n classes[cls] = class_recs\\n cls_img_ids[cls] = []\\n cls_bboxes[cls] = []\\n cls_scores[cls] = []\\n\\n for sample in pred_data:\\n pred_boxes = sample['boxes']\\n box_scores = sample['box_scores']\\n img_id = sample['img_id']\\n h, w = sample['image_shape']\\n\\n final_boxes = []\\n final_label = []\\n final_score = []\\n\\n for c in range(1, num_classes):\\n class_box_scores = box_scores[:, c]\\n score_mask = class_box_scores > config.min_score\\n class_box_scores = class_box_scores[score_mask]\\n class_boxes = pred_boxes[score_mask] * [h, w, h, w]\\n\\n if score_mask.any():\\n nms_index = apply_nms(class_boxes, class_box_scores, config.nms_threshold, config.max_boxes)\\n class_boxes = class_boxes[nms_index]\\n class_box_scores = class_box_scores[nms_index]\\n\\n final_boxes += class_boxes.tolist()\\n final_score += class_box_scores.tolist()\\n final_label += [c] * len(class_box_scores)\\n\\n for loc, label, score in zip(final_boxes, final_label, final_score):\\n cls_img_ids[val_cls[label]].append(img_id)\\n cls_bboxes[val_cls[label]].append([loc[1], loc[0], loc[3], loc[2]])\\n cls_scores[val_cls[label]].append(score)\\n return classes, cls_img_ids, cls_bboxes, cls_scores, cls_npos\",\n \"def _eval_predictions(self, tasks, predictions):\\n self._logger.info(\\\"Preparing results for COCO format ...\\\")\\n coco_results = list(itertools.chain(*[x[\\\"instances\\\"] for x in predictions]))\\n\\n # unmap the category ids for COCO\\n if hasattr(self._metadata, \\\"thing_dataset_id_to_contiguous_id\\\"):\\n reverse_id_mapping = {\\n v: k for k, v in self._metadata.thing_dataset_id_to_contiguous_id.items()\\n }\\n for result in coco_results:\\n category_id = result[\\\"category_id\\\"]\\n assert (\\n category_id in reverse_id_mapping\\n ), \\\"A prediction has category_id={}, which is not available in the dataset.\\\".format(\\n category_id\\n )\\n result[\\\"category_id\\\"] = reverse_id_mapping[category_id]\\n\\n if self._output_dir:\\n file_path = os.path.join(self._output_dir, \\\"coco_instances_results.json\\\")\\n self._logger.info(\\\"Saving results to {}\\\".format(file_path))\\n with PathManager.open(file_path, \\\"w\\\") as f:\\n f.write(json.dumps(coco_results))\\n f.flush()\\n\\n if not self._do_evaluation:\\n self._logger.info(\\\"Annotations are not available for evaluation.\\\")\\n return\\n\\n self._logger.info(\\\"Evaluating predictions ...\\\")\\n for i, task in enumerate(list(sorted(tasks)) + ['segm_voc', 'segm_nvoc']):\\n\\n if task in ['segm_voc', 'segm_nvoc']:\\n iou_type, ps_mode = task.split('_')\\n else:\\n iou_type = task\\n ps_mode = None\\n\\n print('psmode', ps_mode, iou_type)\\n coco_eval = (\\n _evaluate_predictions_on_coco_ps(\\n self._coco_api, coco_results, iou_type, ps_mode, kpt_oks_sigmas=self._kpt_oks_sigmas\\n )\\n if len(coco_results) > 0\\n else None # cocoapi does not handle empty results very well\\n )\\n\\n if ps_mode == 'voc':\\n class_names = list(np.asarray(self._metadata.get(\\\"thing_classes\\\"))[VOC_INDICES])\\n elif ps_mode == 'nvoc':\\n class_names = list(np.asarray(self._metadata.get(\\\"thing_classes\\\"))[NON_VOC_INDICES])\\n else:\\n class_names = self._metadata.get(\\\"thing_classes\\\")\\n\\n res = self._derive_coco_results(\\n coco_eval, iou_type, class_names=class_names\\n )\\n self._results[task] = res\",\n \"def handle_decode(self, encoded_data):\\n \\n config.COD_PROMPT = config.DEC_PROMPT\\n print config.DEC_PROMPT + \\\" decoding...\\\"\\n \\n # while there is another decoder, run each item through the next decoder\\n data = encoded_data\\n success = False\\n for decoder in self.decoder_list:\\n current_decoder = decoder()\\n success, data = self.recursive_decoder(current_decoder.decode, data)\\n if not success:\\n break\\n print config.DEC_PROMPT + \\\"%s decoded to '%s'\\\" % ( current_decoder.name(),data)\\n return success, data\",\n \"def coco_metrics(pred_data, anno_json, config):\\n from pycocotools.coco import COCO\\n from pycocotools.cocoeval import COCOeval\\n num_classes = config.num_classes\\n\\n #Classes need to train or test.\\n val_cls = config.classes\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(anno_json)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n predictions = []\\n img_ids = []\\n\\n for sample in pred_data:\\n pred_boxes = sample['boxes']\\n box_scores = sample['box_scores']\\n img_id = sample['img_id']\\n h, w = sample['image_shape']\\n\\n final_boxes = []\\n final_label = []\\n final_score = []\\n img_ids.append(img_id)\\n\\n for c in range(1, num_classes):\\n class_box_scores = box_scores[:, c]\\n score_mask = class_box_scores > config.min_score\\n class_box_scores = class_box_scores[score_mask]\\n class_boxes = pred_boxes[score_mask] * [h, w, h, w]\\n\\n if score_mask.any():\\n nms_index = apply_nms(class_boxes, class_box_scores, config.nms_threshold, config.max_boxes)\\n class_boxes = class_boxes[nms_index]\\n class_box_scores = class_box_scores[nms_index]\\n\\n final_boxes += class_boxes.tolist()\\n final_score += class_box_scores.tolist()\\n final_label += [classs_dict[val_cls_dict[c]]] * len(class_box_scores)\\n\\n for loc, label, score in zip(final_boxes, final_label, final_score):\\n res = {}\\n res['image_id'] = img_id\\n res['bbox'] = [loc[1], loc[0], loc[3] - loc[1], loc[2] - loc[0]]\\n res['score'] = score\\n res['category_id'] = label\\n predictions.append(res)\\n if not os.path.exists('./eval_out'):\\n os.makedirs('./eval_out')\\n with open('./eval_out/predictions.json', 'w') as f:\\n json.dump(predictions, f)\\n\\n coco_dt = coco_gt.loadRes('./eval_out/predictions.json')\\n E = COCOeval(coco_gt, coco_dt, iouType='bbox')\\n E.params.imgIds = img_ids\\n E.evaluate()\\n E.accumulate()\\n E.summarize()\\n return E.stats[0]\",\n \"def algo(self):\\n audio = np.array([self.audio.popleft() for _ in range(self.count)])\\n # Run Classifier\\n wav_data = np.abs(np.fft.rfft(audio.flatten()))\\n if len(wav_data) > 0:\\n pred = self.clf.predict(np.expand_dims(wav_data, 0))\\n if self.verbose > 1:\\n print('The prediction is : ' + str(pred))\\n self.finished.emit(int(pred[-1]))\\n else:\\n self.finished.emit(0)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\\n #track.du_doan(self.kf_test)\",\n \"def actflowDecodings(data, actflow_data, effects=False, featsel=True, ncvs=1, permutation=False, confusion=False, nproc=5):\\n\\n nSubjs = data.shape[2]\\n stats = np.zeros((1,))\\n \\n ncond = data.shape[1]\\n\\n nsamples = nSubjs * ncond\\n nfeatures = data.shape[0]\\n\\n # Label array for supervised learning\\n labels = np.tile(range(ncond),nSubjs)\\n subjarray = np.repeat(range(nSubjs),ncond)\\n\\n svm_mat = np.zeros((nsamples,nfeatures))\\n actflow_svm_mat = np.zeros((nsamples,nfeatures))\\n samplecount = 0\\n scount = 0\\n for subj in range(nSubjs):\\n roidata = data[:,:,scount]\\n actflow_roidata = actflow_data[:,:,scount]\\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\\n actflow_svm_mat[samplecount:(samplecount+ncond),:] = actflow_roidata.T\\n\\n scount += 1\\n samplecount += ncond\\n\\n # Spatially demean matrix across features\\n# samplemean = np.mean(svm_mat,axis=1)\\n# samplemean.shape = (len(samplemean),1)\\n# svm_mat = svm_mat - samplemean\\n#\\n# samplemean = np.mean(actflow_svm_mat,axis=1)\\n# samplemean.shape = (len(samplemean),1)\\n# actflow_svm_mat = actflow_svm_mat - samplemean\\n\\n scores, rmatch, rmismatch, confusion_mat = actflowRandomSplitLOOBaselineCV(ncvs, svm_mat, actflow_svm_mat, labels, subjarray, featsel=featsel, permutation=permutation, nproc=nproc)\\n# stats = np.mean(scores)\\n stats = scores \\n\\n if effects and confusion:\\n return stats, rmatch, rmismatch, confusion_mat\\n if effects and not confusion:\\n return stats, rmatch, rmismatch\\n if confusion and not effects:\\n return stats, confusion_mat\\n else:\\n return stats\",\n \"def predict_multiple():\\n req = request.json\\n values = pd.DataFrame(data=req['data'])\\n pred = clf2.predict(values)\\n responses = {}\\n for i, rep in enumerate(pred):\\n if rep:\\n responses[f\\\"Customer {i + 1}\\\"] = f\\\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is likely to churn\\\"\\n\\n else:\\n responses[f\\\"Customer {i + 1}\\\"] = f\\\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is a loyal customer\\\"\\n\\n return make_response(jsonify(responses))\",\n \"def process_data(df, encoders, process_target=True):\\n\\n # Pclass\\n pclass_enc = df['Pclass'].values\\n pclass_enc = encoders['pclass_encoder'].transform(pclass_enc)\\n\\n # Sex\\n sex_enc = df['Sex'].values\\n sex_enc = encoders['sex_encoder'].transform(sex_enc)\\n\\n # Age\\n age_enc = pd.cut(df['Age'].values, encoders['age_bins'],\\n labels=False, include_lowest=True)\\n age_enc = encoders['age_encoder'].transform(age_enc)\\n\\n # Siblings/Spouses Aboard\\n siblings_spouses_aboard_enc = df['Siblings/Spouses Aboard'].values\\n siblings_spouses_aboard_enc = encoders['siblings_spouses_aboard_encoder'].transform(\\n siblings_spouses_aboard_enc)\\n\\n # Parents/Children Aboard\\n parents_children_aboard_enc = df['Parents/Children Aboard'].values\\n parents_children_aboard_enc = encoders['parents_children_aboard_encoder'].transform(\\n parents_children_aboard_enc)\\n\\n # Fare\\n fare_enc = pd.cut(df['Fare'].values, encoders['fare_bins'],\\n labels=False, include_lowest=True)\\n fare_enc = encoders['fare_encoder'].transform(fare_enc)\\n\\n data_enc = [pclass_enc,\\n sex_enc,\\n age_enc,\\n siblings_spouses_aboard_enc,\\n parents_children_aboard_enc,\\n fare_enc\\n ]\\n\\n if process_target:\\n # Target Field: Survived\\n survived_enc = df['Survived'].values\\n\\n survived_enc = encoders['survived_encoder'].transform(survived_enc)\\n\\n return (data_enc, survived_enc)\\n\\n return data_enc\",\n \"def main(self, data):\\n\\t\\ttokenizer = BertTokenizer.from_pretrained(\\\"bert-base-uncased\\\", do_lower_case=True)\\n\\t\\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\\n\\t\\tlabel, prob = self.predict(eval_features)\\n\\t\\treturn label, prob\",\n \"def main() -> Dict[int, int]:\\n # DOCUMENTS DIRECTORY\\n # Path of the directory that contains the .txt documents. One .txt document by company. IT NEEDS TO BE \\\"/data\\\" when you upload it in data challenge platform. For test in local, you can modifiy to match your data path.\\n if dev:\\n documents_directory = \\\"../example_dataset/data\\\"\\n else: \\n documents_directory = \\\"/data\\\"\\n\\n path_to_files: List[str] = [os.path.join(documents_directory, file) for file in os.listdir(documents_directory)]\\n assert len(path_to_files) == 10 # 10 files in documents directory\\n path_to_files.sort() # Sort list of path file by alphabetical order to match ground truth annotations order : IT IS ESSENTIAL.\\n\\n # INITIALIZATION OF YOUR OBJECTS\\n data_model = FormDataModel.from_json_file(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"data-model.json\\\")\\n )\\n country_referential = CountryReferential.from_csv(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"countries_code.csv\\\")\\n )\\n form_company_filling = FormCompanyFilling([\\n BasicExtractor(\\n question_ids=NOT_COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n ),\\n BasicCountryExtractor(\\n question_ids=COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n country_code_referential=country_referential,\\n\\n )\\n ])\\n\\n # COMPUTE PREDICTION BY FILE (ie company)\\n print(\\\"##################################\\\")\\n print(\\\"RUNNING PREDICTION\\\")\\n results: Dict[int, int] = {}\\n start_time = time.time()\\n for i, path in enumerate(path_to_files):\\n start = time.time()\\n print(f\\\"File : {path}\\\")\\n with open(path, \\\"r\\\") as input_file:\\n text = input_file.read()\\n print(\\\"... Encoding ...\\\")\\n start_encoding = time.time()\\n embeddings = model.encode(prepare_sentences(text))\\n # embeddings = []\\n print(\\\"Successfully encoded\\\")\\n print(\\\"Encoding time : \\\", time.time() - start_encoding)\\n\\n form_company_response = form_company_filling.fill(text, embeddings, model)\\n form_company_response.sort_by_question_id() # ESSENTIAL : Sort the response by question number for each company\\n for answer in form_company_response.answers:\\n question_number = answer.question_id + i * 22 # ESSENTIAL : each company has 22 questions. Each question_number in results should be unique\\n results[question_number] = answer.answer_id\\n # gc.collect()\\n print(\\\"File time :\\\", time.time()-start, '\\\\n')\\n # CHECK FORMAT RESULTS IS DATACHALLENGE PLATFORM COMPATIBLE\\n assert len(results) == len(path_to_files) * (len(COUNTRY_QUESTIONS_NUMBERS) + len(NOT_COUNTRY_QUESTIONS_NUMBERS))\\n assert set(list(results.keys())) == {i for i in range(1,221)}\\n print(\\\"Full Time\\\", time.time()-start_time)\\n return results\",\n \"def yield_prediction():\\n ## input code here\\n if request.method == \\\"POST\\\":\\n re = request.get_json()\\n city = re[\\\"city\\\"]\\n state = re[\\\"state\\\"]\\n ## convert into lower case\\n state = state.lower()\\n city = city.lower()\\n model_crop = re[\\\"crop\\\"]\\n model_crop = model_crop.lower()\\n model_season = re[\\\"season\\\"]\\n model_season = model_season.lower()\\n model_area = re[\\\"area\\\"]\\n model_area = int(model_area)\\n\\n ## store name of crop for the graph\\n crop = model_crop\\n ## preprocesss the code\\n\\n try:\\n state_le = load(\\\"static/labelencoder/state_le.joblib\\\")\\n district_le = load(\\\"static/labelencoder/district_le.joblib\\\")\\n season_le = load(\\\"static/labelencoder/season_le.joblib\\\")\\n crop_le = load(\\\"static/labelencoder/crop_le.joblib\\\")\\n model_crop = crop_le.transform([model_crop])[0]\\n model_season = season_le.transform([model_season])[0]\\n model_state = state_le.transform([state])[0]\\n model_city = district_le.transform([city])[0]\\n except:\\n response_dict = {\\n \\\"status\\\": False,\\n \\\"message\\\": \\\"Enter Valid Data\\\"\\n }\\n return jsonify(response_dict)\\n\\n model_city = int(model_city)\\n model_state = int(model_state)\\n model_crop = int(model_crop)\\n model_season = int(model_season)\\n model_para = [model_state, model_city, model_season, model_crop, model_area]\\n\\n ## prediction code here\\n\\n import requests\\n # NOTE: you must manually set API_KEY below using information retrieved from your IBM Cloud account.\\n API_KEY = \\\"S30qFHkYTHMDO81ijSRiGSiE1jOfnlt01Vtn9UBU2KqL\\\"\\n token_response = requests.post('https://iam.cloud.ibm.com/identity/token',\\n data={\\\"apikey\\\": API_KEY, \\\"grant_type\\\": 'urn:ibm:params:oauth:grant-type:apikey'})\\n mltoken = token_response.json()[\\\"access_token\\\"]\\n\\n header = {'Content-Type': 'application/json', 'Authorization': 'Bearer ' + mltoken}\\n\\n # NOTE: manually define and pass the array(s) of values to be scored in the next line\\n payload_scoring = {\\\"input_data\\\": [\\n {\\\"fields\\\": [\\\"State_Name\\\", \\\"District_Name\\\", \\\"Season\\\", \\\"Crop\\\", \\\"Area\\\"], \\\"values\\\": [model_para]}]}\\n\\n response_scoring = requests.post(\\n 'https://us-south.ml.cloud.ibm.com/ml/v4/deployments/180fe5c1-a652-4e59-8b33-781326790706/predictions?version=2021-07-16',\\n json=payload_scoring, headers={'Authorization': 'Bearer ' + mltoken})\\n\\n output = response_scoring.json()\\n\\n ## retrive the output\\n\\n pred_yield = output[\\\"predictions\\\"][0]['values'][0][0]\\n pred_production = pred_yield * model_area\\n\\n ## PIE CHART\\n try:\\n kharif_value = kharif_yield.query.filter_by(crop_name=crop).first()\\n kharif_values = kharif_value.yield_value\\n except:\\n kharif_values = 0\\n try:\\n rabi_value = rabi_yield.query.filter_by(crop_name=crop).first()\\n rabi_values = rabi_value.yield_value\\n except:\\n rabi_values = 0\\n\\n try:\\n summer_value = summer_yield.query.filter_by(crop_name=crop).first()\\n summer_values = summer_value.yield_value\\n except:\\n summer_values = 0\\n\\n try:\\n winter_value = winter_yield.query.filter_by(crop_name=crop).first()\\n winter_values = winter_value.yield_value\\n except:\\n winter_values = 0\\n\\n try:\\n autumn_value = autumn_yield.query.filter_by(crop_name=crop).first()\\n autumn_values = autumn_value.yield_value\\n except:\\n autumn_values = 0\\n\\n try:\\n whole_year_value = whole_year_yield.query.filter_by(crop_name=crop).first()\\n whole_year_values = whole_year_value.yield_value\\n except:\\n whole_year_values = 0\\n\\n season_name = ['kharif', 'rabi', 'summer', 'winter', 'autumn', 'whole year']\\n yield_list = [kharif_values, rabi_values, summer_values, winter_values, autumn_values, whole_year_values]\\n\\n season_yield_dict = dict()\\n pie_list = list()\\n for season, value in zip(season_name, yield_list):\\n if value == 0:\\n pass\\n else:\\n season_yield_dict[season] = round(value, 2)\\n pie_list.append(round(value, 2))\\n bar_graph_label = list(season_yield_dict.keys())\\n pie_final_list = list()\\n sum_list = sum(pie_list)\\n for val in pie_list:\\n suceess = val / sum_list\\n suceess = round(suceess, 2)\\n pie_final_list.append(suceess * 100)\\n\\n ## reponse dict here\\n response_dict = {\\n \\\"predYield\\\": pred_yield,\\n \\\"predProduction\\\": pred_production,\\n \\\"barGraphLabel\\\": bar_graph_label,\\n \\\"barGraphvalue\\\": yield_list,\\n \\\"pieChartLabel\\\": bar_graph_label,\\n \\\"pieChartValue\\\": pie_final_list\\n }\\n return jsonify(response_dict)\",\n \"def predict(self, x):\\n\\n x_ = self.scaler_s1.transform(x)\\n s1_df = self.basemodel.decision_function(x_)\\n s2_df = self.confidencemodel.decision_function(x_)\\n\\n '''\\n hc_df = np.max(dfs, 1)\\n\\n # high confidence vector\\n hc_df[(dfs > 0).sum(1) > 1] = np.min(dfs, 1)[(dfs > 0).sum(1) > 1]\\n '''\\n\\n hc_df = -np.ones((s2_df.shape[0], 1))\\n y_pred1 = self.basemodel.predict(x_)\\n\\n unique_labels = range(s2_df.shape[1])\\n for label in unique_labels:\\n hc_df[y_pred1 == label, :] = s2_df[y_pred1 == label, label][:, np.newaxis]\\n\\n '''\\n # TODO modif this to be compatible with multilabel classifiers (currently only binary classifier)\\n xor_mask = np.logical_xor(s2_df[:, 0] > 0, s2_df[:, 1] > 0)\\n\\n if xor_mask.sum() > 0:\\n hc_df[xor_mask, 0] = np.max(s2_df, 1)[xor_mask]\\n hc_df[~xor_mask, 0] = -np.abs(np.max(s2_df, 1)[~xor_mask])\\n #hc_labels = np.greater(s2_df[:, 1], s2_df[:, 0]).astype(int)\\n '''\\n\\n hit_proba_estimate = self.hitproba.predict(x_)\\n joint_hc = self.joint_class_hc.predict(x_)\\n\\n data_array = []\\n dict_array = []\\n if len(joint_hc.shape):\\n\\n dict_array = {'s1_df': s1_df[:, np.newaxis],\\n 'hcdf': hc_df,\\n 's2_df': s2_df,\\n 'hitproba': hit_proba_estimate[:, np.newaxis],\\n 'hcjoint': joint_hc[:, np.newaxis],\\n 's1_hat': self.ohe.transform((s1_df[:, np.newaxis]>0).astype(int)),\\n 's2_hat': ((self.ohe.transform((s1_df.reshape(-1, 1)>0).astype(int))>0) & (s2_df>0)).astype(int),\\n }\\n data_array = np.hstack(\\n [s1_df[:, np.newaxis], hc_df, s2_df, hit_proba_estimate[:, np.newaxis], joint_hc[:, np.newaxis]])\\n else:\\n # multiclass\\n data_array = np.hstack([s1_df, hc_df, s2_df, hit_proba_estimate, joint_hc])\\n dict_array = {'s1_df': s1_df,\\n 'hc_df': hc_df,\\n 's2_df': s2_df,\\n 'hitproba': hit_proba_estimate,\\n 'hcjoint': joint_hc,\\n 's1_hat': self.ohe.transform((s1_df > 0).astype(int)),\\n 's2_hat': ((self.ohe.transform((s1_df > 0).astype(int)) > 0) & (s2_df > 0)).astype(int)\\n }\\n\\n return data_array, dict_array\",\n \"def predict_and_sample(inference_model,x_initializer,a_initializer,c_initializer):\\n # Step 1: Use your inference model to predict an output sequence given x_initializer, a_initializer and c_initializer.\\n pred = inference_model.predict([x_initializer,a_initializer,c_initializer])\\n \\n # Step 2: Convert \\\"pred\\\" into an np.array() of indices with the maximum probabilities\\n indices = np.argmax(pred,axis=-1)\\n \\n # Step 3: Convert indices to one-hot vectors, the shape of the results should be (1, )\\n results = to_categorical(indices,num_classes=x_initializer.shape[-1])\\n \\n return results,indices\",\n \"def post_handler(_dev_idx, raw_res, _captured_frames_path):\\n global CUR_IMAGE\\n if CUR_IMAGE % 2:\\n print(\\\"\\\\nFox classification\\\")\\n else:\\n print(\\\"\\\\nCat classification\\\")\\n\\n scores, _labels = postprocess(raw_res[0])\\n top_indices(scores[0], 3)\\n\\n CUR_IMAGE += 1\",\n \"def postprocess(self, data):\\n if self.error is not None:\\n return [self.error]\\n\\n # Iterating over inference results to render the normalized probabilities\\n response = []\\n for inference_result in data:\\n softmax_result = inference_result.softmax().asnumpy()\\n for idx, label in enumerate(self.labels):\\n response.append({label: float(softmax_result[0][idx])})\\n return [response]\",\n \"def make_predictions(self):\\n if is_classification(self.model):\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data.to_numpy())\\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\\n return prediction, probabilities\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n probabilities = self.model.predict_proba(self.data_into_model())\\n return prediction, probabilities\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.model))\\n \\n else:\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data)\\n return prediction\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n return prediction\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.self.model))\",\n \"def Prediction(self):\\n # converts first 19 chunks of audio bytes into 16 bit int values\\n in_data = np.fromstring(np.array(self.frames[:19]), 'Int16')\\n\\n # extract MFCCs from the 19 chunks of audio\\n audio_sig = np.array([mfcc(in_data, self.rate, self.window,\\n self.stride, self.mfcc, self.filter_banks,\\n self.fft_num, 0, None, True)])\\n\\n # makes predictions\\n prediction = self.ww_model.model.predict(audio_sig)\\n\\n if(self.print_pred):\\n print(prediction)\\n\\n return prediction\",\n \"def test_service_api_predict_single_raw_classified(service_app):\\n response = service_app.post('/predict',\\n data=json.dumps(data[1:2]),\\n content_type='application/json')\\n\\n response_data = json.loads(response.data)\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 200\\n assert response_data['message'] == 'Records successfully classified'\\n assert len(response_data['prediction'].keys()) == 102\\n assert response_data['prediction']['business_outcome'] == [4]\\n assert response_data['prediction']['phat'] == [0.8228085289874678]\\n assert all(len(value) == 1 for value in response_data['prediction'].values())\",\n \"def do_decode(decoder, \\n output_handlers, \\n src_sentences,\\n trgt_sentences=None,\\n estimator=None,\\n iterations=1,\\n num_log=1):\\n if not decoder.has_predictor():\\n logging.fatal(\\\"Terminated due to an error in the \\\"\\n \\\"predictor configuration.\\\")\\n return\\n all_hypos = []\\n text_output_handler = _get_text_output_handler(output_handlers)\\n if text_output_handler:\\n text_output_handler.open_file()\\n score_output_handler = _get_score_output_handler(output_handlers)\\n\\n start_time = time.time()\\n logging.info(\\\"Start time: %s\\\" % start_time)\\n sen_indices = []\\n diversity_metrics = []\\n not_full = 0\\n num_iterations = iterations if estimator and not decoder.is_deterministic() else 1\\n \\n estimates = []\\n\\n for sen_idx in get_sentence_indices(args.range, src_sentences):\\n decoder.set_current_sen_id(sen_idx)\\n try:\\n src = \\\"0\\\" if src_sentences is False else src_sentences[sen_idx]\\n if len(src.split()) > 1000:\\n print(\\\"Skipping ID\\\", str(sen_idx), \\\". Too long...\\\")\\n continue\\n src_print = io_utils.src_sentence(src)\\n logging.info(\\\"Next sentence (ID: %d): %s\\\" % (sen_idx + 1, src_print))\\n src = io_utils.encode(src)\\n sen_estimates = []\\n\\n for i in range(num_iterations):\\n start_hypo_time = time.time()\\n decoder.apply_predictor_count = 0\\n decoder.seed=i\\n if decoder.name == \\\"reference\\\":\\n hypos = decoder.decode(src, io_utils.encode_trg(trgt_sentences[sen_idx]))\\n else:\\n hypos = decoder.decode(src)\\n if not hypos:\\n logging.error(\\\"No translation found for ID %d!\\\" % (sen_idx+1))\\n logging.info(\\\"Stats (ID: %d): score=<not-found> \\\"\\n \\\"num_expansions=%d \\\"\\n \\\"time=%.2f\\\" % (sen_idx+1,\\n decoder.apply_predictor_count,\\n time.time() - start_hypo_time))\\n hypos = [_generate_dummy_hypo()]\\n \\n hypos = _postprocess_complete_hypos(hypos)\\n for logged_hypo in hypos[:num_log]:\\n logging.info(\\\"Decoded (ID: %d): %s\\\" % (\\n sen_idx+1,\\n io_utils.decode(logged_hypo.trgt_sentence)))\\n logging.info(\\\"Stats (ID: %d): score=%f \\\"\\n \\\"num_expansions=%d \\\"\\n \\\"time=%.2f \\\" \\n \\\"perplexity=%.2f\\\"% (sen_idx+1,\\n logged_hypo.total_score,\\n #logged_hypo.base_score if logged_hypo.base_score else logged_hypo.total_score,\\n decoder.apply_predictor_count,\\n time.time() - start_hypo_time,\\n utils.perplexity(logged_hypo.score_breakdown)))\\n if estimator:\\n container = []\\n kau = min(hypos).total_score if decoder.gumbel else None\\n for h in hypos:\\n if kau and h.total_score <= kau:\\n continue\\n inc_prob = decoder.get_inclusion_prob_estimate(src, h, kau=kau)\\n model_prob = h.base_score if h.base_score else h.total_score\\n val = estimator.add_value(h, model_prob - inc_prob, \\n ref=trgt_sentences[sen_idx] if trgt_sentences else None)\\n container.append((model_prob - inc_prob, val))\\n logging.info(\\\"Estimator value: %.5f\\\" % (estimator.estimate()))\\n estimator.reset()\\n sen_estimates.append(container)\\n\\n\\n if score_output_handler:\\n try:\\n score_output_handler.write_score(logged_hypo.score_breakdown)\\n except IOError as e:\\n logging.error(\\\"I/O error %d occurred when creating output files: %s\\\"\\n % (sys.exc_info()[0], e))\\n\\n if decoder.nbest > 1:\\n diversity_score = utils.ngram_diversity([io_utils.decode(h.trgt_sentence) for h in hypos])\\n logging.info(\\\"Diversity: score=%f \\\"\\n % (diversity_score))\\n diversity_metrics.append(diversity_score)\\n\\n if len(hypos) < decoder.nbest:\\n not_full += 1\\n\\n \\n all_hypos.append(hypos)\\n sen_indices.append(sen_idx)\\n estimates.append(sen_estimates)\\n try:\\n # Write text output as we go\\n if text_output_handler:\\n text_output_handler.write_hypos([hypos])\\n except IOError as e:\\n logging.error(\\\"I/O error %d occurred when creating output files: %s\\\"\\n % (sys.exc_info()[0], e))\\n except ValueError as e:\\n logging.error(\\\"Number format error at sentence id %d: %s, \\\"\\n \\\"Stack trace: %s\\\" % (sen_idx+1, \\n e,\\n traceback.format_exc()))\\n except AttributeError as e:\\n logging.fatal(\\\"Attribute error at sentence id %d: %s. This often \\\"\\n \\\"indicates an error in the predictor configuration \\\"\\n \\\"which could not be detected in initialisation. \\\"\\n \\\"Stack trace: %s\\\" \\n % (sen_idx+1, e, traceback.format_exc()))\\n except Exception as e:\\n logging.error(\\\"An unexpected %s error has occurred at sentence id \\\"\\n \\\"%d: %s, Stack trace: %s\\\" % (sys.exc_info()[0],\\n sen_idx+1,\\n e,\\n traceback.format_exc()))\\n try:\\n # Write text output as we go\\n if text_output_handler:\\n hypos = [_generate_dummy_hypo()]\\n text_output_handler.write_hypos([hypos])\\n except IOError as e:\\n logging.error(\\\"I/O error %d occurred when creating output files: %s\\\"\\n % (sys.exc_info()[0], e))\\n if estimator:\\n file_name = decoder.name + '_' + args.fairseq_lang_pair + '_' + estimator.name + '_' +str(args.range) + '_' + str(args.nbest)\\n if hasattr(args, 'inc_prob_estimate_rounds'):\\n file_name += '_' + str(args.inc_prob_estimate_rounds)\\n file_name += '.out'\\n with open(file_name, 'w') as f:\\n f.write('\\\\n'.join([str(x) for x in estimates]))\\n\\n logging.info(\\\"Decoding finished. Time: %.2f\\\" % (time.time() - start_time))\\n if decoder.nbest > 1:\\n print(diversity_metrics)\\n print(\\\"Total not full:\\\", str(not_full))\\n try:\\n for output_handler in output_handlers:\\n if output_handler == text_output_handler:\\n output_handler.close_file()\\n else:\\n output_handler.write_hypos(all_hypos, sen_indices)\\n except IOError as e:\\n logging.error(\\\"I/O error %s occurred when creating output files: %s\\\"\\n % (sys.exc_info()[0], e))\",\n \"def inference(self, inputs):\\n\\n input_ids = torch.tensor([inputs[\\\"head_ids\\\"]], dtype=torch.long).to(self.device)\\n attention_masks = torch.tensor([inputs[\\\"attention_masks\\\"]], dtype=torch.bool).to(self.device)\\n \\n # Handling inference for sequence_classification.\\n with torch.no_grad():\\n output = self.model(input_ids, attention_masks)\\n predict_label = output[0].argmax(dim=2)\\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\\n\\n logger.info(\\\"Model predicted: '%s'\\\", predict_string)\\n return [{'predict': predict_string}]\",\n \"def _predict(self, probabilities):\\n child_categories = []\\n for i in range(0, self.category_level):\\n child_categories.append({})\\n for category_label in self.classifiers[i].classes_:\\n main_category = self._get_categories(category_label)[0]\\n if main_category not in child_categories[i]:\\n child_categories[i][main_category] = []\\n child_categories[i][main_category].append(category_label)\\n\\n # find the primary category\\n max_score = -1\\n primary_category_label = None\\n\\n for i in range(0, self.category_level):\\n for category_label in self.classifiers[i].classes_:\\n if probabilities[category_label] < 1e-9:\\n continue\\n total_score = 0\\n main_category = self._get_categories(category_label)[0]\\n candidates = child_categories[i][main_category]\\n for actual_label in candidates:\\n probability = probabilities[actual_label]\\n if probability < 1e-9:\\n continue\\n score = self._cal_score(category_label, None, actual_label, i)\\n total_score += score * probability\\n if total_score > max_score:\\n max_score = total_score\\n primary_category_label = category_label\\n\\n # find the secondary category\\n max_score = -1\\n secondary_category_label = None\\n for i in range(0, self.category_level):\\n for category_label in self.classifiers[i].classes_:\\n if probabilities[category_label] < 1e-9 and secondary_category_label:\\n continue\\n if category_label == primary_category_label:\\n continue\\n total_score = 0\\n main_category = self._get_categories(category_label)[0]\\n main_category2 = self._get_categories(primary_category_label)[0]\\n candidates = list(set(child_categories[i][main_category] + child_categories[i][main_category2]))\\n for actual_label in candidates:\\n probability = probabilities[actual_label]\\n if probability < 1e-9:\\n continue\\n score = self._cal_score(primary_category_label, category_label, actual_label, i)\\n total_score += score * probability\\n if total_score > max_score:\\n max_score = total_score\\n secondary_category_label = category_label\\n\\n return [self._get_categories(primary_category_label), self._get_categories(secondary_category_label)]\",\n \"def predict(image_path, wrapper):\\n \\\"\\\"\\\"\\n #Don't forget to store your prediction into ImgPred\\n img_prediction = ImgPred(...)\\n \\\"\\\"\\\"\\n\\n #This is where all of our code will probably go. Here are the steps to success\\n\\n \\n #Step One: Make a list which will contain the locations of every character in our source Image.\\n SymPredList = []\\n\\n #Step Two: Go down that list we just made and use the code from PA4 in conjunction with our new Model to analyze each character. George made this part.\\n #This is the find a character part of the code. Max and George worked it out.\\n im = cv2.imread(image_path,0)\\n (thresh, imbw) = cv2.threshold(im,20,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU)\\n #cv2.imwrite('clapfuck.jpg', imbw)\\n im3,contours,hierarchy = cv2.findContours(imbw,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\\n idx = 0\\n for cnt in contours:\\n idx += 1\\n x1,y1,w,h = cv2.boundingRect(cnt)\\n roi=imbw[y1:y1+h,x1:x1+w]\\n\\n #Step Two.1: Make a Numpy Array of all the pixels starting from the top left corner of an identified character to the bottom right corner of the identified character.\\n height, width = roi.shape\\n if height >= width:\\n padded = cv2.copyMakeBorder(roi,0,0,(height-width)//2,(height-width)//2,cv2.BORDER_CONSTANT,value=[0,0,0])\\n else:\\n padded = cv2.copyMakeBorder(roi,(width-height)//2,(width-height)//2,0,0,cv2.BORDER_CONSTANT,value=[0,0,0])\\n Smol = cv2.resize(padded, (28, 28))\\n (thresh, evaluateMe) = cv2.threshold(Smol, 20, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\\n #scipy.misc.imsave(os.path.basename(file), ree)\\n #Step Two.2: Feed that numpy into our PA4 image analyzer converter thing but using our new trained model\\n evaluateMeMe = numpy.reshape(evaluateMe, (1, 28, 28, 1))\\n prediction = tf.argmax(y_conv,1)\\n final_number = prediction.eval(feed_dict={x:evaluateMeMe,y_:numpy.zeros((1,40)), keep_prob:1.0})\\n #Step Two.3: Record what we think it is as the prediction field of the SymPred we are currently on\\n final_guess = wrapper.label_types[int(final_number)]\\n DisSymPred = SymPred(final_guess,x1,y1,x1+w,y1-h)\\n SymPredList.append(DisSymPred)\\n\\n #Step Three: Wrap that now complete SymPred list, in an ImgPred, fill out all the fields of that ImgPred, and then return that shit.\\n img_prediction = ImgPred(os.path.basename(image_path), SymPredList)\\n\\n #Step Four: Were Donezo\\n return img_prediction\",\n \"def do_training(self):\\n json_data = request.data\\n global g_list_of_classifier\\n\\n datas = json.loads(json_data.decode('UTF-8')) #datas = liste\\n\\n for ite_clf in g_list_of_classifier:\\n for data in datas:\\n ite_clf.add_data(data['score'], data['answer'])\\n print(ite_clf.get_info())\\n return ''\",\n \"def get_mc_pred(output,eng,frame,nImg):\\n preds_2d = [];\\n preds_3d = [];\\n \\n c,s = ut.calc_cent_scale(frame);\\n \\n center = matlab.double([list(c)],(1,2));\\n scale = matlab.double([s],(1,1));\\n \\n for i in tqdm(range(0,nImg)):\\n preds_2d.append(eng.transformMPII(output[\\\"W_final\\\"][2*i:2*(i+1)],center,scale,matlab.double([64,64],(1,2)),1));\\n preds_3d.append(output[\\\"S_final\\\"][3*i:3*i + 3]);\\n \\n print(\\\"Converting estimates to Python format...\\\");\\n preds_2d = np.array(preds_2d);\\n preds_3d = np.array(preds_3d);\\n \\n preds_2d = preds_2d.swapaxes(1, 2);\\n preds_3d = preds_3d.swapaxes(1, 2);\\n \\n return preds_2d, preds_3d;\",\n \"def evaluate(self, model, data):\\n model.eval()\\n\\n loss = self.loss\\n loss.reset()\\n match = 0\\n total = 0\\n correct_spk = 0\\n total_response = 0\\n y_true = np.array([])\\n y_pred = np.array([])\\n\\n device = None if torch.cuda.is_available() else -1\\n batch_iterator = torchtext.data.BucketIterator(\\n dataset=data, batch_size=self.batch_size,\\n sort=True, sort_key=lambda x: len(x.src),\\n device=device, train=False)\\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\\n\\n for batch in batch_iterator:\\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\\n\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs)\\n\\n # Predict Speaker:\\n target_spk = spk_inputs[-1]\\n target_lengths = target_lengths.cpu().numpy()\\n prob_per_spk = []\\n for i in range(self.args.num_spk):\\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\\n spk_inputs_.append(spk_inputs_predict)\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs_)\\n prob_per_responce = []\\n target = target_variables.transpose(0,1)\\n for word, prob in zip(target[1:], decoder_outputs):\\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\\n indices = zip(np.arange(len(word)), word)\\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\\n prob_per_responce.append(prob_per_word)\\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\\n\\n predicts = np.argmax(prob_per_spk, axis=1)\\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\\n total_response += len(batch.tgt[0])\\n\\n # Evaluation\\n seqlist = other['sequence']\\n for step, step_output in enumerate(decoder_outputs):\\n target = target_variables[:, step + 1]\\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\\n\\n non_padding = target.ne(pad)\\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\\n match += correct\\n total += non_padding.sum().data[0]\\n\\n y_pred = np.append(y_pred, predicts)\\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\\n\\n print(y_pred.shape)\\n\\n print(accuracy_score(y_true, y_pred))\\n print(confusion_matrix(y_true, y_pred))\\n\\n if total == 0:\\n accuracy = float('nan')\\n else:\\n accuracy = match / total\\n\\n if total_response == 0:\\n accuracy_spk = float('nan')\\n else:\\n accuracy_spk = correct_spk / total_response\\n\\n return loss.get_loss(), accuracy, accuracy_spk\",\n \"def decode(self, probs, embedded_inputs, selections, decode_type):\\n batch_size = self.shape(probs)[0]\\n idxs = mindspore.ops.multinomial(probs, 1)\\n squeeze = mindspore.ops.Squeeze(1)\\n idxs = squeeze(idxs)\\n\\n sels = embedded_inputs[idxs.item(), [i for i in range(batch_size)], :]\\n return sels, idxs\",\n \"def mite_2m(train_df, test_df, features, outcome, treatment, exposure, clf_t, clf_c, clf_er):\\n np.random.seed(0)\\n\\n train_exposed_df, train_not_exposed_df = split_treatment_control(train_df, exposure)\\n train_t_df, _ = split_treatment_control(train_df, treatment)\\n\\n clf_t_trained = clf_t.fit(train_exposed_df[features], train_exposed_df[outcome])\\n clf_c_trained = clf_c.fit(train_not_exposed_df[features], train_not_exposed_df[outcome])\\n clf_er_trained = clf_er.fit(train_t_df[features], train_t_df[exposure])\\n\\n test_f_df = test_df[features]\\n return clf_er_trained.predict_proba(test_f_df)[:, 1] * \\\\\\n (clf_t_trained.predict_proba(test_f_df)[:, 1] - clf_c_trained.predict_proba(test_f_df)[:, 1])\",\n \"def CardiacDiagnosisModelTester(clf, final_test_path, name, scaler, save_dir='./', label_available=False, prediction_csv=None):\\n class_names = [MINF, DCM]\\n df = load_dataframe(final_test_path, column='GROUP')\\n features = list(df.columns[np.r_[START_COL:END_COL]])\\n X_df = df[features]\\n X_scaled = scaler.transform(X_df) \\n y_pred = clf.predict(X_scaled)\\n print (\\\"Writing predictions to file\\\", name)\\n target = open(save_dir+'/'+ name+'predictions_{}.txt'.format(time.strftime(\\\"%Y%m%d_%H%M%S\\\")), 'w')\\n classes = {MINF:0, DCM:0}\\n for pid, pred in zip(df['Name'], y_pred):\\n classes[class_names[pred]] +=1\\n line = '{} {}'.format(pid, class_names[pred])\\n target.write(line)\\n target.write(\\\"\\\\n\\\")\\n target.close()\\n print (classes)\\n if label_available:\\n y_true,_ = encode_target(df, 'GROUP', heart_disease_label_map)\\n accuracy = accuracy_score(y_true['GROUP'], y_pred)\\n print(\\\"Accuracy: %.2f%%\\\" % (accuracy * 100.0))\\n else:\\n if prediction_csv:\\n pdf = pd.read_csv(test_on_prediction)\\n for pid, pred in zip(df['Name'], y_pred):\\n #https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/\\n pdf.loc[pdf['Name']== pid, 'GROUP'] = class_names[pred]\\n pdf.to_csv(prediction_csv, index=False)\\n # Upload file\\n with open(os.path.join(os.path.dirname(prediction_csv), 'ACDC_Predictions.txt'),'w') as outfile:\\n pdf.to_string(outfile, columns=['Name','GROUP'], index=False, header=False)\",\n \"def _postprocess(self, responses):\\n for idx, response in enumerate(responses):\\n responses[idx] = {'id': response[0],\\n 'text': self.target_test[response[0]]}\\n\\n for jdx, score in enumerate(response[1:]):\\n responses[idx]['score_' + str(jdx)] = response[1:][jdx]\\n\\n return responses\",\n \"def decode(self, tgt, encoder_out):\\n tgt_mask = get_lookahead_mask(tgt)\\n tgt = self.emb(tgt)\\n tgt = self.phn_lin(tgt)\\n if self.attention_type == \\\"RelPosMHAXL\\\":\\n # we use fixed positional encodings in the decoder\\n tgt = tgt + self.positional_encoding_decoder(tgt)\\n encoder_out = encoder_out + self.positional_encoding_decoder(\\n encoder_out\\n )\\n elif self.positional_encoding_type == \\\"fixed_abs_sine\\\":\\n tgt = tgt + self.positional_encoding(tgt) # add the encodings here\\n prediction, self_attns, multihead_attns = self.decoder(\\n tgt,\\n encoder_out,\\n tgt_mask=tgt_mask,\\n pos_embs_tgt=None,\\n pos_embs_src=None,\\n )\\n attention = multihead_attns[-1]\\n return prediction, attention\",\n \"def predict_note_authentication(totalyearlycompensation,safety,classifier):\\n \\n prediction=classifier.predict([[totalyearlycompensation,safety]])\\n print(prediction)\\n return prediction\",\n \"def test_predict(self):\\n\\n classifier = BertCCAMClassifier()\\n classifier.load_model(\\\"models\\\")\\n prediction = classifier.predict([\\\"bartosz\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}])\\n\\n # with multiple labels\\n prediction = classifier.predict([\\\"ala bert\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"A\\\", \\\"B\\\")}])\\n\\n # in a batch\\n prediction = classifier.predict([\\\"bartosz\\\", \\\"adam\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}, {\\\"labels\\\": (\\\"A\\\",)}])\",\n \"def decode(self, img_metas, output, **kwargs):\\n batch_size = len(img_metas)\\n if 'bbox_id' in img_metas[0]:\\n bbox_ids = []\\n else:\\n bbox_ids = None\\n c = np.zeros((batch_size, 2), dtype=np.float32)\\n s = np.zeros((batch_size, 2), dtype=np.float32)\\n image_paths = []\\n score = np.ones(batch_size)\\n for i in range(batch_size):\\n c[i, :] = img_metas[i]['center']\\n s[i, :] = img_metas[i]['scale']\\n image_paths.append(img_metas[i]['image_file'])\\n if 'bbox_score' in img_metas[i]:\\n score[i] = np.array(img_metas[i]['bbox_score']).reshape(-1)\\n if bbox_ids is not None:\\n bbox_ids.append(img_metas[i]['bbox_id'])\\n preds, maxvals = keypoints_from_heatmaps(output, c, s, unbiased=self.test_cfg.get('unbiased_decoding', False), post_process=self.test_cfg.get('post_process', 'default'), kernel=self.test_cfg.get('modulate_kernel', 11), valid_radius_factor=self.test_cfg.get('valid_radius_factor', 0.0546875), use_udp=self.test_cfg.get('use_udp', False), target_type=self.test_cfg.get('target_type', 'GaussianHeatmap'))\\n all_preds = np.zeros((batch_size, preds.shape[1], 3), dtype=np.float32)\\n all_boxes = np.zeros((batch_size, 6), dtype=np.float32)\\n all_preds[:, :, 0:2] = preds[:, :, 0:2]\\n all_preds[:, :, 2:3] = maxvals\\n all_boxes[:, 0:2] = c[:, 0:2]\\n all_boxes[:, 2:4] = s[:, 0:2]\\n all_boxes[:, 4] = np.prod(s * 200.0, axis=1)\\n all_boxes[:, 5] = score\\n result = {}\\n result['preds'] = all_preds\\n result['boxes'] = all_boxes\\n result['image_paths'] = image_paths\\n result['bbox_ids'] = bbox_ids\\n return result\",\n \"def Preprocess_MR(path=\\\"datasets/raw/rt10662\\\"):\\n\\n output_path = \\\"datasets/preprocessed/MR_Data\\\"\\n\\n # load positive and negative data\\n with io.open(os.path.join(path, \\\"rt-polarity.pos\\\"), encoding='latin-1') as f:\\n pos_data = f.readlines()\\n pos_data = [sentence.strip() for sentence in pos_data]\\n with io.open(os.path.join(path, \\\"rt-polarity.neg\\\"), encoding='latin-1') as f:\\n neg_data = f.readlines()\\n neg_data = [sentence.strip() for sentence in neg_data]\\n\\n labels = compute_labels(pos_data, neg_data)\\n text, labels = shuffle_data(pos_data + neg_data, labels)\\n\\n # split data in 70%/20%/10% train/test/dev split\\n train_len = ((len(text) / 10) * 7) + (len(text) % 10)\\n test_len = (len(text) / 10) * 2\\n dev_len = len(text) / 10\\n\\n trX = text[0:train_len]\\n teX = text[train_len:train_len + test_len]\\n vaX = text[train_len + test_len: train_len + test_len + dev_len]\\n\\n trY = labels[0:train_len]\\n teY = labels[train_len:train_len + test_len]\\n vaY = labels[train_len + test_len: train_len + test_len + dev_len]\\n\\n if not os.path.exists(output_path):\\n os.makedirs(output_path)\\n\\n dat1 = pd.DataFrame({'label': trY})\\n dat2 = pd.DataFrame({'sentence': trX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"train_binary_sent.csv\\\"), encoding='utf-8', index=False)\\n\\n\\n dat1 = pd.DataFrame({'label': teY})\\n dat2 = pd.DataFrame({'sentence': teX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"test_binary_sent.csv\\\"), encoding='utf-8', index=False)\\n\\n dat1 = pd.DataFrame({'label': vaY})\\n dat2 = pd.DataFrame({'sentence': vaX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"dev_binary_sent.csv\\\"), encoding='utf-8', index=False)\",\n \"def classify_subjects_parallel(sub, feature_spaces, model, cv):\\n scores, preds, coefs = [], [], dict()\\n for fs in feature_spaces:\\n \\n if not isinstance(fs, (tuple, list)):\\n fs = (fs,)\\n \\n fs_name = '+'.join(fs)\\n\\n dl = DataLoader(sub=sub, log_level=30)\\n dl.load_y(strategy_doubles='hard')\\n dl.load_X(feature_set=fs, n_comp=100)\\n X, y = dl.return_Xy()\\n\\n preds_, scores_, coefs_, model_ = cross_val_predict_and_score(\\n estimator=model,\\n X=X, y=y,\\n cv=cv,\\n scoring=tjur_score,\\n between_sub=False,\\n soft=True\\n )\\n joblib.dump(model_, f'models/sub-{sub}_analysis-within_split-train_fs-{fs_name}_model.jl')\\n\\n dl.log.warning(f\\\"sub-{sub} scores: {np.round(scores_, 2)} (fs = {fs_name})\\\")\\n scores_df = pd.DataFrame(scores_, columns=['score'])\\n scores_df['feature_set'] = fs_name\\n scores_df['emotion'] = dl.le.classes_\\n scores_df['sub'] = sub\\n scores.append(scores_df)\\n\\n for i in range(len(preds_)):\\n preds_[i]['feature_set'] = fs_name\\n preds_[i]['sub'] = sub\\n preds_[i]['rep'] = i\\n \\n preds.append(pd.concat(preds_, axis=0))\\n\\n coefs_df = pd.DataFrame(data=coefs_, columns=X.columns)\\n coefs_df['feature_set'] = fs_name\\n coefs_df['emotion'] = dl.le.classes_\\n coefs_df['sub'] = sub\\n coefs[fs_name] = coefs_df\\n\\n scores = pd.concat(scores, axis=0)\\n preds = pd.concat(preds, axis=0)\\n return preds, scores, coefs\",\n \"def test_BrainMapDecoder(testdata_laird):\\n ids = testdata_laird.ids[:5]\\n labels = testdata_laird.get_labels(ids=testdata_laird.ids)\\n decoder = discrete.BrainMapDecoder(features=labels)\\n decoder.fit(testdata_laird)\\n decoded_df = decoder.transform(ids=ids)\\n assert isinstance(decoded_df, pd.DataFrame)\\n assert decoded_df.shape == (len(labels), 6)\",\n \"def ite_2m(train_df, test_df, features, outcome, treatment, clf_t, clf_c):\\n np.random.seed(0)\\n\\n train_t_df, train_c_df = split_treatment_control(train_df, treatment)\\n\\n clf_t_trained = clf_t.fit(train_t_df[features], train_t_df[outcome])\\n clf_c_trained = clf_c.fit(train_c_df[features], train_c_df[outcome])\\n\\n test_f_df = test_df[features]\\n return clf_t_trained.predict_proba(test_f_df)[:, 1] - clf_c_trained.predict_proba(test_f_df)[:, 1]\",\n \"def results_corr_clsfied_imgs(org_pred_probs_full_data, org_pred_probs_clscorr, perturbed_pred_probs,\\n class_index_json_path, y, y_, img_names, root_folder_to_save_images, threshold,\\n method_type, experiments_file_path):\\n\\n original_image_predicted_classes_full_data = []\\n\\n original_image_predicted_classes = []\\n\\n perturbed_image_predicted_classes = []\\n\\n with open(class_index_json_path) as index_class_mapping_file:\\n mapping_dictionary = json.load(index_class_mapping_file)\\n\\n for org_preds, perturbed_preds in zip(org_pred_probs_clscorr, perturbed_pred_probs):\\n org_top_predicted_label_index = org_preds.argsort()[-1]\\n\\n perturbed_top_predicted_label_index = perturbed_preds.argsort()[-1]\\n original_image_predicted_classes.append(mapping_dictionary[str(org_top_predicted_label_index)])\\n perturbed_image_predicted_classes.append(mapping_dictionary[str(perturbed_top_predicted_label_index)])\\n\\n for org_preds_full_data in org_pred_probs_full_data:\\n top_predicted_label_index = org_preds_full_data.argsort()[-1]\\n original_image_predicted_classes_full_data.append(mapping_dictionary[str(top_predicted_label_index)])\\n\\n with open(os.path.join(root_folder_to_save_images, \\\"output.csv\\\"), 'w', newline='') as output_file:\\n output_writer = csv.writer(output_file, delimiter=',')\\n output_writer.writerow(\\n ['IMAGE Name', 'Original Class Name', 'Predictions On Original Images', 'Predictions On Perturbed Images'])\\n for i in zip(img_names, y_, original_image_predicted_classes, perturbed_image_predicted_classes):\\n output_writer.writerow(i)\\n print(\\\"output.csv has been generated..\\\")\\n\\n # Classwise metrics\\n\\n num_samples_per_class = defaultdict(int)\\n for a_label in y:\\n num_samples_per_class[a_label] += 1 # Example : { 'classA': 100 , 'classB': 99,...., 'classN': 89 }\\n\\n num_adv_samples_per_class = defaultdict(int)\\n for label in y_:\\n num_adv_samples_per_class[label] += 1\\n\\n # num of adversarial examples found for each class\\n # num_of_adv_examples_found = list(num_adv_samples_per_class.values())\\n\\n unique_labels = list(num_adv_samples_per_class.keys())\\n\\n # Y_ ==> only labels for classes where correctly classified.Y==>Overall Data.\\n # We need report only for correctly classified. Hence 'labels' argument has been assigned with classes where\\n # samples have been correctly classified by the model.\\n metrics_org_examples = precision_recall_fscore_support(\\n y, original_image_predicted_classes_full_data, labels=unique_labels)\\n # recall_org_examples = metrics_org_examples[1]\\n support_org_examples = metrics_org_examples[3]\\n\\n # To get true positives on perturbed examples\\n conf_matrix_perturbed_imgs = confusion_matrix(y_, perturbed_image_predicted_classes, labels=unique_labels)\\n conf_matrix_overall_imgs = confusion_matrix(y, original_image_predicted_classes_full_data, labels=unique_labels)\\n\\n # Get diagonal elements from the matrix to get true positives\\n perturbed_ex_correctly_classified_per_class = []\\n for i in range(conf_matrix_perturbed_imgs.shape[0]):\\n perturbed_ex_correctly_classified_per_class.append(conf_matrix_perturbed_imgs[i][i])\\n\\n test_data_correctly_classified_per_class = []\\n for j in range(conf_matrix_overall_imgs.shape[0]):\\n test_data_correctly_classified_per_class.append(conf_matrix_overall_imgs[j][j])\\n\\n # perturbed examples correctly classified divided by original number of examples in each class\\n percent_of_adv_exmpls_classified_correctly = [j / i for i, j in zip(support_org_examples,\\n perturbed_ex_correctly_classified_per_class)]\\n # test data examples correctly classified divided by original number of samples in each class\\n percent_of_test_data_classified_correctly = [n / m for m, n in zip(support_org_examples,\\n test_data_correctly_classified_per_class)]\\n\\n diff_bool = []\\n for m, n in zip(percent_of_test_data_classified_correctly, percent_of_adv_exmpls_classified_correctly):\\n if n == 0:\\n diff_bool.append('TRUE')\\n else:\\n diff_bool.append((m - n) > threshold)\\n with open(os.path.join(root_folder_to_save_images, 'classmetrics.csv'), 'w', newline='') as classmetrics_file:\\n classmetrics_writer = csv.writer(classmetrics_file, delimiter=',')\\n classmetrics_writer.writerow(\\n ['ClassNames', 'Number Of Examples In Each Class(Overall Test Data)',\\n 'Number Of Test Data Correctly Classified(Overall)', 'Perturbed Examples Correctly Classified',\\n 'Accuracy-TestData', 'Accuracy-PerturbedExamples', 'Diff-Accuracy'])\\n for row in zip(unique_labels, support_org_examples, test_data_correctly_classified_per_class,\\n perturbed_ex_correctly_classified_per_class, percent_of_test_data_classified_correctly,\\n percent_of_adv_exmpls_classified_correctly, diff_bool):\\n classmetrics_writer.writerow(row)\\n\\n print(\\\"classwisemetrics.csv has been generated..\\\")\\n\\n # Overall Metrics\\n # calculate overall true positives\\n conf_matrix_full_testdata = confusion_matrix(y, original_image_predicted_classes_full_data, labels=list(set(y)))\\n true_positives_overall_testdata = 0\\n for d in range(conf_matrix_full_testdata.shape[0]):\\n true_positives_overall_testdata += conf_matrix_full_testdata[d][d]\\n\\n accuracy_overall_testdata = true_positives_overall_testdata / len(y)\\n accuracy_perturbed_examples = sum(perturbed_ex_correctly_classified_per_class) / len(y)\\n with open(os.path.join(root_folder_to_save_images, 'overallmetrics.csv'), 'w', newline='') as overall_metrics_file:\\n overall_metrics_writer = csv.writer(overall_metrics_file, delimiter=',')\\n overall_metrics_writer.writerow(['Metrics', 'OnOriginalExamples', 'OnPerturbedExamples', 'Diff-Accuracy'])\\n overall_metrics_writer.writerow(['Accuracy', accuracy_overall_testdata, accuracy_perturbed_examples,\\n accuracy_overall_testdata - accuracy_perturbed_examples > threshold])\\n\\n print(\\\"overallmetrics.csv has been generated..\\\")\\n\\n # Generate experiments.csv file.\\n generate_experiments(experiments_file_path, method_type)\\n\\n # Check if the result files have been generated and the return a message\\n\\n return result_message(root_folder_to_save_images)\",\n \"def prep_metrics(ap_data, dets, img, gt, gt_masks, h, w, num_crowd, image_id, detections: Detections = None):\\n if not args.output_coco_json:\\n with timer.env('Prepare gt'):\\n gt_boxes = torch.Tensor(gt[:, :4])\\n gt_boxes[:, [0, 2]] *= w\\n gt_boxes[:, [1, 3]] *= h\\n gt_classes = list(gt[:, 4].astype(int))\\n gt_masks = torch.Tensor(gt_masks).view(-1, h * w)\\n\\n if num_crowd > 0:\\n split = lambda x: (x[-num_crowd:], x[:-num_crowd])\\n crowd_boxes, gt_boxes = split(gt_boxes)\\n crowd_masks, gt_masks = split(gt_masks)\\n crowd_classes, gt_classes = split(gt_classes)\\n\\n with timer.env('Postprocess'):\\n classes, scores, boxes, masks = postprocess(dets, w, h, crop_masks=args.crop,\\n score_threshold=args.score_threshold)\\n\\n if classes.size(0) == 0:\\n return\\n\\n classes = list(classes.cpu().numpy().astype(int))\\n if isinstance(scores, list):\\n box_scores = list(scores[0].cpu().numpy().astype(float))\\n mask_scores = list(scores[1].cpu().numpy().astype(float))\\n else:\\n scores = list(scores.cpu().numpy().astype(float))\\n box_scores = scores\\n mask_scores = scores\\n masks = masks.view(-1, h * w).cuda()\\n boxes = boxes.cuda()\\n\\n if args.output_coco_json:\\n with timer.env('JSON Output'):\\n boxes = boxes.cpu().numpy()\\n masks = masks.view(-1, h, w).cpu().numpy()\\n for i in range(masks.shape[0]):\\n # Make sure that the bounding box actually makes sense and a mask was produced\\n if (boxes[i, 3] - boxes[i, 1]) * (boxes[i, 2] - boxes[i, 0]) > 0:\\n detections.add_bbox(image_id, classes[i], boxes[i, :], box_scores[i])\\n detections.add_mask(image_id, classes[i], masks[i, :, :], mask_scores[i])\\n return\\n\\n with timer.env('Eval Setup'):\\n num_pred = len(classes)\\n num_gt = len(gt_classes)\\n\\n mask_iou_cache = _mask_iou(masks, gt_masks)\\n bbox_iou_cache = _bbox_iou(boxes.float(), gt_boxes.float())\\n\\n if num_crowd > 0:\\n crowd_mask_iou_cache = _mask_iou(masks, crowd_masks, iscrowd=True)\\n crowd_bbox_iou_cache = _bbox_iou(boxes.float(), crowd_boxes.float(), iscrowd=True)\\n else:\\n crowd_mask_iou_cache = None\\n crowd_bbox_iou_cache = None\\n\\n box_indices = sorted(range(num_pred), key=lambda i: -box_scores[i])\\n mask_indices = sorted(box_indices, key=lambda i: -mask_scores[i])\\n\\n iou_types = [\\n ('box', lambda i, j: bbox_iou_cache[i, j].item(),\\n lambda i, j: crowd_bbox_iou_cache[i, j].item(),\\n lambda i: box_scores[i], box_indices),\\n ('mask', lambda i, j: mask_iou_cache[i, j].item(),\\n lambda i, j: crowd_mask_iou_cache[i, j].item(),\\n lambda i: mask_scores[i], mask_indices)\\n ]\\n\\n timer.start('Main loop')\\n for _class in set(classes + gt_classes):\\n ap_per_iou = []\\n num_gt_for_class = sum([1 for x in gt_classes if x == _class])\\n\\n for iouIdx in range(len(iou_thresholds)):\\n iou_threshold = iou_thresholds[iouIdx]\\n\\n for iou_type, iou_func, crowd_func, score_func, indices in iou_types:\\n gt_used = [False] * len(gt_classes)\\n\\n ap_obj = ap_data[iou_type][iouIdx][_class]\\n ap_obj.add_gt_positives(num_gt_for_class)\\n\\n for i in indices:\\n if classes[i] != _class:\\n continue\\n\\n max_iou_found = iou_threshold\\n max_match_idx = -1\\n for j in range(num_gt):\\n if gt_used[j] or gt_classes[j] != _class:\\n continue\\n\\n iou = iou_func(i, j)\\n\\n if iou > max_iou_found:\\n max_iou_found = iou\\n max_match_idx = j\\n\\n if max_match_idx >= 0:\\n gt_used[max_match_idx] = True\\n ap_obj.push(score_func(i), True)\\n else:\\n # If the detection matches a crowd, we can just ignore it\\n matched_crowd = False\\n\\n if num_crowd > 0:\\n for j in range(len(crowd_classes)):\\n if crowd_classes[j] != _class:\\n continue\\n\\n iou = crowd_func(i, j)\\n\\n if iou > iou_threshold:\\n matched_crowd = True\\n break\\n\\n # All this crowd code so that we can make sure that our eval code gives the\\n # same result as COCOEval. There aren't even that many crowd annotations to\\n # begin with, but accuracy is of the utmost importance.\\n if not matched_crowd:\\n ap_obj.push(score_func(i), False)\\n timer.stop('Main loop')\",\n \"def main(domain):\\n\\n filepath_train1 = '../../Non_covid_data_15oct/train_data_batch1_disregard_removed.pkl'\\n filepath_test1 = '../../Non_covid_data_15oct/test_data_batch1_disregard_removed.pkl'\\n filepath_train2 = '../../Covid_data_11nov/traindata_covidbatch.pkl'\\n filepath_test2 = '../../Covid_data_11nov/testdata_covidbatch.pkl'\\n\\n df_train_nc, df_test_nc = createDataframe(filepath_train1, filepath_test1, domain, 'noncovid')\\n df_train_c, df_test_c = createDataframe(filepath_train2, filepath_test2, domain, 'covid')\\n #print(df_train)\\n sen_reps_tr_nc, labels_tr_nc, sen_reps_te_nc, labels_te_nc = prepro(df_train_nc, df_test_nc)\\n sen_reps_tr_c, labels_tr_c, sen_reps_te_c, labels_te_c = prepro(df_train_c, df_test_c)\\n #print(labels_te)\\n\\n #Uncomment to combine training datasets \\n #sen_reps_tr_c += sen_reps_tr_nc\\n #labels_tr_c += labels_tr_nc\\n\\n #Uncomment to combine test datasets and test labels if necessary (if you do so, also combine test df's)\\n #sen_reps_te_c += sen_reps_te_nc\\n #labels_te_c += labels_te_nc\\n #df_test = pd.concat([df_test_c, df_test_nc])\\n\\n #Feed selected train and test data to regression model\\n predictions = get_predictions(sen_reps_tr_c, labels_tr_c, sen_reps_te_c)\\n\\n #Make dataframes of note id's and labels\\n df_ann = make_note_df(df_test_c, labels_te_c)\\n df_pred = make_note_df(df_test_c, predictions)\\n\\n #Evaluate on sentence level\\n MSE, MAE, RMSE = evaluation(labels_te_c, predictions)\\n\\n print(\\\"MSE \\\"+domain, MSE)\\n print(\\\"MAE \\\"+domain, MAE)\\n print(\\\"RMSE \\\"+domain, RMSE)\\n\\n #Aggregate per note\\n means_ann = means(df_ann)\\n means_pred = means(df_pred)\\n\\n #Evaluate on note level\\n MSE, MAE, RMSE = evaluation(means_ann, means_pred)\\n\\n print(\\\"MSE agg\\\"+domain, MSE)\\n print(\\\"MAE agg\\\"+domain, MAE)\\n print(\\\"RMSE agg\\\"+domain, RMSE)\",\n \"def decode(self, output_dict):\\n top_spans_batch = output_dict[\\\"top_spans\\\"].detach().cpu()\\n predicted_relations_batch = output_dict[\\\"predicted_relations\\\"].detach().cpu()\\n num_spans_to_keep_batch = output_dict[\\\"num_spans_to_keep\\\"].detach().cpu()\\n res_dict = []\\n res_list = []\\n\\n # Collect predictions for each sentence in minibatch.\\n zipped = zip(top_spans_batch, predicted_relations_batch, num_spans_to_keep_batch)\\n for top_spans, predicted_relations, num_spans_to_keep in zipped:\\n entry_dict, entry_list = self._decode_sentence(\\n top_spans, predicted_relations, num_spans_to_keep)\\n res_dict.append(entry_dict)\\n res_list.append(entry_list)\\n\\n output_dict[\\\"decoded_relations_dict\\\"] = res_dict\\n output_dict[\\\"decoded_relations\\\"] = res_list\\n return output_dict\",\n \"def prep_metrics(ap_data, dets, gt, gt_masks, h, w, num_crowd):\\n gt_boxes = torch.Tensor(gt[:, :4])\\n gt_boxes[:, [0, 2]] *= w\\n gt_boxes[:, [1, 3]] *= h\\n gt_classes = list(gt[:, 4].astype(int))\\n gt_masks = torch.Tensor(gt_masks).view(-1, h*w)\\n\\n if num_crowd > 0:\\n split = lambda x: (x[-num_crowd:], x[:-num_crowd])\\n crowd_boxes , gt_boxes = split(gt_boxes)\\n crowd_masks , gt_masks = split(gt_masks)\\n crowd_classes, gt_classes = split(gt_classes)\\n\\n classes, scores, boxes, masks = postprocess(dets, w, h, crop_masks=True, score_threshold=0)\\n\\n classes = list(classes.cpu().numpy().astype(int))\\n scores = list(scores.cpu().numpy().astype(float))\\n masks = masks.view(-1, h*w)\\n \\n num_pred = len(classes)\\n num_gt = len(gt_classes)\\n\\n mask_iou_cache = mask_iou(masks, gt_masks)\\n bbox_iou_cache = bbox_iou(boxes.float(), gt_boxes.float())\\n\\n if num_crowd > 0:\\n crowd_mask_iou_cache = mask_iou(masks, crowd_masks, iscrowd=True)\\n crowd_bbox_iou_cache = bbox_iou(boxes.float(), crowd_boxes.float(), iscrowd=True)\\n else:\\n crowd_mask_iou_cache = None\\n crowd_bbox_iou_cache = None\\n\\n iou_types = [\\n ('box', lambda i,j: bbox_iou_cache[i, j].item(), lambda i,j: crowd_bbox_iou_cache[i,j].item()),\\n ('mask', lambda i,j: mask_iou_cache[i, j].item(), lambda i,j: crowd_mask_iou_cache[i,j].item())\\n ]\\n\\n for _class in set(classes + gt_classes):\\n ap_per_iou = []\\n num_gt_for_class = sum([1 for x in gt_classes if x == _class])\\n \\n for iouIdx in range(len(iou_thresholds)):\\n iou_threshold = iou_thresholds[iouIdx]\\n\\n for iou_type, iou_func, crowd_func in iou_types:\\n gt_used = [False] * len(gt_classes)\\n\\n ap_obj = ap_data[iou_type][iouIdx][_class]\\n ap_obj.add_gt_positives(num_gt_for_class)\\n\\n for i in range(num_pred):\\n if classes[i] != _class:\\n continue\\n \\n max_iou_found = iou_threshold\\n max_match_idx = -1\\n for j in range(num_gt):\\n if gt_used[j] or gt_classes[j] != _class:\\n continue\\n \\n iou = iou_func(i, j)\\n\\n if iou > max_iou_found:\\n max_iou_found = iou\\n max_match_idx = j\\n \\n if max_match_idx >= 0:\\n gt_used[max_match_idx] = True\\n ap_obj.push(scores[i], True)\\n else:\\n # If the detection matches a crowd, we can just ignore it\\n matched_crowd = False\\n\\n if num_crowd > 0:\\n for j in range(len(crowd_classes)):\\n if crowd_classes[j] != _class:\\n continue\\n \\n iou = crowd_func(i, j)\\n\\n if iou > iou_threshold:\\n matched_crowd = True\\n break\\n\\n # All this crowd code so that we can make sure that our eval code gives the\\n # same result as COCOEval. There aren't even that many crowd annotations to\\n # begin with, but accuracy is of the utmost importance.\\n if not matched_crowd:\\n ap_obj.push(scores[i], False)\",\n \"def main(args):\\r\\n # Parse inputs\\r\\n parser = _argparse()\\r\\n argp = parser.parse_args(args[1:])\\r\\n # Read training data\\r\\n sparse_training = sp.sparse.load_npz( argp.training_data )\\r\\n training_data = np.array( sparse_training.todense() )\\r\\n training_labels = np.array(pd.read_csv(argp.training_labels,index_col = 0 ))\\r\\n\\r\\n # Train classifier \\r\\n classifier = train_classifier.train_LR( training_data, training_labels, num_genes = argp.num_genes, pct_var = argp.pca_variance/100, save_results = False )\\r\\n\\r\\n training_predictions, training_probabilities = predict_cell_types( training_data, classifier )\\r\\n confusion_mat = pd.DataFrame(confusion_matrix( training_labels, training_predictions ),\\r\\n index = np.unique(training_labels), columns = np.unique(training_labels)).to_csv(\\r\\n \\\"results/classification/confusion_matrix.csv\\\")\\r\\n # Make predictions for all cells\\r\\n sparse_scRNA_expression = sp.sparse.load_npz( argp.test_data )\\r\\n scRNA_expression = np.array( sparse_scRNA_expression.todense() )\\r\\n predicted_cell_types, prediction_probabilities = predict_cell_types( scRNA_expression, classifier ) \\r\\n \\r\\n sequencing_metrics = pd.read_csv(\\\"data/combined/processed_metrics.csv\\\",index_col = 0)\\r\\n # Save outputs\\r\\n pd.DataFrame(prediction_probabilities, \\r\\n index = sequencing_metrics.index.values,\\r\\n columns = np.unique(predicted_cell_types) ).to_csv(\\\"results/classification/prediction_probabilities.csv\\\")\\r\\n pd.DataFrame(predicted_cell_types, \\r\\n index = sequencing_metrics.index.values,\\r\\n columns = [\\\"predicted_cell_type\\\"] ).to_csv(\\\"results/classification/predicted_cell_types.csv\\\")\",\n \"def prob_category(new_music, fit):\\n\\tr = robjects.r\\n\\t#Be careful not to include the word 'data' in the function call below, although data is a keyword\\n\\tpredictions = r.predict(fit,new_music,type=\\\"prob\\\")\\n\\treturn predictions\",\n \"def process(self, classifications, detections):\\n det_len = len(detections)\\n if len(classifications) != len(detections):\\n raise Exception(\\\"Classifications / Detections difer in length!\\\")\\n\\n sequence_length = self.sequenceSize()\\n sequence_count = math.ceil(det_len / sequence_length)\\n overall_keyframes = []\\n\\n sequences=[] # The sequence of features to run the network on\\n seq_class=[] # the underlying classifictions for each sequence\\n # Iterate over each sequence to generate a batch request\\n for sequence_idx in range(sequence_count):\\n start_idx = sequence_idx*sequence_length\\n end_idx = max((sequence_idx+1)*sequence_length,len(detections))\\n classification_sublist=classifications[start_idx:end_idx]\\n detections_sublist=detections[start_idx:end_idx]\\n sequences.append(self._generateSequence(classification_sublist,\\n detections_sublist))\\n seq_class.append(classification_sublist)\\n\\n # Now that each sequence is setup, run the network on all of them\\n # TODO: May have practical limitations here if we have a huge\\n # video\\n return self._processSequences(sequences, seq_class)\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_svm.predict(data)\",\n \"def doContPopEvaluation(self, is_train):\\n if is_train:\\n my_type = \\\"TRAINING\\\"\\n else:\\n my_type = \\\"TESTING\\\"\\n no_match = 0 #How often does the population fail to have a classifier that matches an instance in the data.\\n cons.env.resetDataRef(is_train) #Go to first instance in data set\\n accuracy_estimate_sum = 0\\n\\n if is_train:\\n instances = cons.env.format_data.numb_train_instances\\n else:\\n instances = cons.env.format_data.numb_test_instances\\n #----------------------------------------------------------------------------------------------\\n for _ in range(instances):\\n if is_train:\\n state_action = cons.env.getTrainInstance()\\n else:\\n state_action = cons.env.getTestInstance()\\n #-----------------------------------------------------------------------------\\n self.population.makeEvalMatchSet(state_action[0])\\n prediction = Prediction(self.population)\\n selected_action = prediction.getDecision()\\n #-----------------------------------------------------------------------------\\n if selected_action == None:\\n no_match += 1\\n else: #Instances which failed to be covered are excluded from the initial accuracy calculation\\n prediction_err = math.fabs(float(selected_action) - float(state_action[1]))\\n action_range = cons.env.format_data.action_list[1] - cons.env.format_data.action_list[0]\\n accuracy_estimate_sum += 1.0 - (prediction_err / float(action_range))\\n\\n self.population.clearSets()\\n #----------------------------------------------------------------------------------------------\\n #Accuracy Estimate\\n if instances == no_match:\\n accuracy_estimate = 0\\n else:\\n accuracy_estimate = accuracy_estimate_sum / float(instances - no_match)\\n\\n #Adjustment for uncovered instances - to avoid positive or negative bias we incorporate the probability of guessing a phenotype by chance (e.g. 50% if two phenotypes)\\n covered_instances = 1.0 - (float(no_match)/float(instances))\\n adjusted_accuracy_estimate = accuracy_estimate_sum / float(instances) #no_matchs are treated as incorrect predictions (can see no other fair way to do this)\\n\\n print(\\\"-----------------------------------------------\\\")\\n print(str(my_type)+\\\" Accuracy Results:-------------\\\")\\n print(\\\"Instance Coverage = \\\"+ str(covered_instances*100.0)+ '%')\\n print(\\\"Estimated Prediction Accuracy (Ignore uncovered) = \\\" + str(accuracy_estimate))\\n print(\\\"Estimated Prediction Accuracy (Penalty uncovered) = \\\" + str(adjusted_accuracy_estimate))\\n #Balanced and Standard Accuracies will only be the same when there are equal instances representative of each phenotype AND there is 100% covering.\\n result_list = [adjusted_accuracy_estimate, covered_instances]\\n return result_list\",\n \"def decode(self, encoded_train, encoded_dev):\\n decoded_train_A = self.decoder_A.predict(encoded_train)\\n decoded_dev_A = self.decoder_A.predict(encoded_dev)\\n self.save_reconstruction(decoded_train_A, decoded_dev_A, modality=True, no_modality=0)\\n decoded_train_V = self.decoder_V.predict(encoded_train)\\n decoded_dev_V = self.decoder_V.predict(encoded_dev)\\n self.save_reconstruction(decoded_train_V, decoded_dev_V, modality=True, no_modality=1)\",\n \"def decode(dummy_y,encoder):\\n # from dummy back to class names\\n encoded_y = np.zeros(len(dummy_y))\\n for i in range(len(dummy_y)):\\n encoded_y[i] = int(np.argmax(dummy_y[i]))\\n classes_y = encoder.inverse_transform(encoded_y.astype(int))\\n \\n return classes_y,encoded_y\",\n \"def decode(dummy_y,encoder):\\n # from dummy back to class names\\n encoded_y = np.zeros(len(dummy_y))\\n for i in range(len(dummy_y)):\\n encoded_y[i] = int(np.argmax(dummy_y[i]))\\n classes_y = encoder.inverse_transform(encoded_y.astype(int))\\n \\n return classes_y,encoded_y\",\n \"def predict_results_for_tweets(X_test, pipeline_dicts):\\r\\n results_dict = {}\\r\\n for emotion, pipeline in pipeline_dicts.items():\\r\\n print('Predicting for emotion: ' + emotion)\\r\\n if X_test[emotion].empty == False:\\r\\n y_pred = pipeline.predict(X_test[emotion])\\r\\n results_dict[emotion] = y_pred\\r\\n else:\\r\\n #Create array of None values with same length as that of X_test\\r\\n results_dict[emotion] = [None] * len(X_test)\\r\\n return results_dict\",\n \"def get_cae_outputs(self, seq, traj_n, pred_h):\\r\\n st_seq, cond_seq = seq\\r\\n # reshape to fit model\\r\\n st_seq.shape = (1, st_seq.shape[0], st_seq.shape[1])\\r\\n\\r\\n for n in range(5):\\r\\n cond_seq[n].shape = (1, 1, 1)\\r\\n cond_seq[n] = np.repeat(cond_seq[n], traj_n, axis=0)\\r\\n\\r\\n st_seq = np.repeat(st_seq, traj_n, axis=0)\\r\\n # get enc_h state\\r\\n enc_state = self.enc_model(st_seq)\\r\\n\\r\\n self.skip_n = 2 # done for a smoother trajectory\\r\\n self.step_len = round(self.skip_n*self.data_obj.step_size*0.1, 1) # [s]\\r\\n steps_n = int(np.ceil(np.ceil(pred_h/self.step_len)*self.step_len/ \\\\\\r\\n (self.data_obj.step_size*0.1)))\\r\\n print('steps_n: ', steps_n)\\r\\n self.dec_model.steps_n = steps_n\\r\\n self.dec_model.traj_n = traj_n\\r\\n t0 = time.time()\\r\\n\\r\\n sampled_actions, gmm_mlon, gmm_mlat, prob_mlon, prob_mlat = self.dec_model(\\\\\\r\\n [cond_seq, enc_state])\\r\\n print(time.time() - t0)\\r\\n prob_mlon = prob_mlon.numpy()\\r\\n prob_mlat = prob_mlat.numpy()\\r\\n return sampled_actions, gmm_mlon, gmm_mlat, prob_mlon, prob_mlat\",\n \"def predict(video_generators, audio_generator, subject):\\n prediction = [random.randint(0, 4)]\\n\\n # TODO: implement prediction method\\n # video_frame_subject = next(video_generators[int(subject[-1]) - 1])\\n # audio_value = next(audio_generator)\\n\\n return prediction\",\n \"def do_subjects_preproc(subjects,\\n output_dir=None,\\n subject_callback=None,\\n dataset_id=\\\"UNNAMED DATASET!\\\",\\n do_deleteorient=False,\\n do_report=True,\\n do_export_report=False,\\n dataset_description=None,\\n report_filename=None,\\n do_shutdown_reloaders=True,\\n fwhm=0,\\n do_bet=False,\\n do_slicetiming=False,\\n TR=None,\\n do_realign=True,\\n do_coreg=True,\\n do_segment=True,\\n do_normalize=True,\\n do_dartel=False,\\n do_cv_tc=True,\\n ignore_exception=True,\\n n_jobs=N_JOBS,\\n ):\\n\\n # sanitize input\\n subjects = list(subjects)\\n\\n if do_dartel:\\n do_segment = False\\n do_normalize = False\\n\\n # if do_report and report_filename is None:\\n # raise RuntimeError(\\n # (\\\"You asked for reporting (do_report=True) but specified\\\"\\n # \\\" an invalid report_filename (None)\\\"))\\n\\n kwargs = {'do_deleteorient': do_deleteorient,\\n 'do_bet': do_bet,\\n 'do_report': do_report,\\n 'do_slicetiming': do_slicetiming,\\n 'do_realign': do_realign, 'do_coreg': do_coreg,\\n 'do_segment': do_segment, 'do_normalize': do_normalize,\\n 'do_cv_tc': do_cv_tc,\\n 'fwhm': fwhm,\\n 'TR': TR,\\n 'ignore_exception': ignore_exception,\\n 'last_stage': not do_dartel,\\n }\\n\\n if output_dir is None:\\n output_dir = os.path.abspath(\\\"/tmp/runs_XYZ\\\")\\n print \\\"Output directory set to: %s\\\" % output_dir\\n\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n additional_preproc_undergone = \\\"\\\"\\n if do_dartel:\\n additional_preproc_undergone += (\\n \\\"<li>\\\"\\n \\\"Group/Inter-subject Normalization has been done using the \\\"\\n \\\"SPM8 <a href='%s'>DARTEL</a> to warp subject brains into \\\"\\n \\\"MNI space. \\\"\\n \\\"The idea is to register images by computing a “flow\\\"\\n \\\" field” which can then be “exponentiated\\\"\\n \\\"” to generate both forward and backward deformation\\\"\\n \\\"s. Processing begins with the “import” \\\"\\n \\\"step. This involves taking the parameter files \\\"\\n \\\"produced by the segmentation (NewSegment), and writing \\\"\\n \\\"out rigidly \\\"\\n \\\"transformed versions of the tissue class images, \\\"\\n \\\"such that they are in as close alignment as possible with\\\"\\n \\\" the tissue probability maps. \\\"\\n \\\"The next step is the registration itself. This involves \\\"\\n \\\"the simultaneous registration of e.g. GM with GM, \\\"\\n \\\"WM with WM and 1-(GM+WM) with 1-(GM+WM) (when needed, the\\\"\\n \\\" 1- (GM+WM) class is generated implicitly, so there \\\"\\n \\\"is no need to include this class yourself). This \\\"\\n \\\"procedure begins by creating a mean of all the images, \\\"\\n \\\"which is used as an initial template. Deformations \\\"\\n \\\"from this template to each of the individual images \\\"\\n \\\"are computed, and the template is then re-generated\\\"\\n \\\" by applying the inverses of the deformations to \\\"\\n \\\"the images and averaging. This procedure is repeated a \\\"\\n \\\"number of times. Finally, warped \\\"\\n \\\"versions of the images (or other images that are in \\\"\\n \\\"alignment with them) can be generated. \\\"\\n \\\"</li>\\\") % DARTEL_URL\\n\\n # get caller module handle from stack-frame\\n user_script_name = sys.argv[0]\\n user_source_code = base_reporter.get_module_source_code(\\n user_script_name)\\n\\n preproc_undergone = \\\"\\\"\\\"\\\\\\n <p>All preprocessing has been done using the <i>%s</i> script of\\n <a href=\\\"%s\\\">pypreprocess</a>, which is powered by\\n <a href=\\\"%s\\\">nipype</a>, and <a href=\\\"%s\\\">SPM8</a>.\\n </p>\\\"\\\"\\\" % (user_script_name, PYPREPROCESS_URL,\\n NIPYPE_URL, SPM8_URL)\\n\\n preproc_undergone += \\\"<ul>\\\"\\n\\n preproc_undergone += additional_preproc_undergone + \\\"</ul>\\\"\\n\\n kwargs['additional_preproc_undergone'] = additional_preproc_undergone\\n\\n # generate html report (for QA) as desired\\n parent_results_gallery = None\\n if do_report:\\n # copy css and js stuff to output dir\\n for js_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\\n \\\"js/*.js\\\")):\\n shutil.copy(js_file, output_dir)\\n for css_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\\n \\\"css/*.css\\\")):\\n shutil.copy(css_file, output_dir)\\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\\n \\\"icons/*.gif\\\")):\\n shutil.copy(icon_file, output_dir)\\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\\n \\\"images/*.png\\\")):\\n shutil.copy(icon_file, output_dir)\\n for icon_file in glob.glob(os.path.join(base_reporter.ROOT_DIR,\\n \\\"images/*.jpeg\\\")):\\n shutil.copy(icon_file, output_dir)\\n\\n report_log_filename = os.path.join(\\n output_dir, 'report_log.html')\\n report_preproc_filename = os.path.join(\\n output_dir, 'report_preproc.html')\\n report_filename = os.path.join(\\n output_dir, 'report.html')\\n\\n # scrape this function's arguments\\n preproc_params = \\\"\\\"\\n frame = inspect.currentframe()\\n args, _, _, values = inspect.getargvalues(frame)\\n preproc_func_name = inspect.getframeinfo(frame)[2]\\n preproc_params += (\\\"Function <i>%s(...)</i> was invoked by the script\\\"\\n \\\" <i>%s</i> with the following arguments:\\\"\\n ) % (preproc_func_name,\\n user_script_name)\\n preproc_params += base_reporter.dict_to_html_ul(\\n dict((arg, values[arg]) for arg in args if not arg in [\\n \\\"dataset_description\\\",\\n \\\"report_filename\\\",\\n \\\"do_report\\\",\\n \\\"do_cv_tc\\\",\\n \\\"do_export_report\\\",\\n \\\"do_shutdown_reloaders\\\",\\n \\\"subjects\\\",\\n # add other args to exclude below\\n ]\\n ))\\n\\n # initialize results gallery\\n loader_filename = os.path.join(\\n output_dir, \\\"results_loader.php\\\")\\n parent_results_gallery = base_reporter.ResultsGallery(\\n loader_filename=loader_filename,\\n refresh_timeout=30,\\n )\\n\\n # initialize progress bar\\n progress_logger = base_reporter.ProgressReport(\\n report_log_filename,\\n other_watched_files=[report_filename,\\n report_preproc_filename])\\n\\n # html markup\\n log = base_reporter.get_dataset_report_log_html_template(\\n ).substitute(\\n start_time=time.ctime(),\\n )\\n\\n preproc = base_reporter.get_dataset_report_preproc_html_template(\\n ).substitute(\\n results=parent_results_gallery,\\n start_time=time.ctime(),\\n preproc_undergone=preproc_undergone,\\n dataset_description=dataset_description,\\n source_code=user_source_code,\\n source_script_name=user_script_name,\\n preproc_params=preproc_params,\\n )\\n\\n main_html = base_reporter.get_dataset_report_html_template(\\n ).substitute(\\n results=parent_results_gallery,\\n start_time=time.ctime(),\\n dataset_id=dataset_id,\\n )\\n\\n with open(report_log_filename, 'w') as fd:\\n fd.write(str(log))\\n fd.close()\\n with open(report_preproc_filename, 'w') as fd:\\n fd.write(str(preproc))\\n fd.close()\\n with open(report_filename, 'w') as fd:\\n fd.write(str(main_html))\\n fd.close()\\n\\n def finalize_report():\\n progress_logger.finish(report_preproc_filename)\\n\\n if do_shutdown_reloaders:\\n progress_logger.finish_all()\\n\\n kwargs['parent_results_gallery'] = parent_results_gallery\\n\\n results = joblib.Parallel(\\n n_jobs=n_jobs,\\n pre_dispatch='1.5*n_jobs', # for scalability over RAM\\n verbose=100)(joblib.delayed(\\n _do_subject_preproc)(\\n subject_data, **kwargs) for subject_data in subjects)\\n\\n if do_dartel:\\n # collect subject_ids and session_ids\\n subject_ids = [output['subject_id'] for _, output in results]\\n session_ids = [output['session_id'] for _, output in results]\\n _preproc_undergone = dict((output['subject_id'],\\n output['preproc_undergone'])\\n for _, output in results)\\n # collect estimated motion\\n if do_realign:\\n estimated_motion = dict((output[\\\"subject_id\\\"],\\n output['estimated_motion'])\\n for _, output in results)\\n\\n # collect structural files for DARTEL pipeline\\n if do_coreg:\\n structural_files = [\\n output['coreg_result'].outputs.coregistered_source\\n for _, output in results]\\n else:\\n structural_files = [\\n subject_data.anat for subject_data, _ in results]\\n\\n # collect functional files for DARTEL pipeline\\n if do_realign:\\n functional_files = [\\n output['realign_result'].outputs.realigned_files\\n for _, output in results]\\n else:\\n functional_files = [output['func'] for _, output in results]\\n\\n # collect subject output dirs\\n subject_output_dirs = [output['output_dir'] for _, output in results]\\n\\n # collect gallery related subject-specific stuff\\n subject_final_thumbs = None\\n subject_results_galleries = None\\n subject_progress_loggers = None\\n\\n if do_report:\\n subject_final_thumbs = [output['final_thumbnail']\\n for _, output in results]\\n subject_results_galleries = [output['results_gallery']\\n for _, output in results]\\n subject_progress_loggers = [output['progress_logger']\\n for _, output in results]\\n if do_realign:\\n estimated_motion = dict((output[\\\"subject_id\\\"],\\n output['estimated_motion'])\\n for _, output in results)\\n\\n # normalize brains to their own template space (DARTEL)\\n results, newsegment_result = do_group_DARTEL(\\n output_dir,\\n subject_ids,\\n session_ids,\\n structural_files,\\n functional_files,\\n fwhm=fwhm,\\n subject_output_dirs=subject_output_dirs,\\n do_report=do_report,\\n do_cv_tc=do_cv_tc,\\n subject_final_thumbs=subject_final_thumbs,\\n subject_results_galleries=subject_results_galleries,\\n subject_progress_loggers=subject_progress_loggers,\\n parent_results_gallery=parent_results_gallery,\\n ignore_exception=ignore_exception,\\n )\\n\\n # collect results\\n _results = []\\n\\n if results:\\n for item in results:\\n if item:\\n subject_result = {}\\n subject_result['preproc_undergone'] = _preproc_undergone[\\n item['subject_id']]\\n subject_result['subject_id'] = item['subject_id']\\n\\n # output final fmri and anat image filenames\\n subject_result['func'] = item['func']\\n subject_result['anat'] = item['anat']\\n\\n # output segmented GM compartment\\n subject_result['gm'] = item['gm']\\n\\n # output segmented WM compartment\\n subject_result['wm'] = item['wm']\\n\\n # output motion parameters\\n if do_realign:\\n subject_result['estimated_motion'] = estimated_motion[\\n item['subject_id']]\\n subject_result['output_dir'] = item['output_dir']\\n\\n json_output_filename = os.path.join(\\n subject_result['output_dir'], 'infos_DARTEL.json')\\n json.dump(subject_result, open(json_output_filename, 'wb'))\\n\\n if do_report:\\n subject_result['progress_logger'] = item[\\n 'progress_logger']\\n\\n if do_shutdown_reloaders:\\n subject_result['progress_logger'].finish_all()\\n\\n _results.append(subject_result)\\n\\n results = _results\\n else:\\n # collect results\\n _results = []\\n\\n if results:\\n for x in results:\\n if x is None:\\n continue\\n else:\\n item = x[1]\\n subject_result = {}\\n subject_result['preproc_undergone'] = item['preproc_undergone']\\n subject_result['subject_id'] = item['subject_id']\\n subject_result['func'] = item['func']\\n if 'anat' in item.keys():\\n subject_result['anat'] = item['anat']\\n if do_coreg:\\n subject_result['coregistered_anat'] = item[\\n 'coregistered_anat']\\n if do_realign:\\n subject_result['estimated_motion'] = item[\\n 'estimated_motion']\\n subject_result['realigned_func'] = item['realigned_func']\\n\\n subject_result['output_dir'] = item['output_dir']\\n\\n json_output_filename = os.path.join(\\n subject_result['output_dir'], 'infos.json')\\n json.dump(subject_result, open(json_output_filename, 'wb'))\\n\\n if do_report:\\n subject_result['progress_logger'] = item['progress_logger']\\n\\n if do_shutdown_reloaders:\\n subject_result['progress_logger'].finish_all()\\n\\n _results.append(subject_result)\\n\\n results = _results\\n\\n if do_report:\\n finalize_report()\\n\\n print \\\"HTML report (dynamic) written to %s\\\" % report_filename\\n\\n # export report (so it can be emailed and QA'ed offline, for example)\\n if do_report:\\n if do_export_report:\\n if do_dartel:\\n tag = \\\"DARTEL_workflow\\\"\\n else:\\n tag = \\\"standard_workflow\\\"\\n preproc_reporter.export_report(os.path.dirname(report_filename),\\n tag=tag)\\n\\n return results\",\n \"def loadMotorResponses(subj,hand='Right'):\\n \\n hands = {'Left':[0,1],'Right':[2,3]}\\n\\n x = tgp.loadTaskTiming(subj,'ALL')\\n stimIndex = np.asarray(x['stimIndex'])\\n ind = np.where(stimIndex=='motorResponse')[0]\\n \\n datadir = projectdir + 'data/postProcessing/hcpPostProcCiric/'\\n h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')\\n data = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()\\n data = data[:,ind].copy()\\n h5f.close()\\n \\n # Isolate hand responses\\n hand_ind = hands[hand]\\n tmpdat = np.zeros((data.shape[0],2))\\n if hand=='Right':\\n #tmpdat[:,0] = data[:,3] #rmid -- need to flip this once glm is re-run -- check the new reffunc\\n tmpdat[:,0] = np.real(data[:,2]) \\n tmpdat[:,1] = np.real(data[:,3]) \\n elif hand=='Left':\\n tmpdat[:,0] = np.real(data[:,0]) #lmid\\n tmpdat[:,1] = np.real(data[:,1]) #lind\\n data = tmpdat.copy()\\n\\n return data\",\n \"def infer():\\n\\n # Create StreamManagerApi object\\n stream_manager_api = StreamManagerApi()\\n # Use InitManager method init StreamManagerApi\\n ret = stream_manager_api.InitManager()\\n if ret != 0:\\n print(\\\"Failed to init Stream manager, ret=%s\\\" % str(ret))\\n exit()\\n\\n # create streams by pipeline config file\\n with open(args.pipeline_path, \\\"rb\\\") as f:\\n pipeline_str = f.read()\\n\\n # Configuring a stream\\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\\n if ret != 0:\\n print(\\\"Failed to create Stream, ret=%s\\\" % str(ret))\\n exit()\\n\\n # Construct the input of the stream\\n data_input = MxDataInput()\\n # Stream_name encoded in UTF-8\\n stream_name = args.stream_name.encode()\\n print(stream_name)\\n predictions = []\\n with open(args.label_path, 'rt') as f:\\n val_cls = f.read().rstrip(\\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(args.instances_path)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n for file_name in os.listdir(args.img_path):\\n pred_data = []\\n # Gets the Address of each image\\n img_id = int(file_name.split('.')[0])\\n file_path = args.img_path + file_name\\n size = (cv2.imread(file_path)).shape\\n\\n # Read each photo in turn\\n with open(file_path, \\\"rb\\\") as f:\\n img_data = f.read()\\n if not img_data:\\n print(f\\\"read empty data from img:{file_name}\\\")\\n continue\\n # The element value img_data\\n data_input.data = img_data\\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\\n pred_data.append({\\\"boxes\\\": boxes_output,\\n \\\"box_scores\\\": scores_output,\\n \\\"img_id\\\": img_id,\\n \\\"image_shape\\\": size})\\n\\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\\n print(f\\\"Inferred image:{file_name} success!\\\")\\n\\n # Save the result in JSON format\\n if not os.path.exists(args.res_path):\\n os.makedirs(args.res_path)\\n with open(args.res_path + 'predictions_test.json', 'w') as f:\\n json.dump(predictions, f)\\n stream_manager_api.DestroyAllStreams()\",\n \"def apply_manual_codes(cls, user, data, coda_input_dir):\\n for plan in PipelineConfiguration.TEST_SHOWS_CODING_PLANS:\\n test_pipeline_messages = [td for td in data if plan.raw_field in td]\\n coda_input_path = path.join(coda_input_dir, plan.coda_filename)\\n\\n f = None\\n try:\\n if path.exists(coda_input_path):\\n f = open(coda_input_path, 'r')\\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable_multi_coded(\\n user, test_pipeline_messages, plan.id_field, {plan.coded_field: plan.code_scheme}, f)\\n\\n if plan.binary_code_scheme is not None:\\n if f is not None:\\n f.seek(0)\\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable(\\n user, test_pipeline_messages, plan.id_field, {plan.binary_coded_field:plan.binary_code_scheme}, f)\\n finally:\\n if f is not None:\\n f.close()\\n\\n # Merge manually coded survey files into cleaned dataset\\n for plan in PipelineConfiguration.SURVEY_CODING_PLANS:\\n f = None\\n try:\\n coda_input_path = path.join(coda_input_dir, plan.coda_filename)\\n if path.exists(coda_input_path):\\n f = open(coda_input_path, 'r')\\n TracedDataCodaV2IO.import_coda_2_to_traced_data_iterable(\\n user, data, plan.id_field, {plan.coded_field: plan.code_scheme}, f)\\n finally:\\n if f is not None:\\n f.close()\\n \\n return data\",\n \"def bio_classification_report(y_true, y_pred):\\n lb = LabelBinarizer()\\n y_true_combined = lb.fit_transform(list(chain.from_iterable(y_true)))\\n y_pred_combined = lb.transform(list(chain.from_iterable(y_pred)))\\n \\n tagset = set(lb.classes_) #- {'O'}\\n tagset = sorted(tagset, key=lambda tag: tag.split('-', 1)[::-1])\\n class_indices = {cls: idx for idx, cls in enumerate(lb.classes_)}\\n \\n return classification_report(\\n y_true_combined,\\n y_pred_combined,\\n labels = [class_indices[cls] for cls in tagset],\\n target_names = tagset,\\n )\",\n \"def perform_Surrogate_Prediction(next_gen_conc,\\n conc_array_actual,\\n spectra_array_actual):\\n gpr = GaussianProcessRegressor().fit(\\n conc_array_actual, spectra_array_actual)\\n score = gpr.score(conc_array_actual,\\n spectra_array_actual)\\n spectra_prediction = gpr.predict(next_gen_conc)\\n return spectra_prediction, score\",\n \"def _decode_step(self, states: List[ModelState]) -> Tuple[mx.nd.NDArray, mx.nd.NDArray, List[ModelState]]:\\n model_probs, model_attention_probs, model_states = [], [], []\\n for model, state in zip(self.models, states):\\n probs, attention_probs, state = model.run_decoder(state)\\n model_probs.append(probs)\\n model_attention_probs.append(attention_probs)\\n model_states.append(state)\\n probs, attention_probs = self._combine_predictions(model_probs, model_attention_probs)\\n return probs, attention_probs, model_states\",\n \"def test_decoding_batch(self):\\r\\n\\r\\n # Data path\\r\\n cur_dir = os.path.abspath(os.path.join(os.path.realpath(__file__), '..'))\\r\\n img_path = os.path.join(cur_dir, 'resources', 'input_decode')\\r\\n img_names = os.listdir(img_path)\\r\\n for img_name in img_names:\\r\\n\\r\\n img_qr_patch = cv2.imread(img_path+'/'+img_name)\\r\\n\\r\\n displays1((img_qr_patch,))\\r\\n decode_result = decode_one(img_qr_patch)\\r\\n print(decode_result)\",\n \"def decode(self, output_dict: Dict[str, Any]) -> Dict[str, Any]:\\n\\n # If the predictions are already decoded, skip the step\\n if 'relex_predictions' in output_dict:\\n return output_dict\\n\\n output_dict: Dict[str, Any] = super().decode(output_dict)\\n batch_relex_predictions = self._decode_relex_predictions(output_dict)\\n output_dict['relex_predictions'] = batch_relex_predictions\\n\\n batch_clusters: List[List[List[Tuple[int, int]]]] = output_dict['clusters']\\n batch_flat_tokens: List[List[Token]] = output_dict['flat_tokens']\\n batch_flat_text: List[str] = output_dict['flat_text']\\n\\n batch_updates = defaultdict(list)\\n for (clusters, relations,\\n flat_tokens, flat_text) in zip(batch_clusters, batch_relex_predictions,\\n batch_flat_tokens, batch_flat_text):\\n updates = self._decode_sample(clusters, relations,\\n flat_tokens, flat_text)\\n for key, value in updates.items():\\n batch_updates[key].append(value)\\n\\n output_dict.update(batch_updates)\\n return output_dict\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def test_dict():\\n print(\\\"DictClassifier\\\")\\n print(\\\"---\\\" * 45)\\n\\n from spa.classifiers import DictClassifier\\n\\n ds = DictClassifier()\\n\\n # 对一个单句进行情感分析\\n #a_sentence = \\\"剁椒鸡蛋好咸,土豆丝很好吃\\\" # result值: 修改前(1)/修改后(1)\\n #a_sentence = \\\"要是米饭再多点儿就好了\\\" # result值: 修改前(1)/修改后(0)\\n #a_sentence = \\\"要是米饭再多点儿就更好了\\\" # result值: 修改前(0)/修改后(0)\\n # a_sentence = \\\"不太好吃，相当难吃，要是米饭再多点儿就好了\\\" # result值: 修改前(1)/修改后(0)\\n #result = ds.analyse_sentence(a_sentence)\\n #print(result)\\n\\n # 对一个文件内语料进行情感分析\\n count = 6001\\n flag = 0\\n corpus_filepath = \\\"fileInput/jdnew1.txt\\\"\\n for i in range(0,3000):\\n count += 1\\n if count%300 == 0:\\n print(count)\\n flag += 1\\n runout_filepath_ = \\\"f_runout/relsultAppleMac%s.txt\\\" % flag\\n pos_results = ds.analysis_file(corpus_filepath, runout_filepath_, start=count, end=count+300)\\n #\\n # corpus_filepath = \\\"D:/My Data/NLP/SA/waimai/negative_corpus_v1.txt\\\"\\n # runout_filepath_ = \\\"f_runout/f_dict-negative_test.txt\\\"\\n # neg_results = ds.analysis_file(corpus_filepath, runout_filepath_, start=3000, end=4000-1)\\n #\\n # origin_labels = [1] * 1000 + [0] * 1000\\n # classify_labels = pos_results + neg_results\\n #\\n # print(len(classify_labels))\\n #\\n # filepath = \\\"f_runout/Dict-waimai-%s.xls\\\" % (\\n # datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n # results = get_accuracy(origin_labels, classify_labels, [1000, 1000, 0])\\n #\\n # Write2File.write_contents(filepath, results)\",\n \"def classify(self, data):\\n abstract\",\n \"def inference(self, data_loader):\\n\\n # Handling inference for Multiclass classification\\n outputs_list = []\\n with torch.no_grad():\\n for bi, d in enumerate(data_loader):\\n ids = d['ids']\\n mask = d['mask']\\n\\n # send them to the cpu\\n ids = ids.to(self.device, dtype=torch.long)\\n mask = mask.to(self.device, dtype=torch.long)\\n\\n outputs = self.model(\\n input_ids=ids,\\n attention_mask=mask\\n )\\n outputs_list.extend(torch.softmax(outputs, dim=1).cpu().detach().numpy().tolist())\\n\\n print(\\\"This the output from the Multiclass classification model\\\", outputs_list[0])\\n\\n inferences = np.argmax(outputs_list, axis=1)\\n inferences = [self.mapping[str(pred)] for pred in inferences]\\n\\n return inferences\",\n \"def decode_center(self,\\n pred_dict, img_metas,\\n K=50, score_threshold=0.25):\\n\\n fmap = pred_dict['cls_preds']\\n\\n dim_pred = pred_dict['dim_preds']\\n xy_pred = pred_dict['xy_preds']\\n z_pred = pred_dict['z_preds']\\n dir_pred = pred_dict['dir_preds']\\n batch, channel, height, width = fmap.shape\\n\\n # assert batch == 1, \\\"only batch size 1 is supported\\\"\\n\\n # image_ids = example['image_idx']\\n\\n fmap = self.pseudo_nms(fmap)\\n\\n scores, index, clses, ys, xs = self.topk_score(fmap, K=K)\\n\\n xy_pred = gather_feature(xy_pred, index, use_transform=True)\\n xy_pred = xy_pred.reshape(batch, K, 2)\\n xs = xs.view(batch, K, 1) + xy_pred[:, :, 0:1]\\n ys = ys.view(batch, K, 1) + xy_pred[:, :, 1:2]\\n xs = xs * self.downsample_ratio * self.voxel_size[0] + self.pc_range[0]\\n ys = ys * self.downsample_ratio* self.voxel_size[1] + self.pc_range[1]\\n\\n z_pred = gather_feature(z_pred, index, use_transform=True)\\n zs = z_pred\\n\\n dim_pred = gather_feature(dim_pred, index, use_transform=True)\\n dim_pred = dim_pred.reshape(batch, K, 3)\\n\\n clses_batch = clses.reshape(batch, K).float().detach()\\n scores_batch = scores.reshape(batch, K).detach()\\n\\n dir_pred = gather_feature(dir_pred, index, use_transform=True)\\n if self.num_rad_bin<=0:\\n dir_pred = torch.atan2(dir_pred[:, :, 0], dir_pred[:, :, 1])\\n dir_pred = dir_pred.reshape(batch, K, 1)\\n\\n else:\\n dir_bin = torch.argmax(dir_pred[:, :, :self.num_rad_bin], dim=-1)\\n dir_res_norm = torch.gather(dir_pred[:, :, self.num_rad_bin:], dim=-1,\\n index=dir_bin.unsqueeze(dim=-1)).squeeze(dim=-1)\\n angle_per_class = (2 * np.pi) / self.num_rad_bin\\n dir_res = dir_res_norm * (angle_per_class / 2)\\n dir_pred = (dir_bin.float() * angle_per_class + dir_res)% (2 * np.pi)\\n dir_pred[dir_pred > np.pi] -= 2 * np.pi\\n dir_pred+=np.pi\\n dir_pred = dir_pred.reshape(batch, K, 1)\\n\\n bboxes_batch = torch.cat([xs, ys, zs, dim_pred, dir_pred], dim=-1).detach()\\n\\n detections=[]\\n for clses,scores, bboxes,img_meta in zip(clses_batch,scores_batch, bboxes_batch,img_metas):\\n keep = scores > score_threshold\\n scores = scores[keep]\\n clses = clses[keep]\\n bboxes = bboxes[keep]\\n bboxes = img_meta['box_type_3d'](bboxes, box_dim=7)\\n detection = (bboxes, scores, clses, img_meta)\\n detections.append(detection)\\n\\n return detections\",\n \"def __train__(self):\\n if (self.type_camf == 'CAMF_CI'):\\n #users, items, context, ratings\\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = ci.fit()\\n elif (self.type_camf == 'CAMF_CU'):\\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = cu.fit()\\n elif (self.type_camf == 'CAMF_C'):\\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = c.fit()\\n\\n dummy_pred = np.zeros((predictions.shape))\\n for r, pred_array in enumerate(predictions):\\n for c, pred in enumerate(pred_array):\\n dummy_pred[r][c] = self.__check_ratings__(pred)\\n predictions = dummy_pred\\n #save a plot with a loss function\\n plots = prs.PlotRSData()\\n #print(losses)\\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\\\"_loop\\\"+str(self.loop))\\n pd.DataFrame(losses).to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ +\\\"losses_loop\\\"+str(self.loop)+\\\".csv\\\")\\n print('Saving the feature matrix...')\\n # set predictions back to the pivot table\\n self.__utility_saved_training__(predictions) \\n # save results\\n self.utility_predictions.to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ + \\\"_SGD_predictions_loop\\\"+str(self.loop)+\\\".csv\\\")\",\n \"def bio_classification_report(y_true, y_pred):\\n lb = LabelBinarizer()\\n y_true_combined = lb.fit_transform(list(chain.from_iterable(y_true)))\\n y_pred_combined = lb.transform(list(chain.from_iterable(y_pred)))\\n\\n tagset = set(lb.classes_) - {'O'}\\n #tagset = set(lb.classes_)\\n tagset = sorted(tagset, key=lambda tag: tag.split('-', 1)[::-1])\\n class_indices = {cls: idx for idx, cls in enumerate(lb.classes_)}\\n\\n return classification_report(\\n y_true_combined,\\n y_pred_combined,\\n labels = [class_indices[cls] for cls in tagset],\\n target_names = tagset,\\n )\",\n \"def fetch_compas_df(preprocess=False):\\n (train_X, train_y), (test_X, test_y) = lale.datasets.openml.fetch(\\n \\\"compas\\\", \\\"classification\\\", astype=\\\"pandas\\\", preprocess=False\\n )\\n orig_X = pd.concat([train_X, test_X]).sort_index().astype(np.float64)\\n orig_y = pd.concat([train_y, test_y]).sort_index().astype(np.float64)\\n if preprocess:\\n race = pd.Series(orig_X[\\\"race_caucasian\\\"] == 1, dtype=np.float64)\\n dropped_X = orig_X.drop(\\n labels=[\\\"race_african-american\\\", \\\"race_caucasian\\\"], axis=1\\n )\\n encoded_X = dropped_X.assign(race=race)\\n fairness_info = {\\n \\\"favorable_labels\\\": [1],\\n \\\"protected_attributes\\\": [\\n {\\\"feature\\\": \\\"sex\\\", \\\"reference_group\\\": [1]},\\n {\\\"feature\\\": \\\"race\\\", \\\"reference_group\\\": [1]},\\n ],\\n }\\n return encoded_X, orig_y, fairness_info\\n else:\\n fairness_info = {\\n \\\"favorable_labels\\\": [1],\\n \\\"protected_attributes\\\": [\\n {\\\"feature\\\": \\\"sex\\\", \\\"reference_group\\\": [1]},\\n {\\\"feature\\\": \\\"race_caucasian\\\", \\\"reference_group\\\": [1]},\\n ],\\n }\\n return orig_X, orig_y, fairness_info\",\n \"def _classification(text_path_list, id_list, label_list):\\n textnum = len(text_path_list)\\n batched_num = ((textnum - 1) // classify.BATCH_SIZE + 1) * classify.BATCH_SIZE\\n for i in range(batched_num - textnum):\\n text_path_list.append(text_path_list[0])\\n id_list.append(id_list[0])\\n annotations = classify_obj.inference(text_path_list, id_list, label_list) #\\n return annotations[0:textnum]\",\n \"def model(self, conjectures, axioms):\\n with self.graph.as_default():\\n conjecture_embeddings = self.conjecture_embedding(conjectures)\\n axiom_embeddings = self.axiom_embedding(axioms)\\n predictions = self.classifier(conjecture_embeddings, axiom_embeddings)\\n return predictions\",\n \"def predict():\\n\\n\\n json_payload = request.json\\n #LOG.info(f\\\"JSON payload: %s\\\" %json_payload)\\n inference_payload = pd.DataFrame(json_payload)\\n #LOG.info(\\\"inference payload DataFrame: %s\\\" %inference_payload)\\n scaled_payload = scale(inference_payload)\\n prediction = list(clf.predict(scaled_payload))\\n return jsonify({'prediction': prediction})\",\n \"def extract_features_cue(sentence_dicts, cue_lexicon, affixal_cue_lexicon, mode='training'):\\n instances = []\\n for sent in sentence_dicts:\\n # print(sent)\\n for key, value in sent.items():\\n features = {}\\n if isinstance(key, int):\\n if not_known_cue_word(value[3].lower(), cue_lexicon, affixal_cue_lexicon):\\n sent[key]['not-pred-cue'] = True\\n continue\\n\\n features['token'] = value[3].lower()\\n features['lemma'] = value[4].lower()\\n features['pos'] = value[5]\\n\\n if key == 0:\\n features['bw-bigram1'] = 'null'\\n else:\\n features['bw-bigram1'] = \\\"%s_*\\\" %sent[key-1][4].lower()\\n if not (key+1) in sent:\\n features['fw-bigram1'] = 'null'\\n else:\\n features['fw-bigram1'] = \\\"*_%s\\\" %sent[key+1][4].lower()\\n \\n affix = get_affix_cue(value[3].lower(), affixal_cue_lexicon)\\n if affix != None:\\n base = value[3].lower().replace(affix, \\\"\\\")\\n features['char-5gram1'], features['char-5gram2'] = get_character_ngrams(base, affix, 5)\\n features['char-4gram1'], features['char-4gram2'] = get_character_ngrams(base, affix, 4)\\n features['char-3gram1'], features['char-3gram2'] = get_character_ngrams(base, affix, 3)\\n features['char-2gram1'], features['char-2gram2'] = get_character_ngrams(base, affix, 2)\\n features['char-1gram1'], features['char-1gram2'] = get_character_ngrams(base, affix, 1)\\n features['affix'] = affix\\n else:\\n features['char-5gram1'], features['char-5gram2'] = 'null','null'\\n features['char-4gram1'], features['char-4gram2'] = 'null','null'\\n features['char-3gram1'], features['char-3gram2'] = 'null','null'\\n features['char-2gram1'], features['char-2gram2'] = 'null','null'\\n features['char-1gram1'], features['char-1gram2'] = 'null','null'\\n features['affix'] = 'null'\\n \\n instances.append(features)\\n if mode == 'training':\\n labels = extract_labels_cue(sentence_dicts, cue_lexicon, affixal_cue_lexicon)\\n return sentence_dicts, instances, labels\\n return sentence_dicts, instances\",\n \"def _run_unlabelled_extraction(self, dataset_type: DatasetType, device: str) -> None:\\n dataset = self.image_datasets.get_dataset(dataset_type)\\n self.extractor_model = self.extractor_model.to(device)\\n\\n for image, file_id in tqdm(\\n dataset, desc=\\\"Extracting features - competition\\\",\\n ):\\n feature_tensor = self.extractor_model(image.unsqueeze(0).to(device))\\n self._save_tensor(DatasetType.Competition, feature_tensor, file_id)\",\n \"def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\\n assert step in ['train', 'test']\\n binary = False \\n undersample_majority = False\\n\\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\\n if data_type == 'ct':\\n data_r = pd.read_excel(paths[0])\\n else:\\n data_r = pd.read_excel(paths[1])\\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\\n\\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \\n\\n if data_subtype == 'primary':\\n data = data_p\\n y = y_p -1\\n else:\\n data = data_n\\n y = y_n -1\\n\\n if binary:\\n y[y<2]=0\\n y[y>0]=1\\n\\n y_dist = [np.sum(y==x) for x in np.unique(y)]\\n print(\\\"Distribution of all labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\\n\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if step =='train':\\n if use_syntetic_data:\\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\\n\\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\\n train_text = np.concatenate((train_text,test_text))\\n y_train = np.concatenate((y_train,y_test))\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels after inserting syntetic data: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if not undersample_majority:\\n data_to_use = train_text.copy()\\n y_to_use = y_train.copy()\\n else:\\n max_label1 = 1000\\n data_to_use = []\\n y_to_use = []\\n y1=0\\n for x in range(len(y_train)):\\n if y_train[x] !=1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n else:\\n if y1 <max_label1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n y1+=1\\n\\n else:\\n data_to_use = test_text.copy()\\n y_to_use = y_test.copy()\\n\\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\\n examples = []\\n\\n for i, tokens in tqdm(enumerate(data_to_use)):\\n label = y_to_use[i]\\n examples.append(\\n ClassificationExample(\\n id=i,\\n tokens_a=basic_tokenizer.tokenize(tokens),\\n tokens_b=None,\\n label=label,\\n )\\n )\\n logging.info('Number of `%s` examples: %d', step, len(examples))\\n \\n return examples\",\n \"def test_http_classifier(self):\\n \\n msg = \\\"\\\"\\n \\n files = 0\\n tp = 0\\n fp = 0\\n tn = 0\\n fn = 0\\n\\n self.addr = \\\"http://\\\" + self.Helpers.confs[\\\"cnn\\\"][\\\"api\\\"][\\\"server\\\"] + \\\\\\n ':'+str(self.Helpers.confs[\\\"cnn\\\"][\\\"api\\\"][\\\"port\\\"]) + '/Inference'\\n self.headers = {'content-type': 'image/jpeg'}\\n\\n for data in os.listdir(self.testing_dir):\\n if os.path.splitext(data)[1] in self.valid:\\n \\n response = self.send_request(self.testing_dir + \\\"/\\\" + data)\\n\\n msg = \\\"\\\"\\n if response[\\\"Diagnosis\\\"] == \\\"Positive\\\" and \\\"_1.\\\" in data:\\n tp += 1\\n msg = \\\"Acute Lymphoblastic Leukemia correctly detected (True Positive)\\\"\\n elif response[\\\"Diagnosis\\\"] == \\\"Positive\\\" and \\\"_0.\\\" in data:\\n fp += 1\\n msg = \\\"Acute Lymphoblastic Leukemia incorrectly detected (False Positive)\\\"\\n elif response[\\\"Diagnosis\\\"] == \\\"Negative\\\" and \\\"_0.\\\" in data:\\n tn += 1\\n msg = \\\"Acute Lymphoblastic Leukemia correctly not detected (True Negative)\\\"\\n elif response[\\\"Diagnosis\\\"] == \\\"Negative\\\" and \\\"_1.\\\" in data:\\n fn += 1\\n msg = \\\"Acute Lymphoblastic Leukemia incorrectly not detected (False Negative)\\\" \\n \\n files += 1\\n \\n self.Helpers.logger.info(msg)\\n print()\\n time.sleep(7)\\n \\n self.Helpers.logger.info(\\\"Images Classifier: \\\" + str(files))\\n self.Helpers.logger.info(\\\"True Positives: \\\" + str(tp))\\n self.Helpers.logger.info(\\\"False Positives: \\\" + str(fp))\\n self.Helpers.logger.info(\\\"True Negatives: \\\" + str(tn))\\n self.Helpers.logger.info(\\\"False Negatives: \\\" + str(fn))\",\n \"def launch(self, data, classifiers, output_dir, plot, cv):\\n\\t\\tself.logger.info('Encoding data...')\\n\\t\\tencode_data, labels, classes, predicted_labels, le = ML.encode(data)\\n\\t\\tresults_proba, dict_y_test, classifiers = self.stratifier(\\n\\t\\t\\tencode_data, labels, classifiers, cv, output_dir)\\n\\t\\tself.logger.info('Saving outputs...')\\n\\t\\tML.dump_models(classifiers, output_dir)\\n\\t\\tif plot is True:\\n\\t\\t\\tutils.mkdir(output_dir + \\\"/Plots\\\")\\n\\t\\t\\tself.logger.info('Saving plots and results...')\\n\\t\\t\\tvisualization.plot_roc_curve_training(\\n\\t\\t\\t\\tdict_y_test, results_proba, output_dir)\",\n \"def resp_to_pc(rec, pc_idx=None, resp_sig='resp', pc_sig='pca',\\n pc_count=None, pc_source='all', overwrite_resp=True,\\n compute_power='no',\\n whiten=True, **context):\\n rec0 = rec.copy()\\n resp = rec0[resp_sig]\\n\\n # compute duration of spont period\\n d = resp.get_epoch_bounds('PreStimSilence')\\n if len(d):\\n PreStimSilence = np.mean(np.diff(d))\\n else:\\n PreStimSilence = 0\\n prestimbins = int(PreStimSilence * resp.fs)\\n\\n # compute PCs only on valid (masked) times\\n rec0[resp_sig] = rec0[resp_sig].rasterize()\\n rec_masked = generate_psth_from_resp(rec0, resp_sig=resp_sig)\\n\\n if 'mask' in rec0.signals:\\n rec_masked = rec_masked.apply_mask()\\n\\n if pc_source=='all':\\n D_ref = rec_masked[resp_sig].as_continuous().T\\n elif pc_source=='psth':\\n D_ref = rec_masked['psth'].as_continuous().T\\n elif pc_source=='noise':\\n D_psth = rec_masked['psth'].as_continuous().T\\n D_raw = rec_masked[resp_sig].as_continuous().T\\n D_ref = D_raw - D_psth\\n else:\\n raise ValueError('pc_source {} not supported'.format(pc_source))\\n\\n # project full response dataset to preserve time\\n D = rec0[resp_sig].as_continuous().T\\n\\n if pc_count is None:\\n pc_count = D_ref.shape[1]\\n if pc_idx is None:\\n pc_idx=list(np.arange(pc_count))\\n elif type(pc_idx) is int:\\n pc_idx = [pc_idx]\\n\\n log.info(f\\\"PCA: inputs={D_ref.shape[1]}, source={pc_source}, pc_idx(es): {pc_idx}, whiten: {whiten}\\\")\\n\\n if False:\\n # use sklearn. maybe someday\\n pca = PCA(n_components=pc_count)\\n pca.fit(D_ref)\\n\\n X = pca.transform(D)\\n else:\\n # each row(??) of v is a PC --weights to project into PC domain\\n m = np.nanmean(D_ref, axis=0, keepdims=True)\\n if whiten:\\n sd = np.nanstd(D_ref, axis=0, keepdims=True)\\n else:\\n sd = np.ones(m.shape)\\n D_ref = D_ref[np.sum(np.isfinite(D_ref),axis=1)>0,:]\\n sd[sd==0]=1\\n D_ = (D_ref-m)/sd\\n\\n #import pdb;\\n #pdb.set_trace()\\n\\n # A = u @ np.diag(s) @ vh = (u * s) @ vh\\n u, s, v = np.linalg.svd(D_.T @ D_, full_matrices=False)\\n X = ((D-m) / sd) @ u\\n\\n rec0[pc_sig] = rec0[resp_sig]._modified_copy(X.T)\\n\\n r = rec0[pc_sig].extract_epoch('REFERENCE', mask=rec0['mask'])\\n mr = np.nanmean(r, axis=0)\\n if prestimbins>0:\\n spont = np.mean(mr[:,:prestimbins],axis=1,keepdims=True)\\n mr -= spont\\n vs = np.sign(np.sum(mr[:, prestimbins:(prestimbins+10)], axis=1, keepdims=True))\\n u *= vs\\n X = ((D-m) / sd) @ u\\n\\n if compute_power == 'single_trial':\\n smwin = 5\\n X = smooth(np.abs(X), smwin, axis=0)\\n X = X - X.mean(axis=0, keepdims=True)\\n\\n pc_chans = [f'PC{i}' for i in range(pc_count)]\\n rec0[pc_sig] = rec0[resp_sig]._modified_copy(X.T[np.arange(pc_count),:], chans=pc_chans)\\n\\n# r = rec0[pc_sig].extract_epoch('REFERENCE')\\n# mr=np.mean(r,axis=0)\\n# spont=np.mean(mr[:,:50],axis=1,keepdims=True)\\n# mr-=spont\\n# plt.figure()\\n# plt.plot(mr[:5,:].T)\\n# plt.legend(('1','2','3','4','5'))\\n\\n rec0.meta['pc_weights'] = u\\n rec0.meta['pc_mag'] = s\\n if overwrite_resp:\\n rec0[resp_sig] = rec0[resp_sig]._modified_copy(X[:, pc_idx].T, \\n chans=[pc_chans[c] for c in pc_idx])\\n rec0.meta['pc_idx'] = pc_idx\\n\\n return {'rec': rec0}\",\n \"def StageSubjects(self,X_test, Y_test, Xrange):\\r\\n\\r\\n # subject prediction\\r\\n pred_sub = []\\r\\n expectation_sub = []\\r\\n\\r\\n # distribution of trajectory samples\\r\\n sampling_dist = []\\r\\n\\r\\n for biomarker in range(self.nrBiomk):\\r\\n sampling_dist.append([])\\r\\n for i in range(500):\\r\\n s_omega, m_omega, s, m, sigma, l, eps = self.unpack_parameters(self.parameters[biomarker])\\r\\n perturbation_zero_W = np.random.randn(int(2 * self.N_rnd_features)).reshape(\\r\\n [2 * self.N_rnd_features, 1])\\r\\n perturbation_zero_Omega = np.random.randn(int(self.N_rnd_features))\\r\\n Omega = 1 / np.sqrt(np.exp(l)) * self.perturbation_Omega\\r\\n W = np.multiply(perturbation_zero_W, np.sqrt(np.exp(s))) + m\\r\\n output = self.basis(Xrange, np.exp(sigma), Omega)\\r\\n sampling_dist[biomarker].append(np.dot(output, W))\\r\\n\\r\\n for sub in range(len(X_test[0])):\\r\\n print(\\\"predicting sub: \\\", sub, \\\"out of \\\", len(X_test[0]))\\r\\n pred_sub.append([])\\r\\n expectation_sub.append([])\\r\\n for pos_index,position in enumerate(Xrange):\\r\\n pred_sub[sub].append(0)\\r\\n for biomarker in range(self.nrBiomk):\\r\\n Y_test_biom = np.array(Y_test[biomarker][sub]).reshape([len(Y_test[biomarker][sub]),1])\\r\\n X_test_biom = np.array(X_test[biomarker][sub]).reshape([len(X_test[biomarker][sub]),1])\\r\\n\\r\\n X_test_biom = (X_test_biom - self.mean_std_X[biomarker][0]) / self.mean_std_X[biomarker][1]\\r\\n X_test_biom = X_test_biom / self.max_X[biomarker]\\r\\n\\r\\n Y_test_biom = (Y_test_biom - self.mean_std_Y[biomarker][0]) / self.mean_std_Y[biomarker][1]\\r\\n Y_test_biom = Y_test_biom / self.max_Y[biomarker]\\r\\n\\r\\n if len(X_test_biom > 0):\\r\\n X_to_test = position + X_test_biom\\r\\n for i in range(500):\\r\\n current_sample = sampling_dist[biomarker][i][pos_index:(pos_index + len(Y_test_biom))]\\r\\n if (len(Y_test_biom) == len(current_sample)):\\r\\n pred_sub[sub][pos_index] = pred_sub[sub][pos_index] \\\\\\r\\n + np.sum((Y_test_biom - current_sample) ** 2)\\r\\n # - 0.5 * (np.log(2 * np.pi * np.exp(eps)) \\\\\\r\\n\\r\\n final_pred = []\\r\\n for sub in range(len(pred_sub)):\\r\\n invalid_indices = np.where(np.array(pred_sub[sub])==0)[0]\\r\\n # pred_sub[sub][pred_sub[sub] == 0] = 1e10\\r\\n # print('valid_indices', valid_indices, np.array(pred_sub[sub]).shape)\\r\\n # invalid_indices = np.logical_not(np.in1d(np.array(range(Xrange.shape[0])), valid_indices))\\r\\n # print(asds)\\r\\n # predictions = np.array(pred_sub[sub])[valid_indices]\\r\\n predictions = np.array(pred_sub[sub])\\r\\n final_pred.append([])\\r\\n final_pred[sub] = np.exp(-predictions/500)/ np.sum(np.exp(-predictions/500))\\r\\n final_pred[sub][invalid_indices] = 0\\r\\n final_pred[sub] /= np.sum(final_pred[sub])\\r\\n scaling = self.mean_std_X[biomarker][1]*self.max_X[biomarker]\\r\\n #expectation_sub[sub] = np.sum(final_pred[sub] * Xrange.flatten()[valid_indices]) * scaling + self.mean_std_X[biomarker][0]\\r\\n # expectation_sub[sub] = np.sum(final_pred[sub] * (Xrange.flatten()[valid_indices] * scaling + self.mean_std_X[biomarker][0]))\\r\\n expectation_sub[sub] = np.sum(final_pred[sub] * (Xrange.flatten() * scaling + self.mean_std_X[biomarker][0]))\\r\\n return final_pred, expectation_sub\",\n \"def predict(data, samples, classifier='SVM',\\r\\n classification='combined', selectFeatures=('CUK', 10)):\\r\\n if (classification == \\\"trained\\\"):\\r\\n classifyTrained = True\\r\\n classifySurface = False\\r\\n elif (classification == 'surface'):\\r\\n classifyTrained = False\\r\\n classifySurface = True\\r\\n else:\\r\\n classifyTrained = True\\r\\n classifySurface = True\\r\\n if (classifier == \\\"SVM\\\"):\\r\\n clf = cl.classifyDataSVM(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"DT\\\"):\\r\\n clf = cl.classifyDataDT(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"KNN\\\"):\\r\\n clf = cl.classifyDataKNN(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"LogReg\\\"):\\r\\n clf = cl.classifyDataLR(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n else:\\r\\n print (str(classifier) + \\\" is not a valid option\\\")\\r\\n \\r\\n [samples, _,_,_] = clf.extractData(samples,scaling=False)\\r\\n \\r\\n predictions = [clf.predict(s) for s in samples]\\r\\n return predictions\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59594476","0.59384817","0.5736482","0.5718673","0.56810707","0.5647129","0.56446636","0.5607695","0.5556696","0.55397236","0.55289805","0.5528581","0.55254686","0.55149966","0.548933","0.54383725","0.54022396","0.53819793","0.5377064","0.5372356","0.5364357","0.5353774","0.5322647","0.5320938","0.5318854","0.5312002","0.53105175","0.53028154","0.5302465","0.52671534","0.5264841","0.5261324","0.5252875","0.5248671","0.5247461","0.5238995","0.5234838","0.5234514","0.52317715","0.5220909","0.5216292","0.52117777","0.5208655","0.51884127","0.51855797","0.5183315","0.5169032","0.5168289","0.51667535","0.5166358","0.5154493","0.51524115","0.5151217","0.5137725","0.5130875","0.5127166","0.51209193","0.5113934","0.5107597","0.5106876","0.510676","0.510621","0.5105125","0.5104941","0.5103396","0.50999224","0.50999224","0.50994354","0.5091948","0.5090171","0.50840104","0.5082278","0.5081389","0.50579983","0.5053391","0.50494397","0.50456125","0.5043151","0.5039593","0.50395495","0.50395495","0.50395495","0.50375986","0.5035781","0.50336766","0.50324816","0.50312215","0.5027063","0.5022421","0.501751","0.50153935","0.5012444","0.50062054","0.50059","0.5005062","0.50039345","0.5002032","0.50019276","0.49987593","0.49973208"],"string":"[\n \"0.59594476\",\n \"0.59384817\",\n \"0.5736482\",\n \"0.5718673\",\n \"0.56810707\",\n \"0.5647129\",\n \"0.56446636\",\n \"0.5607695\",\n \"0.5556696\",\n \"0.55397236\",\n \"0.55289805\",\n \"0.5528581\",\n \"0.55254686\",\n \"0.55149966\",\n \"0.548933\",\n \"0.54383725\",\n \"0.54022396\",\n \"0.53819793\",\n \"0.5377064\",\n \"0.5372356\",\n \"0.5364357\",\n \"0.5353774\",\n \"0.5322647\",\n \"0.5320938\",\n \"0.5318854\",\n \"0.5312002\",\n \"0.53105175\",\n \"0.53028154\",\n \"0.5302465\",\n \"0.52671534\",\n \"0.5264841\",\n \"0.5261324\",\n \"0.5252875\",\n \"0.5248671\",\n \"0.5247461\",\n \"0.5238995\",\n \"0.5234838\",\n \"0.5234514\",\n \"0.52317715\",\n \"0.5220909\",\n \"0.5216292\",\n \"0.52117777\",\n \"0.5208655\",\n \"0.51884127\",\n \"0.51855797\",\n \"0.5183315\",\n \"0.5169032\",\n \"0.5168289\",\n \"0.51667535\",\n \"0.5166358\",\n \"0.5154493\",\n \"0.51524115\",\n \"0.5151217\",\n \"0.5137725\",\n \"0.5130875\",\n \"0.5127166\",\n \"0.51209193\",\n \"0.5113934\",\n \"0.5107597\",\n \"0.5106876\",\n \"0.510676\",\n \"0.510621\",\n \"0.5105125\",\n \"0.5104941\",\n \"0.5103396\",\n \"0.50999224\",\n \"0.50999224\",\n \"0.50994354\",\n \"0.5091948\",\n \"0.5090171\",\n \"0.50840104\",\n \"0.5082278\",\n \"0.5081389\",\n \"0.50579983\",\n \"0.5053391\",\n \"0.50494397\",\n \"0.50456125\",\n \"0.5043151\",\n \"0.5039593\",\n \"0.50395495\",\n \"0.50395495\",\n \"0.50395495\",\n \"0.50375986\",\n \"0.5035781\",\n \"0.50336766\",\n \"0.50324816\",\n \"0.50312215\",\n \"0.5027063\",\n \"0.5022421\",\n \"0.501751\",\n \"0.50153935\",\n \"0.5012444\",\n \"0.50062054\",\n \"0.50059\",\n \"0.5005062\",\n \"0.50039345\",\n \"0.5002032\",\n \"0.50019276\",\n \"0.49987593\",\n \"0.49973208\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.53299624"},"document_rank":{"kind":"string","value":"22"}}},{"rowIdx":20273,"cells":{"query":{"kind":"string","value":"Runs cross validation for an acrosssubject SVM analysis"},"document":{"kind":"string","value":"def compositionalActflowRandomSplitLOOBaselineCV(ncvs, svm_mat, nov_svm_mat, prc_svm_mat, labels, subjarray, featsel=True, nproc=5):\n \n ntasks = len(np.unique(labels))\n nsamples = svm_mat.shape[0]\n nsubjs = nsamples/ntasks\n\n subjects = np.unique(subjarray)\n indices = np.arange(nsamples)\n \n numsubjs_perfold = 1\n if nsubjs%numsubjs_perfold!=0: \n raise Exception(\"Error: Folds don't match number of subjects\")\n \n nfolds = nsubjs/numsubjs_perfold\n subj_array_folds = subjarray.copy()\n \n inputs = [] \n \n for fold in range(nfolds):\n #test_subjs = np.random.choice(subj_array_folds,numsubjs_perfold,replace=False)\n test_subjs = [subjects[fold]]\n train_subjs_all = np.delete(subjects,test_subjs)\n for cv in range(ncvs):\n # Randomly sample half of train set subjects for each cv (CV bootstrapping)\n# train_subjs = np.random.choice(train_subjs_all,\n# int(np.floor(len(train_subjs_all)*(4.0))),\n# replace=True)\n train_subjs = train_subjs_all\n\n train_ind = []\n for subj in train_subjs:\n train_ind.extend(np.where(subjarray==subj)[0])\n\n test_ind = []\n for subj in test_subjs:\n test_ind.extend(np.where(subjarray==subj)[0])\n \n train_ind = np.asarray(train_ind)\n test_ind = np.asarray(test_ind)\n\n trainset = prc_svm_mat[train_ind,:]\n testset = nov_svm_mat[test_ind,:]\n orig_training = svm_mat[train_ind,:]\n\n ## Normalize trainset and testset\n trainmean = np.mean(prc_svm_mat[train_ind,:],axis=0)\n trainmean.shape = (1,len(trainmean))\n trainstd = np.std(prc_svm_mat[train_ind,:],axis=0)\n trainstd.shape = (1,len(trainstd))\n #\n ## Normalize trainset and testset\n testmean = np.mean(nov_svm_mat[train_ind,:],axis=0)\n testmean.shape = (1,len(testmean))\n teststd = np.std(nov_svm_mat[train_ind,:],axis=0)\n teststd.shape = (1,len(teststd))\n\n trainset = np.divide((trainset - trainmean),trainstd)\n testset = np.divide((testset - testmean),teststd)\n\n ######## FEATURE SELECTION & REDUCTION\n ## Feature selection and downsampling\n trainlabels = labels[train_ind]\n testlabels = labels[test_ind]\n unique_labels = np.unique(labels)\n feat1_labs = np.where(trainlabels==0)[0]\n feat2_labs = np.where(trainlabels==1)[0]\n # Perform t-test\n t, p = stats.ttest_rel(orig_training[feat1_labs,:],orig_training[feat2_labs,:],axis=0)\n #t, p = stats.ttest_rel(trainset[feat1_labs,:],trainset[feat2_labs,:],axis=0)\n h0, qs = mc.fdrcorrection0(p)\n\n ### BEGIN REGULAR FEATURE SELECTION ###\n if featsel:\n thresh = 0.05\n feat_mask = np.where(qs < thresh)[0]\n feat_mask = np.intersect1d(feat_mask,np.where(np.isnan(trainset[0,:])==False)[0]) # make sure no bad values are included\n inputs.append((trainset[:,feat_mask],testset[:,feat_mask],labels[train_ind],labels[test_ind])) \n ### END REGULAR FEATURE SELECTION ###\n\n# ### BEGIN DIGIT REPRESENTATION FEATURE SELECTION ###\n# # Construct feature masks\n# feat1_mask = np.multiply(t<0,qs<0.05)\n# feat2_mask = np.multiply(t>0,qs<0.05)\n# #feat1_mask = t>0\n# #feat2_mask = t<0\n# \n# # Downsample training set into original vertices into 2 ROI signals\n# trainset_downsampled = np.zeros((trainset.shape[0],2))\n# trainset_downsampled[:,0] = np.nanmean(trainset[:,feat1_mask],axis=1)\n# trainset_downsampled[:,1] = np.nanmean(trainset[:,feat2_mask],axis=1)\n# # Downsample test set into original vertices\n# testset_downsampled = np.zeros((testset.shape[0],2))\n# testset_downsampled[:,0] = np.nanmean(testset[:,feat1_mask],axis=1)\n# testset_downsampled[:,1] = np.nanmean(testset[:,feat2_mask],axis=1)\n# if np.nansum(feat1_mask)==0 or np.nansum(feat2_mask)==0:\n# print 'not running feature selection'\n# inputs.append((trainset,testset,labels[train_ind],labels[test_ind]))\n# else:\n# inputs.append((trainset_downsampled,testset_downsampled,labels[train_ind],labels[test_ind]))\n# ### END DIGIT REPRESENTATION FEATURE SELECTION ###\n else:\n inputs.append((trainset,testset,labels[train_ind],labels[test_ind])) \n \n subj_array_folds = np.delete(subj_array_folds,test_subjs)\n \n pool = mp.Pool(processes=nproc)\n scores = pool.starmap_async(_decoding,inputs).get()\n pool.close()\n pool.join()\n\n acc = []\n r_match = []\n r_mismatch = []\n for score in scores:\n acc.extend(score[0])\n r_match.append(score[1])\n r_mismatch.append(score[2])\n \n return acc, r_match, r_mismatch"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def crossValidate(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationPath))\n return -1\n\n data = self.readData(args.annotationPath)\n\n ############################\n # Execute the K-Fold cross validation\n ############################\n\n x = []\n y = []\n l = []\n for subject, df in data.items():\n lx = df[['gradient', 'rate']].values.tolist()\n #lx = df[['rate']].values.tolist()\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\n x.extend(lx)\n y.extend(ly.tolist())\n l.append(len(lx))\n\n x = np.array(x)\n y = np.array(y)\n\n print('Executing cross-validation with k = {}...'.format(args.k))\n clf = StructuredPerceptron(random_state=2)\n scores = []\n folds = SequenceKFold(l, n_folds=args.k)\n for train_idx, train_len, test_idx, test_len in folds:\n xTrain = x[train_idx]\n yTrain = y[train_idx]\n clf.fit(xTrain, yTrain, train_len)\n\n xTest = x[test_idx]\n yTest = y[test_idx]\n yPred = clf.predict(xTest, test_len)\n scores.append(accuracy_score(yTest, yPred))\n\n scores = np.array(scores)\n print(scores)\n print('Result of the K-Fold CV: {:3f} (+- {:3f})' \\\n .format(scores.mean(), 2 * scores.std()))\n\n ############################\n # Execute the Leave-One-Out cross validation\n ############################\n\n\n return 0","def cross_validation(feature_train, help_rank_train, model_name):\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\n clf_model = open(model_name,'wb')\n dump(clf, clf_model, -1)\n return","def crossvalidate(*args, **kwargs):\n\n scores = []\n j = 0\n for i, _ in enumerate(data):\n if i in good_patients:\n\n if 'silent' in kwargs:\n if kwargs['silent']:\n pass\n else:\n print \"real patient index:\", i\n else:\n print \"real patient index:\", i\n\n kwargs['patient_index'] = j\n score, reconstruction = runmodel(*args, **kwargs)\n scores.append(score)\n\n if 'save_reconstruction' in kwargs:\n if kwargs['save_reconstruction']:\n scipy.misc.imsave(\"patient_{}_reconstruction.png\".format(i), reconstruction)\n j += 1\n\n cvmodel = args[0].__class__.__name__\n print \"{} overall cross validated score {}\".format(cvmodel, np.mean(scores))\n return np.mean(scores)","def cross_validate(pipeline, data, cv=4):\n print \"Running cross validation...\"\n (Xcv, ycv) = data\n kfold = KFold(n_splits=cv, shuffle=True, random_state=42)\n results = []\n for train_idx, val_idx in kfold.split(Xtrain):\n pipeline.fit(Xcv[train_idx], ycv[train_idx])\n results.append(accuracy_score(\n ycv[val_idx], pipeline.predict(Xcv[val_idx])\n ))\n print \"{} +/- {}\".format(np.mean(results), np.std(results))","def _do_training_cross_validation(self) -> None:\n\n cfg = self.cfg_\n fit_kwargs = {'classes': list(self.data_.classes)}\n\n # Store all of the samples used during cross-validation\n self.y_training_set_all_ = list(self._generate_samples(self.train_ids_, 'y'))\n\n # Initialize learner objects with the optimal set of parameters\n # learned from the grid search round (one for each\n # sub-experiment of the cross-validation round)\n for learner, learner_name in zip(self.learners_, self.learner_names_):\n self.cv_learners_[learner_name] = \\\n [learner(**self.learner_gs_cv_params_[learner_name])\n for i in range(len(self.data_.training_set))]\n\n # Make a list of empty lists corresponding to each estimator\n # instance for each learner, which will be used to store the\n # performance metrics for each cross-validation\n # leave-one-fold-out sub-experiment\n self.cv_learner_stats_ = [[] for _ in cfg.learners]\n\n # Fit the `SelectPercentile` feature selector (if applicable)\n if cfg.feature_selection_percentile != 1.0:\n loginfo('Removing {0}% of the features during training round...'\n .format(100 - 100*cfg.feature_selection_percentile))\n feature_selector = \\\n (SelectPercentile(chi2,\n percentile=100*cfg.feature_selection_percentile)\n .fit(self._vectorize_and_sparsify_data(self.training_vec_,\n self.train_ids_),\n self.y_training_set_all_))\n\n # For each fold of the training set, train on all of the other\n # folds and evaluate on the one left out fold\n for i, held_out_fold in enumerate(self.data_.training_set):\n\n loginfo('Cross-validation sub-experiment #{0} in progress'\n .format(i + 1))\n\n # Use each training fold (except for the held-out set) to\n # incrementally build up the model\n training_folds = (self.data_.training_set[:i]\n + self.data_.training_set[i + 1:])\n y_train_all = []\n for j, training_fold in enumerate(training_folds):\n\n # Get the training data\n y_train = list(self._generate_samples(training_fold, 'y'))\n y_train_all.extend(y_train)\n X_train = self._vectorize_and_sparsify_data(self.training_vec_,\n training_fold)\n if cfg.feature_selection_percentile != 1.0:\n X_train = feature_selector.transform(X_train)\n\n # Iterate over the learners\n for learner_name in self.learner_names_:\n\n # Partially fit each estimator with the new training\n # data (specifying the `classes` keyword argument if\n # this is the first go-round and it's a learner that\n # requires this to be specified initially)\n (self.cv_learners_[learner_name][i]\n .partial_fit(X_train,\n y_train,\n **fit_kwargs if not j and learner_name\n in self.requires_classes_kwarg_\n else {}))\n\n # Get mean and standard deviation for actual values\n y_train_all = np.array(y_train_all)\n y_train_mean = y_train_all.mean()\n y_train_std = y_train_all.std()\n\n # Get test data\n y_test = list(self._generate_samples(held_out_fold, 'y'))\n X_test = self._vectorize_and_sparsify_data(self.training_vec_,\n held_out_fold)\n if cfg.feature_selection_percentile != 1.0:\n X_test = feature_selector.transform(X_test)\n\n # Make predictions with the modified estimators\n for j, learner_name in enumerate(self.learner_names_):\n\n # Make predictions with the given estimator,rounding the\n # predictions\n y_test_preds = \\\n np.round(self.cv_learners_[learner_name][i].predict(X_test))\n\n # Rescale the predicted values based on the\n # mean/standard deviation of the actual values and\n # fit the predicted values within the original scale\n # (i.e., no predicted values should be outside the range\n # of possible values)\n y_test_preds_dict = \\\n ex.rescale_preds_and_fit_in_scale(y_test_preds,\n self.data_.classes,\n y_train_mean,\n y_train_std)\n\n if cfg.rescale:\n y_test_preds = y_test_preds_dict['rescaled']\n else:\n y_test_preds = y_test_preds_dict['fitted_only']\n\n # Evaluate the predictions and add to list of evaluation\n # reports for each learner\n (self.cv_learner_stats_[j]\n .append(ex.evaluate_predictions_from_learning_round(\n y_test=y_test,\n y_test_preds=y_test_preds,\n classes=self.data_.classes,\n prediction_label=cfg.prediction_label,\n non_nlp_features=cfg.non_nlp_features,\n nlp_features=cfg.nlp_features,\n learner=self.cv_learners_[learner_name][i],\n learner_name=learner_name,\n games=cfg.games,\n test_games=cfg.games,\n _round=i + 1,\n iteration_rounds=self.data_.folds,\n n_train_samples=len(y_train_all),\n n_test_samples=len(held_out_fold),\n rescaled=cfg.rescale,\n transformation_string=self.transformation_string_,\n bin_ranges=cfg.bin_ranges)))","def cross_validation(self, x, t, k=5):\n print(\"Cross validation of the SVM Model...\")\n\n # Initialize best error / hyperparameters\n best_error = float('inf')\n best_reg = 0\n best_deg = 0\n\n # Cross-validation 80-20\n N = len(x)\n N_train = math.floor(0.8 * N)\n t = t.reshape((N,))\n\n #Initialize the grid search\n\n log_min_reg = np.log(0.001)\n log_max_reg = np.log(1000)\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\n\n min_deg = 1\n max_deg = 4\n\n for deg in range(min_deg, max_deg):\n for reg in reg_list:\n errors = np.zeros(k)\n for j in range(k):\n map_index = list(zip(x, t))\n random.shuffle(map_index)\n random_x, random_t = zip(*map_index)\n\n train_x = random_x[:N_train]\n valid_x = random_x[N_train:]\n train_t = random_t[:N_train]\n valid_t = random_t[N_train:]\n\n self.model = SVC(gamma='auto', kernel='poly', degree=deg, C=reg, cache_size=1000)\n self.train(train_x, train_t)\n\n error_valid = np.array([self.error(x_n, t_n) for t_n, x_n in zip(valid_t, valid_x)])\n errors[j] = error_valid.mean()\n\n mean_error = np.mean(errors)\n print(mean_error)\n if mean_error < best_error:\n best_error = mean_error\n best_reg = reg\n best_deg = deg\n print(\"The new best hyper parameters are : \", best_reg, best_deg)\n\n print(\"Best hyper parameters are : \", best_reg, best_deg)\n print(\"Validation error : \", 100 * best_error, \"%\")\n self.model = SVC(gamma='auto', kernel='poly', degree=best_deg, C=best_reg)\n self.train(x, t)","def sklearn_train() -> None:\n cross_validate(args=SklearnTrainArgs().parse_args(), train_func=run_sklearn)","def do_crossval():\n df = read_df()\n # X = df['review'].apply(remove_html_lower)\n\n X = df['review']\n y = df['sentiment']\n X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.3, shuffle=True, stratify=y, random_state=222 )\n\n tfidf = TfidfVectorizer(stop_words='english', min_df=2, max_df=0.8, ngram_range=(1,4))\n stem_pipeline = make_pipeline(TextNormalizer(), tfidf, LogisticRegression(C=100))\n cv = StratifiedShuffleSplit(n_splits=3, test_size=0.2)\n\n scores = cross_val_score(stem_pipeline, X_train, y_train, cv=cv, scoring='accuracy', n_jobs=-1)\n print(scores, scores.mean())","def crossValidate(dataset, folds):\n\tshuffle(dataset)\n\tcv_results = []\n\tprecision_recall_acc = []\n\tfoldSize = int(len(dataset)/folds)\n\tfor i in range(0,len(dataset),foldSize):\n\t\t# preparing data\n\t\tvalD = dataset[i:i+foldSize]\n\t\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\n\t\t# Training\n\t\tprint(\"*\"*60)\n\t\tprint(\"Training on data-set size \"+str(len(testD))+\" of batch \"+str(i/(foldSize)))\n\t\tclassi = trainClassifier(testD)\n\t\t# Prediction on validation data \n\t\tprint(\"Predicting on heldout data-set size...\"+str(len(valD))+\" of batch \"+str(i/(foldSize)))\n\t\ty_true = list(map(lambda t: t[1], valD))\n\t\ty_pred = predictLabels(valD,classi)\t\t\n\t\t# Performance Metrics\t\t\n\t\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\n\t\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\n\t\tacc = accuracy_score(y_true,y_pred)\n\t\tprecision_recall[-1] = acc\n\t\tprint(precision_recall)\n\t\tprecision_recall_acc.append(precision_recall)\n\tdf = pd.DataFrame(precision_recall_acc,columns = [\"Precision\",\"Recall\",\"F1 score\",\"Accuracy Score\"])\n\tprint(df)\n\tcv_results = df.mean().tolist()\n\treturn cv_results","def crossValidationKfold(automodel, \r\n X, y,\r\n params_automl : dict = {},\r\n score_function = accuracy_score,\r\n cv : int = 3,\r\n shuffle: bool = True,\r\n verbose : bool = True,\r\n allmetrics: bool = False):\r\n if(isinstance(X, pd.DataFrame) or isinstance(y, pd.DataFrame)):\r\n X = X.values\r\n y = y.values\r\n skf = StratifiedKFold(n_splits = cv, \r\n shuffle = shuffle, \r\n random_state = 42)\r\n if(allmetrics):\r\n train_scores = {'accuracy' : [], \r\n 'roc_auc': [], \r\n 'f1' : [], \r\n 'recall' : [], \r\n 'precision': []}\r\n test_scores = {'accuracy' : [], \r\n 'roc_auc': [], \r\n 'f1' : [], \r\n 'recall' : [], \r\n 'precision': []}\r\n else:\r\n train_scores = np.empty((cv, ))\r\n test_scores = np.empty((cv, ))\r\n for idx, (idx_tr, idx_ts) in enumerate(skf.split(X, y)):\r\n X_tr, X_ts = X[idx_tr], X[idx_ts]\r\n y_tr, y_ts = y[idx_tr], y[idx_ts] \r\n am = automodel(**params_automl)\r\n am.fit(X_tr, y_tr)\r\n if(not allmetrics):\r\n \r\n train_scores[idx] = score_function(am.predict(X_tr), y_tr)\r\n test_scores[idx] = score_function(am.predict(X_ts), y_ts)\r\n if(verbose):\r\n print('it: {} train score: {:.3f}, val score: {:.3f}'.format(idx, \r\n train_scores[idx],\r\n test_scores[idx]))\r\n else:\r\n train_current = {}\r\n test_current = {}\r\n for name, metric in all_metrics_classifications.items():\r\n train_current[name] = metric(am.predict(X_tr), y_tr)\r\n test_current[name] = metric(am.predict(X_ts), y_ts)\r\n train_scores[name].append(train_current[name])\r\n test_scores[name].append(test_current[name])\r\n \r\n if(verbose):\r\n print('it: {} train scores: {}, val scores: {}'.format(idx, train_current,\r\n test_current))\r\n\r\n if(not allmetrics):\r\n return test_scores.mean(), test_scores.std()\r\n else:\r\n # -- calculate means of all metrics-- #\r\n return dict(map(lambda kv: (kv[0], np.asarray(kv[1]).mean()), test_scores.items()))","def cross_validation(exp_name):\n click.echo(\"Mode: Cross-validation.\")\n # defaults = get_defaults()\n\n # fitted_model_filename = add_extension(fitted_model_filename)\n\n # derive final path for fitted model as base output path for fitted models + model filename\n # fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\n # new_options = [\"OUTPUT.FITTED_MODEL_PATH\", fitted_model_path]\n\n # don't reserve dev set at this point since we need to do it in each cv fold\n boot_data = bootstrap(new_options=None, mode=\"cv\")\n\n defaults = boot_data['defaults']\n X_train, y_train = boot_data['data']\n\n cv = RepeatedStratifiedKFold(n_splits=defaults.EVAL.N_SPLITS,\n n_repeats=defaults.EVAL.N_REPEATS,\n random_state=defaults.MISC.SEED)\n\n s = time.time()\n outer_results, outer_preds = cross_validate(X=X_train, y=y_train,\n cv=cv,\n conf=defaults)\n print(\"Execution time: %s seconds.\" % (time.time() - s))\n\n # dump results\n # fitted_model_best_params_path = os.path.join(defaults.OUTPUT.PARAMS_PATH,\n # \"best_params_{}.pkl\".format(fitted_model_filename.split('.')[0]))\n\n outer_results_formatted = show_cross_val_results(outer_results, conf=defaults)\n\n cv_results_path = os.path.join(defaults.OUTPUT.RESULTS_PATH, \"cv_results_{}.csv\".format(exp_name))\n outer_results_formatted.to_csv(cv_results_path)\n\n # save predictions\n outer_preds_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \"cv_pooled_preds_{}.pkl\".format(exp_name))\n save_obj(outer_preds, outer_preds_path)","def train(self, trainingData, trainingLabels, validationData, validationLabels ):\n import sklearn\n from sklearn import svm\n\n \"*** YOUR CODE HERE ***\"\n self.sklearn_classifier = svm.SVC(C=2, gamma=0.025, decision_function_shape='ovo', tol=0.015)\n self.sklearn_classifier.fit(trainingData, trainingLabels)","def train(self, trainingData, trainingLabels, validationData, validationLabels):\n from sklearn import svm\n \n \"*** YOUR CODE HERE ***\"\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\n self.sklearn_svm.fit(trainingData, trainingLabels)","def cross_validate_model(self, X_train, y_train):\n\n\t\t# Build a stratified k-fold cross-validator object\n\t\tskf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n\n\t\t'''\n\t\tEvaluate the score by cross-validation\n\t\tThis fits the classification model on the training data, according to the cross-validator\n\t\tand reports the scores.\n\t\tAlternative: sklearn.model_selection.cross_validate\n\t\t'''\n\t\tscores = cross_val_score(self.classifier, X_train, y_train, scoring='accuracy', cv=skf)\n\n\t\tprint(\"%.2f seconds: Cross-validation finished\" % time.process_time())\n\n\t\t# Log the cross-validation scores, the mean score and the 95% confidence interval, according to:\n\t\t# http://scikit-learn.org/stable/modules/cross_validation.html#computing-cross-validated-metrics\n\t\t# https://en.wikipedia.org/wiki/Standard_error#Assumptions_and_usage\n\t\t# print(\"Scores = %s\" % scores)\n\t\t# print(\"Accuracy: %0.2f (±%0.2f)\" % (scores.mean()*100, scores.std()*2*100))\n\t\t# ↳ https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html","def crossValidation(data, output_variable_name):\r\n X, xt, y, yt = train_test_split(\r\n data.drop(output_variable_name, axis=1), data[output_variable_name], test_size=0.01, random_state=SEED)\r\n\r\n model = pickle.load(open(\"models/lasso.sav\", 'rb'))\r\n lassoCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n model = pickle.load(open(\"models/ridge.sav\", 'rb'))\r\n ridgeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n model = pickle.load(open(\"models/decisionTree.sav\", 'rb'))\r\n decTreeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n param = {\r\n 'max_depth': 15,\r\n 'eta': 0.1,\r\n 'objective': 'reg:squarederror',\r\n 'nthread': 16,\r\n \"subsample\": 0.5,\r\n \"colsample_bytree\": 0.5,\r\n 'eval_metric': 'rmse'\r\n }\r\n num_round = XGB_EPOCH_NR\r\n\r\n dtrain = xgb.DMatrix(X, label=y)\r\n xgbCV = xgb.cv(\r\n param,\r\n dtrain,\r\n num_boost_round=num_round,\r\n seed=SEED,\r\n nfold=5,\r\n metrics={'rmse'}\r\n )[\"test-rmse-mean\"][-1:]\r\n\r\n param = {\r\n \"iterations\": 400,\r\n \"learning_rate\": 0.02,\r\n \"depth\": 12,\r\n \"eval_metric\": 'RMSE',\r\n \"random_seed\": 23,\r\n \"bagging_temperature\": 0.2,\r\n \"od_type\": 'Iter',\r\n \"metric_period\": 75,\r\n \"od_wait\": 100\r\n }\r\n\r\n catBoostCV = cv(data, param, fold_count=5, plot=True)\r\n\r\n return lassoCV, ridgeCV, decTreeCV, xgbCV, catBoostCV","def __implement_cross_validation(self, X, y, model):\n\n skfolds = StratifiedKFold(n_splits=3, random_state=42)\n\n for train_index, test_index in skfolds.split(X, y):\n clone_clf = clone(model)\n X_train_folds = X[train_index]\n y_train_folds = y[train_index]\n X_test_fold = X[test_index]\n y_test_fold = y[test_index]\n\n clone_clf.fit(X_train_folds, y_train_folds)\n y_pred = clone_clf.predict(X_test_fold)\n n_correct = sum(y_pred == y_test_fold)\n message = \"ratio of correct predictions: \", n_correct / len(y_pred)\n self.__logger.info(message)","def cross_valid(model,x,folds,metric,verbose=True): \r\n\r\n score=[]\r\n \r\n\r\n kf = KFold(folds,shuffle=False,random_state=0) \r\n\r\n\r\n i=0\r\n for train_index, test_index in kf.split(x):\r\n\r\n xtrain = x[train_index,:]\r\n xtest = x[test_index,:]\r\n\r\n model.fit(xtrain[:,:-1],xtrain[:,-1])\r\n\r\n ypred = model.predict(xtest[:,:-1])\r\n\r\n ytrue= xtest[:,-1] \r\n \r\n \r\n if metric == 'mae':\r\n score.append(mae(ytrue,ypred))\r\n elif metric == 'mse':\r\n score.append(mse(ytrue,ypred))\r\n elif metric == 'rrmse':\r\n score.append(rrmse(ytrue,ypred))\r\n\r\n else:\r\n score.append(rmse(xtest[:,-1],ypred))\r\n\r\n if verbose:\r\n print('-'*30)\r\n print(f'\\nFold {i+1} out of {folds}')\r\n print(f'{metric}: {score[i]}')\r\n\r\n i+=1\r\n\r\n if verbose:\r\n print(f'\\n Overall Score:')\r\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\r\n\r\n\r\n return score","def _cross_validate(self, fit_params={}):\n\n # Flatten the true labels for the training data\n y_train = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\n\n if self.model.estimator_type == \"classifier\":\n\n # Get unique labels for classification\n labels = np.unique(y_train)\n\n # Set up a dictionary for the scoring metrics\n scoring = {'accuracy':'accuracy'}\n\n # Prepare arguments for the scorers\n metric_args = self.model.metric_args\n \n if 'average' in metric_args and metric_args['average'] is not None:\n # If the score is being averaged over classes a single scorer per metric is sufficient\n scoring['precision'] = metrics.make_scorer(metrics.precision_score, **metric_args)\n scoring['recall'] = metrics.make_scorer(metrics.recall_score, **metric_args)\n scoring['fscore'] = metrics.make_scorer(metrics.f1_score, **metric_args)\n\n output_format = \"clf_overall\"\n else:\n # If there is no averaging we will need multiple scorers; one for each class\n for label in labels:\n metric_args['pos_label'] = label\n metric_args['labels'] = [label]\n scoring['precision_'+str(label)] = metrics.make_scorer(metrics.precision_score, **metric_args)\n scoring['recall_'+str(label)] = metrics.make_scorer(metrics.recall_score, **metric_args)\n scoring['fscore_'+str(label)] = metrics.make_scorer(metrics.f1_score, **metric_args)\n \n output_format = \"clf_classes\"\n\n elif self.model.estimator_type == \"regressor\":\n scoring = ['r2', 'neg_mean_squared_error', 'neg_mean_absolute_error', 'neg_median_absolute_error', 'explained_variance']\n \n # Perform cross validation using the training data and the model pipeline\n scores = cross_validate(self.model.pipe, self.X_train, y_train, scoring=scoring, cv=self.model.cv, fit_params=fit_params, return_train_score=False)\n\n # Prepare the metrics data frame according to the output format\n if self.model.estimator_type == \"classifier\": \n # Get cross validation predictions for the confusion matrix\n y_pred = cross_val_predict(self.model.pipe, self.X_train, y_train, cv=self.model.cv, fit_params=fit_params)\n\n # Prepare the confusion matrix and add it to the model\n self._prep_confusion_matrix(y_train, y_pred, labels)\n\n # Create an empty data frame to set the structure\n metrics_df = pd.DataFrame(columns=[\"class\", \"accuracy\", \"accuracy_std\", \"precision\", \"precision_std\", \"recall\",\\\n \"recall_std\", \"fscore\", \"fscore_std\"])\n\n if output_format == \"clf_overall\": \n # Add the overall metrics to the data frame\n metrics_df.loc[0] = [\"overall\", np.average(scores[\"test_accuracy\"]), np.std(scores[\"test_accuracy\"]),\\\n np.average(scores[\"test_precision\"]), np.std(scores[\"test_precision\"]),\\\n np.average(scores[\"test_recall\"]), np.std(scores[\"test_recall\"]),\\\n np.average(scores[\"test_fscore\"]), np.std(scores[\"test_fscore\"])]\n\n elif output_format == \"clf_classes\":\n # Add accuracy which is calculated at an overall level\n metrics_df.loc[0] = [\"overall\", np.average(scores[\"test_accuracy\"]), np.std(scores[\"test_accuracy\"]),\\\n np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN]\n\n # Add the metrics for each class to the data frame\n for i, label in enumerate(labels):\n metrics_df.loc[i+1] = [label, np.NaN, np.NaN, np.average(scores[\"test_precision_\"+str(label)]),\\\n np.std(scores[\"test_precision_\"+str(label)]), np.average(scores[\"test_recall_\"+str(label)]),\\\n np.std(scores[\"test_recall_\"+str(label)]), np.average(scores[\"test_fscore_\"+str(label)]),\\\n np.std(scores[\"test_fscore_\"+str(label)])]\n \n # Finalize the structure of the result DataFrame\n metrics_df.loc[:,\"model_name\"] = self.model.name\n metrics_df = metrics_df.loc[:,[\"model_name\", \"class\", \"accuracy\", \"accuracy_std\", \"precision\", \"precision_std\", \"recall\",\\\n \"recall_std\", \"fscore\", \"fscore_std\"]]\n\n # Add the score to the model\n self.model.score = metrics_df[\"accuracy\"].values[0]\n\n elif self.model.estimator_type == \"regressor\":\n # Create an empty data frame to set the structure\n metrics_df = pd.DataFrame(columns=[\"r2_score\", \"r2_score_std\", \"mean_squared_error\", \"mean_squared_error_std\",\\\n \"mean_absolute_error\", \"mean_absolute_error_std\", \"median_absolute_error\", \"median_absolute_error_std\",\\\n \"explained_variance_score\", \"explained_variance_score_std\"])\n \n # Add the overall metrics to the data frame\n metrics_df.loc[0] = [np.average(scores[\"test_r2\"]), np.std(scores[\"test_r2\"]),\\\n np.average(scores[\"test_neg_mean_squared_error\"]), np.std(scores[\"test_neg_mean_squared_error\"]),\\\n np.average(scores[\"test_neg_mean_absolute_error\"]), np.std(scores[\"test_neg_mean_absolute_error\"]),\\\n np.average(scores[\"test_neg_median_absolute_error\"]), np.std(scores[\"test_neg_median_absolute_error\"]),\\\n np.average(scores[\"test_explained_variance\"]), np.std(scores[\"test_explained_variance\"])]\n \n # Finalize the structure of the result DataFrame\n metrics_df.loc[:,\"model_name\"] = self.model.name\n metrics_df = metrics_df.loc[:,[\"model_name\", \"r2_score\", \"r2_score_std\", \"mean_squared_error\", \"mean_squared_error_std\",\\\n \"mean_absolute_error\", \"mean_absolute_error_std\", \"median_absolute_error\", \"median_absolute_error_std\",\\\n \"explained_variance_score\", \"explained_variance_score_std\"]]\n\n # Add the score to the model\n self.model.score = metrics_df[\"r2_score\"].values[0]\n\n # Save the metrics_df to the model\n self.model.metrics_df = metrics_df","def nestedValidation(X, y, kernel):\n\n # list of slack variable values to test the SVM with\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]\n # number of iterations to run the bootstraping\n B = 30\n\n # split positive and negative valued samples\n positive_samples = list(np.where(y==1)[0])\n negative_samples = list(np.where(y==-1)[0])\n\n # randomize data for testing\n np.random.shuffle(positive_samples)\n np.random.shuffle(negative_samples)\n\n # split samples into two folds with similar proportion of positive:negative\n samples_in_fold1 = positive_samples[:106] + negative_samples[:178]\n samples_in_fold2 = positive_samples[106:] + negative_samples[178:]\n\n y_pred = np.zeros(len(X), int)\n\n # finding the best slack value and its corresponding error\n best_err = 1.0\n best_C = 0.0\n\n print(\"testing with first fold\")\n for C in C_list:\n err = bootstrapping(B, X[samples_in_fold1], y[samples_in_fold1], C, kernel)\n print(\"C=\", C, \"err=\", err)\n if (err <= best_err):\n best_err = err\n best_C = C\n\n print(\"Best C=\", best_C)\n\n alg = SVC(C=best_C, kernel=kernel)\n alg.fit(X[samples_in_fold1], y[samples_in_fold1])\n y_pred[samples_in_fold2] = alg.predict(X[samples_in_fold2])\n\n best_err = 1.1 # any value greater than 1.0\n best_C = 0.0\n\n print(\"testing with second fold\")\n for C in C_list:\n err = bootstrapping(B, X[samples_in_fold2], y[samples_in_fold2], C, kernel)\n print(\"C=\", C, \"err=\", err)\n if (err <= best_err):\n best_err = err\n best_C = C\n\n print(\"Best C=\", best_C)\n\n alg = SVC(C=best_C, kernel=kernel)\n alg.fit(X[samples_in_fold2], y[samples_in_fold2])\n y_pred[samples_in_fold1] = alg.predict(X[samples_in_fold1])\n\n err = np.mean(y != y_pred)\n\n print(\"Nested Validation Error=\", err)\n return err","def cross_validation(self):\r\n kfold = KFold(10, shuffle=True, random_state=1)\r\n data = self.read_data()\r\n # error from each kth iteration\r\n errors = []\r\n for train, test in kfold.split(data):\r\n\r\n #Splitting into test and training data\r\n X_test, Y_test = data[test][:, 1], data[test][:, 2]\r\n X_train, Y_train = data[train][:, 1], data[train][:, 2]\r\n\r\n #Training on the split data\r\n weights, design_matrix = self.train(X_train, Y_train)\r\n\r\n y_pred = self.make_prediction(X_test, weights)\r\n self.plot(y_true=Y_test, y_pred=y_pred, x=X_test)\r\n\r\n #error matrix\r\n errors.append(np.mean(y_pred - Y_test) ** 2)\r\n\r\n #cross-validation parameter taken as mean of errors obtained from each iteration\r\n print(\"%0.10f mean with a standard deviation of %0.10f across the k-folds\" % (np.mean(errors), np.std(errors)))","def hyperparameter_cv(X_data, y_data, hyperparameters):\n\n # Create Grid of hyperparameters\n grid = cartesian_product(hyperparameters)\n\n # Loop through hyperparameters \n best_score = 0\n for hyperparameter in grid:\n # Initialize Modle\n model = svm.SVC(kernel='linear', **hyperparameter)\n\n # Train and Get Accuracy\n print(f\"Training using hyperparameters: {hyperparameter}\")\n score = cross_validation_score(X_data, y_data, model, folds=5)\n print(f\"Accuracy Score: {score}\")\n\n if score > best_score:\n best_score = score\n best_parameters = hyperparameter\n \n return best_score, best_parameters","def run_svm(data):\n X, y = data.ix[:, :-1], data.ix[:, -1]\n\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, train_size = int(TRAIN_PCT * len(X)))\n\n clf = SVC()\n\n param_grid = {\n 'C': [10 ** k for k in range(-3, 3)],\n # 'C': range(1, 11),\n 'kernel': ['linear', 'poly', 'rbf']}\n # 'kernel': ['rbf']}\n\n grid_results = GridSearchCV(clf, param_grid,\n scoring='roc_auc',\n cv=StratifiedKFold(y_train, n_folds=20),\n verbose=1)\n\n grid_results.fit(X_train, y_train)\n\n print '\\ngenlzn errors:'\n for params, mean_score, all_scores in grid_results.grid_scores_:\n print '{}\\t{}\\t(+/-) {}'.format(\n params,\n round(mean_score, 3),\n round(all_scores.std() / 2, 3))\n\n print '\\nbest model:'\n print '{}\\t{}'.format(grid_results.best_params_,\n round(grid_results.best_score_, 3))\n\n print '\\nclassification report:'\n print classification_report(y_test, grid_results.predict(X_test))\n\n print 'confusion matrix ({} total test recs, {} positive)'.format(\n len(y_test), sum(y_test))\n print confusion_matrix(y_test, grid_results.predict(X_test),\n labels=[1, 0])\n print","def cross_validate(cv, x, y, k=1):\n indices = np.arange(len(x))\n np.random.shuffle(indices)\n stepsize = int(len(x) / cv)\n metrics = np.zeros(4)\n for i in range(cv):\n logging.info(f\"Cross-validation fold {i+1}\")\n\n # Slice test set out of data\n test_indices = indices[i*stepsize:i*stepsize+stepsize]\n x_test = x[test_indices]\n y_test = y[test_indices]\n\n # Everything else is the training set\n x_train = np.copy(x)\n x_train = np.delete(x_train, test_indices, axis=0)\n y_train = np.copy(y)\n y_train = np.delete(y_train, test_indices, axis=0)\n\n metrics += evaluate(knn(x_test, x_train, y_train, k), y_test)\n metrics /= cv\n\n print(metrics)\n return metrics","def crossValidate(k, epochs, hyperparams, data, trainFunc, testFunc, report=None):\n \n if not (report == None):\n tabs = '\\t' * report;\n print tabs, 'Performing %d-fold cross validation...' % k;\n \n # create vars to save the best hyperparameters and their performance\n bestTheta = None;\n bestRate = float(\"-inf\");\n \n # create queue for worker threads to post results to\n queue = mp.Queue();\n \n # create train/test folds\n numPerFold = len(data) // k;\n numLeftOver = len(data) % k;\n folds = [data[i*numPerFold:i*numPerFold+numPerFold] for i in range(0, k)];\n if numLeftOver > 0:\n folds[-1].extend(data[-numLeftOver:]); \n \n # create a list of tuples; each tuple defining a unique assignment of hyperparameters \n thetas = list(itertools.product(*hyperparams));\n \n # create worker threads try all combinations of hyperparameters \n workers = []; \n for theta in thetas: \n p = mp.Process(target=cvWorker, args=(epochs, theta, folds, trainFunc, \\\n testFunc, report, queue));\n workers.append(p)\n \n # start worker threads and wait for them to finish\n for p in workers:\n p.start();\n for p in workers:\n p.join()\n \n if not (report == None):\n print tabs, 'All worker threads have terminated.';\n \n # read results out of queue \n while not queue.empty():\n [theta, rate] = queue.get();\n if rate > bestRate:\n bestTheta = theta\n bestRate = rate;\n \n return bestTheta;","def do_cross_val(sem, data_desc, perf_ml_model, ml_model_desc, ml_model, train_feature,\n train_result):\n scores = cross_val_score(ml_model, train_feature, train_result, cv = NUM_KFOLD,\n scoring = 'neg_mean_absolute_error')\n if VERB: \n print(\"model: %s - score: %f\" % (ml_model_desc, statistics.mean(scores)))\n perf_ml_model[(sem, data_desc, ml_model_desc)] = statistics.mean(scores)","def tenfold_cross_validation(X, y):\n\n i = 0\n x_score = []\n y_score = []\n\n for i in range(1, 11):\n for train_index, test_index in KFold(10).split(X):\n x_train, x_test = X[train_index], X[test_index]\n y_train, y_test = y[train_index], y[test_index]\n\n # change the parameters to see how each parameter affects the l1inear classifier\n linear_classifier = linear_model.SGDClassifier(max_iter=1000, tol=1e-3)\n\n # start training the classifier\n linear_classifier.fit(x_train, y_train)\n\n # create and plot the confusion matrix\n # cross validation done with cross_val_\n y_train_pred = cross_val_predict(linear_classifier, x_test, y_test, cv=10)\n\n print(\"\\n Statistics and Confusion matrix obtained with pandas_ml: \\n\")\n cm = ConfusionMatrix(y_test, y_train_pred)\n stats = cm.stats()\n\n file = open(\"linear_classification_9000_cross_validation_\" + str(i) + \".txt\", \"w\")\n file.write(str(stats))\n file.close()\n\n # cm.print_stats()\n # print confusion matrix\n cm.plot(normalized=True)\n plt.show()","def nestedKFoldValidation(k, X, y, kernel):\n\n print(\"running k-folds cross validation to find best slack C\")\n\n # list of slack variable values used to test the SVM with\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100, 1000]\n # number of iterations to run the bootstrapping\n B = 30\n\n sample_list = list(range(len(y)))\n np.random.shuffle(sample_list)\n\n # splitting list into k folds\n foldSize = len(y)//k\n folds = [sample_list[i*foldSize:(i+1)*foldSize] for i in range(k)]\n\n # add remaining items to the last fold\n folds[-1] += sample_list[foldSize*k:]\n\n test_results = {}\n for test in folds:\n print('==== next outer fold ====')\n # python dictionary to keep track of errors\n error_dict = {}\n for validation in folds:\n # do not want identical test and validation folds\n if validation == test:\n continue\n\n # training data is all folds except for test and validation\n train = [f for f in folds if f != test and f != validation][0]\n # find errors across all parameters\n for c in C_list:\n alg = SVC(C=c, kernel=kernel)\n alg.fit(X[train], y[train])\n err = np.mean(y[validation] != alg.predict(X[validation]))\n # keep track of all errors\n if c not in error_dict:\n error_dict[c] = {}\n error_dict[c]['err'] = []\n error_dict[c]['model'] = alg\n error_dict[c]['err'].append(err)\n\n # finding the best parameter from the inner loop\n bestC = -1\n bestError = 1.0\n for c in error_dict:\n print('c=', c, 'err=', np.mean(error_dict[c]['err']))\n err = np.mean(error_dict[c]['err'])\n if err < bestError:\n bestError = err\n bestC = c\n print('best c from inner loop is', bestC)\n\n # testing the best model from the inner loop against test data\n train_err = np.mean(y[test] != alg.predict(X[test]))\n if bestC not in test_results:\n test_results[bestC] = []\n test_results[bestC].append(train_err)\n\n for c in test_results:\n print('c=', c,\n 'mean error=', np.mean(test_results[c]),\n 'stddev of errors=', np.std(test_results[c]))","def cv(data, folds, model):\n def rmsle(predicted, actual):\n # Root Mean Squared Logarithmic Error\n return mean_squared_error(\n np.log(predicted+1),\n np.log(actual+1)\n ) ** 0.5\n\n errors = []\n print \" Cross Validation in progress...\"\n kf = cross_validation.KFold(n=len(data.index), n_folds=folds)\n for i, (train_index, validation_index) in enumerate(kf):\n print ' F%d.' % i\n train = data.iloc[train_index]\n validation = data.iloc[validation_index]\n\n model.fit(train)\n prediction = model.predict(validation)\n actual = data.iloc[validation_index]['count'].as_matrix()\n error = rmsle(prediction, actual)\n errors.append(error)\n return np.mean(errors)","def train_svm_model(self, X_train, X_test, y_train, y_test):\r\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\r\n ('clf', LinearSVC())])\r\n clf = clf.fit(X_train, y_train)\r\n pred = clf.predict(X_test)\r\n print('Confusion matrix\\n',confusion_matrix(y_test,pred))\r\n print('Classification_report\\n',classification_report(y_test,pred))\r\n return clf","def main(args):\n\n # load dataset\n with open(args.infile, 'rb') as fin:\n x_train, y_train, x_test, y_test = pickle.load(fin)\n\n y_train = y_train.astype('int64')\n y_test = y_test.astype('int64')\n\n random_index = list(range(len(x_train)))\n random.shuffle(random_index)\n x_train = np.array(x_train[random_index])\n y_train = np.array(y_train[random_index])\n\n # y_train = y_train.astype(bool).astype(int)\n # y_test = y_test.astype(bool).astype(int)\n\n # combined different features\n feature_extractors = [\n # ('general', MyScaler(False)),\n # ('wordcount', MyCountVectorizer(ngram_range=(1, 1), stop_words='english')),\n ('tfidf', MyTfidfVectorizer(stop_words='english')),\n ]\n combined_feature = FeatureUnion(feature_extractors)\n\n estimators = [('feature', combined_feature),\n ('clf', svm.LinearSVC(C=0.3))]\n pipeline = Pipeline(estimators)\n\n # pipeline.fit(x_train, y_train)\n # print(pipeline.score(x_test, y_test))\n\n # parameters to search\n param_grid = [\n {\n 'clf': [MultinomialNB()],\n 'clf__alpha': [10, 1.0, 0.1, 0.01],\n },\n {\n 'clf': [svm.LinearSVC()],\n 'clf__C': [3, 1, 0.3, 0.1],\n },\n ]\n\n # start training\n t0 = time.time()\n grid = GridSearchCV(pipeline, param_grid=param_grid, verbose=4, n_jobs=4)\n grid.fit(x_train, y_train)\n\n print()\n print('done in %.2f seconds' % (time.time() - t0))\n print()\n print('train accuracy: %.2f%%' % (100 * grid.score(x_train, y_train)))\n print('test accuracy: %.2f%%' % (100 * grid.score(x_test, y_test)))\n print()\n print('the best parameters are:', grid.best_params_)\n print()\n print('confusion matrix:')\n print(metrics.confusion_matrix(y_test, grid.predict(x_test)))","def svm_clf_training(max_features, data):\r\n X_train, y_train, X_test, y_test = data\r\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\r\n ('clf', svm.SVC(C=1., kernel='linear'))])\r\n\r\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\r\n X_matrix_tr = vectorizer.fit_transform(X_train)\r\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\r\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\r\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\r\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\r\n clf.fit(X_matrix_tr, y_train)\r\n # print(\"Best parameters set found on development set:\")\r\n # print()\r\n # print(clf.best_estimator_)\r\n # print()\r\n # print(\"Grid scores on development set:\")\r\n # print()\r\n # for params, mean_score, scores in clf.grid_scores_:\r\n # print(\"%0.3f (+/-%0.03f) for %r\"\r\n # % (mean_score, scores.std() / 2, params))\r\n # print()\r\n voc = vectorizer.get_feature_names()\r\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\r\n # X_matrix_val = vectorizer1.fit_transform(X_test)\r\n # y_pred = clf.predict(X_matrix_val)\r\n\r\n # for i in range(len(X_test)):\r\n # if y_test[i] != y_pred[i]:\r\n # print(X_test[i], y_test[i], y_pred[i])\r\n # print(classification_report(y_test, y_pred))\r\n return clf, voc","def crossValidatePredictor(X,y,clfinputs,logfile='cvout.log'):\n \n models,modelcvs,preds,probs = [],[],[],[]\n scores = dict([(key,[]) for key in list(scorefn.keys())])\n errors = dict([(key,[]) for key in list(errorfn.keys())])\n\n # validate class labels\n uy = np.unique(y)\n if len(uy) != 2:\n print('error: need 2 classes for classification!')\n return {}\n \n N,ymin = len(y),uy[0]\n\n if cv_type == 'loo':\n cv = KFold(N,n_folds=N,random_state=train_state)\n y_pred = np.zeros(N)\n y_prob = np.zeros(N)\n else: \n cv = StratifiedKFold(y,n_folds=train_folds,random_state=train_state)\n\n n_folds = len(cv) \n model_id = clfinputs['clf_type']\n widgets = ['%s cv: '%cv_type, Percentage(), ' ', Bar('='), ' ', ETA()]\n pbar = ProgressBar(widgets=widgets, maxval=n_folds+(cv_type=='loo')).start()\n with open(logfile,'w') as logfid:\n cv_test_index = []\n scorekeys = sorted(scores.keys())\n for i,(train_index,test_index) in enumerate(cv):\n pbar.update(i)\n X_train, X_test = X[train_index], X[test_index]\n y_train, y_test = y[train_index], y[test_index]\n\n cv_test_index.extend(test_index) \n \n # xgb assumes labels \\in {0,1}\n if model_id == 'xgb' and ymin == -1: \n y_train[y_train==-1] = 0 \n\n # train/predict as usual\n clf,clf_cv = train(X_train,y_train,clfinputs)\n clf_pred = clf.predict(X_test)\n if model_id == 'xgb' and ymin == -1:\n clf_pred[clf_pred==0] = -1\n\n if cv_probs:\n clf_prob = clf.predict_proba(X_test)[:,0]\n else:\n clf_prob = np.ones(len(clf_pred))*np.nan\n \n # loo predicts one label per 'fold'\n if cv_type == 'loo':\n\n y_pred[test_index] = clf_pred\n y_prob[test_index] = clf_prob\n # compute scores for the points we've classified thus far\n y_test_cur = np.atleast_1d(y[cv_test_index])\n y_pred_cur = np.atleast_1d(y_pred[cv_test_index])\n \n for score,score_fn in list(scorefn.items()):\n scorei = score_fn(y_test_cur,y_pred_cur,uy)\n scores[score] = [scorei] \n else:\n # collect output for all test samples in this fold\n for score,score_fn in list(scorefn.items()):\n scorei = score_fn(y_test,clf_pred,uy)\n scores[score].append(scorei) \n preds.append(clf_pred)\n probs.append(clf_prob)\n models.append(clf)\n modelcvs.append(clf_cv)\n for error,error_fn in list(errorfn.items()):\n errors[error].append(error_fn(y_test,clf_pred))\n\n if i==0:\n scorenames = ['%-16s'%score for score in scorekeys]\n logstr = '%-8s %s'%('i',''.join(scorenames))\n else:\n curscores = ['%-16.4f'%(np.mean(scores[score]))\n for score in scorekeys] \n logstr = '%-8.3g %s'%(i,''.join(curscores))\n print(logstr,file=logfid,flush=True)\n\n # train full model for loo cv, score on loo preds from above\n if cv_type == 'loo':\n for score,score_fn in list(scorefn.items()): \n scores[score] = [score_fn(y,y_pred,uy)]\n for error,error_fn in list(errorfn.items()):\n errors[error] = [error_fn(y,y_pred)]\n\n clf,clf_cv = train(X,y,clfinputs)\n models = [clf]\n modelcvs = [clf_cv]\n preds = [y_pred]\n probs = [y_prob]\n pbar.update(i+1)\n pbar.finish() \n\n # output scores ordered by key\n for score_id in scorekeys:\n score_vals = scores[score_id]\n print('mean %s: %7.4f (std=%7.4f)'%(score_id, np.mean(score_vals),\n np.std(score_vals)))\n\n return {'preds':preds,'probs':probs,'scores':scores,'errors':errors,\n 'models':models,'modelcvs':modelcvs}","def validate_one_class(normal,outliers):\n print \"running a validation\"\n \n #classifier\n \n train_data = genfromtxt(normal, delimiter='\\t',skip_header=0)\n test_data = genfromtxt(outliers, delimiter='\\t',skip_header=0)\n\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\n outliers_proportion=0.01\n\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\n #processing data without targets\n X_train = clf.scale(train_data)\n X_test = clf.scale(test_data)\n\n y_pred_train = clf.predict(X_train)\n y_pred_test = clf.predict(X_test)\n n_error_train = y_pred_train[y_pred_train == 1].size\n n_error_test = y_pred_test[y_pred_test == -1].size\n \n print \"training: \", 100.0*(float(n_error_train)/float(X_train.shape[0])), \"testing (test/outliers): \",100.0*(float(n_error_test)/float(X_test.shape[0]))\n\n sys.exit(0)\n\n #for further information about parameters, please google sklearn docs\n parameters = {'kernel':('sigmoid', 'rbf'), 'C':[.1,.2,1.0],'cache_size':[500]}\n svr = svm.SVC()\n clf = grid_search.GridSearchCV(svr, parameters,n_jobs=3)\n sys.stdout.write(\"%s:validating... \"%(strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())))\n output = clf.fit(X,Y)\n print output\n print \"(%s) DONE.\" % (strftime(\"%Y-%m-%d %H:%M:%S\", gmtime()))\n sys.exit(0)","def cross_validate(X, Y, folds=5):\n\n log = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n intercept_scaling=1, max_iter=200, multi_class='ovr', n_jobs=3,\n penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n verbose=0, warm_start=False)\n \n\n \n\n\n scores_log = [] \n scores_forest = []\n index = np.arange(X.shape[0])\n score_log = 0\n score_forest = 0\n \n for i in range(folds):\n score_log = 0\n score_forest = 0\n \n test_index = np.random.choice(index, int(X.shape[0]*1/folds),replace=False)\n index = np.setdiff1d(np.arange(X.shape[0]),test_index)\n \n test_x = X[test_index]\n test_y = Y[test_index]\n\n log.fit(X[index],Y[index])\n pred_log = log.predict(test_x)\n \n ran.fit(X[index],Y[index])\n pred_ran = ran.predict(test_x)\n \n for i in range(len(test_y)):\n if(pred_log[i] == test_y[i]):\n score_log += 1\n if(pred_ran[i] == test_y[i]):\n score_forest += 1\n scores_log.append(score_log/len(test_y))\n scores_forest.append(score_forest/len(test_y))\n \n\n return (np.mean(scores_log),np.mean(scores_forest))","def set_cross_validation(x,y):\n\tx_train_1 = x[50:]\n\ty_train_1 = y[50:]\n\tx_test_1 = x[:50]\n\ty_test_1 = y[:50]\n\tx_train_2 = np.concatenate((x[:50], x[100:]),axis=0)\n\ty_train_2 = np.concatenate((y[:50], y[100:]),axis=0)\n\tx_test_2 = x[50:100]\n\ty_test_2 = y[50:100]\n\tx_train_3 = np.concatenate((x[:100], x[150:]),axis=0)\n\ty_train_3 = np.concatenate((y[:100], y[150:]),axis=0)\n\tx_test_3 = x[100:150]\n\ty_test_3 = y[100:150]\n\tx_train_4 = x[:150]\n\ty_train_4 = y[:150]\n\tx_test_4 = x[150:]\n\ty_test_4 = y[150:]\n\n\tx_train = [x_train_1,x_train_2,x_train_3,x_train_4]\n\ty_train = [y_train_1,y_train_2,y_train_3,y_train_4]\n\tx_test = [x_test_1,x_test_2,x_test_3,x_test_4]\n\ty_test = [y_test_1,y_test_2,y_test_3,y_test_4]\n\t# print 'cross val shapes', x_train.shape, y_train.shape, x_test.shape, y_test.shape\n\treturn x_train, y_train, x_test, y_test","def crossvalidation(X, y, folds, lambdavals):\n n = X.shape[0]\n Errors = np.empty((0, len(lambdavals)))\n index = (list(range(folds)) * (n//folds+1))[0:n]\n np.random.shuffle(index)\n index = np.array(index)\n for i in range(folds):\n X_train_CV = X[index != i, :]\n X_test_CV = X[index == i, :]\n y_train_CV = y[index != i]\n y_test_CV = y[index == i]\n Errorsinter = []\n for lam in lambdavals:\n betas, _ = mylinearsvm(lam, 0.1, 100, X_train_CV, y_train_CV)\n y_pred = np.dot(X_test_CV, betas[-1])\n Errorsinter.append(mean_squared_error(y_test_CV, y_pred))\n Errors = np.vstack((Errors, Errorsinter))\n mean_errors = np.mean(Errors, axis = 0)\n minimum_val = np.max(np.where(mean_errors == mean_errors.min()))\n lambda_best = lambdavals[minimum_val]\n print(\"The best value of lambda is:\", lambda_best)\n return lambda_best","def cross_validation(T, y):\r\n from sklearn.model_selection import LeaveOneOut\r\n y = np.array(y)\r\n judge = list()\r\n for train_index, valid_index in LeaveOneOut().split(T):\r\n T_train = T[train_index]\r\n T_valid = T[valid_index]\r\n y_train = y[train_index]\r\n y_valid = y[valid_index]\r\n\r\n T_train, mean, std = feature.normalize(T_train)\r\n T_principle, T_principle_index, dist, AUC = feature_select(T_train,\r\n y_train, k=3)\r\n ts = threshold(dist, y_train)\r\n C = gen_center(T_principle, y_train)\r\n T_valid = (T_valid - mean) / std\r\n dist_valid = util.distance(T_valid.T[T_principle_index].T, C)\r\n if y_valid[0] == 1:\r\n if dist_valid[0] < ts:\r\n judge.append(1)\r\n else:\r\n judge.append(0)\r\n else:\r\n if dist_valid[0] < ts:\r\n judge.append(0)\r\n else:\r\n judge.append(1)\r\n accuracy = sum(judge) / len(judge)\r\n return accuracy","def ex_2_a(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train an SVM with a linear kernel for the given dataset\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n\n machine = svm.SVC(kernel='linear')\n machine.fit(x_train, y_train)\n plot_svm_decision_boundary(machine, x_train, y_train, x_test, y_test)\n\n print('Linear SVM score: {}'.format(machine.score(x_test, y_test)))","def cross_validation2(T, y):\r\n from sklearn.model_selection import LeaveOneOut\r\n y = np.array(y)\r\n judge = list()\r\n T_principle_index = np.array([0, 18, 43])\r\n\r\n for train_index, valid_index in LeaveOneOut().split(T):\r\n T_train = T[train_index]\r\n T_valid = T[valid_index]\r\n y_train = y[train_index]\r\n\r\n T_train, mean, std = feature.normalize(T_train)\r\n\r\n T_principle = T_train.T[T_principle_index].T\r\n C = gen_center(T_principle, y_train)\r\n dist = util.distance(T_principle, C)\r\n ts = threshold(dist, y_train)\r\n\r\n T_valid = (T_valid - mean) / std\r\n dist_valid = util.distance(T_valid.T[T_principle_index].T, C)\r\n\r\n if dist_valid[0] < ts:\r\n judge.append(1)\r\n else:\r\n judge.append(0)\r\n return np.array(judge)","def validate(inputs):\n print \"running validation\"\n my_data = genfromtxt(inputs, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #processing data without targets\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #for further information about parameters, please google sklearn docs\n parameters = {'kernel':('sigmoid', 'rbf'), 'C':[.1,.2,1.0],'cache_size':[500]}\n svr = svm.SVC()\n clf = grid_search.GridSearchCV(svr, parameters,n_jobs=3)\n sys.stdout.write(\"%s:validating... \"%(strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())))\n output = clf.fit(X,Y)\n print output\n print \"(%s) DONE.\" % (strftime(\"%Y-%m-%d %H:%M:%S\", gmtime()))\n sys.exit(0)","def ex_2_a(x_train, y_train, x_test, y_test):\n ###########\n ## Train an SVM with a linear kernel for the given dataset\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x_train, y_train)\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\n print(\"ex_2_a score:\", clf.score(x_test, y_test))\n\n pass","def cross_validation(features, target, n_neighbors=5, n_folds=5):\n clf = KNeighborsClassifier(n_neighbors=n_neighbors)\n cv_scores = cross_val_score(clf, features, target, cv=n_folds)\n # print each cv score (accuracy) and average them\n print('Cross Validation Scores Mean: %.2f' % (np.mean(cv_scores) * 100))","def cross_validation(self, k_folds, **inputs):\n self.cv_stats, self.cv_traces = [], []\n self.k_folds = k_folds\n inputs = self._clean_inputs(inputs)\n for i, fold in enumerate(k_folds):\n train, test = fold\n input_train, input_test = {}, {}\n for name, data in inputs.items():\n if name in self.cv_vars:\n input_train[name] = data[train]\n input_test[name] = data[test]\n else:\n input_train[name] = data\n input_test[name] = data\n trace = self.run(**input_train)\n stats = self.calculate_statistics(trace, **input_test)\n self.cv_traces.append(trace)\n self.cv_stats.append(stats)\n return self.cv_traces, self.cv_stats","def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):","def performance_metrics(model, X_train, y_train, X_test, y_test, train=True, cv=True):\n from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, f1_score \n from sklearn.metrics import precision_score, recall_score, roc_auc_score\n from sklearn.model_selection import cross_validate, cross_val_score, StratifiedKFold\n scoring = {'acc': 'accuracy',\n 'prec_micro': 'precision_micro',\n 'rec_micro': 'recall_micro',\n 'f1_micro': 'f1_micro',\n 'auc':'roc_auc'} \n if train==True:\n if cv==True:\n kfold=StratifiedKFold(n_splits=10, random_state=42)\n scores = cross_validate(model, X_train, y_train, scoring=scoring, cv=kfold)\n ypredTrain = model.predict(X_train)\n Acc_train = scores['test_acc'].mean()\n Precision_train = scores['test_prec_micro'].mean()\n Recall_train = scores['test_rec_micro'].mean()\n F1_train = scores['test_f1_micro'].mean()\n AUC_train = scores['test_auc'].mean()\n conf_matrix_train = confusion_matrix(y_train, ypredTrain)\n class_report = classification_report(y_train, ypredTrain)\n print(\"TRAIN:\\n===========================================\")\n print(f\"CV - Accuracy : {Acc_train:.2f}\\n\")\n print(f\"CV - Precision: {Precision_train:.2f}\\n\")\n print(f\"CV - Recall: {Recall_train:.2f}\\n\")\n print(f\"CV - F1 score: {F1_train:.2f}\\n\") \n print(f\"CV - AUC score: {AUC_train:.2f}\\n\") \n print(f\"Confusion Matrix:\\n {conf_matrix_train}\\n\")\n print(f\"Classification Report:\\n {class_report}\\n\") \n elif cv==False:\n scores = cross_validate(model, X_train, y_train, scoring=scoring)\n ypredTrain = model.predict(X_train)\n Acc_train = scores['test_acc'].mean()\n Precision_train = scores['test_prec_micro'].mean()\n Recall_train = scores['test_rec_micro'].mean()\n F1_train = scores['test_f1_micro'].mean()\n AUC_train = scores['test_auc'].mean()\n conf_matrix_train = confusion_matrix(y_train, ypredTrain)\n class_report = classification_report(y_train, ypredTrain)\n print(\"TRAIN:\\n===========================================\")\n print(f\"CV - Accuracy : {Acc_train:.2f}\\n\")\n print(f\"CV - Precision: {Precision_train:.2f}\\n\")\n print(f\"CV - Recall: {Recall_train:.2f}\\n\")\n print(f\"CV - F1 score: {F1_train:.2f}\\n\") \n print(f\"CV - AUC score: {AUC_train:.2f}\\n\") \n print(f\"Confusion Matrix:\\n {conf_matrix_train}\\n\")\n print(f\"Classification Report:\\n {class_report}\\n\")\n elif train==False:\n if cv==True:\n kfold=StratifiedKFold(n_splits=10, random_state=42)\n scores = cross_validate(model, X_test, y_test, scoring=scoring, cv=kfold)\n ypredTest = model.predict(X_test)\n Acc_test = scores['test_acc'].mean()\n Precision_test = scores['test_prec_micro'].mean()\n Recall_test = scores['test_rec_micro'].mean()\n F1_test = scores['test_f1_micro'].mean()\n AUC_test = scores['test_auc'].mean()\n conf_matrix_test = confusion_matrix(y_test, ypredTest)\n class_report = classification_report(y_test, ypredTest) \n print(\"TEST:\\n===========================================\")\n print(f\"CV - Accuracy : {Acc_test:.2f}\\n\")\n print(f\"CV - Precision: {Precision_test:.2f}\\n\")\n print(f\"CV - Recall: {Recall_test:.2f}\\n\")\n print(f\"CV - F1 score: {F1_test:.2f}\\n\") \n print(f\"CV - AUC score: {AUC_test:.2f}\\n\") \n print(f\"Confusion Matrix:\\n {conf_matrix_test}\\n\")\n print(f\"Classification Report:\\n {class_report}\\n\")\n elif cv==False:\n scores = cross_validate(model, X_test, y_test, scoring=scoring)\n ypredTest = model.predict(X_test)\n Acc_test = scores['test_acc'].mean()\n Precision_test = scores['test_prec_micro'].mean()\n Recall_test = scores['test_rec_micro'].mean()\n F1_test = scores['test_f1_micro'].mean()\n AUC_test = scores['test_auc'].mean()\n conf_matrix_test = confusion_matrix(y_test, ypredTest)\n class_report = classification_report(y_test, ypredTest) \n print(\"TEST:\\n===========================================\")\n print(f\"CV - Accuracy : {Acc_test:.2f}\\n\")\n print(f\"CV - Precision: {Precision_test:.2f}\\n\")\n print(f\"CV - Recall: {Recall_test:.2f}\\n\")\n print(f\"CV - F1 score: {F1_test:.2f}\\n\") \n print(f\"CV - AUC score: {AUC_test:.2f}\\n\") \n print(f\"Confusion Matrix:\\n {conf_matrix_test}\\n\")\n print(f\"Classification Report:\\n {class_report}\\n\")","def cross_validation_score(self, model, x, y, cv, groups):\n losses = []\n for train_idx, test_idx in cv.split(x, y, groups):\n x_tr, x_te = x[train_idx], x[test_idx]\n y_tr, y_te = y[train_idx], y[test_idx]\n\n model.fit(x_tr, y_tr)\n if self.is_classier:\n test_preds = model.predict_proba(x_te)[:, 1]\n else:\n test_preds = model.predict(x_te)[:,]\n loss = self.loss_metric(y_true=y_te, y_pred=test_preds)\n losses.append(loss)\n return np.mean(losses)","def ovo_classifier(X_train, y_train, X_val, y_val):\n beta_matrix = []\n #obj_matrix =[obj(np.zeros(X_train.shape[1]), 1, X_train, y_train, h=0.5)]\n obj_matrix = []\n final_matrix = []\n final_matrix_test =[]\n for i in np.unique(y_train):\n for j in np.unique(y_train):\n if i < j:\n print(i,j)\n # Slicing X train and y train into each pair wise comparison\n # location scale y labels into [-1,1] for loss calculation\n sliced_X_train = X_train[np.ix_(np.bitwise_or(y_train == i, y_train == j))]\n sliced_y_train = ((y_train[np.ix_(np.bitwise_or(y_train == i, y_train == j))]-min(i,j))/(max(i,j)-min(i,j)))*2-1\n \n # generating index for cross validation indexing\n index = np.random.randint(low=0,high=3,size=sliced_X_train.shape[0])\n print('starting cross validation...', i, j)\n avg_error, set_of_lambda = fold3_CV_for_lambda(x=sliced_X_train, y=sliced_y_train, index=index)\n optimal_lambda = set_of_lambda[np.argmin(avg_error)]\n print('starting mylinearsvm...', i, j)\n beta_vals, obj_vals = mylinearsvm(beta = np.zeros(sliced_X_train.shape[1]),\n \t lambd = optimal_lambda,\n x = sliced_X_train,\n y = sliced_y_train,\n step_size_init=1)\n \n # Store classifier and objective value from each iteration\n beta_matrix.append(np.copy(beta_vals[-1]))\n obj_matrix.append(np.copy(obj_vals))\n\n print('starting prediction...', i, j)\n # Predict y_val from X_val using the trained classifiers\n pred = 2*(beta_vals.dot(X_val.T)>0)-1\n y_hat = np.zeros(X_val.shape[0])\n y_hat[pred[-1]==1] = j\n y_hat[pred[-1]==-1] = i\n final_matrix.append(np.copy(y_hat))\n\n beta_matrix = np.array(beta_matrix)\n obj_matrix = np.array(obj_matrix)\n print('beta matrix shape:', beta_matrix.shape)\n print('obj matrix shape:', obj_matrix.shape)\n\n prediction_matrix = np.array(final_matrix)\n \n y_val_pred = []\n for f in range(X_val.shape[0]):\n data = pd.DataFrame(prediction_matrix[:,f].astype(int))\n # Use mode to find the most frequent class\n assignment = data.mode()\n # In the case of a tie, use random int generator for the indexing of a random mode\n if assignment.shape[0] > 1:\n assign = assignment.loc[np.random.randint(assignment.shape[0]),0]\n else:\n assign = assignment.loc[0,0]\n y_val_pred.append(assign)\n \n misclassification_error = np.mean(np.array(y_val_pred) != y_val)\n print('misclassification_error:', misclassification_error)\n \n return np.array(beta_matrix), np.array(obj_matrix), np.array(y_val_pred), misclassification_error","def test_searchcv_runs_multiple_subspaces():\n\n X, y = load_iris(True)\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, train_size=0.75, random_state=0\n )\n\n opt = BayesSearchCV(\n SVC(),\n [\n ({\n 'C': Real(1e-6, 1e+6, prior='log-uniform'),\n 'gamma': Real(1e-6, 1e+1, prior='log-uniform'),\n }, 10),\n {\n 'degree': Integer(1, 8),\n 'kernel': Categorical(['linear', 'poly', 'rbf']),\n }\n ],\n n_iter=10\n )\n\n opt.fit(X_train, y_train)","def run(self, df: pd.DataFrame, model: Any):\n print(f'Running cross validation with the following model:\\n{model}')\n\n df['timestamp'] = pd.to_datetime(df['timestamp'])\n\n date_1 = datetime.datetime(year=2016, month=1, day=1)\n date_2 = datetime.datetime(year=2016, month=4, day=1)\n date_3 = datetime.datetime(year=2016, month=7, day=1)\n date_4 = datetime.datetime(year=2016, month=10, day=1)\n date_5 = datetime.datetime(year=2017, month=1, day=1)\n\n summaries: List[FoldSummary] = []\n\n for train_start, train_end, test_start, test_end in [\n (date_1, date_2, date_2, date_3),\n # (date_1, date_3, date_3, date_4),\n # (date_1, date_4, date_4, date_5)\n ]:\n print('Calculating train and test datasets')\n train_df = df[(df['timestamp'] >= train_start) & (df['timestamp'] < train_end)]\n test_df = df[(df['timestamp'] >= test_start) & (df['timestamp'] < test_end)]\n\n columns = list(train_df.columns)\n columns.remove('timestamp')\n columns.remove('meter_reading')\n\n print(columns)\n\n train_data = train_df[columns]\n test_data = test_df[columns]\n\n print(f'Fitting the model on train dataset of size {len(train_data)}')\n model.fit(train_data, train_df['meter_reading'])\n print(f'Predicting for test dataset of size {len(test_data)}')\n predictions = model.predict(test_data)\n\n score = self._calculate_score(predictions, test_df['meter_reading'])\n print(f'Score: {score}')\n\n summaries.append(FoldSummary(\n train_start=train_start,\n train_end=train_end,\n test_start=test_start,\n test_end=test_end,\n score=score\n ))\n\n filename = f'../resources/runs/{time.time()}.txt'\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n with open(filename, 'w+') as f:\n f.write(f'{model.__class__.__name__}\\n')\n f.write(f'{str(model.get_params())}\\n')\n for summary in summaries:\n f.write(f'Summary (\\n'\n f'\\ttrain start: {summary.train_start}\\n'\n f'\\ttrain end: {summary.train_end}\\n'\n f'\\ttest start: {summary.test_start}\\n'\n f'\\ttest end: {summary.test_end}\\n'\n f'\\tscore: {summary.score}\\n'\n f')\\n')\n\n print(summaries)\n\n return model","def cross_validate(model, X, y, folds=5, epochs=5, batch_size=32, callbacks=None, shuffle=False, random_state=None):\n\n # Initalize KFold\n kfolds = KFold(n_splits=folds, random_state=random_state, shuffle=shuffle)\n all_metrics = []\n\n # To build the model\n if type(model).__name__ == 'SVDpp':\n model.implicit_feedback(X[:10, :])\n model(X[:10, :])\n\n # Workaround to reset weights after each fold fit\n weights = model.get_weights()\n i = 1\n\n for train, val in kfolds.split(X, y):\n\n # Gather implicit feedback if model is SVD++\n if type(model).__name__ == 'SVDpp':\n model.implicit_feedback(X[train])\n\n print(f'\\nFitting on Fold {i}')\n # Train and evaluate metrics\n history = model.fit(\n X[train], y[train], batch_size=batch_size, epochs=epochs, callbacks=callbacks)\n print(f'\\nEvaluating on Fold {i}')\n fold_score = history.model.evaluate(X[val], y[val])\n all_metrics.append(fold_score)\n\n # Reset Weights\n model.set_weights(weights)\n\n i += 1\n\n all_metrics = np.array(all_metrics)\n\n for i, metric in enumerate(model.metrics_names):\n print(f'Mean {metric.capitalize()} : {np.mean(all_metrics.T[i])}')\n\n return all_metrics","def classify(self, X, y):\n\n clf = svm.SVC(kernel='linear', C=1)\n cv = StratifiedKFold(n_splits=5, random_state=0, shuffle=True)\n\n scores = cross_val_score(clf, X, y, cv=cv, scoring='balanced_accuracy')\n\n return scores","def crossValidate(cls, trinary_data, num_holdout=5, num_iter=10,\n clf_desc=ClassifierDescriptorSVM(), **kwargs):\n def dropIndices(df, indices):\n \"\"\"\n Drops the indices from the dataframe or series.\n \"\"\"\n df_result = df.copy()\n sorted_indices = list(indices)\n sorted_indices.sort()\n sorted_indices.reverse()\n for idx in sorted_indices:\n df_result = df_result.drop(idx, axis=0)\n return df_result\n #\n def getClasses(indices=None):\n \"\"\"\n Returns the list of classes for the indices.\n \"\"\"\n if indices is None:\n indices = list(trinary_data.ser_y.index)\n return list(set(trinary_data.ser_y.loc[indices]))\n #\n svm_ensemble = cls(clf_desc=clf_desc, **kwargs)\n all_classes = getClasses()\n total_correct = 0\n for _ in range(num_iter):\n # Select holdouts for each class\n holdout_idxs = []\n for cls in all_classes:\n cls_ser = trinary_data.ser_y[trinary_data.ser_y == cls]\n cls_idxs = list(cls_ser.index)\n if num_holdout >= len(cls_idxs):\n raise ValueError(\"Not enough samples in class %s for %d holdouts!\"\n % (cls, num_holdout))\n # Choose holdouts\n random_positions = np.random.permutation(range(len(cls_idxs)))\n [holdout_idxs.append(cls_idxs[n])\n for n in random_positions[:num_holdout]]\n # Fit\n df_X = dropIndices(trinary_data.df_X, holdout_idxs)\n ser_y = dropIndices(trinary_data.ser_y, holdout_idxs)\n svm_ensemble.fit(df_X, ser_y)\n # Evaluate\n df = pd.DataFrame(trinary_data.df_X.loc[holdout_idxs, :])\n df_pred = svm_ensemble.predict(df)\n for idx in holdout_idxs:\n true_cls = trinary_data.ser_y.loc[idx]\n total_correct += df_pred.loc[idx, true_cls]\n accuracy = total_correct/(num_holdout*num_iter*len(all_classes))\n return accuracy","def cross_validate(featureFile, nFolds, verbosity = False, percentTData = 1., extype='attribution'):\n oData,aData = importC5(featureFile)\n nAuthors = len(set(aData))\n if extype == 'attribution' and np.mean(Counter(aData).values()) != Counter(aData).values()[0]:\n print('Number of docs per author should be equal in attribution experiment')\n docsPerFold = len(oData) / nFolds\n cMatrix = np.zeros( (nAuthors, nAuthors) )\n\n for N in range(0,nFolds):\n testAuthors = list()\n trainAuthors= list()\n testData = list()\n trainData = list()\n for idv in range(0,len(oData)):\n if (N+idv) % nFolds == 0:\n testData.append(oData[idv])\n testAuthors.append(aData[idv])\n else:\n trainData.append(oData[idv])\n trainAuthors.append(aData[idv]) \n teFile = '%s.cvtest' % (os.path.splitext(featureFile)[0])\n trFile = '%s.cvtrain' % (os.path.splitext(featureFile)[0])\n tAmount = int(round(len(trainAuthors) * percentTData)) # limit training data\n exportFoldFile(testData, testAuthors, teFile)\n exportFoldFile(trainData[0:tAmount], trainAuthors[0:tAmount], trFile)\n predict = classify(trFile, teFile, len(oData[0]))\n if extype != 'attribution':\n cMatrix += confusionMatrix(testAuthors, predict, extype)\n os.remove(teFile)\n os.remove(trFile)\n if percentTData != 1.0: print('Ran CV only with %.f %% (%d docs) of training data.' % (percentTData * 100, tAmount))\n return cMatrix","def learn1_svc():\n \n svc.fit(vector_training,sentiment_training) ##fit the training data of vector tweets and sentiments using LinearSVC\n correct = 0\n for i in range(vector_testing.shape[0]): ##using the testing data, see how accurate LinearSVC is\n prediction = svc.predict(vector_testing[i])\n sentiment = sentiment_testing[i]\n if prediction[0] == sentiment:\n correct +=1\n accuracy = correct/vector_testing.shape[0]\n print('Linear Support Vector Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##print the accuracy of the algorithm","def LOSO_cross_validation(signal, device):\n rf = RandomForestClassifier(random_state=0)\n hyperparams = {\"n_estimators\": [30, 50, 100], \"max_depth\": [10, 30, 50]}\n clf = GridSearchCV(estimator=rf, param_grid=hyperparams, scoring=\"accuracy\", cv=None, refit=True, verbose=0)\n\n all_subjects_but_one = []\n for subject_out in range(0, 51):\n for subject_in in range(0, 51):\n if subject_in == subject_out:\n print(f'Leaving subject {subject_out} out: \\n ==================================================')\n else:\n _, _, _, _, normalized_all_feature, all_labels = input_features_labels(device=device,\n signal=signal,\n subject_ID=subject_in)\n feature_label = pd.concat([normalized_all_feature, all_labels], axis=1)\n all_subjects_but_one.append(feature_label)\n\n all_subjects_but_one = pd.concat(all_subjects_but_one, axis=0)\n all_subjects_but_one = all_subjects_but_one.dropna()\n feature_train = all_subjects_but_one.drop(columns=['Activity_ID'])\n label_train = all_subjects_but_one['Activity_ID']\n print(feature_train)\n print(label_train)\n\n _, _, _, _, feature_test, label_test = input_features_labels(device=device,\n signal=signal, subject_ID=subject_out)\n print(feature_test)\n print(label_test)\n clf.fit(feature_train, label_train)\n print('Best parameters: ', clf.best_params_)\n prediction = clf.predict(feature_test)\n report = sklearn.metrics.classification_report(label_test, prediction, digits=3, zero_division=1)\n\n conf_matrix = confusion_matrix(label_test, prediction)\n print(conf_matrix.shape[0])\n # plotitng_confusion_matrix(confusion_matrix=con_matrix, evaluation_mode='personal', subject_ID=subject_ID)\n print(report)\n for row in range(conf_matrix.shape[0]):\n print(f'Accuracy for class {row}: ',\n accuracy_per_class(conf_matrix=conf_matrix, row_index=row, to_print=False))\n\n all_subjects_but_one = []","def CalculateSVM(data=None):\n vectorizer = TfidfVectorizer(tokenizer=pre_process)\n classifier = LinearSVC()\n train, test = train_test_split([(i['text'], i['stars']) for i in data],\n test_size=.2,\n random_state=10)\n x_train = vectorizer.fit_transform(i[0] for i in train)\n x_test = vectorizer.transform(i[0] for i in test)\n classifier.fit(x_train, [i[1] for i in train])\n score = classifier.score(x_test, [i[1] for i in test])\n print score","def cross_validation(self, cv, lambdas, lambda_name, seed=1, skip=False, plot=False, **kwargs):\n np.set_printoptions(precision=4)\n k_indices = build_k_indices(self.train_y, cv, seed)\n # define lists to store the loss of training data and test data\n err_tr = []\n err_te = []\n weights = []\n print(\"K-fold ({}) cross validation to examine [{}]\".\n format(cv, lambdas))\n for lamb in lambdas:\n print(\"For lambda: {}\".format(lamb))\n _mse_tr = []\n _mse_te = []\n _weight = []\n for k in range(cv):\n print('Cross valid iteration {}'.format(k))\n weight, loss_tr, loss_te = self._loop_cross_validation(self.train_y, self.train_x,\n k_indices, k,\n lamb, lambda_name, **kwargs)\n _mse_tr += [loss_tr]\n _mse_te += [loss_te]\n _weight.append(weight)\n if skip:\n break\n avg_tr = np.average(_mse_tr)\n avg_te = np.average(_mse_te)\n err_tr += [avg_tr]\n err_te += [avg_te]\n weights.append(_weight)\n print(\"\\t train error {}, \\t valid error {}\".\n format(avg_tr, avg_te))\n # Select the best parameter during the cross validations.\n print('K-fold cross validation result: \\n {} \\n {}'.\n format(err_tr, err_te))\n # Select the best based on least err_te\n min_err_te = np.argmin(err_te)\n print('Best err_te result {}, lambda {}'.\n format(err_te[min_err_te], lambdas[min_err_te]))\n if plot:\n from plots import cross_validation_visualization\n cross_validation_visualization(lambdas, err_tr, err_te, title=lambda_name,\n error_name=self.loss_function_name)\n else:\n save_numpy_array(lambdas, err_tr, err_te, names=['lambda', 'err_tr', 'err_te'], title=self.regularizer.name)\n\n return weights[min_err_te], lambdas[min_err_te], (err_tr, err_te)","def ex_3_a(x_train, y_train, x_test, y_test):\n ###########\n ## Train multi-class SVMs with one-versus-rest strategy with\n ## - linear kernel\n ## - rbf kernel with gamma going from 10**-5 to 10**5\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\n ###########\n dfs = 'ovr'\n c = 10\n\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\n linear.fit(x_train, y_train)\n lin_score_train = linear.score(x_train, y_train)\n lin_score_test = linear.score(x_test, y_test)\n\n gammas = [pow(10, i) for i in range(-5, 6)]\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\n for rbf in rbfs:\n rbf.fit(x_train, y_train)\n\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\n\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)","def cross_val_SVM_linear(variables, targeted):\n\n\tsvm = SVC(kernel = \"linear\")\n\tpca = decomposition.PCA()\n\tpipe = Pipeline(steps=[('pca', pca), ('svm', svm)])\n\n\tn_components = [4,5]\n\tC = np.logspace(-10,10,10)\n\n\testimator = GridSearchCV(\n\t\tpipe,\n\t\tdict(pca__n_components = n_components,\n\t\t\tsvm__C = C)\n\t\t)\n\t\n\tpredicted = cross_val_predict(\n\testimator, variables, targeted, cv = 5)\n\n\treturn {\n\t\t'accuracy':metrics.accuracy_score(targeted, predicted),\n\t\t'report':metrics.classification_report(targeted, predicted)\n\t\t}","def train_all(self, dataset, mu=None):\n\n\t\tX = dataset.X #get_design_matrix()\n\t\ty = dataset.y\n\n\t\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\n\t\t\t\tclass_weight = None, coef0=0.0, degree=3,\n\t\t\t\tmax_iter = -1, probability=False, random_state=None,\n\t\t\t\tshrinking = True, tol=0.001, verbose=False)\n\t\tclf.fit (X, y)\n\t\t\n\t\t# save the last classifier\n\t\tself.classifier = clf\n\n\t\t# get model parameter\n\t\tself.alpha = clf.dual_coef_\n\t\tself.bias = clf.intercept_\n\t\t# TODO\n\t\tself.params = clf.get_params (deep=True)\n\n\n\t\t#TODO:self.mu = sharedX(mu)?\n\t\tself._params = [self.alpha, self.bias]\n\t\tprint(self._params)","def SVM(x_train, x_test, y_train, kernel):\n svc_model = SVC(kernel=kernel)\n svc_model.fit(x_train, y_train)\n y_pred = svc_model.predict(x_test)\n return y_pred","def cross_validation(ww_data, rw_data, k):\n # shuffle the data\n np.random.shuffle(ww_data)\n np.random.shuffle(rw_data)\n\n # calculate cutoff for each partition\n cutoff = ww_data.shape[0]//k\n redArr = []\n whiteArr = []\n tmpStart = 0\n tmpEnd = cutoff\n \n # create a list of k partitions for red and white data\n for x in range(k):\n if x != k-1:\n redArr.append(rw_data[tmpStart:tmpEnd])\n whiteArr.append(ww_data[tmpStart:tmpEnd])\n else:\n redArr.append(rw_data[tmpStart:])\n whiteArr.append(ww_data[tmpStart:])\n tmpStart+=cutoff\n tmpEnd+=cutoff\n\n\n redTraining = np.array(())\n whiteTraining = np.array(())\n accuracy = 0\n count = 0\n \n for x in range(k):\n # creates Test data set\n tmpRedTest = redArr[x]\n tmpWhiteTest = whiteArr[x]\n \n # creates list of partitons for training data set\n if x!=k-1:\n redTrainingList = redArr[:x] + redArr[x+1:]\n whiteTrainingList = whiteArr[:x] + whiteArr[x+1:]\n else:\n redTrainingList = redArr[:x]\n whiteTrainingList = whiteArr[:x]\n\n # stacks each training list into one nparray\n redTraining = np.vstack(redTrainingList)\n whiteTraining = np.vstack(whiteTrainingList)\n\n accuracy += experiment(whiteTraining, redTraining, tmpWhiteTest, tmpRedTest)\n count += 1\n # calculates accuracy and returns it\n result = accuracy/count\n return result","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n\n test_scores = np.array([])\n train_scores = np.array([])\n best_svm = None\n best_test_score = 0\n\n for gamma in gammas:\n clf = svm.SVC(kernel='rbf', gamma=gamma)\n clf.fit(x_train, y_train)\n\n test_score = clf.score(x_test, y_test)\n\n if test_score > best_test_score:\n best_test_score = test_score\n best_svm = clf\n\n test_scores = np.append(test_scores, test_score)\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\n\n plot_score_vs_gamma(train_scores, test_scores, gammas)\n\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)","def SVM():\n x1, x2 = generate_training_data_2D()\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\n np.ones(x2.shape[0], dtype=np.int32)])\n X = np.concatenate([x1, x2], axis=0)\n rng = np.random.get_state()\n np.random.shuffle(X)\n # Set the random state back to previous to shuffle X & Y similarly\n np.random.set_state(rng)\n np.random.shuffle(Y)\n\n models, titles = get_fitted_svm(X, Y)\n\n plot_decision_boundary(X, Y, models, titles)","def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\n if not scaled :\n scaler = StandardScaler()\n xtrain = scaler.fit_transform(xtrain)\n xtest = scaler.transform(xtest)\n\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\n return svm","def train(self, X, y, X_cv=None, y_cv=None, verbose=False):\n np.random.seed(seed=self.randomSeed)\n\n n, m = X.shape # n samples, m features\n if self.loss == 'linear':\n w = np.array([np.zeros(m)]).T # dim: m by 1\n elif self.loss == 'logistic':\n w = np.array([np.random.rand(m)]).T / 1 # dim: m by 1\n # w = np.array([np.zeros(m)]).T # dim: m by 1\n elif self.loss == 'perceptron':\n w = np.array([np.random.rand(m)]).T # dim: m by 1\n # w = np.array([np.zeros(m)]).T # dim: m by 1\n elif self.loss == 'svm':\n w = np.array([np.random.rand(m)]).T / 5 # dim: m by 1\n # w = np.array([np.zeros(m)]).T # dim: m by 1\n\n for i in range(1, self.iteration + 1):\n gradient = self.computeGradient(X, y, w)\n w = w - self.learning_rate * gradient / n\n Error, Acc = self.evaluate(X, y, w)\n self.trainError.append(Error)\n self.trainAcc.append(Acc)\n self.w.append(w)\n # evaluate on the cross-validation set\n if self.CV == True:\n tmp_cv_Error, tmp_cv_Acc = self.evaluate(X_cv, y_cv, w)\n self.cvError.append(tmp_cv_Error)\n self.cvAcc.append(tmp_cv_Acc)\n\n # print current process\n if verbose == True and self.showFreq != 0 and i % self.showFreq == 0:\n print(str(i) + \"th Iteration, \", \"Error: \", Error, \" Accuracy : \", Acc)\n if self.CV == True:\n print(\"Cross-Validation: \", \"Error: \", tmp_cv_Error, \" Accuracy : \", tmp_cv_Acc)\n if verbose == True:\n print(\"Reach the Maximum Iteration : \" + str(i) + \"th Iteration\")\n bestError, bestAcc, bestW = self.getBest(\"Accuracy\")\n print(\"Best Training Error: \", bestError, \" Highest Training Accuracy : \", bestAcc)\n if self.CV == True:\n best_cv_Error, best_cv_Acc = self.evaluate(X_cv, y_cv, bestW)\n print(\"Best Development Error: \", best_cv_Error, \" Highest Development Accuracy : \", best_cv_Acc)","def nested_cv(X, y, model, n_splits, n_folds, unique_id):\n \n cv = StratifiedKFold(n_splits=n_splits,\n shuffle=True,\n random_state=42) # Outer CV\n \n i_start = 0\n i_list = []\n results_df = None\n cv_path = unique_id + '_NestedCV.pkl'\n \n if os.path.isfile(cv_path) == True: # If CV is incomplete, resume\n results_df = pd.read_pickle(cv_path)\n i_start = results_df.Outer_fold.max() + 1\n print('Resuming cross-validation from fold ' + str(i_start + 1))\n \n # Generate indices to split data by StratifiedKFold\n # Append indices for each fold to list \n for tr_i, te_i in cv.split(X,y):\n i_list.append([tr_i, te_i])\n \n # For each fold...\n for i in range(i_start, len(i_list)):\n results_list = []\n print('Beginning fold ' + str(i+1) + ' of ' + str(len(i_list)))\n \n # Split data into training and test tests\n X_train = X.loc[X.index.intersection(i_list[i][0])]\n y_train = y.loc[y.index.intersection(i_list[i][0])]\n X_test = X.loc[X.index.intersection(i_list[i][1])]\n y_test = y.loc[y.index.intersection(i_list[i][1])]\n\n start = time.time()\n \n # Fit the HyperoptEstimator to training data (optimise model)\n model.fit(X_train,\n y_train,\n n_folds=n_folds, # Inner stratified k-fold CV\n cv_shuffle=True)\n \n end = time.time()\n duration = end - start\n\n # Use optimised model to predict labels for test data\n y_pred = model.predict(X_test)\n score = f1_score(y_test, y_pred, average='weighted') # Evaluate\n \n # Everything below: formats and/or calculates results for output file\n sorted_labels = np.sort(y_test.unique())\n unweighted_score = f1_score(y_test, y_pred,\n average=None,\n labels=sorted_labels)\n c_matrix = confusion_matrix(y_test, y_pred,\n labels=sorted_labels)\n\n for trial in range(len(model.trials.trials)):\n if model.trials.trials[trial].get('result').get('status') == 'ok':\n trial_loss = model.trials.trials[trial].get('result').get('loss')\n trial_duration = model.trials.trials[trial].get('result').get('duration')\n else:\n trial_loss = np.nan\n trial_duration = np.nan\n \n results_list.append([i,\n score,\n unweighted_score,\n le.inverse_transform(sorted_labels),\n c_matrix,\n duration,\n trial,\n trial_loss,\n trial_duration])\n \n append_df = pd.DataFrame(results_list,\n columns=['Outer_fold',\n 'Outer_score',\n 'Outer_unweighted_scores',\n 'Outer_unweighted_score_labels',\n 'Outer_confusion_matrix',\n 'Outer_training_duration',\n 'Trial',\n 'Trial_loss',\n 'Trial_duration'])\n if i == i_start:\n if results_df is not None:\n final_df = pd.concat([results_df,\n append_df],\n ignore_index=True)\n else:\n final_df = append_df\n final_df.to_pickle(cv_path)\n \n else:\n results_df = pd.read_pickle(cv_path)\n final_df = pd.concat([results_df,\n append_df],\n ignore_index=True)\n final_df.to_pickle(cv_path)","def cross_validate(all_tetrode_data, target, tetrode_ids, tetrode_units, verbose=True):\n kf = StratifiedKFold(n_splits=10)\n y_true = np.zeros(target.shape)\n y_hat = np.zeros(target.shape)\n i = 0\n\n for train_index, test_index in kf.split(np.zeros(target.shape[0]), target.argmax(axis=-1)):\n X_train, X_test = select_data(all_tetrode_data, train_index), select_data(all_tetrode_data, test_index)\n y_train, y_test = target[train_index, :], target[test_index, :]\n\n model = build_tetrode_model(tetrode_ids, tetrode_units)\n checkpointer = ModelCheckpoint('temp_model.h5',\n verbose=0, save_best_only=True)\n hist = model.fit(X_train, y_train,\n nb_epoch=200, batch_size=20,\n validation_data=(X_test, y_test),\n callbacks=[checkpointer], verbose=0)\n best_model = load_model('temp_model.h5')\n\n n = y_test.shape[0]\n y_true[i:(i + n), :] = y_test\n y_hat[i:(i + n), :] = best_model.predict(X_test)\n i += n\n\n if verbose:\n accuracy = max(hist.history['val_acc'])\n print('Current fold validation accuracy: {acc}'.format(acc=accuracy))\n\n return y_true, y_hat","def cross_validation(self, X, y, n_folds=5, shuffle=True, evaluation_metric='top30'):\n # WE DON'T USE THIS\n # We use basic train-test split to evaluate or models as a first approach\n # We will then use CV for searching the best parameters via random search\n pass","def cross_validation(whole_train_data, whole_train_labels, k, k_fold):\n accuracies = []\n for i in range(k_fold):\n train_data, train_labels, validation_data, validation_labels = split_train_and_validation(whole_train_data, whole_train_labels, i, k_fold)\n accuracy = knn(train_data, train_labels, validation_data, validation_labels, k)\n accuracies.append(accuracy)\n avg_accuracy = np.mean(accuracies)\n return avg_accuracy","def executeKFoldValidation(train_data, train_labels, val_data, val_labels, test_data, test_labels,\n images_47, labels_47, images_84, labels_84, all_unseen_images, all_unseen_labels):\n if run_k_fold_validation:\n print(\"In executingKFoldValidation\")\n\n # this is doing it manually:\n kfold = StratifiedKFold(n_splits=k_fold_num, shuffle=True)\n\n test_scores_list = []\n unseen_47_scores_list = []\n unseen_84_scores_list = []\n all_unseen_scores_list = []\n\n test_matrix_list = []\n matrix_47_list = []\n matrix_84_list = []\n all_matrix_list = []\n kf_counter = 0\n\n for train, test in kfold.split(train_data, train_labels):\n kf_counter += 1\n print('KFold #:', kf_counter)\n\n model = buildClassifier()\n # fit the model\n model.fit(train_data[train],\n train_labels[train],\n epochs=epochs,\n validation_data=(val_data, val_labels),\n batch_size=batch_size\n )\n\n unseen_47_scores = model.evaluate(images_47, labels_47, batch_size=batch_size)\n unseen_47_scores_list.append(unseen_47_scores[1] * 100)\n unseen_84_scores = model.evaluate(images_84, labels_84, batch_size=batch_size)\n unseen_84_scores_list.append(unseen_84_scores[1] * 100)\n test_scores = model.evaluate(test_data, test_labels, batch_size=batch_size)\n test_scores_list.append(test_scores[1] * 100)\n all_unseen_score = model.evaluate(all_unseen_images, all_unseen_labels, batch_size=batch_size)\n all_unseen_scores_list.append(all_unseen_score[1] * 100)\n\n # show confusion matrix\n test_confusion_matrix, confusion_matrix_47, confusion_matrix_84, all_confusion_matrix = \\\n gettingKFoldConfusionMatrix(test_data, test_labels, images_47, labels_47, images_84, labels_84,\n all_unseen_images,\n all_unseen_labels, kf_counter)\n test_matrix_list.append(test_confusion_matrix)\n matrix_47_list.append(confusion_matrix_47)\n matrix_84_list.append(confusion_matrix_84)\n all_matrix_list.append(all_confusion_matrix)\n\n test_scores_mean = np.mean(test_scores_list)\n test_scores_std = np.std(test_scores_list)\n unseen_47_mean = np.mean(unseen_47_scores_list)\n unseen_47_std = np.std(unseen_47_scores_list)\n unseen_84_mean = np.mean(unseen_84_scores_list)\n unseen_84_std = np.std(unseen_84_scores_list)\n all_unseen_mean = np.mean(all_unseen_scores_list)\n all_unseen_std = np.std(all_unseen_scores_list)\n\n print(\"Test Scores: \" + str(test_scores_list))\n print(\"Test Scores Mean: \" + str(test_scores_mean))\n print(\"Test Scores Std: \" + str(test_scores_std))\n print(\"Unseen 47 Scores: \" + str(unseen_47_scores_list))\n print(\"Unseen 47 Scores Mean: \" + str(unseen_47_mean))\n print(\"Unseen 47 Scores Std: \" + str(unseen_47_std))\n print(\"Unseen 84 Scores: \" + str(unseen_84_scores_list))\n print(\"Unseen 84 Scores Mean: \" + str(unseen_84_mean))\n print(\"Unseen 84 Scores Std: \" + str(unseen_84_std))\n print(\"All Unseen Scores: \" + str(all_unseen_scores_list))\n print(\"All Unseen Scores Mean: \" + str(all_unseen_mean))\n print(\"All Unseen Scores Std: \" + str(all_unseen_std))\n print(\"Test Confusion Matrices: \" + str(test_matrix_list))\n print(\"47 Confusion Matrices: \" + str(matrix_47_list))\n print(\"84 Confusion Matrices: \" + str(matrix_84_list))\n print(\"All Confusion Matrices: \" + str(all_matrix_list))\n\n excel_headers.append(\"Test Scores Mean\")\n excel_dictionary.append(test_scores_mean)\n excel_headers.append(\"Test Scores Std\")\n excel_dictionary.append(test_scores_std)\n excel_headers.append(\"Unseen 47 Scores Mean\")\n excel_dictionary.append(unseen_47_mean)\n excel_headers.append(\"Unseen 47 Scores Std\")\n excel_dictionary.append(unseen_47_std)\n excel_headers.append(\"Unseen 84 Scores Mean\")\n excel_dictionary.append(unseen_84_mean)\n excel_headers.append(\"Unseen 84 Scores Std\")\n excel_dictionary.append(unseen_84_std)\n excel_headers.append(\"All Unseen Scores Mean\")\n excel_dictionary.append(all_unseen_mean)\n excel_headers.append(\"All Unseen Scores Std\")\n excel_dictionary.append(all_unseen_std)\n\n plt.plot(test_scores_list, color='red', label='Testing Scores')\n plt.plot(unseen_47_scores_list, color='blue', label='Unseen 47 Scores')\n plt.plot(unseen_84_scores_list, color='black', label='Unseen 84 Scores')\n plt.plot(all_unseen_scores_list, color='green', label='Unseen Scores')\n plt.xlabel('Folds')\n plt.ylabel('Accuracy')\n plt.legend()\n\n plt.show()","def cross_validation(self, x, t):\n # Initialize accuracy / hyperparameters\n best_accuracy = 0.0\n best_reg = 0.0\n\n # Cross-validation 80-20\n N = x.shape[0]\n N_train = int(math.floor(0.8 * N))\n\n # Initialize the grid search hyperparameters\n min_reg = 0.001\n max_reg = 1000\n log_min_reg = np.log(min_reg)\n log_max_reg = np.log(max_reg)\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\n\n for reg in reg_list:\n accuracy = np.zeros((self.k_fold))\n for i in range(self.k_fold):\n map_index = list(zip(x, t))\n random.shuffle(map_index)\n random_x, random_t = zip(*map_index)\n\n train_x = random_x[:N_train]\n valid_x = random_x[N_train:]\n train_t = random_t[:N_train]\n valid_t = random_t[N_train:]\n\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=reg, max_iter=1000, \n random_state=self.random_state)\n self.train(train_x, train_t)\n accuracy[i] = self.model.score(valid_x, valid_t)\n\n mean_accuracy = np.mean(accuracy)\n # print(mean_accuracy)\n if mean_accuracy > best_accuracy:\n best_accuracy = mean_accuracy\n best_reg = reg\n print(\"The new best hyperparameters are : \", best_reg)\n\n print(\"Best hyperparameters are : \", best_reg)\n print(\"Valid Accuracy :\", best_accuracy)\n self.reg = best_reg\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=best_reg, max_iter=1000, \n random_state=self.random_state)\n self.train(x, t)","def test_svm_cnn_comparison_alex(self, syn_fm, syn_labels, syn_labels_cat, rep, syn_idx):\n\n fm_3d = syn_fm(\"3d\")\n fm_2d = syn_fm(\"2d\")\n\n def fit_cnn(x, y, idx):\n best_params_montaez['n_snps']= x.shape[1]\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(y[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n return model.fit(x=x[idx.train], y=y[idx.train], validation_data=(x[idx.test], y[idx.test]), epochs=best_params_montaez['epochs'],class_weight=d_class_weights, callbacks=[ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min')]).history['val_weighted_categorical_accuracy'][-1]\n\t\t\t# change if you want accuracy or balanced accuracy: val_categorical_accuracy, val_weighted_categorical_accuracy, AUC(not working... would need higher keras version)\n\n def fit_svm(x, y, idx):\n # if you want to optimize c:\n #c_candidates = np.logspace(-7, -1, num=20)\n #scores=np.zeros(len(c_candidates))\n #for i in np.arange(len(c_candidates)):\n # c = c_candidates[i]\n # clf = LinearSVC(C=c, penalty='l2', loss='hinge', tol= 1e-3,dual=True, verbose=0, class_weight='balanced')\n # scores[i] = np.mean(cross_val_score(clf, x, y, cv=StratifiedShuffleSplit(n_splits=5), scoring='accuracy'))\n #print(c_candidates, scores)\t\t\t\n #c_max = c_candidates[np.argmax(scores)]\n c_max = 0.0022\n toy_classifier = LinearSVC(C=c_max, penalty='l2', loss='hinge', tol= 1e-3,dual=True, verbose=0, class_weight='balanced')\n bla = cross_val_score(toy_classifier, x, y, cv=StratifiedShuffleSplit(n_splits=5), scoring='balanced_accuracy')\n #change if you want accuracy or balanced accuracy: scoring = accuracy, balanced_accuracy, roc_auc, average_precision_score\n return np.mean(bla)\n\n svm_val_acc = Parallel(n_jobs=1)(delayed(fit_svm)(fm_2d[str(i)][:], syn_labels[str(i)], syn_idx[str(i)]) for i in tqdm(range(1, rep)))\n cnn_val_acc = Parallel(n_jobs=1)(delayed(fit_cnn)(fm_3d[str(i)][:], syn_labels_cat[str(i)], syn_idx[str(i)]) for i in tqdm(range(1, rep)))\n\n cnn_val_acc = cnn_val_acc * 100\n svm_val_acc = svm_val_acc * 100\n\n # 3. Compare average val_acc on all syn datasets\n print('SVM val_acc mean {} / std {} / max {} / min {}'.format(np.mean(svm_val_acc), np.std(svm_val_acc), np.max(svm_val_acc), np.min(svm_val_acc)))\n print('cnn val_acc mean {} / std {} / max {} / min {}'.format(np.mean(cnn_val_acc), np.std(cnn_val_acc), np.max(cnn_val_acc), np.min(cnn_val_acc)))","def run_cross_validation_create_models(nfolds=10):\n print(\"nfold value=\",nfolds)\n x_train, y_train, x_train_id = load_images_train()\n print(len(x_train))\n\n # input image dimensions\n batch_size = 16\n nb_epoch = 32\n random_state = 159\n\n seed = 7\n np.random.seed(seed)\n kfold = StratifiedKFold(n_splits=nfolds, shuffle=True, random_state=random_state)\n #kfold = StratifiedShuffleSplit(n_splits=nfolds,test_size=0.1,train_size=0.7,random_state=random_state)\n cvscores = []\n models = []\n\n image_array = np.asarray(x_train, dtype=np.float32)\n # print(image_array.shape)\n\n datagen_test = ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization=True,\n preprocessing_function=pre_processing_image\n )\n\n datagen = ImageDataGenerator(\n rotation_range=20,\n width_shift_range=0.2,\n height_shift_range=0.2,\n shear_range=0.2,\n zoom_range=0.2,\n preprocessing_function=pre_processing_image,\n vertical_flip=True,\n horizontal_flip=True,\n fill_mode='nearest'\n )\n\n start_time = time.time()\n print(\"Datagen.fit started\")\n datagen.fit(image_array, augment=True, rounds=3)\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\n\n img_label = np_utils.to_categorical(y_train, 8)\n\n yfull_train = dict()\n num_fold = 0\n sum_score = 0\n\n for train_index, test_index in kfold.split(x_train, y_train):\n # create model\n model = create_model()\n train_x = image_array[train_index]\n train_y = img_label[train_index]\n validate_x = image_array[test_index]\n validate_y = img_label[test_index]\n\n num_fold += 1\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\n print('Split train: ', len(train_x), len(train_y))\n print('Split valid: ', len(validate_x), len(validate_y))\n\n callbacks = [EarlyStopping(monitor='val_loss', min_delta=0, patience=4, verbose=1, mode='auto')]\n\n model.fit_generator(generator=datagen.flow(train_x, train_y, batch_size=batch_size, shuffle=True),\n steps_per_epoch=len(image_array)/32, epochs=nb_epoch, verbose=1,\n callbacks=callbacks,validation_data=(validate_x,validate_y),\n validation_steps=len(image_array)/32)\n\n predictions_valid = model.predict(validate_x.astype('float32'), batch_size=batch_size, verbose=1)\n\n\n score = log_loss(validate_y, predictions_valid)\n print('Score log_loss: ', score)\n\n\n sum_score += score * len(test_index)\n\n # Store valid predictions\n for i in range(len(test_index)):\n yfull_train[test_index[i]] = predictions_valid[i]\n\n models.append(model)\n\n score = sum_score / len(x_train)\n print(\"Log_loss train independent avg: \", score)\n\n info_string = 'loss_' + str(score) + '_folds_' + str(10) + '_ep_' + str(28)\n return info_string,models","def __cross_validation(self, classifier, X, y, k, stratify=True):\n\t\tif k == X.shape[0]:\t\t# leave-one-out\n\t\t\tkf = model_selection.KFold(n_splits=k)\n\t\telse:\n\t\t\tif stratify:\n\t\t\t\tkf = model_selection.StratifiedKFold(n_splits=k, shuffle=True, random_state=0)\n\t\t\telse:\n\t\t\t\tkf = model_selection.KFold(n_splits=k, shuffle=True, random_state=0)\n\n\t\t# training data and predictions for each fold\n\t\ty_train_list = []\n\t\ty_train_pred_list = []\n\t\ty_train_prob_list = []\n\t\ty_val_list = []\n\t\ty_val_pred_list = []\n\t\ty_val_prob_list = []\n\n\t\tfor train_idx, val_idx in kf.split(X, y):\n\t\t\tX_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n\t\t\ty_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n\t\t\ty_train_list.append(y_train)\n\t\t\ty_val_list.append(y_val)\n\n\t\t\t# catch convergence warning\n\t\t\twith warnings.catch_warnings():\n\t\t\t\twarnings.filterwarnings('error', category=exceptions.ConvergenceWarning)\n\t\t\t\ttry:\n\t\t\t\t\tclassifier = classifier.fit(X_train, y_train)\n\t\t\t\texcept exceptions.ConvergenceWarning:\n\t\t\t\t\tModel.counter -= 1\n\t\t\t\t\traise\n\n\t\t\ty_train_pred_list.append(classifier.predict(X_train))\n\t\t\ty_val_pred_list.append(classifier.predict(X_val))\n\t\t\ty_train_prob_list.append(classifier.predict_proba(X_train))\n\t\t\ty_val_prob_list.append(classifier.predict_proba(X_val))\n\n\t\tif k == X.shape[0]:\t\t# leave-one-out\n\t\t\ty_val = np.hstack(y_val_list)\n\t\t\ty_val_pred = np.hstack(y_val_pred_list)\n\t\t\ty_val_prob = np.vstack(y_val_prob_list)\n\n\t\t\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\n\t\t\t\tModelMetrics(classifier, y_val, y_val_pred, y_val_prob, 'loo')\n\t\telse:\n\t\t\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\n\t\t\t\tModelMetrics(classifier, y_val_list, y_val_pred_list, y_val_prob_list, 'cv')","def run_cross_validation_process_test(info_string, models):\n\n batch_size = 64\n num_fold = 0\n yfull_test = []\n x_test_id = []\n nfolds = len(models)\n\n datagen_test = ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization=True,\n preprocessing_function=pre_processing_image\n )\n\n # print(image_array.shape)\n x_test, x_test_id = load_images_test()\n print(len(x_test))\n image_test_array = np.asarray(x_test, dtype=np.float32)\n start_time = time.time()\n print(\"Datagen.fit started\")\n datagen_test.fit(image_test_array, augment=False)\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\n\n for i in range(nfolds):\n model = models[i]\n num_fold += 1\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\n\n #test_prediction = model.predict_generator(generator=datagen_test.fit(image_test_array, seed=79),\n # steps=len(image_test_array)/32, max_q_size=20, workers=8, verbose=1)\n\n test_prediction = model.predict(image_test_array, batch_size=batch_size, verbose=1)\n\n yfull_test.append(test_prediction)\n\n test_res = merge_several_folds_mean(yfull_test, nfolds)\n info_string = 'loss_' + info_string \\\n + '_folds_' + str(nfolds)\n create_submission(test_res, x_test_id, info_string)\n d=pd.DataFrame(test_res,columns=FISH_CLASSES)","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\n\n for machine in machines:\n machine.fit(x_train, y_train)\n\n trainScores = [machine.score(x_train, y_train) for machine in machines]\n testScores = [machine.score(x_test, y_test) for machine in machines]\n\n plot_score_vs_gamma(trainScores, testScores, gammas)\n\n bestGamma = np.argmax(testScores)\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)","def cross_validate(self, X, y):\n roc_ap = []\n kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=0)\n for train_ix, test_ix in kfold.split(X, y):\n train_X, test_X = X.iloc[train_ix, :], X.iloc[test_ix, :]\n train_y, test_y = y[train_ix], y[test_ix]\n self.train(train_X, train_y)\n roc_ap.append(self.test(test_X, test_y))\n return roc_ap","def run_CV(X,y,model,func, n_splits = 3, how = 'up', categorical = 'label_encoder'):\n logloss = []\n skf = StratifiedKFold(n_splits = n_splits, random_state = 144)\n for i, (train_idx, val_idx) in enumerate(skf.split(X,y)):\n X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n y_train, y_val = y[train_idx], y[val_idx]\n\n # # SMOTE\n # X_train = X_train.drop('poor', axis = 1) # drop target\n # cat_columns = X_train.select_dtypes(['object']).columns\n # X_train[cat_columns] = X_train[cat_columns].apply(LabelEncoder().fit_transform)\n # orig_cols = X_train.columns # SMOTE will return a numpy array. Store the column names here to recreate the dataframe for feature engineering/transforms below\n # X_train, y_train = SMOTE().fit_sample(X_train,y_train)\n # # recreate dataframe\n # X_train = pd.DataFrame(X_train, columns = orig_cols)\n\n if how is not None:\n # resample to balance data\n X_resampled = resample_data(X_train, how = how)\n # store the targets now that they are balanced\n y_train = X_resampled['poor']\n # drop target from train\n X_train = X_resampled.drop('poor', axis = 1)\n X_val.drop('poor', axis = 1, inplace = True)\n # print(X_val.columns.values)\n ####### feature engineering goes blow this comment:\n \n func(X_train)\n func(X_val)\n \n ###### end feature eng\n X_train = pre_process_data(X_train, normalize_num='standardize', categorical = categorical)\n assert X_train.shape[0] == y_train.shape[0]\n\n model.fit(X_train, y_train)\n # standardize X_val to predict\n X_val = pre_process_data(X_val,normalize_num= 'standardize', enforce_cols=X_train.columns, categorical = categorical)\n preds = model.predict_proba(X_val)\n \n logloss.append(log_loss(y_val, preds[:,1]))\n \n return logloss","def cross_validate(features, outputs, model): \n # do k-folds cross validation\n scores = cross_validation.cross_val_score(model,\n features,\n outputs)\n\n # get average accuracy\n return np.average(scores)","def cross_validate(self, pre_train=None, **kwargs):\n \n inferred = np.nan * np.ones_like(self.labels_array)\n N_training_set, N_labels = inferred.shape\n N_stop_at = kwargs.pop(\"N\", N_training_set)\n\n debug = kwargs.pop(\"debug\", False)\n \n kwds = { \"threads\": self.threads }\n kwds.update(kwargs)\n\n for i in range(N_training_set):\n \n training_set = np.ones(N_training_set, dtype=bool)\n training_set[i] = False\n\n # Create a clean model to use so we don't overwrite self.\n model = self.__class__(\n self.training_labels[training_set],\n self.training_fluxes[training_set],\n self.training_flux_uncertainties[training_set],\n **kwds)\n\n # Initialise and run any pre-training function.\n for _attribute in self._descriptive_attributes:\n setattr(model, _attribute[1:], getattr(self, _attribute[1:]))\n\n if pre_train is not None:\n pre_train(self, model)\n\n # Train and solve.\n model.train()\n\n try:\n inferred[i, :] = model.fit(self.training_fluxes[i],\n self.training_flux_uncertainties[i], full_output=False)\n\n except:\n logger.exception(\"Exception during cross-validation on object \"\n \"with index {0}:\".format(i))\n if debug: raise\n\n if i == N_stop_at + 1:\n break\n\n return inferred[:N_stop_at, :]","def algo_CVmetrics(classifier_object, X_train, Y_train):\r\n \r\n cv = RepeatedStratifiedKFold(n_splits = 5, n_repeats = 3, random_state = seed_custom)\r\n \r\n metricslist = {'f2': make_scorer(metrics.fbeta_score, beta = 2), \r\n 'balacc': make_scorer(metrics.balanced_accuracy_score),\r\n 'precision': make_scorer(metrics.precision_score),\r\n 'recall': make_scorer(metrics.recall_score)}\r\n \r\n cv_results = cross_validate(classifier_object, X_train, Y_train, cv = cv, scoring = metricslist, return_estimator = True)\r\n \r\n f2_mean = np.mean(cv_results['test_f2'])\r\n f2_std = np.std(cv_results['test_f2'])\r\n \r\n balacc_mean = np.mean(cv_results['test_balacc'])\r\n balacc_std = np.std(cv_results['test_balacc'])\r\n\r\n precision_mean = np.mean(cv_results['test_precision'])\r\n precision_std = np.std(cv_results['test_precision'])\r\n \r\n recall_mean = np.mean(cv_results['test_recall'])\r\n recall_std = np.std(cv_results['test_recall'])\r\n \r\n scorebox = pd.DataFrame(np.zeros((1,8)), columns = list(['F2-Score Mean', 'F2-Score STD', 'Balanced Accuracy Mean', 'Balanced Accuracy STD',\r\n 'Precision Mean', 'Precision STD', 'Recall Mean', 'Recall STD']))\r\n \r\n scorebox.iloc[0,0] = f2_mean\r\n scorebox.iloc[0,1] = f2_std\r\n scorebox.iloc[0,2] = balacc_mean\r\n scorebox.iloc[0,3] = balacc_std\r\n scorebox.iloc[0,4] = precision_mean\r\n scorebox.iloc[0,5] = precision_std\r\n scorebox.iloc[0,6] = recall_mean\r\n scorebox.iloc[0,7] = recall_std \r\n \r\n scorebox = np.round(scorebox, 3)\r\n \r\n print(\"Model has a mean CV balanced accuracy of {0}, (Std: {1})\".format(round(balacc_mean,3), round(balacc_std,3)))\r\n print(\"Model has a mean CV F2_Score of {0}, (Std: {1})\".format(round(f2_mean,3), round(f2_std,3)))\r\n print(\"Model has a mean CV Precision of {0}, (Std: {1})\".format(round(precision_mean,3), round(precision_std,3)))\r\n print(\"Model has a mean CV Recall of {0}, (Std: {1})\".format(round(recall_mean,3), round(recall_std,3)))\r\n \r\n return scorebox","def _cross_valid_feature(max_fold, num_movies, num_users, lamda, subplt):\n loss_train_vector = [.0]*31\n loss_cross_vector = [.0]*31\n cost_train_per_fold = [.0]*max_fold\n cost_cross_per_fold = [.0]*max_fold\n for i in range(1, 31, 1):\n for k in range(1, max_fold + 1, 1):\n cost_train_per_fold[k-1], cost_cross_per_fold[k-1] = (\n _cross_valid_fold(k, num_movies, num_users,\n i, lamda))\n loss_train_vector[i] = np.mean(cost_train_per_fold)\n loss_cross_vector[i] = np.mean(cost_cross_per_fold)\n\n # draw the Loss v.s num_feature graph\n subplt.plot(loss_train_vector, \"r\")\n subplt.plot(loss_cross_vector, \"b\")\n v1 = np.array(loss_cross_vector)\n v2 = np.array(loss_train_vector)\n v3 = v1 + v2\n sel_feature = np.argmin(v3[1:]) + 1\n subplt.plot(v3, \"g\", label=\"lambda=\"+str(lamda))\n plt.axis([1, 30, 0, 1.2*max(v3)])\n return sel_feature","def validate_model(classifier, data_path=\"data/data.csv\", folds=10, n_jobs=2):\n from sklearn.model_selection import cross_validate\n\n folds = 10\n\n X, y = convert_data(data_path=data_path)\n\n scoring = {'accuracy': 'accuracy',\n 'recall': 'recall',\n 'precision': 'precision',\n 'roc_auc': 'roc_auc'}\n\n cv_results = cross_validate(classifier, X, y, cv=folds,\n return_train_score=False,\n scoring=scoring, n_jobs=n_jobs)\n\n average_recall = sum(cv_results[\"test_recall\"])/folds\n average_precision = sum(cv_results[\"test_precision\"])/folds\n average_accuracy = sum(cv_results[\"test_accuracy\"])/folds\n\n print(\"Precision = {}, Recall = {}, Accuracy = {}\".format(\n average_precision,\n average_recall,\n average_accuracy))","def _cross_val(self, X, y, classifier, nfolds=10):\n\n # Make sure dimensions agree\n assert X.shape[0] == y.shape[0], \"Number of observations should equal\" \\\n \"number of labels.\"\n\n # Concatenate data in order to shuffle without changing X-y correspondence\n data = np.c_[X, y]\n\n # Shuffle data (swaps rows when 2D - works OK for us)\n np.random.seed(42)\n np.random.shuffle(data)\n\n # Split data into (almost) equal folds (returns a list of arrays)\n # and we cast the list into a numpy array in order to do list indexing\n data = np.array(np.array_split(data, nfolds))\n\n # Do the k-fold cross-validation\n accs = []\n for k in range(nfolds):\n # Get current test set\n X_k_test = data[k][:, :-1]\n y_k_test = data[k][:, -1]\n\n # Get remaining indices and current training set\n remaining_idx = [i for i, v in enumerate(data) if i != k]\n X_k_train = np.vstack(data[remaining_idx])[:, :-1]\n y_k_train = np.vstack(data[remaining_idx])[:, -1]\n\n # Fit and predict with classifier\n classifier.fit(X_k_train, y_k_train)\n yhat = classifier.predict(X_k_test)\n\n # Store error rate\n accs.append(self._accuracy(y_k_test, yhat))\n\n return np.array(accs)","def cross_validation_score(X_data, y_data, model, folds=5):\n\n # Shuffle index\n index = np.random.permutation(len(X_data))\n\n fold_size = int(len(X_data) / folds)\n scores = []\n for i in range(folds):\n \n # Partition Data\n X_train, X_val = partition_data(X_data[index], folds, i + 1, fold_size)\n y_train, y_val = partition_data(y_data[index], folds, i + 1, fold_size)\n\n # Train Model\n print(f\"Training on Fold: {i + 1}\")\n model.fit(X_train, y_train)\n\n # Predict Values on Validation Set\n val_pred = model.predict(X_val)\n\n # Get Accuracy\n score = accuracy_score(y_val, val_pred)\n scores.append(score)\n \n return sum(scores) / len(scores)","def stratifier(self, data, labels, classifiers, cv, output_dir):\n\t\tresults_proba = collections.defaultdict(dict)\n\t\tdict_y_test = collections.defaultdict()\n\t\tsss = StratifiedShuffleSplit(n_splits=cv, test_size=0.2, random_state=3)\n\t\tsss.get_n_splits(data, labels)\n\t\ti = 1\n\t\tself.logger.info('Training processing ...')\n\t\tloop = sss.split(data, labels)\n\t\tt = tqdm(loop)\n\t\tl = collections.defaultdict(dict)\n\t\tfor train_index, test_index in t:\n\t\t\tt.set_description('Cross-validation n°')\n\t\t\tx_train, x_test = data.values[train_index], data.values[test_index]\n\t\t\ty_train, y_test = labels[train_index], labels[test_index]\n\t\t\tdict_y_test[i] = y_test\n\t\t\tresults_proba, tmp_l = \\\n\t\t\t\tself.classification(\n\t\t\t\t\ti, classifiers, results_proba, x_train, x_test, y_train, y_test)\n\t\t\t[l[d].update(tmp_l[d]) for d in tmp_l]\n\t\t\ti += 1\n\t\t[l[clf].update({'Mean': np.mean(np.asarray(list(l[clf].values())))})\n\t\t for clf in l]\n\t\tlog_cv = pd.DataFrame(l)\n\t\tlog_cv.index.names = ['Cross-validation']\n\t\tlog_cv.to_csv(output_dir + '/Cross-validation_accuracy.csv',\n\t\t index=True, sep='\\t')\n\t\tprint('Cross-validation results : \\n')\n\t\tprint(log_cv)\n\n\t\treturn results_proba, dict_y_test, classifiers","def cross_validation(self, stock_data):\n\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)","def crossValidation(training, k, performance):\n\n predictions = []\n accuracy = []\n\n for index in range(1, 6):\n # print index\n temp = list(range(1, 6))\n temp.remove(index)\n # print 'index: ' + str(index) + ', temp: ' + str(temp)\n\n for x in range(len(training.get_group(index))):\n if x % 100 != 0:\n continue\n target = training.get_group(index).values.tolist()[x][-1]\n # if x % 500 == 0:\n # print 'index: ' + str(index) + ', x: ' + str(x)\n neighbors = []\n distances = []\n for validationSet in temp:\n getDistances(training.get_group(validationSet).values.tolist(), training.get_group(index).values.tolist()[x], distances)\n # Sort the distances list by the distance\n distances.sort(key = lambda item: item[1])\n # print distances\n # Select first k closest elements to return as the neighbors\n for x in range(k):\n neighbors.append(distances[x][0])\n\n result=getResponse(neighbors)\n\n # print distances\n # print neighbors\n # print result\n predictions.append(result)\n # print 'result: ' + str(result)\n # print 'target: ' + str(target)\n # print 'result == target: ' + str(result == target)\n if result == target:\n accuracy.append((True, target))\n else:\n accuracy.append((False, target))\n\n count = 0\n for item in accuracy:\n if item[0] == True:\n count += 1\n\n # print 'number of instances: ' + str(len(accuracy)) + ' number correct: ' + str(count)\n\n count = 0\n for item in accuracy:\n if item[0] == True:\n count += 1\n\n # Add the current k-value and its accuracy for this run to dictionary\n performance[k] = count / len(accuracy)\n\n print performance\n return performance","def predict_and_cv_score_regression(self, x_data, y_data, custom_kfold=None):\n r2_scores = []\n mse_scores = []\n for model in self.list_of_models:\n r2_scores.append(cross_val_score(model, x_data, y_data, cv=custom_kfold, scoring='r2').mean())\n mse_scores.append(cross_val_score(model, x_data, y_data, cv=custom_kfold, scoring='neg_mean_squared_error').mean())\n return r2_scores, mse_scores","def test_svm(x, y, tune):\n if tune:\n params = {'clf__C': stats.uniform(0, 100),\n 'clf__gamma': stats.uniform(0, 1)}\n\n # Perform hyperparameter tuning on C and gamma using randomized searching\n rand_search = RandomizedSearchCV(create_pipeline(SVC()),\n n_iter=20,\n param_distributions=params,\n n_jobs=-1,\n cv=5,\n random_state=2017)\n rand_search.fit(x, y)\n print(\"best_params: {0}\".format(rand_search.best_params_))\n return rand_search.best_score_ * 100\n else:\n # Perform classification without tuning\n svc = SVC(\n gamma=0.93121875826256051,\n C=70.331975797816796\n )\n pipeline = create_pipeline(svc)\n return accuracy(pipeline, x, y)","def cross_val_pred_both(model, X_train, y_train, X_test, cv=5, n_class=2, problem_type='infer'):\n if problem_type == 'infer':\n problem_type = get_problem_type(y_train)\n if problem_type == 'classification':\n pred_train = np.zeros((len(y_train), n_class))\n pred_test = np.zeros((len(X_test), n_class))\n else:\n pred_train = np.zeros(len(y_train))\n pred_test = np.zeros(len(X_test))\n \n if cv > 1:\n kfold=KFold(len(X_train), n_folds=cv)\n\n if problem_type == 'classification':\n for train_index, test_index in kfold:\n model.fit(X_train.iloc[train_index], y_train.iloc[train_index])\n pred_train[test_index] = model.predict_proba(X_train.iloc[test_index])\n pred_test = pred_test + model.predict_proba(X_test)\n else:\n for train_index, test_index in kfold:\n model.fit(X_train.iloc[train_index], y_train.iloc[train_index])\n pred_train[test_index] = model.predict(X_train.iloc[test_index])\n pred_test = pred_test + model.predict(X_test) \n\n pred_test = pred_test/float(cv)\n elif cv == 1:\n if problem_type == 'classification':\n model.fit(X_train, y_train)\n pred_train = model.predict_proba(X_train)\n pred_test = model.predict_proba(X_test)\n else:\n model.fit(X_train, y_train)\n pred_train = model.predict(X_train)\n pred_test = model.predict(X_test) \n return pred_train, pred_test","def train(x_train, y_train, x_test, y_test):\n\n print(\" Nearest centroid : \", end='')\n run(x_train, y_train, x_test, y_test, NearestCentroid())\n print(\" k-NN classifier (k=3) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\n print(\" k-NN classifier (k=7) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\n print(\" Naive Bayes (Gaussian) : \", end='')\n run(x_train, y_train, x_test, y_test, GaussianNB())\n print(\" Random Forest (trees= 5) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\n print(\" Random Forest (trees= 50) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\n print(\" Random Forest (trees=500) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\n print(\" Random Forest (trees=1000): \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\n print(\" LinearSVM (C=0.01) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\n print(\" LinearSVM (C=0.1) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\n print(\" LinearSVM (C=1.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\n print(\" LinearSVM (C=10.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))","def svc(n_components=10):\n\n train = pandas.read_csv('train.csv')\n y = train['target'].values\n X = raw_scaled_features(train)\n\n folds = StratifiedKFold(train['target'], 10)\n \n for train_indices, test_indices in folds:\n #print train_indices, test_indices\n X_train = X[train_indices]\n y_train = y[train_indices]\n X_test = X[test_indices]\n y_test = y[test_indices]\n\n pca = PCA(n_components=n_components)\n X_train = pca.fit_transform(X_train)\n X_test = pca.transform(X_test)\n #print X_train.shape\n\n svc = SVC(probability=True, verbose=False)\n svc.fit(X_train, y_train)\n y_prob = svc.predict_proba(X_test)\n\n print log_loss(y_test, y_prob, svc.classes_)","def train_and_score_pipeline(pipeline, automl, full_X_train, full_y_train):\n start = time.time()\n cv_data = []\n logger.info(\"\\tStarting cross validation\")\n X_pd = _convert_woodwork_types_wrapper(full_X_train.to_dataframe())\n y_pd = _convert_woodwork_types_wrapper(full_y_train.to_series())\n y_pd_encoded = y_pd\n # Encode target for classification problems so that we can support float targets. This is okay because we only use split to get the indices to split on\n if is_classification(automl.problem_type):\n y_mapping = {original_target: encoded_target for (encoded_target, original_target) in enumerate(y_pd.value_counts().index)}\n y_pd_encoded = y_pd.map(y_mapping)\n for i, (train, valid) in enumerate(automl.data_splitter.split(X_pd, y_pd_encoded)):\n if pipeline.model_family == ModelFamily.ENSEMBLE and i > 0:\n # Stacked ensembles do CV internally, so we do not run CV here for performance reasons.\n logger.debug(f\"Skipping fold {i} because CV for stacked ensembles is not supported.\")\n break\n logger.debug(f\"\\t\\tTraining and scoring on fold {i}\")\n X_train, X_valid = full_X_train.iloc[train], full_X_train.iloc[valid]\n y_train, y_valid = full_y_train.iloc[train], full_y_train.iloc[valid]\n if is_binary(automl.problem_type) or is_multiclass(automl.problem_type):\n diff_train = set(np.setdiff1d(full_y_train.to_series(), y_train.to_series()))\n diff_valid = set(np.setdiff1d(full_y_train.to_series(), y_valid.to_series()))\n diff_string = f\"Missing target values in the training set after data split: {diff_train}. \" if diff_train else \"\"\n diff_string += f\"Missing target values in the validation set after data split: {diff_valid}.\" if diff_valid else \"\"\n if diff_string:\n raise Exception(diff_string)\n objectives_to_score = [automl.objective] + automl.additional_objectives\n cv_pipeline = None\n try:\n logger.debug(f\"\\t\\t\\tFold {i}: starting training\")\n cv_pipeline = EngineBase.train_pipeline(pipeline, X_train, y_train, automl.optimize_thresholds, automl.objective)\n logger.debug(f\"\\t\\t\\tFold {i}: finished training\")\n if automl.optimize_thresholds and pipeline.can_tune_threshold_with_objective(automl.objective) and automl.objective.can_optimize_threshold:\n logger.debug(f\"\\t\\t\\tFold {i}: Optimal threshold found ({cv_pipeline.threshold:.3f})\")\n logger.debug(f\"\\t\\t\\tFold {i}: Scoring trained pipeline\")\n scores = cv_pipeline.score(X_valid, y_valid, objectives=objectives_to_score)\n logger.debug(f\"\\t\\t\\tFold {i}: {automl.objective.name} score: {scores[automl.objective.name]:.3f}\")\n score = scores[automl.objective.name]\n except Exception as e:\n if automl.error_callback is not None:\n automl.error_callback(exception=e, traceback=traceback.format_tb(sys.exc_info()[2]), automl=automl,\n fold_num=i, pipeline=pipeline)\n if isinstance(e, PipelineScoreError):\n nan_scores = {objective: np.nan for objective in e.exceptions}\n scores = {**nan_scores, **e.scored_successfully}\n scores = OrderedDict({o.name: scores[o.name] for o in [automl.objective] + automl.additional_objectives})\n score = scores[automl.objective.name]\n else:\n score = np.nan\n scores = OrderedDict(zip([n.name for n in automl.additional_objectives], [np.nan] * len(automl.additional_objectives)))\n\n ordered_scores = OrderedDict()\n ordered_scores.update({automl.objective.name: score})\n ordered_scores.update(scores)\n ordered_scores.update({\"# Training\": y_train.shape[0]})\n ordered_scores.update({\"# Validation\": y_valid.shape[0]})\n\n evaluation_entry = {\"all_objective_scores\": ordered_scores, \"score\": score, 'binary_classification_threshold': None}\n if is_binary(automl.problem_type) and cv_pipeline is not None and cv_pipeline.threshold is not None:\n evaluation_entry['binary_classification_threshold'] = cv_pipeline.threshold\n cv_data.append(evaluation_entry)\n training_time = time.time() - start\n cv_scores = pd.Series([fold['score'] for fold in cv_data])\n cv_score_mean = cv_scores.mean()\n logger.info(f\"\\tFinished cross validation - mean {automl.objective.name}: {cv_score_mean:.3f}\")\n return {'cv_data': cv_data, 'training_time': training_time, 'cv_scores': cv_scores, 'cv_score_mean': cv_score_mean}","def SVM_train(X, y, cv):\r\n rev = 10000\r\n start_time = time.time()\r\n print('\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\r\n parameters = {\r\n 'kernel':('linear', 'poly', 'rbf'),\r\n 'C':(1, 5, 10),\r\n 'gamma':('scale', 'auto')\r\n }\r\n print('-'*2+'Grid Search Parameters:')\r\n print(parameters)\r\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\r\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\r\n clf.fit(X, y)\r\n print('-'*2+'GridSearch Results:')\r\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\r\n print(pd.DataFrame(clf.cv_results_))\r\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\r\n return clf","def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \r\n\r\n score=[]\r\n \r\n keys = x[key].unique().tolist()\r\n \r\n\r\n\r\n for idx, item in enumerate([1,2,3,4,5]):\r\n\r\n xtrain,xtest = split_camp(x,keys,0.2)\r\n \r\n model.fit(xtrain[feat],xtrain[target])\r\n\r\n ypred = model.predict(xtest[feat])\r\n \r\n ytrue= xtest[target].values \r\n \r\n if metric == 'mae':\r\n score.append(mae(ytrue,ypred))\r\n elif metric == 'mse':\r\n score.append(mse(ytrue,ypred))\r\n elif metric == 'rrmse':\r\n score.append(rrmse(ytrue,ypred))\r\n\r\n else:\r\n score.append(rmse(xtest[target].tolist(),ypred))\r\n\r\n if verbose:\r\n print('-'*30)\r\n print(f'\\nFold {idx} out of 5')\r\n print(f'Key {item}')\r\n print(f'{metric}: {score[idx]}')\r\n\r\n \r\n\r\n if verbose:\r\n print(f'\\n Overall Score:')\r\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\r\n\r\n\r\n return score","def kFoldCrossValidation(self, n_splits ):\n X = self.X\n y = self.y\n\n k_fold = KFold(n_splits)\n model = self.model\n\n for train, test in k_fold.split(X):\n model.fit(X[train], y[train])\n p = model.predict( X[test] )\n # Add line for scores\n\n return model #return scores here?","def generate_cross_val_score(clf, data, target, cv):\n return cross_val_score(clf, data, target, cv=cv)","def ex_3_b(x_train, y_train, x_test, y_test):\n ###########\n ## Train multi-class SVMs with a LINEAR kernel\n ## Use the sklearn.metrics.confusion_matrix to plot the confusion matrix.\n ## Find the index for which you get the highest error rate.\n ## Plot the confusion matrix with plot_confusion_matrix.\n ## Plot the first 10 occurrences of the most misclassified digit using plot_mnist.\n ###########\n\n labels = range(1, 6)\n linear = svm.SVC(kernel='linear', C=10, decision_function_shape='ovr')\n linear.fit(x_train, y_train)\n y_pred = linear.predict(x_test)\n cm = confusion_matrix(y_test, y_pred)\n plot_confusion_matrix(cm, labels)\n\n errors = np.zeros(5)\n for i in range(5):\n for j in range(5):\n if i != j:\n errors[j] += cm[i][j]\n max_err_label = np.argmax(errors) + 1 # should be the label number corresponding the largest classification error\n\n indices = np.nonzero(y_pred == max_err_label)[0].astype(int)\n sel_err = np.array([], dtype=int) # Numpy indices to select images that are misclassified.\n for i in indices:\n if y_test[i] != y_pred[i]:\n sel_err = np.insert(sel_err, sel_err.size, i)\n\n # Plot with mnist plot\n plot_mnist(x_test[sel_err], y_pred[sel_err], labels=max_err_label, k_plots=10, prefix='Predicted class')"],"string":"[\n \"def crossValidate(self, args):\\n\\n ##################################\\n # Read the training data\\n ##################################\\n if not os.path.isdir(args.annotationPath):\\n print('annotation path does not exist: {}' \\\\\\n .format(args.annotationPath))\\n return -1\\n\\n data = self.readData(args.annotationPath)\\n\\n ############################\\n # Execute the K-Fold cross validation\\n ############################\\n\\n x = []\\n y = []\\n l = []\\n for subject, df in data.items():\\n lx = df[['gradient', 'rate']].values.tolist()\\n #lx = df[['rate']].values.tolist()\\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\\n x.extend(lx)\\n y.extend(ly.tolist())\\n l.append(len(lx))\\n\\n x = np.array(x)\\n y = np.array(y)\\n\\n print('Executing cross-validation with k = {}...'.format(args.k))\\n clf = StructuredPerceptron(random_state=2)\\n scores = []\\n folds = SequenceKFold(l, n_folds=args.k)\\n for train_idx, train_len, test_idx, test_len in folds:\\n xTrain = x[train_idx]\\n yTrain = y[train_idx]\\n clf.fit(xTrain, yTrain, train_len)\\n\\n xTest = x[test_idx]\\n yTest = y[test_idx]\\n yPred = clf.predict(xTest, test_len)\\n scores.append(accuracy_score(yTest, yPred))\\n\\n scores = np.array(scores)\\n print(scores)\\n print('Result of the K-Fold CV: {:3f} (+- {:3f})' \\\\\\n .format(scores.mean(), 2 * scores.std()))\\n\\n ############################\\n # Execute the Leave-One-Out cross validation\\n ############################\\n\\n\\n return 0\",\n \"def cross_validation(feature_train, help_rank_train, model_name):\\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\\n clf_model = open(model_name,'wb')\\n dump(clf, clf_model, -1)\\n return\",\n \"def crossvalidate(*args, **kwargs):\\n\\n scores = []\\n j = 0\\n for i, _ in enumerate(data):\\n if i in good_patients:\\n\\n if 'silent' in kwargs:\\n if kwargs['silent']:\\n pass\\n else:\\n print \\\"real patient index:\\\", i\\n else:\\n print \\\"real patient index:\\\", i\\n\\n kwargs['patient_index'] = j\\n score, reconstruction = runmodel(*args, **kwargs)\\n scores.append(score)\\n\\n if 'save_reconstruction' in kwargs:\\n if kwargs['save_reconstruction']:\\n scipy.misc.imsave(\\\"patient_{}_reconstruction.png\\\".format(i), reconstruction)\\n j += 1\\n\\n cvmodel = args[0].__class__.__name__\\n print \\\"{} overall cross validated score {}\\\".format(cvmodel, np.mean(scores))\\n return np.mean(scores)\",\n \"def cross_validate(pipeline, data, cv=4):\\n print \\\"Running cross validation...\\\"\\n (Xcv, ycv) = data\\n kfold = KFold(n_splits=cv, shuffle=True, random_state=42)\\n results = []\\n for train_idx, val_idx in kfold.split(Xtrain):\\n pipeline.fit(Xcv[train_idx], ycv[train_idx])\\n results.append(accuracy_score(\\n ycv[val_idx], pipeline.predict(Xcv[val_idx])\\n ))\\n print \\\"{} +/- {}\\\".format(np.mean(results), np.std(results))\",\n \"def _do_training_cross_validation(self) -> None:\\n\\n cfg = self.cfg_\\n fit_kwargs = {'classes': list(self.data_.classes)}\\n\\n # Store all of the samples used during cross-validation\\n self.y_training_set_all_ = list(self._generate_samples(self.train_ids_, 'y'))\\n\\n # Initialize learner objects with the optimal set of parameters\\n # learned from the grid search round (one for each\\n # sub-experiment of the cross-validation round)\\n for learner, learner_name in zip(self.learners_, self.learner_names_):\\n self.cv_learners_[learner_name] = \\\\\\n [learner(**self.learner_gs_cv_params_[learner_name])\\n for i in range(len(self.data_.training_set))]\\n\\n # Make a list of empty lists corresponding to each estimator\\n # instance for each learner, which will be used to store the\\n # performance metrics for each cross-validation\\n # leave-one-fold-out sub-experiment\\n self.cv_learner_stats_ = [[] for _ in cfg.learners]\\n\\n # Fit the `SelectPercentile` feature selector (if applicable)\\n if cfg.feature_selection_percentile != 1.0:\\n loginfo('Removing {0}% of the features during training round...'\\n .format(100 - 100*cfg.feature_selection_percentile))\\n feature_selector = \\\\\\n (SelectPercentile(chi2,\\n percentile=100*cfg.feature_selection_percentile)\\n .fit(self._vectorize_and_sparsify_data(self.training_vec_,\\n self.train_ids_),\\n self.y_training_set_all_))\\n\\n # For each fold of the training set, train on all of the other\\n # folds and evaluate on the one left out fold\\n for i, held_out_fold in enumerate(self.data_.training_set):\\n\\n loginfo('Cross-validation sub-experiment #{0} in progress'\\n .format(i + 1))\\n\\n # Use each training fold (except for the held-out set) to\\n # incrementally build up the model\\n training_folds = (self.data_.training_set[:i]\\n + self.data_.training_set[i + 1:])\\n y_train_all = []\\n for j, training_fold in enumerate(training_folds):\\n\\n # Get the training data\\n y_train = list(self._generate_samples(training_fold, 'y'))\\n y_train_all.extend(y_train)\\n X_train = self._vectorize_and_sparsify_data(self.training_vec_,\\n training_fold)\\n if cfg.feature_selection_percentile != 1.0:\\n X_train = feature_selector.transform(X_train)\\n\\n # Iterate over the learners\\n for learner_name in self.learner_names_:\\n\\n # Partially fit each estimator with the new training\\n # data (specifying the `classes` keyword argument if\\n # this is the first go-round and it's a learner that\\n # requires this to be specified initially)\\n (self.cv_learners_[learner_name][i]\\n .partial_fit(X_train,\\n y_train,\\n **fit_kwargs if not j and learner_name\\n in self.requires_classes_kwarg_\\n else {}))\\n\\n # Get mean and standard deviation for actual values\\n y_train_all = np.array(y_train_all)\\n y_train_mean = y_train_all.mean()\\n y_train_std = y_train_all.std()\\n\\n # Get test data\\n y_test = list(self._generate_samples(held_out_fold, 'y'))\\n X_test = self._vectorize_and_sparsify_data(self.training_vec_,\\n held_out_fold)\\n if cfg.feature_selection_percentile != 1.0:\\n X_test = feature_selector.transform(X_test)\\n\\n # Make predictions with the modified estimators\\n for j, learner_name in enumerate(self.learner_names_):\\n\\n # Make predictions with the given estimator,rounding the\\n # predictions\\n y_test_preds = \\\\\\n np.round(self.cv_learners_[learner_name][i].predict(X_test))\\n\\n # Rescale the predicted values based on the\\n # mean/standard deviation of the actual values and\\n # fit the predicted values within the original scale\\n # (i.e., no predicted values should be outside the range\\n # of possible values)\\n y_test_preds_dict = \\\\\\n ex.rescale_preds_and_fit_in_scale(y_test_preds,\\n self.data_.classes,\\n y_train_mean,\\n y_train_std)\\n\\n if cfg.rescale:\\n y_test_preds = y_test_preds_dict['rescaled']\\n else:\\n y_test_preds = y_test_preds_dict['fitted_only']\\n\\n # Evaluate the predictions and add to list of evaluation\\n # reports for each learner\\n (self.cv_learner_stats_[j]\\n .append(ex.evaluate_predictions_from_learning_round(\\n y_test=y_test,\\n y_test_preds=y_test_preds,\\n classes=self.data_.classes,\\n prediction_label=cfg.prediction_label,\\n non_nlp_features=cfg.non_nlp_features,\\n nlp_features=cfg.nlp_features,\\n learner=self.cv_learners_[learner_name][i],\\n learner_name=learner_name,\\n games=cfg.games,\\n test_games=cfg.games,\\n _round=i + 1,\\n iteration_rounds=self.data_.folds,\\n n_train_samples=len(y_train_all),\\n n_test_samples=len(held_out_fold),\\n rescaled=cfg.rescale,\\n transformation_string=self.transformation_string_,\\n bin_ranges=cfg.bin_ranges)))\",\n \"def cross_validation(self, x, t, k=5):\\n print(\\\"Cross validation of the SVM Model...\\\")\\n\\n # Initialize best error / hyperparameters\\n best_error = float('inf')\\n best_reg = 0\\n best_deg = 0\\n\\n # Cross-validation 80-20\\n N = len(x)\\n N_train = math.floor(0.8 * N)\\n t = t.reshape((N,))\\n\\n #Initialize the grid search\\n\\n log_min_reg = np.log(0.001)\\n log_max_reg = np.log(1000)\\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\\n\\n min_deg = 1\\n max_deg = 4\\n\\n for deg in range(min_deg, max_deg):\\n for reg in reg_list:\\n errors = np.zeros(k)\\n for j in range(k):\\n map_index = list(zip(x, t))\\n random.shuffle(map_index)\\n random_x, random_t = zip(*map_index)\\n\\n train_x = random_x[:N_train]\\n valid_x = random_x[N_train:]\\n train_t = random_t[:N_train]\\n valid_t = random_t[N_train:]\\n\\n self.model = SVC(gamma='auto', kernel='poly', degree=deg, C=reg, cache_size=1000)\\n self.train(train_x, train_t)\\n\\n error_valid = np.array([self.error(x_n, t_n) for t_n, x_n in zip(valid_t, valid_x)])\\n errors[j] = error_valid.mean()\\n\\n mean_error = np.mean(errors)\\n print(mean_error)\\n if mean_error < best_error:\\n best_error = mean_error\\n best_reg = reg\\n best_deg = deg\\n print(\\\"The new best hyper parameters are : \\\", best_reg, best_deg)\\n\\n print(\\\"Best hyper parameters are : \\\", best_reg, best_deg)\\n print(\\\"Validation error : \\\", 100 * best_error, \\\"%\\\")\\n self.model = SVC(gamma='auto', kernel='poly', degree=best_deg, C=best_reg)\\n self.train(x, t)\",\n \"def sklearn_train() -> None:\\n cross_validate(args=SklearnTrainArgs().parse_args(), train_func=run_sklearn)\",\n \"def do_crossval():\\n df = read_df()\\n # X = df['review'].apply(remove_html_lower)\\n\\n X = df['review']\\n y = df['sentiment']\\n X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.3, shuffle=True, stratify=y, random_state=222 )\\n\\n tfidf = TfidfVectorizer(stop_words='english', min_df=2, max_df=0.8, ngram_range=(1,4))\\n stem_pipeline = make_pipeline(TextNormalizer(), tfidf, LogisticRegression(C=100))\\n cv = StratifiedShuffleSplit(n_splits=3, test_size=0.2)\\n\\n scores = cross_val_score(stem_pipeline, X_train, y_train, cv=cv, scoring='accuracy', n_jobs=-1)\\n print(scores, scores.mean())\",\n \"def crossValidate(dataset, folds):\\n\\tshuffle(dataset)\\n\\tcv_results = []\\n\\tprecision_recall_acc = []\\n\\tfoldSize = int(len(dataset)/folds)\\n\\tfor i in range(0,len(dataset),foldSize):\\n\\t\\t# preparing data\\n\\t\\tvalD = dataset[i:i+foldSize]\\n\\t\\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\\n\\t\\t# Training\\n\\t\\tprint(\\\"*\\\"*60)\\n\\t\\tprint(\\\"Training on data-set size \\\"+str(len(testD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\tclassi = trainClassifier(testD)\\n\\t\\t# Prediction on validation data \\n\\t\\tprint(\\\"Predicting on heldout data-set size...\\\"+str(len(valD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\ty_true = list(map(lambda t: t[1], valD))\\n\\t\\ty_pred = predictLabels(valD,classi)\\t\\t\\n\\t\\t# Performance Metrics\\t\\t\\n\\t\\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\\n\\t\\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\\n\\t\\tacc = accuracy_score(y_true,y_pred)\\n\\t\\tprecision_recall[-1] = acc\\n\\t\\tprint(precision_recall)\\n\\t\\tprecision_recall_acc.append(precision_recall)\\n\\tdf = pd.DataFrame(precision_recall_acc,columns = [\\\"Precision\\\",\\\"Recall\\\",\\\"F1 score\\\",\\\"Accuracy Score\\\"])\\n\\tprint(df)\\n\\tcv_results = df.mean().tolist()\\n\\treturn cv_results\",\n \"def crossValidationKfold(automodel, \\r\\n X, y,\\r\\n params_automl : dict = {},\\r\\n score_function = accuracy_score,\\r\\n cv : int = 3,\\r\\n shuffle: bool = True,\\r\\n verbose : bool = True,\\r\\n allmetrics: bool = False):\\r\\n if(isinstance(X, pd.DataFrame) or isinstance(y, pd.DataFrame)):\\r\\n X = X.values\\r\\n y = y.values\\r\\n skf = StratifiedKFold(n_splits = cv, \\r\\n shuffle = shuffle, \\r\\n random_state = 42)\\r\\n if(allmetrics):\\r\\n train_scores = {'accuracy' : [], \\r\\n 'roc_auc': [], \\r\\n 'f1' : [], \\r\\n 'recall' : [], \\r\\n 'precision': []}\\r\\n test_scores = {'accuracy' : [], \\r\\n 'roc_auc': [], \\r\\n 'f1' : [], \\r\\n 'recall' : [], \\r\\n 'precision': []}\\r\\n else:\\r\\n train_scores = np.empty((cv, ))\\r\\n test_scores = np.empty((cv, ))\\r\\n for idx, (idx_tr, idx_ts) in enumerate(skf.split(X, y)):\\r\\n X_tr, X_ts = X[idx_tr], X[idx_ts]\\r\\n y_tr, y_ts = y[idx_tr], y[idx_ts] \\r\\n am = automodel(**params_automl)\\r\\n am.fit(X_tr, y_tr)\\r\\n if(not allmetrics):\\r\\n \\r\\n train_scores[idx] = score_function(am.predict(X_tr), y_tr)\\r\\n test_scores[idx] = score_function(am.predict(X_ts), y_ts)\\r\\n if(verbose):\\r\\n print('it: {} train score: {:.3f}, val score: {:.3f}'.format(idx, \\r\\n train_scores[idx],\\r\\n test_scores[idx]))\\r\\n else:\\r\\n train_current = {}\\r\\n test_current = {}\\r\\n for name, metric in all_metrics_classifications.items():\\r\\n train_current[name] = metric(am.predict(X_tr), y_tr)\\r\\n test_current[name] = metric(am.predict(X_ts), y_ts)\\r\\n train_scores[name].append(train_current[name])\\r\\n test_scores[name].append(test_current[name])\\r\\n \\r\\n if(verbose):\\r\\n print('it: {} train scores: {}, val scores: {}'.format(idx, train_current,\\r\\n test_current))\\r\\n\\r\\n if(not allmetrics):\\r\\n return test_scores.mean(), test_scores.std()\\r\\n else:\\r\\n # -- calculate means of all metrics-- #\\r\\n return dict(map(lambda kv: (kv[0], np.asarray(kv[1]).mean()), test_scores.items()))\",\n \"def cross_validation(exp_name):\\n click.echo(\\\"Mode: Cross-validation.\\\")\\n # defaults = get_defaults()\\n\\n # fitted_model_filename = add_extension(fitted_model_filename)\\n\\n # derive final path for fitted model as base output path for fitted models + model filename\\n # fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n # new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n # don't reserve dev set at this point since we need to do it in each cv fold\\n boot_data = bootstrap(new_options=None, mode=\\\"cv\\\")\\n\\n defaults = boot_data['defaults']\\n X_train, y_train = boot_data['data']\\n\\n cv = RepeatedStratifiedKFold(n_splits=defaults.EVAL.N_SPLITS,\\n n_repeats=defaults.EVAL.N_REPEATS,\\n random_state=defaults.MISC.SEED)\\n\\n s = time.time()\\n outer_results, outer_preds = cross_validate(X=X_train, y=y_train,\\n cv=cv,\\n conf=defaults)\\n print(\\\"Execution time: %s seconds.\\\" % (time.time() - s))\\n\\n # dump results\\n # fitted_model_best_params_path = os.path.join(defaults.OUTPUT.PARAMS_PATH,\\n # \\\"best_params_{}.pkl\\\".format(fitted_model_filename.split('.')[0]))\\n\\n outer_results_formatted = show_cross_val_results(outer_results, conf=defaults)\\n\\n cv_results_path = os.path.join(defaults.OUTPUT.RESULTS_PATH, \\\"cv_results_{}.csv\\\".format(exp_name))\\n outer_results_formatted.to_csv(cv_results_path)\\n\\n # save predictions\\n outer_preds_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \\\"cv_pooled_preds_{}.pkl\\\".format(exp_name))\\n save_obj(outer_preds, outer_preds_path)\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels ):\\n import sklearn\\n from sklearn import svm\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.sklearn_classifier = svm.SVC(C=2, gamma=0.025, decision_function_shape='ovo', tol=0.015)\\n self.sklearn_classifier.fit(trainingData, trainingLabels)\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels):\\n from sklearn import svm\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\\n self.sklearn_svm.fit(trainingData, trainingLabels)\",\n \"def cross_validate_model(self, X_train, y_train):\\n\\n\\t\\t# Build a stratified k-fold cross-validator object\\n\\t\\tskf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\\n\\n\\t\\t'''\\n\\t\\tEvaluate the score by cross-validation\\n\\t\\tThis fits the classification model on the training data, according to the cross-validator\\n\\t\\tand reports the scores.\\n\\t\\tAlternative: sklearn.model_selection.cross_validate\\n\\t\\t'''\\n\\t\\tscores = cross_val_score(self.classifier, X_train, y_train, scoring='accuracy', cv=skf)\\n\\n\\t\\tprint(\\\"%.2f seconds: Cross-validation finished\\\" % time.process_time())\\n\\n\\t\\t# Log the cross-validation scores, the mean score and the 95% confidence interval, according to:\\n\\t\\t# http://scikit-learn.org/stable/modules/cross_validation.html#computing-cross-validated-metrics\\n\\t\\t# https://en.wikipedia.org/wiki/Standard_error#Assumptions_and_usage\\n\\t\\t# print(\\\"Scores = %s\\\" % scores)\\n\\t\\t# print(\\\"Accuracy: %0.2f (±%0.2f)\\\" % (scores.mean()*100, scores.std()*2*100))\\n\\t\\t# ↳ https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html\",\n \"def crossValidation(data, output_variable_name):\\r\\n X, xt, y, yt = train_test_split(\\r\\n data.drop(output_variable_name, axis=1), data[output_variable_name], test_size=0.01, random_state=SEED)\\r\\n\\r\\n model = pickle.load(open(\\\"models/lasso.sav\\\", 'rb'))\\r\\n lassoCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n model = pickle.load(open(\\\"models/ridge.sav\\\", 'rb'))\\r\\n ridgeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n model = pickle.load(open(\\\"models/decisionTree.sav\\\", 'rb'))\\r\\n decTreeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n param = {\\r\\n 'max_depth': 15,\\r\\n 'eta': 0.1,\\r\\n 'objective': 'reg:squarederror',\\r\\n 'nthread': 16,\\r\\n \\\"subsample\\\": 0.5,\\r\\n \\\"colsample_bytree\\\": 0.5,\\r\\n 'eval_metric': 'rmse'\\r\\n }\\r\\n num_round = XGB_EPOCH_NR\\r\\n\\r\\n dtrain = xgb.DMatrix(X, label=y)\\r\\n xgbCV = xgb.cv(\\r\\n param,\\r\\n dtrain,\\r\\n num_boost_round=num_round,\\r\\n seed=SEED,\\r\\n nfold=5,\\r\\n metrics={'rmse'}\\r\\n )[\\\"test-rmse-mean\\\"][-1:]\\r\\n\\r\\n param = {\\r\\n \\\"iterations\\\": 400,\\r\\n \\\"learning_rate\\\": 0.02,\\r\\n \\\"depth\\\": 12,\\r\\n \\\"eval_metric\\\": 'RMSE',\\r\\n \\\"random_seed\\\": 23,\\r\\n \\\"bagging_temperature\\\": 0.2,\\r\\n \\\"od_type\\\": 'Iter',\\r\\n \\\"metric_period\\\": 75,\\r\\n \\\"od_wait\\\": 100\\r\\n }\\r\\n\\r\\n catBoostCV = cv(data, param, fold_count=5, plot=True)\\r\\n\\r\\n return lassoCV, ridgeCV, decTreeCV, xgbCV, catBoostCV\",\n \"def __implement_cross_validation(self, X, y, model):\\n\\n skfolds = StratifiedKFold(n_splits=3, random_state=42)\\n\\n for train_index, test_index in skfolds.split(X, y):\\n clone_clf = clone(model)\\n X_train_folds = X[train_index]\\n y_train_folds = y[train_index]\\n X_test_fold = X[test_index]\\n y_test_fold = y[test_index]\\n\\n clone_clf.fit(X_train_folds, y_train_folds)\\n y_pred = clone_clf.predict(X_test_fold)\\n n_correct = sum(y_pred == y_test_fold)\\n message = \\\"ratio of correct predictions: \\\", n_correct / len(y_pred)\\n self.__logger.info(message)\",\n \"def cross_valid(model,x,folds,metric,verbose=True): \\r\\n\\r\\n score=[]\\r\\n \\r\\n\\r\\n kf = KFold(folds,shuffle=False,random_state=0) \\r\\n\\r\\n\\r\\n i=0\\r\\n for train_index, test_index in kf.split(x):\\r\\n\\r\\n xtrain = x[train_index,:]\\r\\n xtest = x[test_index,:]\\r\\n\\r\\n model.fit(xtrain[:,:-1],xtrain[:,-1])\\r\\n\\r\\n ypred = model.predict(xtest[:,:-1])\\r\\n\\r\\n ytrue= xtest[:,-1] \\r\\n \\r\\n \\r\\n if metric == 'mae':\\r\\n score.append(mae(ytrue,ypred))\\r\\n elif metric == 'mse':\\r\\n score.append(mse(ytrue,ypred))\\r\\n elif metric == 'rrmse':\\r\\n score.append(rrmse(ytrue,ypred))\\r\\n\\r\\n else:\\r\\n score.append(rmse(xtest[:,-1],ypred))\\r\\n\\r\\n if verbose:\\r\\n print('-'*30)\\r\\n print(f'\\\\nFold {i+1} out of {folds}')\\r\\n print(f'{metric}: {score[i]}')\\r\\n\\r\\n i+=1\\r\\n\\r\\n if verbose:\\r\\n print(f'\\\\n Overall Score:')\\r\\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\\r\\n\\r\\n\\r\\n return score\",\n \"def _cross_validate(self, fit_params={}):\\n\\n # Flatten the true labels for the training data\\n y_train = self.y_train.values if self.y_train.shape[1] > 1 else self.y_train.values.ravel()\\n\\n if self.model.estimator_type == \\\"classifier\\\":\\n\\n # Get unique labels for classification\\n labels = np.unique(y_train)\\n\\n # Set up a dictionary for the scoring metrics\\n scoring = {'accuracy':'accuracy'}\\n\\n # Prepare arguments for the scorers\\n metric_args = self.model.metric_args\\n \\n if 'average' in metric_args and metric_args['average'] is not None:\\n # If the score is being averaged over classes a single scorer per metric is sufficient\\n scoring['precision'] = metrics.make_scorer(metrics.precision_score, **metric_args)\\n scoring['recall'] = metrics.make_scorer(metrics.recall_score, **metric_args)\\n scoring['fscore'] = metrics.make_scorer(metrics.f1_score, **metric_args)\\n\\n output_format = \\\"clf_overall\\\"\\n else:\\n # If there is no averaging we will need multiple scorers; one for each class\\n for label in labels:\\n metric_args['pos_label'] = label\\n metric_args['labels'] = [label]\\n scoring['precision_'+str(label)] = metrics.make_scorer(metrics.precision_score, **metric_args)\\n scoring['recall_'+str(label)] = metrics.make_scorer(metrics.recall_score, **metric_args)\\n scoring['fscore_'+str(label)] = metrics.make_scorer(metrics.f1_score, **metric_args)\\n \\n output_format = \\\"clf_classes\\\"\\n\\n elif self.model.estimator_type == \\\"regressor\\\":\\n scoring = ['r2', 'neg_mean_squared_error', 'neg_mean_absolute_error', 'neg_median_absolute_error', 'explained_variance']\\n \\n # Perform cross validation using the training data and the model pipeline\\n scores = cross_validate(self.model.pipe, self.X_train, y_train, scoring=scoring, cv=self.model.cv, fit_params=fit_params, return_train_score=False)\\n\\n # Prepare the metrics data frame according to the output format\\n if self.model.estimator_type == \\\"classifier\\\": \\n # Get cross validation predictions for the confusion matrix\\n y_pred = cross_val_predict(self.model.pipe, self.X_train, y_train, cv=self.model.cv, fit_params=fit_params)\\n\\n # Prepare the confusion matrix and add it to the model\\n self._prep_confusion_matrix(y_train, y_pred, labels)\\n\\n # Create an empty data frame to set the structure\\n metrics_df = pd.DataFrame(columns=[\\\"class\\\", \\\"accuracy\\\", \\\"accuracy_std\\\", \\\"precision\\\", \\\"precision_std\\\", \\\"recall\\\",\\\\\\n \\\"recall_std\\\", \\\"fscore\\\", \\\"fscore_std\\\"])\\n\\n if output_format == \\\"clf_overall\\\": \\n # Add the overall metrics to the data frame\\n metrics_df.loc[0] = [\\\"overall\\\", np.average(scores[\\\"test_accuracy\\\"]), np.std(scores[\\\"test_accuracy\\\"]),\\\\\\n np.average(scores[\\\"test_precision\\\"]), np.std(scores[\\\"test_precision\\\"]),\\\\\\n np.average(scores[\\\"test_recall\\\"]), np.std(scores[\\\"test_recall\\\"]),\\\\\\n np.average(scores[\\\"test_fscore\\\"]), np.std(scores[\\\"test_fscore\\\"])]\\n\\n elif output_format == \\\"clf_classes\\\":\\n # Add accuracy which is calculated at an overall level\\n metrics_df.loc[0] = [\\\"overall\\\", np.average(scores[\\\"test_accuracy\\\"]), np.std(scores[\\\"test_accuracy\\\"]),\\\\\\n np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN]\\n\\n # Add the metrics for each class to the data frame\\n for i, label in enumerate(labels):\\n metrics_df.loc[i+1] = [label, np.NaN, np.NaN, np.average(scores[\\\"test_precision_\\\"+str(label)]),\\\\\\n np.std(scores[\\\"test_precision_\\\"+str(label)]), np.average(scores[\\\"test_recall_\\\"+str(label)]),\\\\\\n np.std(scores[\\\"test_recall_\\\"+str(label)]), np.average(scores[\\\"test_fscore_\\\"+str(label)]),\\\\\\n np.std(scores[\\\"test_fscore_\\\"+str(label)])]\\n \\n # Finalize the structure of the result DataFrame\\n metrics_df.loc[:,\\\"model_name\\\"] = self.model.name\\n metrics_df = metrics_df.loc[:,[\\\"model_name\\\", \\\"class\\\", \\\"accuracy\\\", \\\"accuracy_std\\\", \\\"precision\\\", \\\"precision_std\\\", \\\"recall\\\",\\\\\\n \\\"recall_std\\\", \\\"fscore\\\", \\\"fscore_std\\\"]]\\n\\n # Add the score to the model\\n self.model.score = metrics_df[\\\"accuracy\\\"].values[0]\\n\\n elif self.model.estimator_type == \\\"regressor\\\":\\n # Create an empty data frame to set the structure\\n metrics_df = pd.DataFrame(columns=[\\\"r2_score\\\", \\\"r2_score_std\\\", \\\"mean_squared_error\\\", \\\"mean_squared_error_std\\\",\\\\\\n \\\"mean_absolute_error\\\", \\\"mean_absolute_error_std\\\", \\\"median_absolute_error\\\", \\\"median_absolute_error_std\\\",\\\\\\n \\\"explained_variance_score\\\", \\\"explained_variance_score_std\\\"])\\n \\n # Add the overall metrics to the data frame\\n metrics_df.loc[0] = [np.average(scores[\\\"test_r2\\\"]), np.std(scores[\\\"test_r2\\\"]),\\\\\\n np.average(scores[\\\"test_neg_mean_squared_error\\\"]), np.std(scores[\\\"test_neg_mean_squared_error\\\"]),\\\\\\n np.average(scores[\\\"test_neg_mean_absolute_error\\\"]), np.std(scores[\\\"test_neg_mean_absolute_error\\\"]),\\\\\\n np.average(scores[\\\"test_neg_median_absolute_error\\\"]), np.std(scores[\\\"test_neg_median_absolute_error\\\"]),\\\\\\n np.average(scores[\\\"test_explained_variance\\\"]), np.std(scores[\\\"test_explained_variance\\\"])]\\n \\n # Finalize the structure of the result DataFrame\\n metrics_df.loc[:,\\\"model_name\\\"] = self.model.name\\n metrics_df = metrics_df.loc[:,[\\\"model_name\\\", \\\"r2_score\\\", \\\"r2_score_std\\\", \\\"mean_squared_error\\\", \\\"mean_squared_error_std\\\",\\\\\\n \\\"mean_absolute_error\\\", \\\"mean_absolute_error_std\\\", \\\"median_absolute_error\\\", \\\"median_absolute_error_std\\\",\\\\\\n \\\"explained_variance_score\\\", \\\"explained_variance_score_std\\\"]]\\n\\n # Add the score to the model\\n self.model.score = metrics_df[\\\"r2_score\\\"].values[0]\\n\\n # Save the metrics_df to the model\\n self.model.metrics_df = metrics_df\",\n \"def nestedValidation(X, y, kernel):\\n\\n # list of slack variable values to test the SVM with\\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]\\n # number of iterations to run the bootstraping\\n B = 30\\n\\n # split positive and negative valued samples\\n positive_samples = list(np.where(y==1)[0])\\n negative_samples = list(np.where(y==-1)[0])\\n\\n # randomize data for testing\\n np.random.shuffle(positive_samples)\\n np.random.shuffle(negative_samples)\\n\\n # split samples into two folds with similar proportion of positive:negative\\n samples_in_fold1 = positive_samples[:106] + negative_samples[:178]\\n samples_in_fold2 = positive_samples[106:] + negative_samples[178:]\\n\\n y_pred = np.zeros(len(X), int)\\n\\n # finding the best slack value and its corresponding error\\n best_err = 1.0\\n best_C = 0.0\\n\\n print(\\\"testing with first fold\\\")\\n for C in C_list:\\n err = bootstrapping(B, X[samples_in_fold1], y[samples_in_fold1], C, kernel)\\n print(\\\"C=\\\", C, \\\"err=\\\", err)\\n if (err <= best_err):\\n best_err = err\\n best_C = C\\n\\n print(\\\"Best C=\\\", best_C)\\n\\n alg = SVC(C=best_C, kernel=kernel)\\n alg.fit(X[samples_in_fold1], y[samples_in_fold1])\\n y_pred[samples_in_fold2] = alg.predict(X[samples_in_fold2])\\n\\n best_err = 1.1 # any value greater than 1.0\\n best_C = 0.0\\n\\n print(\\\"testing with second fold\\\")\\n for C in C_list:\\n err = bootstrapping(B, X[samples_in_fold2], y[samples_in_fold2], C, kernel)\\n print(\\\"C=\\\", C, \\\"err=\\\", err)\\n if (err <= best_err):\\n best_err = err\\n best_C = C\\n\\n print(\\\"Best C=\\\", best_C)\\n\\n alg = SVC(C=best_C, kernel=kernel)\\n alg.fit(X[samples_in_fold2], y[samples_in_fold2])\\n y_pred[samples_in_fold1] = alg.predict(X[samples_in_fold1])\\n\\n err = np.mean(y != y_pred)\\n\\n print(\\\"Nested Validation Error=\\\", err)\\n return err\",\n \"def cross_validation(self):\\r\\n kfold = KFold(10, shuffle=True, random_state=1)\\r\\n data = self.read_data()\\r\\n # error from each kth iteration\\r\\n errors = []\\r\\n for train, test in kfold.split(data):\\r\\n\\r\\n #Splitting into test and training data\\r\\n X_test, Y_test = data[test][:, 1], data[test][:, 2]\\r\\n X_train, Y_train = data[train][:, 1], data[train][:, 2]\\r\\n\\r\\n #Training on the split data\\r\\n weights, design_matrix = self.train(X_train, Y_train)\\r\\n\\r\\n y_pred = self.make_prediction(X_test, weights)\\r\\n self.plot(y_true=Y_test, y_pred=y_pred, x=X_test)\\r\\n\\r\\n #error matrix\\r\\n errors.append(np.mean(y_pred - Y_test) ** 2)\\r\\n\\r\\n #cross-validation parameter taken as mean of errors obtained from each iteration\\r\\n print(\\\"%0.10f mean with a standard deviation of %0.10f across the k-folds\\\" % (np.mean(errors), np.std(errors)))\",\n \"def hyperparameter_cv(X_data, y_data, hyperparameters):\\n\\n # Create Grid of hyperparameters\\n grid = cartesian_product(hyperparameters)\\n\\n # Loop through hyperparameters \\n best_score = 0\\n for hyperparameter in grid:\\n # Initialize Modle\\n model = svm.SVC(kernel='linear', **hyperparameter)\\n\\n # Train and Get Accuracy\\n print(f\\\"Training using hyperparameters: {hyperparameter}\\\")\\n score = cross_validation_score(X_data, y_data, model, folds=5)\\n print(f\\\"Accuracy Score: {score}\\\")\\n\\n if score > best_score:\\n best_score = score\\n best_parameters = hyperparameter\\n \\n return best_score, best_parameters\",\n \"def run_svm(data):\\n X, y = data.ix[:, :-1], data.ix[:, -1]\\n\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, train_size = int(TRAIN_PCT * len(X)))\\n\\n clf = SVC()\\n\\n param_grid = {\\n 'C': [10 ** k for k in range(-3, 3)],\\n # 'C': range(1, 11),\\n 'kernel': ['linear', 'poly', 'rbf']}\\n # 'kernel': ['rbf']}\\n\\n grid_results = GridSearchCV(clf, param_grid,\\n scoring='roc_auc',\\n cv=StratifiedKFold(y_train, n_folds=20),\\n verbose=1)\\n\\n grid_results.fit(X_train, y_train)\\n\\n print '\\\\ngenlzn errors:'\\n for params, mean_score, all_scores in grid_results.grid_scores_:\\n print '{}\\\\t{}\\\\t(+/-) {}'.format(\\n params,\\n round(mean_score, 3),\\n round(all_scores.std() / 2, 3))\\n\\n print '\\\\nbest model:'\\n print '{}\\\\t{}'.format(grid_results.best_params_,\\n round(grid_results.best_score_, 3))\\n\\n print '\\\\nclassification report:'\\n print classification_report(y_test, grid_results.predict(X_test))\\n\\n print 'confusion matrix ({} total test recs, {} positive)'.format(\\n len(y_test), sum(y_test))\\n print confusion_matrix(y_test, grid_results.predict(X_test),\\n labels=[1, 0])\\n print\",\n \"def cross_validate(cv, x, y, k=1):\\n indices = np.arange(len(x))\\n np.random.shuffle(indices)\\n stepsize = int(len(x) / cv)\\n metrics = np.zeros(4)\\n for i in range(cv):\\n logging.info(f\\\"Cross-validation fold {i+1}\\\")\\n\\n # Slice test set out of data\\n test_indices = indices[i*stepsize:i*stepsize+stepsize]\\n x_test = x[test_indices]\\n y_test = y[test_indices]\\n\\n # Everything else is the training set\\n x_train = np.copy(x)\\n x_train = np.delete(x_train, test_indices, axis=0)\\n y_train = np.copy(y)\\n y_train = np.delete(y_train, test_indices, axis=0)\\n\\n metrics += evaluate(knn(x_test, x_train, y_train, k), y_test)\\n metrics /= cv\\n\\n print(metrics)\\n return metrics\",\n \"def crossValidate(k, epochs, hyperparams, data, trainFunc, testFunc, report=None):\\n \\n if not (report == None):\\n tabs = '\\\\t' * report;\\n print tabs, 'Performing %d-fold cross validation...' % k;\\n \\n # create vars to save the best hyperparameters and their performance\\n bestTheta = None;\\n bestRate = float(\\\"-inf\\\");\\n \\n # create queue for worker threads to post results to\\n queue = mp.Queue();\\n \\n # create train/test folds\\n numPerFold = len(data) // k;\\n numLeftOver = len(data) % k;\\n folds = [data[i*numPerFold:i*numPerFold+numPerFold] for i in range(0, k)];\\n if numLeftOver > 0:\\n folds[-1].extend(data[-numLeftOver:]); \\n \\n # create a list of tuples; each tuple defining a unique assignment of hyperparameters \\n thetas = list(itertools.product(*hyperparams));\\n \\n # create worker threads try all combinations of hyperparameters \\n workers = []; \\n for theta in thetas: \\n p = mp.Process(target=cvWorker, args=(epochs, theta, folds, trainFunc, \\\\\\n testFunc, report, queue));\\n workers.append(p)\\n \\n # start worker threads and wait for them to finish\\n for p in workers:\\n p.start();\\n for p in workers:\\n p.join()\\n \\n if not (report == None):\\n print tabs, 'All worker threads have terminated.';\\n \\n # read results out of queue \\n while not queue.empty():\\n [theta, rate] = queue.get();\\n if rate > bestRate:\\n bestTheta = theta\\n bestRate = rate;\\n \\n return bestTheta;\",\n \"def do_cross_val(sem, data_desc, perf_ml_model, ml_model_desc, ml_model, train_feature,\\n train_result):\\n scores = cross_val_score(ml_model, train_feature, train_result, cv = NUM_KFOLD,\\n scoring = 'neg_mean_absolute_error')\\n if VERB: \\n print(\\\"model: %s - score: %f\\\" % (ml_model_desc, statistics.mean(scores)))\\n perf_ml_model[(sem, data_desc, ml_model_desc)] = statistics.mean(scores)\",\n \"def tenfold_cross_validation(X, y):\\n\\n i = 0\\n x_score = []\\n y_score = []\\n\\n for i in range(1, 11):\\n for train_index, test_index in KFold(10).split(X):\\n x_train, x_test = X[train_index], X[test_index]\\n y_train, y_test = y[train_index], y[test_index]\\n\\n # change the parameters to see how each parameter affects the l1inear classifier\\n linear_classifier = linear_model.SGDClassifier(max_iter=1000, tol=1e-3)\\n\\n # start training the classifier\\n linear_classifier.fit(x_train, y_train)\\n\\n # create and plot the confusion matrix\\n # cross validation done with cross_val_\\n y_train_pred = cross_val_predict(linear_classifier, x_test, y_test, cv=10)\\n\\n print(\\\"\\\\n Statistics and Confusion matrix obtained with pandas_ml: \\\\n\\\")\\n cm = ConfusionMatrix(y_test, y_train_pred)\\n stats = cm.stats()\\n\\n file = open(\\\"linear_classification_9000_cross_validation_\\\" + str(i) + \\\".txt\\\", \\\"w\\\")\\n file.write(str(stats))\\n file.close()\\n\\n # cm.print_stats()\\n # print confusion matrix\\n cm.plot(normalized=True)\\n plt.show()\",\n \"def nestedKFoldValidation(k, X, y, kernel):\\n\\n print(\\\"running k-folds cross validation to find best slack C\\\")\\n\\n # list of slack variable values used to test the SVM with\\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100, 1000]\\n # number of iterations to run the bootstrapping\\n B = 30\\n\\n sample_list = list(range(len(y)))\\n np.random.shuffle(sample_list)\\n\\n # splitting list into k folds\\n foldSize = len(y)//k\\n folds = [sample_list[i*foldSize:(i+1)*foldSize] for i in range(k)]\\n\\n # add remaining items to the last fold\\n folds[-1] += sample_list[foldSize*k:]\\n\\n test_results = {}\\n for test in folds:\\n print('==== next outer fold ====')\\n # python dictionary to keep track of errors\\n error_dict = {}\\n for validation in folds:\\n # do not want identical test and validation folds\\n if validation == test:\\n continue\\n\\n # training data is all folds except for test and validation\\n train = [f for f in folds if f != test and f != validation][0]\\n # find errors across all parameters\\n for c in C_list:\\n alg = SVC(C=c, kernel=kernel)\\n alg.fit(X[train], y[train])\\n err = np.mean(y[validation] != alg.predict(X[validation]))\\n # keep track of all errors\\n if c not in error_dict:\\n error_dict[c] = {}\\n error_dict[c]['err'] = []\\n error_dict[c]['model'] = alg\\n error_dict[c]['err'].append(err)\\n\\n # finding the best parameter from the inner loop\\n bestC = -1\\n bestError = 1.0\\n for c in error_dict:\\n print('c=', c, 'err=', np.mean(error_dict[c]['err']))\\n err = np.mean(error_dict[c]['err'])\\n if err < bestError:\\n bestError = err\\n bestC = c\\n print('best c from inner loop is', bestC)\\n\\n # testing the best model from the inner loop against test data\\n train_err = np.mean(y[test] != alg.predict(X[test]))\\n if bestC not in test_results:\\n test_results[bestC] = []\\n test_results[bestC].append(train_err)\\n\\n for c in test_results:\\n print('c=', c,\\n 'mean error=', np.mean(test_results[c]),\\n 'stddev of errors=', np.std(test_results[c]))\",\n \"def cv(data, folds, model):\\n def rmsle(predicted, actual):\\n # Root Mean Squared Logarithmic Error\\n return mean_squared_error(\\n np.log(predicted+1),\\n np.log(actual+1)\\n ) ** 0.5\\n\\n errors = []\\n print \\\" Cross Validation in progress...\\\"\\n kf = cross_validation.KFold(n=len(data.index), n_folds=folds)\\n for i, (train_index, validation_index) in enumerate(kf):\\n print ' F%d.' % i\\n train = data.iloc[train_index]\\n validation = data.iloc[validation_index]\\n\\n model.fit(train)\\n prediction = model.predict(validation)\\n actual = data.iloc[validation_index]['count'].as_matrix()\\n error = rmsle(prediction, actual)\\n errors.append(error)\\n return np.mean(errors)\",\n \"def train_svm_model(self, X_train, X_test, y_train, y_test):\\r\\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\\r\\n ('clf', LinearSVC())])\\r\\n clf = clf.fit(X_train, y_train)\\r\\n pred = clf.predict(X_test)\\r\\n print('Confusion matrix\\\\n',confusion_matrix(y_test,pred))\\r\\n print('Classification_report\\\\n',classification_report(y_test,pred))\\r\\n return clf\",\n \"def main(args):\\n\\n # load dataset\\n with open(args.infile, 'rb') as fin:\\n x_train, y_train, x_test, y_test = pickle.load(fin)\\n\\n y_train = y_train.astype('int64')\\n y_test = y_test.astype('int64')\\n\\n random_index = list(range(len(x_train)))\\n random.shuffle(random_index)\\n x_train = np.array(x_train[random_index])\\n y_train = np.array(y_train[random_index])\\n\\n # y_train = y_train.astype(bool).astype(int)\\n # y_test = y_test.astype(bool).astype(int)\\n\\n # combined different features\\n feature_extractors = [\\n # ('general', MyScaler(False)),\\n # ('wordcount', MyCountVectorizer(ngram_range=(1, 1), stop_words='english')),\\n ('tfidf', MyTfidfVectorizer(stop_words='english')),\\n ]\\n combined_feature = FeatureUnion(feature_extractors)\\n\\n estimators = [('feature', combined_feature),\\n ('clf', svm.LinearSVC(C=0.3))]\\n pipeline = Pipeline(estimators)\\n\\n # pipeline.fit(x_train, y_train)\\n # print(pipeline.score(x_test, y_test))\\n\\n # parameters to search\\n param_grid = [\\n {\\n 'clf': [MultinomialNB()],\\n 'clf__alpha': [10, 1.0, 0.1, 0.01],\\n },\\n {\\n 'clf': [svm.LinearSVC()],\\n 'clf__C': [3, 1, 0.3, 0.1],\\n },\\n ]\\n\\n # start training\\n t0 = time.time()\\n grid = GridSearchCV(pipeline, param_grid=param_grid, verbose=4, n_jobs=4)\\n grid.fit(x_train, y_train)\\n\\n print()\\n print('done in %.2f seconds' % (time.time() - t0))\\n print()\\n print('train accuracy: %.2f%%' % (100 * grid.score(x_train, y_train)))\\n print('test accuracy: %.2f%%' % (100 * grid.score(x_test, y_test)))\\n print()\\n print('the best parameters are:', grid.best_params_)\\n print()\\n print('confusion matrix:')\\n print(metrics.confusion_matrix(y_test, grid.predict(x_test)))\",\n \"def svm_clf_training(max_features, data):\\r\\n X_train, y_train, X_test, y_test = data\\r\\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\\r\\n ('clf', svm.SVC(C=1., kernel='linear'))])\\r\\n\\r\\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\\r\\n X_matrix_tr = vectorizer.fit_transform(X_train)\\r\\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\\r\\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\\r\\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\\r\\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\\r\\n clf.fit(X_matrix_tr, y_train)\\r\\n # print(\\\"Best parameters set found on development set:\\\")\\r\\n # print()\\r\\n # print(clf.best_estimator_)\\r\\n # print()\\r\\n # print(\\\"Grid scores on development set:\\\")\\r\\n # print()\\r\\n # for params, mean_score, scores in clf.grid_scores_:\\r\\n # print(\\\"%0.3f (+/-%0.03f) for %r\\\"\\r\\n # % (mean_score, scores.std() / 2, params))\\r\\n # print()\\r\\n voc = vectorizer.get_feature_names()\\r\\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\\r\\n # X_matrix_val = vectorizer1.fit_transform(X_test)\\r\\n # y_pred = clf.predict(X_matrix_val)\\r\\n\\r\\n # for i in range(len(X_test)):\\r\\n # if y_test[i] != y_pred[i]:\\r\\n # print(X_test[i], y_test[i], y_pred[i])\\r\\n # print(classification_report(y_test, y_pred))\\r\\n return clf, voc\",\n \"def crossValidatePredictor(X,y,clfinputs,logfile='cvout.log'):\\n \\n models,modelcvs,preds,probs = [],[],[],[]\\n scores = dict([(key,[]) for key in list(scorefn.keys())])\\n errors = dict([(key,[]) for key in list(errorfn.keys())])\\n\\n # validate class labels\\n uy = np.unique(y)\\n if len(uy) != 2:\\n print('error: need 2 classes for classification!')\\n return {}\\n \\n N,ymin = len(y),uy[0]\\n\\n if cv_type == 'loo':\\n cv = KFold(N,n_folds=N,random_state=train_state)\\n y_pred = np.zeros(N)\\n y_prob = np.zeros(N)\\n else: \\n cv = StratifiedKFold(y,n_folds=train_folds,random_state=train_state)\\n\\n n_folds = len(cv) \\n model_id = clfinputs['clf_type']\\n widgets = ['%s cv: '%cv_type, Percentage(), ' ', Bar('='), ' ', ETA()]\\n pbar = ProgressBar(widgets=widgets, maxval=n_folds+(cv_type=='loo')).start()\\n with open(logfile,'w') as logfid:\\n cv_test_index = []\\n scorekeys = sorted(scores.keys())\\n for i,(train_index,test_index) in enumerate(cv):\\n pbar.update(i)\\n X_train, X_test = X[train_index], X[test_index]\\n y_train, y_test = y[train_index], y[test_index]\\n\\n cv_test_index.extend(test_index) \\n \\n # xgb assumes labels \\\\in {0,1}\\n if model_id == 'xgb' and ymin == -1: \\n y_train[y_train==-1] = 0 \\n\\n # train/predict as usual\\n clf,clf_cv = train(X_train,y_train,clfinputs)\\n clf_pred = clf.predict(X_test)\\n if model_id == 'xgb' and ymin == -1:\\n clf_pred[clf_pred==0] = -1\\n\\n if cv_probs:\\n clf_prob = clf.predict_proba(X_test)[:,0]\\n else:\\n clf_prob = np.ones(len(clf_pred))*np.nan\\n \\n # loo predicts one label per 'fold'\\n if cv_type == 'loo':\\n\\n y_pred[test_index] = clf_pred\\n y_prob[test_index] = clf_prob\\n # compute scores for the points we've classified thus far\\n y_test_cur = np.atleast_1d(y[cv_test_index])\\n y_pred_cur = np.atleast_1d(y_pred[cv_test_index])\\n \\n for score,score_fn in list(scorefn.items()):\\n scorei = score_fn(y_test_cur,y_pred_cur,uy)\\n scores[score] = [scorei] \\n else:\\n # collect output for all test samples in this fold\\n for score,score_fn in list(scorefn.items()):\\n scorei = score_fn(y_test,clf_pred,uy)\\n scores[score].append(scorei) \\n preds.append(clf_pred)\\n probs.append(clf_prob)\\n models.append(clf)\\n modelcvs.append(clf_cv)\\n for error,error_fn in list(errorfn.items()):\\n errors[error].append(error_fn(y_test,clf_pred))\\n\\n if i==0:\\n scorenames = ['%-16s'%score for score in scorekeys]\\n logstr = '%-8s %s'%('i',''.join(scorenames))\\n else:\\n curscores = ['%-16.4f'%(np.mean(scores[score]))\\n for score in scorekeys] \\n logstr = '%-8.3g %s'%(i,''.join(curscores))\\n print(logstr,file=logfid,flush=True)\\n\\n # train full model for loo cv, score on loo preds from above\\n if cv_type == 'loo':\\n for score,score_fn in list(scorefn.items()): \\n scores[score] = [score_fn(y,y_pred,uy)]\\n for error,error_fn in list(errorfn.items()):\\n errors[error] = [error_fn(y,y_pred)]\\n\\n clf,clf_cv = train(X,y,clfinputs)\\n models = [clf]\\n modelcvs = [clf_cv]\\n preds = [y_pred]\\n probs = [y_prob]\\n pbar.update(i+1)\\n pbar.finish() \\n\\n # output scores ordered by key\\n for score_id in scorekeys:\\n score_vals = scores[score_id]\\n print('mean %s: %7.4f (std=%7.4f)'%(score_id, np.mean(score_vals),\\n np.std(score_vals)))\\n\\n return {'preds':preds,'probs':probs,'scores':scores,'errors':errors,\\n 'models':models,'modelcvs':modelcvs}\",\n \"def validate_one_class(normal,outliers):\\n print \\\"running a validation\\\"\\n \\n #classifier\\n \\n train_data = genfromtxt(normal, delimiter='\\\\t',skip_header=0)\\n test_data = genfromtxt(outliers, delimiter='\\\\t',skip_header=0)\\n\\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\\n outliers_proportion=0.01\\n\\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\\n #processing data without targets\\n X_train = clf.scale(train_data)\\n X_test = clf.scale(test_data)\\n\\n y_pred_train = clf.predict(X_train)\\n y_pred_test = clf.predict(X_test)\\n n_error_train = y_pred_train[y_pred_train == 1].size\\n n_error_test = y_pred_test[y_pred_test == -1].size\\n \\n print \\\"training: \\\", 100.0*(float(n_error_train)/float(X_train.shape[0])), \\\"testing (test/outliers): \\\",100.0*(float(n_error_test)/float(X_test.shape[0]))\\n\\n sys.exit(0)\\n\\n #for further information about parameters, please google sklearn docs\\n parameters = {'kernel':('sigmoid', 'rbf'), 'C':[.1,.2,1.0],'cache_size':[500]}\\n svr = svm.SVC()\\n clf = grid_search.GridSearchCV(svr, parameters,n_jobs=3)\\n sys.stdout.write(\\\"%s:validating... \\\"%(strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())))\\n output = clf.fit(X,Y)\\n print output\\n print \\\"(%s) DONE.\\\" % (strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime()))\\n sys.exit(0)\",\n \"def cross_validate(X, Y, folds=5):\\n\\n log = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\\n intercept_scaling=1, max_iter=200, multi_class='ovr', n_jobs=3,\\n penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\\n verbose=0, warm_start=False)\\n \\n\\n \\n\\n\\n scores_log = [] \\n scores_forest = []\\n index = np.arange(X.shape[0])\\n score_log = 0\\n score_forest = 0\\n \\n for i in range(folds):\\n score_log = 0\\n score_forest = 0\\n \\n test_index = np.random.choice(index, int(X.shape[0]*1/folds),replace=False)\\n index = np.setdiff1d(np.arange(X.shape[0]),test_index)\\n \\n test_x = X[test_index]\\n test_y = Y[test_index]\\n\\n log.fit(X[index],Y[index])\\n pred_log = log.predict(test_x)\\n \\n ran.fit(X[index],Y[index])\\n pred_ran = ran.predict(test_x)\\n \\n for i in range(len(test_y)):\\n if(pred_log[i] == test_y[i]):\\n score_log += 1\\n if(pred_ran[i] == test_y[i]):\\n score_forest += 1\\n scores_log.append(score_log/len(test_y))\\n scores_forest.append(score_forest/len(test_y))\\n \\n\\n return (np.mean(scores_log),np.mean(scores_forest))\",\n \"def set_cross_validation(x,y):\\n\\tx_train_1 = x[50:]\\n\\ty_train_1 = y[50:]\\n\\tx_test_1 = x[:50]\\n\\ty_test_1 = y[:50]\\n\\tx_train_2 = np.concatenate((x[:50], x[100:]),axis=0)\\n\\ty_train_2 = np.concatenate((y[:50], y[100:]),axis=0)\\n\\tx_test_2 = x[50:100]\\n\\ty_test_2 = y[50:100]\\n\\tx_train_3 = np.concatenate((x[:100], x[150:]),axis=0)\\n\\ty_train_3 = np.concatenate((y[:100], y[150:]),axis=0)\\n\\tx_test_3 = x[100:150]\\n\\ty_test_3 = y[100:150]\\n\\tx_train_4 = x[:150]\\n\\ty_train_4 = y[:150]\\n\\tx_test_4 = x[150:]\\n\\ty_test_4 = y[150:]\\n\\n\\tx_train = [x_train_1,x_train_2,x_train_3,x_train_4]\\n\\ty_train = [y_train_1,y_train_2,y_train_3,y_train_4]\\n\\tx_test = [x_test_1,x_test_2,x_test_3,x_test_4]\\n\\ty_test = [y_test_1,y_test_2,y_test_3,y_test_4]\\n\\t# print 'cross val shapes', x_train.shape, y_train.shape, x_test.shape, y_test.shape\\n\\treturn x_train, y_train, x_test, y_test\",\n \"def crossvalidation(X, y, folds, lambdavals):\\n n = X.shape[0]\\n Errors = np.empty((0, len(lambdavals)))\\n index = (list(range(folds)) * (n//folds+1))[0:n]\\n np.random.shuffle(index)\\n index = np.array(index)\\n for i in range(folds):\\n X_train_CV = X[index != i, :]\\n X_test_CV = X[index == i, :]\\n y_train_CV = y[index != i]\\n y_test_CV = y[index == i]\\n Errorsinter = []\\n for lam in lambdavals:\\n betas, _ = mylinearsvm(lam, 0.1, 100, X_train_CV, y_train_CV)\\n y_pred = np.dot(X_test_CV, betas[-1])\\n Errorsinter.append(mean_squared_error(y_test_CV, y_pred))\\n Errors = np.vstack((Errors, Errorsinter))\\n mean_errors = np.mean(Errors, axis = 0)\\n minimum_val = np.max(np.where(mean_errors == mean_errors.min()))\\n lambda_best = lambdavals[minimum_val]\\n print(\\\"The best value of lambda is:\\\", lambda_best)\\n return lambda_best\",\n \"def cross_validation(T, y):\\r\\n from sklearn.model_selection import LeaveOneOut\\r\\n y = np.array(y)\\r\\n judge = list()\\r\\n for train_index, valid_index in LeaveOneOut().split(T):\\r\\n T_train = T[train_index]\\r\\n T_valid = T[valid_index]\\r\\n y_train = y[train_index]\\r\\n y_valid = y[valid_index]\\r\\n\\r\\n T_train, mean, std = feature.normalize(T_train)\\r\\n T_principle, T_principle_index, dist, AUC = feature_select(T_train,\\r\\n y_train, k=3)\\r\\n ts = threshold(dist, y_train)\\r\\n C = gen_center(T_principle, y_train)\\r\\n T_valid = (T_valid - mean) / std\\r\\n dist_valid = util.distance(T_valid.T[T_principle_index].T, C)\\r\\n if y_valid[0] == 1:\\r\\n if dist_valid[0] < ts:\\r\\n judge.append(1)\\r\\n else:\\r\\n judge.append(0)\\r\\n else:\\r\\n if dist_valid[0] < ts:\\r\\n judge.append(0)\\r\\n else:\\r\\n judge.append(1)\\r\\n accuracy = sum(judge) / len(judge)\\r\\n return accuracy\",\n \"def ex_2_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train an SVM with a linear kernel for the given dataset\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n\\n machine = svm.SVC(kernel='linear')\\n machine.fit(x_train, y_train)\\n plot_svm_decision_boundary(machine, x_train, y_train, x_test, y_test)\\n\\n print('Linear SVM score: {}'.format(machine.score(x_test, y_test)))\",\n \"def cross_validation2(T, y):\\r\\n from sklearn.model_selection import LeaveOneOut\\r\\n y = np.array(y)\\r\\n judge = list()\\r\\n T_principle_index = np.array([0, 18, 43])\\r\\n\\r\\n for train_index, valid_index in LeaveOneOut().split(T):\\r\\n T_train = T[train_index]\\r\\n T_valid = T[valid_index]\\r\\n y_train = y[train_index]\\r\\n\\r\\n T_train, mean, std = feature.normalize(T_train)\\r\\n\\r\\n T_principle = T_train.T[T_principle_index].T\\r\\n C = gen_center(T_principle, y_train)\\r\\n dist = util.distance(T_principle, C)\\r\\n ts = threshold(dist, y_train)\\r\\n\\r\\n T_valid = (T_valid - mean) / std\\r\\n dist_valid = util.distance(T_valid.T[T_principle_index].T, C)\\r\\n\\r\\n if dist_valid[0] < ts:\\r\\n judge.append(1)\\r\\n else:\\r\\n judge.append(0)\\r\\n return np.array(judge)\",\n \"def validate(inputs):\\n print \\\"running validation\\\"\\n my_data = genfromtxt(inputs, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #processing data without targets\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #for further information about parameters, please google sklearn docs\\n parameters = {'kernel':('sigmoid', 'rbf'), 'C':[.1,.2,1.0],'cache_size':[500]}\\n svr = svm.SVC()\\n clf = grid_search.GridSearchCV(svr, parameters,n_jobs=3)\\n sys.stdout.write(\\\"%s:validating... \\\"%(strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())))\\n output = clf.fit(X,Y)\\n print output\\n print \\\"(%s) DONE.\\\" % (strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime()))\\n sys.exit(0)\",\n \"def ex_2_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train an SVM with a linear kernel for the given dataset\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x_train, y_train)\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\\n print(\\\"ex_2_a score:\\\", clf.score(x_test, y_test))\\n\\n pass\",\n \"def cross_validation(features, target, n_neighbors=5, n_folds=5):\\n clf = KNeighborsClassifier(n_neighbors=n_neighbors)\\n cv_scores = cross_val_score(clf, features, target, cv=n_folds)\\n # print each cv score (accuracy) and average them\\n print('Cross Validation Scores Mean: %.2f' % (np.mean(cv_scores) * 100))\",\n \"def cross_validation(self, k_folds, **inputs):\\n self.cv_stats, self.cv_traces = [], []\\n self.k_folds = k_folds\\n inputs = self._clean_inputs(inputs)\\n for i, fold in enumerate(k_folds):\\n train, test = fold\\n input_train, input_test = {}, {}\\n for name, data in inputs.items():\\n if name in self.cv_vars:\\n input_train[name] = data[train]\\n input_test[name] = data[test]\\n else:\\n input_train[name] = data\\n input_test[name] = data\\n trace = self.run(**input_train)\\n stats = self.calculate_statistics(trace, **input_test)\\n self.cv_traces.append(trace)\\n self.cv_stats.append(stats)\\n return self.cv_traces, self.cv_stats\",\n \"def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def performance_metrics(model, X_train, y_train, X_test, y_test, train=True, cv=True):\\n from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, f1_score \\n from sklearn.metrics import precision_score, recall_score, roc_auc_score\\n from sklearn.model_selection import cross_validate, cross_val_score, StratifiedKFold\\n scoring = {'acc': 'accuracy',\\n 'prec_micro': 'precision_micro',\\n 'rec_micro': 'recall_micro',\\n 'f1_micro': 'f1_micro',\\n 'auc':'roc_auc'} \\n if train==True:\\n if cv==True:\\n kfold=StratifiedKFold(n_splits=10, random_state=42)\\n scores = cross_validate(model, X_train, y_train, scoring=scoring, cv=kfold)\\n ypredTrain = model.predict(X_train)\\n Acc_train = scores['test_acc'].mean()\\n Precision_train = scores['test_prec_micro'].mean()\\n Recall_train = scores['test_rec_micro'].mean()\\n F1_train = scores['test_f1_micro'].mean()\\n AUC_train = scores['test_auc'].mean()\\n conf_matrix_train = confusion_matrix(y_train, ypredTrain)\\n class_report = classification_report(y_train, ypredTrain)\\n print(\\\"TRAIN:\\\\n===========================================\\\")\\n print(f\\\"CV - Accuracy : {Acc_train:.2f}\\\\n\\\")\\n print(f\\\"CV - Precision: {Precision_train:.2f}\\\\n\\\")\\n print(f\\\"CV - Recall: {Recall_train:.2f}\\\\n\\\")\\n print(f\\\"CV - F1 score: {F1_train:.2f}\\\\n\\\") \\n print(f\\\"CV - AUC score: {AUC_train:.2f}\\\\n\\\") \\n print(f\\\"Confusion Matrix:\\\\n {conf_matrix_train}\\\\n\\\")\\n print(f\\\"Classification Report:\\\\n {class_report}\\\\n\\\") \\n elif cv==False:\\n scores = cross_validate(model, X_train, y_train, scoring=scoring)\\n ypredTrain = model.predict(X_train)\\n Acc_train = scores['test_acc'].mean()\\n Precision_train = scores['test_prec_micro'].mean()\\n Recall_train = scores['test_rec_micro'].mean()\\n F1_train = scores['test_f1_micro'].mean()\\n AUC_train = scores['test_auc'].mean()\\n conf_matrix_train = confusion_matrix(y_train, ypredTrain)\\n class_report = classification_report(y_train, ypredTrain)\\n print(\\\"TRAIN:\\\\n===========================================\\\")\\n print(f\\\"CV - Accuracy : {Acc_train:.2f}\\\\n\\\")\\n print(f\\\"CV - Precision: {Precision_train:.2f}\\\\n\\\")\\n print(f\\\"CV - Recall: {Recall_train:.2f}\\\\n\\\")\\n print(f\\\"CV - F1 score: {F1_train:.2f}\\\\n\\\") \\n print(f\\\"CV - AUC score: {AUC_train:.2f}\\\\n\\\") \\n print(f\\\"Confusion Matrix:\\\\n {conf_matrix_train}\\\\n\\\")\\n print(f\\\"Classification Report:\\\\n {class_report}\\\\n\\\")\\n elif train==False:\\n if cv==True:\\n kfold=StratifiedKFold(n_splits=10, random_state=42)\\n scores = cross_validate(model, X_test, y_test, scoring=scoring, cv=kfold)\\n ypredTest = model.predict(X_test)\\n Acc_test = scores['test_acc'].mean()\\n Precision_test = scores['test_prec_micro'].mean()\\n Recall_test = scores['test_rec_micro'].mean()\\n F1_test = scores['test_f1_micro'].mean()\\n AUC_test = scores['test_auc'].mean()\\n conf_matrix_test = confusion_matrix(y_test, ypredTest)\\n class_report = classification_report(y_test, ypredTest) \\n print(\\\"TEST:\\\\n===========================================\\\")\\n print(f\\\"CV - Accuracy : {Acc_test:.2f}\\\\n\\\")\\n print(f\\\"CV - Precision: {Precision_test:.2f}\\\\n\\\")\\n print(f\\\"CV - Recall: {Recall_test:.2f}\\\\n\\\")\\n print(f\\\"CV - F1 score: {F1_test:.2f}\\\\n\\\") \\n print(f\\\"CV - AUC score: {AUC_test:.2f}\\\\n\\\") \\n print(f\\\"Confusion Matrix:\\\\n {conf_matrix_test}\\\\n\\\")\\n print(f\\\"Classification Report:\\\\n {class_report}\\\\n\\\")\\n elif cv==False:\\n scores = cross_validate(model, X_test, y_test, scoring=scoring)\\n ypredTest = model.predict(X_test)\\n Acc_test = scores['test_acc'].mean()\\n Precision_test = scores['test_prec_micro'].mean()\\n Recall_test = scores['test_rec_micro'].mean()\\n F1_test = scores['test_f1_micro'].mean()\\n AUC_test = scores['test_auc'].mean()\\n conf_matrix_test = confusion_matrix(y_test, ypredTest)\\n class_report = classification_report(y_test, ypredTest) \\n print(\\\"TEST:\\\\n===========================================\\\")\\n print(f\\\"CV - Accuracy : {Acc_test:.2f}\\\\n\\\")\\n print(f\\\"CV - Precision: {Precision_test:.2f}\\\\n\\\")\\n print(f\\\"CV - Recall: {Recall_test:.2f}\\\\n\\\")\\n print(f\\\"CV - F1 score: {F1_test:.2f}\\\\n\\\") \\n print(f\\\"CV - AUC score: {AUC_test:.2f}\\\\n\\\") \\n print(f\\\"Confusion Matrix:\\\\n {conf_matrix_test}\\\\n\\\")\\n print(f\\\"Classification Report:\\\\n {class_report}\\\\n\\\")\",\n \"def cross_validation_score(self, model, x, y, cv, groups):\\n losses = []\\n for train_idx, test_idx in cv.split(x, y, groups):\\n x_tr, x_te = x[train_idx], x[test_idx]\\n y_tr, y_te = y[train_idx], y[test_idx]\\n\\n model.fit(x_tr, y_tr)\\n if self.is_classier:\\n test_preds = model.predict_proba(x_te)[:, 1]\\n else:\\n test_preds = model.predict(x_te)[:,]\\n loss = self.loss_metric(y_true=y_te, y_pred=test_preds)\\n losses.append(loss)\\n return np.mean(losses)\",\n \"def ovo_classifier(X_train, y_train, X_val, y_val):\\n beta_matrix = []\\n #obj_matrix =[obj(np.zeros(X_train.shape[1]), 1, X_train, y_train, h=0.5)]\\n obj_matrix = []\\n final_matrix = []\\n final_matrix_test =[]\\n for i in np.unique(y_train):\\n for j in np.unique(y_train):\\n if i < j:\\n print(i,j)\\n # Slicing X train and y train into each pair wise comparison\\n # location scale y labels into [-1,1] for loss calculation\\n sliced_X_train = X_train[np.ix_(np.bitwise_or(y_train == i, y_train == j))]\\n sliced_y_train = ((y_train[np.ix_(np.bitwise_or(y_train == i, y_train == j))]-min(i,j))/(max(i,j)-min(i,j)))*2-1\\n \\n # generating index for cross validation indexing\\n index = np.random.randint(low=0,high=3,size=sliced_X_train.shape[0])\\n print('starting cross validation...', i, j)\\n avg_error, set_of_lambda = fold3_CV_for_lambda(x=sliced_X_train, y=sliced_y_train, index=index)\\n optimal_lambda = set_of_lambda[np.argmin(avg_error)]\\n print('starting mylinearsvm...', i, j)\\n beta_vals, obj_vals = mylinearsvm(beta = np.zeros(sliced_X_train.shape[1]),\\n \\t lambd = optimal_lambda,\\n x = sliced_X_train,\\n y = sliced_y_train,\\n step_size_init=1)\\n \\n # Store classifier and objective value from each iteration\\n beta_matrix.append(np.copy(beta_vals[-1]))\\n obj_matrix.append(np.copy(obj_vals))\\n\\n print('starting prediction...', i, j)\\n # Predict y_val from X_val using the trained classifiers\\n pred = 2*(beta_vals.dot(X_val.T)>0)-1\\n y_hat = np.zeros(X_val.shape[0])\\n y_hat[pred[-1]==1] = j\\n y_hat[pred[-1]==-1] = i\\n final_matrix.append(np.copy(y_hat))\\n\\n beta_matrix = np.array(beta_matrix)\\n obj_matrix = np.array(obj_matrix)\\n print('beta matrix shape:', beta_matrix.shape)\\n print('obj matrix shape:', obj_matrix.shape)\\n\\n prediction_matrix = np.array(final_matrix)\\n \\n y_val_pred = []\\n for f in range(X_val.shape[0]):\\n data = pd.DataFrame(prediction_matrix[:,f].astype(int))\\n # Use mode to find the most frequent class\\n assignment = data.mode()\\n # In the case of a tie, use random int generator for the indexing of a random mode\\n if assignment.shape[0] > 1:\\n assign = assignment.loc[np.random.randint(assignment.shape[0]),0]\\n else:\\n assign = assignment.loc[0,0]\\n y_val_pred.append(assign)\\n \\n misclassification_error = np.mean(np.array(y_val_pred) != y_val)\\n print('misclassification_error:', misclassification_error)\\n \\n return np.array(beta_matrix), np.array(obj_matrix), np.array(y_val_pred), misclassification_error\",\n \"def test_searchcv_runs_multiple_subspaces():\\n\\n X, y = load_iris(True)\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, train_size=0.75, random_state=0\\n )\\n\\n opt = BayesSearchCV(\\n SVC(),\\n [\\n ({\\n 'C': Real(1e-6, 1e+6, prior='log-uniform'),\\n 'gamma': Real(1e-6, 1e+1, prior='log-uniform'),\\n }, 10),\\n {\\n 'degree': Integer(1, 8),\\n 'kernel': Categorical(['linear', 'poly', 'rbf']),\\n }\\n ],\\n n_iter=10\\n )\\n\\n opt.fit(X_train, y_train)\",\n \"def run(self, df: pd.DataFrame, model: Any):\\n print(f'Running cross validation with the following model:\\\\n{model}')\\n\\n df['timestamp'] = pd.to_datetime(df['timestamp'])\\n\\n date_1 = datetime.datetime(year=2016, month=1, day=1)\\n date_2 = datetime.datetime(year=2016, month=4, day=1)\\n date_3 = datetime.datetime(year=2016, month=7, day=1)\\n date_4 = datetime.datetime(year=2016, month=10, day=1)\\n date_5 = datetime.datetime(year=2017, month=1, day=1)\\n\\n summaries: List[FoldSummary] = []\\n\\n for train_start, train_end, test_start, test_end in [\\n (date_1, date_2, date_2, date_3),\\n # (date_1, date_3, date_3, date_4),\\n # (date_1, date_4, date_4, date_5)\\n ]:\\n print('Calculating train and test datasets')\\n train_df = df[(df['timestamp'] >= train_start) & (df['timestamp'] < train_end)]\\n test_df = df[(df['timestamp'] >= test_start) & (df['timestamp'] < test_end)]\\n\\n columns = list(train_df.columns)\\n columns.remove('timestamp')\\n columns.remove('meter_reading')\\n\\n print(columns)\\n\\n train_data = train_df[columns]\\n test_data = test_df[columns]\\n\\n print(f'Fitting the model on train dataset of size {len(train_data)}')\\n model.fit(train_data, train_df['meter_reading'])\\n print(f'Predicting for test dataset of size {len(test_data)}')\\n predictions = model.predict(test_data)\\n\\n score = self._calculate_score(predictions, test_df['meter_reading'])\\n print(f'Score: {score}')\\n\\n summaries.append(FoldSummary(\\n train_start=train_start,\\n train_end=train_end,\\n test_start=test_start,\\n test_end=test_end,\\n score=score\\n ))\\n\\n filename = f'../resources/runs/{time.time()}.txt'\\n os.makedirs(os.path.dirname(filename), exist_ok=True)\\n with open(filename, 'w+') as f:\\n f.write(f'{model.__class__.__name__}\\\\n')\\n f.write(f'{str(model.get_params())}\\\\n')\\n for summary in summaries:\\n f.write(f'Summary (\\\\n'\\n f'\\\\ttrain start: {summary.train_start}\\\\n'\\n f'\\\\ttrain end: {summary.train_end}\\\\n'\\n f'\\\\ttest start: {summary.test_start}\\\\n'\\n f'\\\\ttest end: {summary.test_end}\\\\n'\\n f'\\\\tscore: {summary.score}\\\\n'\\n f')\\\\n')\\n\\n print(summaries)\\n\\n return model\",\n \"def cross_validate(model, X, y, folds=5, epochs=5, batch_size=32, callbacks=None, shuffle=False, random_state=None):\\n\\n # Initalize KFold\\n kfolds = KFold(n_splits=folds, random_state=random_state, shuffle=shuffle)\\n all_metrics = []\\n\\n # To build the model\\n if type(model).__name__ == 'SVDpp':\\n model.implicit_feedback(X[:10, :])\\n model(X[:10, :])\\n\\n # Workaround to reset weights after each fold fit\\n weights = model.get_weights()\\n i = 1\\n\\n for train, val in kfolds.split(X, y):\\n\\n # Gather implicit feedback if model is SVD++\\n if type(model).__name__ == 'SVDpp':\\n model.implicit_feedback(X[train])\\n\\n print(f'\\\\nFitting on Fold {i}')\\n # Train and evaluate metrics\\n history = model.fit(\\n X[train], y[train], batch_size=batch_size, epochs=epochs, callbacks=callbacks)\\n print(f'\\\\nEvaluating on Fold {i}')\\n fold_score = history.model.evaluate(X[val], y[val])\\n all_metrics.append(fold_score)\\n\\n # Reset Weights\\n model.set_weights(weights)\\n\\n i += 1\\n\\n all_metrics = np.array(all_metrics)\\n\\n for i, metric in enumerate(model.metrics_names):\\n print(f'Mean {metric.capitalize()} : {np.mean(all_metrics.T[i])}')\\n\\n return all_metrics\",\n \"def classify(self, X, y):\\n\\n clf = svm.SVC(kernel='linear', C=1)\\n cv = StratifiedKFold(n_splits=5, random_state=0, shuffle=True)\\n\\n scores = cross_val_score(clf, X, y, cv=cv, scoring='balanced_accuracy')\\n\\n return scores\",\n \"def crossValidate(cls, trinary_data, num_holdout=5, num_iter=10,\\n clf_desc=ClassifierDescriptorSVM(), **kwargs):\\n def dropIndices(df, indices):\\n \\\"\\\"\\\"\\n Drops the indices from the dataframe or series.\\n \\\"\\\"\\\"\\n df_result = df.copy()\\n sorted_indices = list(indices)\\n sorted_indices.sort()\\n sorted_indices.reverse()\\n for idx in sorted_indices:\\n df_result = df_result.drop(idx, axis=0)\\n return df_result\\n #\\n def getClasses(indices=None):\\n \\\"\\\"\\\"\\n Returns the list of classes for the indices.\\n \\\"\\\"\\\"\\n if indices is None:\\n indices = list(trinary_data.ser_y.index)\\n return list(set(trinary_data.ser_y.loc[indices]))\\n #\\n svm_ensemble = cls(clf_desc=clf_desc, **kwargs)\\n all_classes = getClasses()\\n total_correct = 0\\n for _ in range(num_iter):\\n # Select holdouts for each class\\n holdout_idxs = []\\n for cls in all_classes:\\n cls_ser = trinary_data.ser_y[trinary_data.ser_y == cls]\\n cls_idxs = list(cls_ser.index)\\n if num_holdout >= len(cls_idxs):\\n raise ValueError(\\\"Not enough samples in class %s for %d holdouts!\\\"\\n % (cls, num_holdout))\\n # Choose holdouts\\n random_positions = np.random.permutation(range(len(cls_idxs)))\\n [holdout_idxs.append(cls_idxs[n])\\n for n in random_positions[:num_holdout]]\\n # Fit\\n df_X = dropIndices(trinary_data.df_X, holdout_idxs)\\n ser_y = dropIndices(trinary_data.ser_y, holdout_idxs)\\n svm_ensemble.fit(df_X, ser_y)\\n # Evaluate\\n df = pd.DataFrame(trinary_data.df_X.loc[holdout_idxs, :])\\n df_pred = svm_ensemble.predict(df)\\n for idx in holdout_idxs:\\n true_cls = trinary_data.ser_y.loc[idx]\\n total_correct += df_pred.loc[idx, true_cls]\\n accuracy = total_correct/(num_holdout*num_iter*len(all_classes))\\n return accuracy\",\n \"def cross_validate(featureFile, nFolds, verbosity = False, percentTData = 1., extype='attribution'):\\n oData,aData = importC5(featureFile)\\n nAuthors = len(set(aData))\\n if extype == 'attribution' and np.mean(Counter(aData).values()) != Counter(aData).values()[0]:\\n print('Number of docs per author should be equal in attribution experiment')\\n docsPerFold = len(oData) / nFolds\\n cMatrix = np.zeros( (nAuthors, nAuthors) )\\n\\n for N in range(0,nFolds):\\n testAuthors = list()\\n trainAuthors= list()\\n testData = list()\\n trainData = list()\\n for idv in range(0,len(oData)):\\n if (N+idv) % nFolds == 0:\\n testData.append(oData[idv])\\n testAuthors.append(aData[idv])\\n else:\\n trainData.append(oData[idv])\\n trainAuthors.append(aData[idv]) \\n teFile = '%s.cvtest' % (os.path.splitext(featureFile)[0])\\n trFile = '%s.cvtrain' % (os.path.splitext(featureFile)[0])\\n tAmount = int(round(len(trainAuthors) * percentTData)) # limit training data\\n exportFoldFile(testData, testAuthors, teFile)\\n exportFoldFile(trainData[0:tAmount], trainAuthors[0:tAmount], trFile)\\n predict = classify(trFile, teFile, len(oData[0]))\\n if extype != 'attribution':\\n cMatrix += confusionMatrix(testAuthors, predict, extype)\\n os.remove(teFile)\\n os.remove(trFile)\\n if percentTData != 1.0: print('Ran CV only with %.f %% (%d docs) of training data.' % (percentTData * 100, tAmount))\\n return cMatrix\",\n \"def learn1_svc():\\n \\n svc.fit(vector_training,sentiment_training) ##fit the training data of vector tweets and sentiments using LinearSVC\\n correct = 0\\n for i in range(vector_testing.shape[0]): ##using the testing data, see how accurate LinearSVC is\\n prediction = svc.predict(vector_testing[i])\\n sentiment = sentiment_testing[i]\\n if prediction[0] == sentiment:\\n correct +=1\\n accuracy = correct/vector_testing.shape[0]\\n print('Linear Support Vector Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##print the accuracy of the algorithm\",\n \"def LOSO_cross_validation(signal, device):\\n rf = RandomForestClassifier(random_state=0)\\n hyperparams = {\\\"n_estimators\\\": [30, 50, 100], \\\"max_depth\\\": [10, 30, 50]}\\n clf = GridSearchCV(estimator=rf, param_grid=hyperparams, scoring=\\\"accuracy\\\", cv=None, refit=True, verbose=0)\\n\\n all_subjects_but_one = []\\n for subject_out in range(0, 51):\\n for subject_in in range(0, 51):\\n if subject_in == subject_out:\\n print(f'Leaving subject {subject_out} out: \\\\n ==================================================')\\n else:\\n _, _, _, _, normalized_all_feature, all_labels = input_features_labels(device=device,\\n signal=signal,\\n subject_ID=subject_in)\\n feature_label = pd.concat([normalized_all_feature, all_labels], axis=1)\\n all_subjects_but_one.append(feature_label)\\n\\n all_subjects_but_one = pd.concat(all_subjects_but_one, axis=0)\\n all_subjects_but_one = all_subjects_but_one.dropna()\\n feature_train = all_subjects_but_one.drop(columns=['Activity_ID'])\\n label_train = all_subjects_but_one['Activity_ID']\\n print(feature_train)\\n print(label_train)\\n\\n _, _, _, _, feature_test, label_test = input_features_labels(device=device,\\n signal=signal, subject_ID=subject_out)\\n print(feature_test)\\n print(label_test)\\n clf.fit(feature_train, label_train)\\n print('Best parameters: ', clf.best_params_)\\n prediction = clf.predict(feature_test)\\n report = sklearn.metrics.classification_report(label_test, prediction, digits=3, zero_division=1)\\n\\n conf_matrix = confusion_matrix(label_test, prediction)\\n print(conf_matrix.shape[0])\\n # plotitng_confusion_matrix(confusion_matrix=con_matrix, evaluation_mode='personal', subject_ID=subject_ID)\\n print(report)\\n for row in range(conf_matrix.shape[0]):\\n print(f'Accuracy for class {row}: ',\\n accuracy_per_class(conf_matrix=conf_matrix, row_index=row, to_print=False))\\n\\n all_subjects_but_one = []\",\n \"def CalculateSVM(data=None):\\n vectorizer = TfidfVectorizer(tokenizer=pre_process)\\n classifier = LinearSVC()\\n train, test = train_test_split([(i['text'], i['stars']) for i in data],\\n test_size=.2,\\n random_state=10)\\n x_train = vectorizer.fit_transform(i[0] for i in train)\\n x_test = vectorizer.transform(i[0] for i in test)\\n classifier.fit(x_train, [i[1] for i in train])\\n score = classifier.score(x_test, [i[1] for i in test])\\n print score\",\n \"def cross_validation(self, cv, lambdas, lambda_name, seed=1, skip=False, plot=False, **kwargs):\\n np.set_printoptions(precision=4)\\n k_indices = build_k_indices(self.train_y, cv, seed)\\n # define lists to store the loss of training data and test data\\n err_tr = []\\n err_te = []\\n weights = []\\n print(\\\"K-fold ({}) cross validation to examine [{}]\\\".\\n format(cv, lambdas))\\n for lamb in lambdas:\\n print(\\\"For lambda: {}\\\".format(lamb))\\n _mse_tr = []\\n _mse_te = []\\n _weight = []\\n for k in range(cv):\\n print('Cross valid iteration {}'.format(k))\\n weight, loss_tr, loss_te = self._loop_cross_validation(self.train_y, self.train_x,\\n k_indices, k,\\n lamb, lambda_name, **kwargs)\\n _mse_tr += [loss_tr]\\n _mse_te += [loss_te]\\n _weight.append(weight)\\n if skip:\\n break\\n avg_tr = np.average(_mse_tr)\\n avg_te = np.average(_mse_te)\\n err_tr += [avg_tr]\\n err_te += [avg_te]\\n weights.append(_weight)\\n print(\\\"\\\\t train error {}, \\\\t valid error {}\\\".\\n format(avg_tr, avg_te))\\n # Select the best parameter during the cross validations.\\n print('K-fold cross validation result: \\\\n {} \\\\n {}'.\\n format(err_tr, err_te))\\n # Select the best based on least err_te\\n min_err_te = np.argmin(err_te)\\n print('Best err_te result {}, lambda {}'.\\n format(err_te[min_err_te], lambdas[min_err_te]))\\n if plot:\\n from plots import cross_validation_visualization\\n cross_validation_visualization(lambdas, err_tr, err_te, title=lambda_name,\\n error_name=self.loss_function_name)\\n else:\\n save_numpy_array(lambdas, err_tr, err_te, names=['lambda', 'err_tr', 'err_te'], title=self.regularizer.name)\\n\\n return weights[min_err_te], lambdas[min_err_te], (err_tr, err_te)\",\n \"def ex_3_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train multi-class SVMs with one-versus-rest strategy with\\n ## - linear kernel\\n ## - rbf kernel with gamma going from 10**-5 to 10**5\\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\\n ###########\\n dfs = 'ovr'\\n c = 10\\n\\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\\n linear.fit(x_train, y_train)\\n lin_score_train = linear.score(x_train, y_train)\\n lin_score_test = linear.score(x_test, y_test)\\n\\n gammas = [pow(10, i) for i in range(-5, 6)]\\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\\n for rbf in rbfs:\\n rbf.fit(x_train, y_train)\\n\\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)\",\n \"def cross_val_SVM_linear(variables, targeted):\\n\\n\\tsvm = SVC(kernel = \\\"linear\\\")\\n\\tpca = decomposition.PCA()\\n\\tpipe = Pipeline(steps=[('pca', pca), ('svm', svm)])\\n\\n\\tn_components = [4,5]\\n\\tC = np.logspace(-10,10,10)\\n\\n\\testimator = GridSearchCV(\\n\\t\\tpipe,\\n\\t\\tdict(pca__n_components = n_components,\\n\\t\\t\\tsvm__C = C)\\n\\t\\t)\\n\\t\\n\\tpredicted = cross_val_predict(\\n\\testimator, variables, targeted, cv = 5)\\n\\n\\treturn {\\n\\t\\t'accuracy':metrics.accuracy_score(targeted, predicted),\\n\\t\\t'report':metrics.classification_report(targeted, predicted)\\n\\t\\t}\",\n \"def train_all(self, dataset, mu=None):\\n\\n\\t\\tX = dataset.X #get_design_matrix()\\n\\t\\ty = dataset.y\\n\\n\\t\\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\\n\\t\\t\\t\\tclass_weight = None, coef0=0.0, degree=3,\\n\\t\\t\\t\\tmax_iter = -1, probability=False, random_state=None,\\n\\t\\t\\t\\tshrinking = True, tol=0.001, verbose=False)\\n\\t\\tclf.fit (X, y)\\n\\t\\t\\n\\t\\t# save the last classifier\\n\\t\\tself.classifier = clf\\n\\n\\t\\t# get model parameter\\n\\t\\tself.alpha = clf.dual_coef_\\n\\t\\tself.bias = clf.intercept_\\n\\t\\t# TODO\\n\\t\\tself.params = clf.get_params (deep=True)\\n\\n\\n\\t\\t#TODO:self.mu = sharedX(mu)?\\n\\t\\tself._params = [self.alpha, self.bias]\\n\\t\\tprint(self._params)\",\n \"def SVM(x_train, x_test, y_train, kernel):\\n svc_model = SVC(kernel=kernel)\\n svc_model.fit(x_train, y_train)\\n y_pred = svc_model.predict(x_test)\\n return y_pred\",\n \"def cross_validation(ww_data, rw_data, k):\\n # shuffle the data\\n np.random.shuffle(ww_data)\\n np.random.shuffle(rw_data)\\n\\n # calculate cutoff for each partition\\n cutoff = ww_data.shape[0]//k\\n redArr = []\\n whiteArr = []\\n tmpStart = 0\\n tmpEnd = cutoff\\n \\n # create a list of k partitions for red and white data\\n for x in range(k):\\n if x != k-1:\\n redArr.append(rw_data[tmpStart:tmpEnd])\\n whiteArr.append(ww_data[tmpStart:tmpEnd])\\n else:\\n redArr.append(rw_data[tmpStart:])\\n whiteArr.append(ww_data[tmpStart:])\\n tmpStart+=cutoff\\n tmpEnd+=cutoff\\n\\n\\n redTraining = np.array(())\\n whiteTraining = np.array(())\\n accuracy = 0\\n count = 0\\n \\n for x in range(k):\\n # creates Test data set\\n tmpRedTest = redArr[x]\\n tmpWhiteTest = whiteArr[x]\\n \\n # creates list of partitons for training data set\\n if x!=k-1:\\n redTrainingList = redArr[:x] + redArr[x+1:]\\n whiteTrainingList = whiteArr[:x] + whiteArr[x+1:]\\n else:\\n redTrainingList = redArr[:x]\\n whiteTrainingList = whiteArr[:x]\\n\\n # stacks each training list into one nparray\\n redTraining = np.vstack(redTrainingList)\\n whiteTraining = np.vstack(whiteTrainingList)\\n\\n accuracy += experiment(whiteTraining, redTraining, tmpWhiteTest, tmpRedTest)\\n count += 1\\n # calculates accuracy and returns it\\n result = accuracy/count\\n return result\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n\\n test_scores = np.array([])\\n train_scores = np.array([])\\n best_svm = None\\n best_test_score = 0\\n\\n for gamma in gammas:\\n clf = svm.SVC(kernel='rbf', gamma=gamma)\\n clf.fit(x_train, y_train)\\n\\n test_score = clf.score(x_test, y_test)\\n\\n if test_score > best_test_score:\\n best_test_score = test_score\\n best_svm = clf\\n\\n test_scores = np.append(test_scores, test_score)\\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas)\\n\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\",\n \"def SVM():\\n x1, x2 = generate_training_data_2D()\\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\\n np.ones(x2.shape[0], dtype=np.int32)])\\n X = np.concatenate([x1, x2], axis=0)\\n rng = np.random.get_state()\\n np.random.shuffle(X)\\n # Set the random state back to previous to shuffle X & Y similarly\\n np.random.set_state(rng)\\n np.random.shuffle(Y)\\n\\n models, titles = get_fitted_svm(X, Y)\\n\\n plot_decision_boundary(X, Y, models, titles)\",\n \"def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\\n if not scaled :\\n scaler = StandardScaler()\\n xtrain = scaler.fit_transform(xtrain)\\n xtest = scaler.transform(xtest)\\n\\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\\n return svm\",\n \"def train(self, X, y, X_cv=None, y_cv=None, verbose=False):\\n np.random.seed(seed=self.randomSeed)\\n\\n n, m = X.shape # n samples, m features\\n if self.loss == 'linear':\\n w = np.array([np.zeros(m)]).T # dim: m by 1\\n elif self.loss == 'logistic':\\n w = np.array([np.random.rand(m)]).T / 1 # dim: m by 1\\n # w = np.array([np.zeros(m)]).T # dim: m by 1\\n elif self.loss == 'perceptron':\\n w = np.array([np.random.rand(m)]).T # dim: m by 1\\n # w = np.array([np.zeros(m)]).T # dim: m by 1\\n elif self.loss == 'svm':\\n w = np.array([np.random.rand(m)]).T / 5 # dim: m by 1\\n # w = np.array([np.zeros(m)]).T # dim: m by 1\\n\\n for i in range(1, self.iteration + 1):\\n gradient = self.computeGradient(X, y, w)\\n w = w - self.learning_rate * gradient / n\\n Error, Acc = self.evaluate(X, y, w)\\n self.trainError.append(Error)\\n self.trainAcc.append(Acc)\\n self.w.append(w)\\n # evaluate on the cross-validation set\\n if self.CV == True:\\n tmp_cv_Error, tmp_cv_Acc = self.evaluate(X_cv, y_cv, w)\\n self.cvError.append(tmp_cv_Error)\\n self.cvAcc.append(tmp_cv_Acc)\\n\\n # print current process\\n if verbose == True and self.showFreq != 0 and i % self.showFreq == 0:\\n print(str(i) + \\\"th Iteration, \\\", \\\"Error: \\\", Error, \\\" Accuracy : \\\", Acc)\\n if self.CV == True:\\n print(\\\"Cross-Validation: \\\", \\\"Error: \\\", tmp_cv_Error, \\\" Accuracy : \\\", tmp_cv_Acc)\\n if verbose == True:\\n print(\\\"Reach the Maximum Iteration : \\\" + str(i) + \\\"th Iteration\\\")\\n bestError, bestAcc, bestW = self.getBest(\\\"Accuracy\\\")\\n print(\\\"Best Training Error: \\\", bestError, \\\" Highest Training Accuracy : \\\", bestAcc)\\n if self.CV == True:\\n best_cv_Error, best_cv_Acc = self.evaluate(X_cv, y_cv, bestW)\\n print(\\\"Best Development Error: \\\", best_cv_Error, \\\" Highest Development Accuracy : \\\", best_cv_Acc)\",\n \"def nested_cv(X, y, model, n_splits, n_folds, unique_id):\\n \\n cv = StratifiedKFold(n_splits=n_splits,\\n shuffle=True,\\n random_state=42) # Outer CV\\n \\n i_start = 0\\n i_list = []\\n results_df = None\\n cv_path = unique_id + '_NestedCV.pkl'\\n \\n if os.path.isfile(cv_path) == True: # If CV is incomplete, resume\\n results_df = pd.read_pickle(cv_path)\\n i_start = results_df.Outer_fold.max() + 1\\n print('Resuming cross-validation from fold ' + str(i_start + 1))\\n \\n # Generate indices to split data by StratifiedKFold\\n # Append indices for each fold to list \\n for tr_i, te_i in cv.split(X,y):\\n i_list.append([tr_i, te_i])\\n \\n # For each fold...\\n for i in range(i_start, len(i_list)):\\n results_list = []\\n print('Beginning fold ' + str(i+1) + ' of ' + str(len(i_list)))\\n \\n # Split data into training and test tests\\n X_train = X.loc[X.index.intersection(i_list[i][0])]\\n y_train = y.loc[y.index.intersection(i_list[i][0])]\\n X_test = X.loc[X.index.intersection(i_list[i][1])]\\n y_test = y.loc[y.index.intersection(i_list[i][1])]\\n\\n start = time.time()\\n \\n # Fit the HyperoptEstimator to training data (optimise model)\\n model.fit(X_train,\\n y_train,\\n n_folds=n_folds, # Inner stratified k-fold CV\\n cv_shuffle=True)\\n \\n end = time.time()\\n duration = end - start\\n\\n # Use optimised model to predict labels for test data\\n y_pred = model.predict(X_test)\\n score = f1_score(y_test, y_pred, average='weighted') # Evaluate\\n \\n # Everything below: formats and/or calculates results for output file\\n sorted_labels = np.sort(y_test.unique())\\n unweighted_score = f1_score(y_test, y_pred,\\n average=None,\\n labels=sorted_labels)\\n c_matrix = confusion_matrix(y_test, y_pred,\\n labels=sorted_labels)\\n\\n for trial in range(len(model.trials.trials)):\\n if model.trials.trials[trial].get('result').get('status') == 'ok':\\n trial_loss = model.trials.trials[trial].get('result').get('loss')\\n trial_duration = model.trials.trials[trial].get('result').get('duration')\\n else:\\n trial_loss = np.nan\\n trial_duration = np.nan\\n \\n results_list.append([i,\\n score,\\n unweighted_score,\\n le.inverse_transform(sorted_labels),\\n c_matrix,\\n duration,\\n trial,\\n trial_loss,\\n trial_duration])\\n \\n append_df = pd.DataFrame(results_list,\\n columns=['Outer_fold',\\n 'Outer_score',\\n 'Outer_unweighted_scores',\\n 'Outer_unweighted_score_labels',\\n 'Outer_confusion_matrix',\\n 'Outer_training_duration',\\n 'Trial',\\n 'Trial_loss',\\n 'Trial_duration'])\\n if i == i_start:\\n if results_df is not None:\\n final_df = pd.concat([results_df,\\n append_df],\\n ignore_index=True)\\n else:\\n final_df = append_df\\n final_df.to_pickle(cv_path)\\n \\n else:\\n results_df = pd.read_pickle(cv_path)\\n final_df = pd.concat([results_df,\\n append_df],\\n ignore_index=True)\\n final_df.to_pickle(cv_path)\",\n \"def cross_validate(all_tetrode_data, target, tetrode_ids, tetrode_units, verbose=True):\\n kf = StratifiedKFold(n_splits=10)\\n y_true = np.zeros(target.shape)\\n y_hat = np.zeros(target.shape)\\n i = 0\\n\\n for train_index, test_index in kf.split(np.zeros(target.shape[0]), target.argmax(axis=-1)):\\n X_train, X_test = select_data(all_tetrode_data, train_index), select_data(all_tetrode_data, test_index)\\n y_train, y_test = target[train_index, :], target[test_index, :]\\n\\n model = build_tetrode_model(tetrode_ids, tetrode_units)\\n checkpointer = ModelCheckpoint('temp_model.h5',\\n verbose=0, save_best_only=True)\\n hist = model.fit(X_train, y_train,\\n nb_epoch=200, batch_size=20,\\n validation_data=(X_test, y_test),\\n callbacks=[checkpointer], verbose=0)\\n best_model = load_model('temp_model.h5')\\n\\n n = y_test.shape[0]\\n y_true[i:(i + n), :] = y_test\\n y_hat[i:(i + n), :] = best_model.predict(X_test)\\n i += n\\n\\n if verbose:\\n accuracy = max(hist.history['val_acc'])\\n print('Current fold validation accuracy: {acc}'.format(acc=accuracy))\\n\\n return y_true, y_hat\",\n \"def cross_validation(self, X, y, n_folds=5, shuffle=True, evaluation_metric='top30'):\\n # WE DON'T USE THIS\\n # We use basic train-test split to evaluate or models as a first approach\\n # We will then use CV for searching the best parameters via random search\\n pass\",\n \"def cross_validation(whole_train_data, whole_train_labels, k, k_fold):\\n accuracies = []\\n for i in range(k_fold):\\n train_data, train_labels, validation_data, validation_labels = split_train_and_validation(whole_train_data, whole_train_labels, i, k_fold)\\n accuracy = knn(train_data, train_labels, validation_data, validation_labels, k)\\n accuracies.append(accuracy)\\n avg_accuracy = np.mean(accuracies)\\n return avg_accuracy\",\n \"def executeKFoldValidation(train_data, train_labels, val_data, val_labels, test_data, test_labels,\\n images_47, labels_47, images_84, labels_84, all_unseen_images, all_unseen_labels):\\n if run_k_fold_validation:\\n print(\\\"In executingKFoldValidation\\\")\\n\\n # this is doing it manually:\\n kfold = StratifiedKFold(n_splits=k_fold_num, shuffle=True)\\n\\n test_scores_list = []\\n unseen_47_scores_list = []\\n unseen_84_scores_list = []\\n all_unseen_scores_list = []\\n\\n test_matrix_list = []\\n matrix_47_list = []\\n matrix_84_list = []\\n all_matrix_list = []\\n kf_counter = 0\\n\\n for train, test in kfold.split(train_data, train_labels):\\n kf_counter += 1\\n print('KFold #:', kf_counter)\\n\\n model = buildClassifier()\\n # fit the model\\n model.fit(train_data[train],\\n train_labels[train],\\n epochs=epochs,\\n validation_data=(val_data, val_labels),\\n batch_size=batch_size\\n )\\n\\n unseen_47_scores = model.evaluate(images_47, labels_47, batch_size=batch_size)\\n unseen_47_scores_list.append(unseen_47_scores[1] * 100)\\n unseen_84_scores = model.evaluate(images_84, labels_84, batch_size=batch_size)\\n unseen_84_scores_list.append(unseen_84_scores[1] * 100)\\n test_scores = model.evaluate(test_data, test_labels, batch_size=batch_size)\\n test_scores_list.append(test_scores[1] * 100)\\n all_unseen_score = model.evaluate(all_unseen_images, all_unseen_labels, batch_size=batch_size)\\n all_unseen_scores_list.append(all_unseen_score[1] * 100)\\n\\n # show confusion matrix\\n test_confusion_matrix, confusion_matrix_47, confusion_matrix_84, all_confusion_matrix = \\\\\\n gettingKFoldConfusionMatrix(test_data, test_labels, images_47, labels_47, images_84, labels_84,\\n all_unseen_images,\\n all_unseen_labels, kf_counter)\\n test_matrix_list.append(test_confusion_matrix)\\n matrix_47_list.append(confusion_matrix_47)\\n matrix_84_list.append(confusion_matrix_84)\\n all_matrix_list.append(all_confusion_matrix)\\n\\n test_scores_mean = np.mean(test_scores_list)\\n test_scores_std = np.std(test_scores_list)\\n unseen_47_mean = np.mean(unseen_47_scores_list)\\n unseen_47_std = np.std(unseen_47_scores_list)\\n unseen_84_mean = np.mean(unseen_84_scores_list)\\n unseen_84_std = np.std(unseen_84_scores_list)\\n all_unseen_mean = np.mean(all_unseen_scores_list)\\n all_unseen_std = np.std(all_unseen_scores_list)\\n\\n print(\\\"Test Scores: \\\" + str(test_scores_list))\\n print(\\\"Test Scores Mean: \\\" + str(test_scores_mean))\\n print(\\\"Test Scores Std: \\\" + str(test_scores_std))\\n print(\\\"Unseen 47 Scores: \\\" + str(unseen_47_scores_list))\\n print(\\\"Unseen 47 Scores Mean: \\\" + str(unseen_47_mean))\\n print(\\\"Unseen 47 Scores Std: \\\" + str(unseen_47_std))\\n print(\\\"Unseen 84 Scores: \\\" + str(unseen_84_scores_list))\\n print(\\\"Unseen 84 Scores Mean: \\\" + str(unseen_84_mean))\\n print(\\\"Unseen 84 Scores Std: \\\" + str(unseen_84_std))\\n print(\\\"All Unseen Scores: \\\" + str(all_unseen_scores_list))\\n print(\\\"All Unseen Scores Mean: \\\" + str(all_unseen_mean))\\n print(\\\"All Unseen Scores Std: \\\" + str(all_unseen_std))\\n print(\\\"Test Confusion Matrices: \\\" + str(test_matrix_list))\\n print(\\\"47 Confusion Matrices: \\\" + str(matrix_47_list))\\n print(\\\"84 Confusion Matrices: \\\" + str(matrix_84_list))\\n print(\\\"All Confusion Matrices: \\\" + str(all_matrix_list))\\n\\n excel_headers.append(\\\"Test Scores Mean\\\")\\n excel_dictionary.append(test_scores_mean)\\n excel_headers.append(\\\"Test Scores Std\\\")\\n excel_dictionary.append(test_scores_std)\\n excel_headers.append(\\\"Unseen 47 Scores Mean\\\")\\n excel_dictionary.append(unseen_47_mean)\\n excel_headers.append(\\\"Unseen 47 Scores Std\\\")\\n excel_dictionary.append(unseen_47_std)\\n excel_headers.append(\\\"Unseen 84 Scores Mean\\\")\\n excel_dictionary.append(unseen_84_mean)\\n excel_headers.append(\\\"Unseen 84 Scores Std\\\")\\n excel_dictionary.append(unseen_84_std)\\n excel_headers.append(\\\"All Unseen Scores Mean\\\")\\n excel_dictionary.append(all_unseen_mean)\\n excel_headers.append(\\\"All Unseen Scores Std\\\")\\n excel_dictionary.append(all_unseen_std)\\n\\n plt.plot(test_scores_list, color='red', label='Testing Scores')\\n plt.plot(unseen_47_scores_list, color='blue', label='Unseen 47 Scores')\\n plt.plot(unseen_84_scores_list, color='black', label='Unseen 84 Scores')\\n plt.plot(all_unseen_scores_list, color='green', label='Unseen Scores')\\n plt.xlabel('Folds')\\n plt.ylabel('Accuracy')\\n plt.legend()\\n\\n plt.show()\",\n \"def cross_validation(self, x, t):\\n # Initialize accuracy / hyperparameters\\n best_accuracy = 0.0\\n best_reg = 0.0\\n\\n # Cross-validation 80-20\\n N = x.shape[0]\\n N_train = int(math.floor(0.8 * N))\\n\\n # Initialize the grid search hyperparameters\\n min_reg = 0.001\\n max_reg = 1000\\n log_min_reg = np.log(min_reg)\\n log_max_reg = np.log(max_reg)\\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\\n\\n for reg in reg_list:\\n accuracy = np.zeros((self.k_fold))\\n for i in range(self.k_fold):\\n map_index = list(zip(x, t))\\n random.shuffle(map_index)\\n random_x, random_t = zip(*map_index)\\n\\n train_x = random_x[:N_train]\\n valid_x = random_x[N_train:]\\n train_t = random_t[:N_train]\\n valid_t = random_t[N_train:]\\n\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=reg, max_iter=1000, \\n random_state=self.random_state)\\n self.train(train_x, train_t)\\n accuracy[i] = self.model.score(valid_x, valid_t)\\n\\n mean_accuracy = np.mean(accuracy)\\n # print(mean_accuracy)\\n if mean_accuracy > best_accuracy:\\n best_accuracy = mean_accuracy\\n best_reg = reg\\n print(\\\"The new best hyperparameters are : \\\", best_reg)\\n\\n print(\\\"Best hyperparameters are : \\\", best_reg)\\n print(\\\"Valid Accuracy :\\\", best_accuracy)\\n self.reg = best_reg\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=best_reg, max_iter=1000, \\n random_state=self.random_state)\\n self.train(x, t)\",\n \"def test_svm_cnn_comparison_alex(self, syn_fm, syn_labels, syn_labels_cat, rep, syn_idx):\\n\\n fm_3d = syn_fm(\\\"3d\\\")\\n fm_2d = syn_fm(\\\"2d\\\")\\n\\n def fit_cnn(x, y, idx):\\n best_params_montaez['n_snps']= x.shape[1]\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(y[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n return model.fit(x=x[idx.train], y=y[idx.train], validation_data=(x[idx.test], y[idx.test]), epochs=best_params_montaez['epochs'],class_weight=d_class_weights, callbacks=[ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min')]).history['val_weighted_categorical_accuracy'][-1]\\n\\t\\t\\t# change if you want accuracy or balanced accuracy: val_categorical_accuracy, val_weighted_categorical_accuracy, AUC(not working... would need higher keras version)\\n\\n def fit_svm(x, y, idx):\\n # if you want to optimize c:\\n #c_candidates = np.logspace(-7, -1, num=20)\\n #scores=np.zeros(len(c_candidates))\\n #for i in np.arange(len(c_candidates)):\\n # c = c_candidates[i]\\n # clf = LinearSVC(C=c, penalty='l2', loss='hinge', tol= 1e-3,dual=True, verbose=0, class_weight='balanced')\\n # scores[i] = np.mean(cross_val_score(clf, x, y, cv=StratifiedShuffleSplit(n_splits=5), scoring='accuracy'))\\n #print(c_candidates, scores)\\t\\t\\t\\n #c_max = c_candidates[np.argmax(scores)]\\n c_max = 0.0022\\n toy_classifier = LinearSVC(C=c_max, penalty='l2', loss='hinge', tol= 1e-3,dual=True, verbose=0, class_weight='balanced')\\n bla = cross_val_score(toy_classifier, x, y, cv=StratifiedShuffleSplit(n_splits=5), scoring='balanced_accuracy')\\n #change if you want accuracy or balanced accuracy: scoring = accuracy, balanced_accuracy, roc_auc, average_precision_score\\n return np.mean(bla)\\n\\n svm_val_acc = Parallel(n_jobs=1)(delayed(fit_svm)(fm_2d[str(i)][:], syn_labels[str(i)], syn_idx[str(i)]) for i in tqdm(range(1, rep)))\\n cnn_val_acc = Parallel(n_jobs=1)(delayed(fit_cnn)(fm_3d[str(i)][:], syn_labels_cat[str(i)], syn_idx[str(i)]) for i in tqdm(range(1, rep)))\\n\\n cnn_val_acc = cnn_val_acc * 100\\n svm_val_acc = svm_val_acc * 100\\n\\n # 3. Compare average val_acc on all syn datasets\\n print('SVM val_acc mean {} / std {} / max {} / min {}'.format(np.mean(svm_val_acc), np.std(svm_val_acc), np.max(svm_val_acc), np.min(svm_val_acc)))\\n print('cnn val_acc mean {} / std {} / max {} / min {}'.format(np.mean(cnn_val_acc), np.std(cnn_val_acc), np.max(cnn_val_acc), np.min(cnn_val_acc)))\",\n \"def run_cross_validation_create_models(nfolds=10):\\n print(\\\"nfold value=\\\",nfolds)\\n x_train, y_train, x_train_id = load_images_train()\\n print(len(x_train))\\n\\n # input image dimensions\\n batch_size = 16\\n nb_epoch = 32\\n random_state = 159\\n\\n seed = 7\\n np.random.seed(seed)\\n kfold = StratifiedKFold(n_splits=nfolds, shuffle=True, random_state=random_state)\\n #kfold = StratifiedShuffleSplit(n_splits=nfolds,test_size=0.1,train_size=0.7,random_state=random_state)\\n cvscores = []\\n models = []\\n\\n image_array = np.asarray(x_train, dtype=np.float32)\\n # print(image_array.shape)\\n\\n datagen_test = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True,\\n preprocessing_function=pre_processing_image\\n )\\n\\n datagen = ImageDataGenerator(\\n rotation_range=20,\\n width_shift_range=0.2,\\n height_shift_range=0.2,\\n shear_range=0.2,\\n zoom_range=0.2,\\n preprocessing_function=pre_processing_image,\\n vertical_flip=True,\\n horizontal_flip=True,\\n fill_mode='nearest'\\n )\\n\\n start_time = time.time()\\n print(\\\"Datagen.fit started\\\")\\n datagen.fit(image_array, augment=True, rounds=3)\\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\\n\\n img_label = np_utils.to_categorical(y_train, 8)\\n\\n yfull_train = dict()\\n num_fold = 0\\n sum_score = 0\\n\\n for train_index, test_index in kfold.split(x_train, y_train):\\n # create model\\n model = create_model()\\n train_x = image_array[train_index]\\n train_y = img_label[train_index]\\n validate_x = image_array[test_index]\\n validate_y = img_label[test_index]\\n\\n num_fold += 1\\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\\n print('Split train: ', len(train_x), len(train_y))\\n print('Split valid: ', len(validate_x), len(validate_y))\\n\\n callbacks = [EarlyStopping(monitor='val_loss', min_delta=0, patience=4, verbose=1, mode='auto')]\\n\\n model.fit_generator(generator=datagen.flow(train_x, train_y, batch_size=batch_size, shuffle=True),\\n steps_per_epoch=len(image_array)/32, epochs=nb_epoch, verbose=1,\\n callbacks=callbacks,validation_data=(validate_x,validate_y),\\n validation_steps=len(image_array)/32)\\n\\n predictions_valid = model.predict(validate_x.astype('float32'), batch_size=batch_size, verbose=1)\\n\\n\\n score = log_loss(validate_y, predictions_valid)\\n print('Score log_loss: ', score)\\n\\n\\n sum_score += score * len(test_index)\\n\\n # Store valid predictions\\n for i in range(len(test_index)):\\n yfull_train[test_index[i]] = predictions_valid[i]\\n\\n models.append(model)\\n\\n score = sum_score / len(x_train)\\n print(\\\"Log_loss train independent avg: \\\", score)\\n\\n info_string = 'loss_' + str(score) + '_folds_' + str(10) + '_ep_' + str(28)\\n return info_string,models\",\n \"def __cross_validation(self, classifier, X, y, k, stratify=True):\\n\\t\\tif k == X.shape[0]:\\t\\t# leave-one-out\\n\\t\\t\\tkf = model_selection.KFold(n_splits=k)\\n\\t\\telse:\\n\\t\\t\\tif stratify:\\n\\t\\t\\t\\tkf = model_selection.StratifiedKFold(n_splits=k, shuffle=True, random_state=0)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkf = model_selection.KFold(n_splits=k, shuffle=True, random_state=0)\\n\\n\\t\\t# training data and predictions for each fold\\n\\t\\ty_train_list = []\\n\\t\\ty_train_pred_list = []\\n\\t\\ty_train_prob_list = []\\n\\t\\ty_val_list = []\\n\\t\\ty_val_pred_list = []\\n\\t\\ty_val_prob_list = []\\n\\n\\t\\tfor train_idx, val_idx in kf.split(X, y):\\n\\t\\t\\tX_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\\n\\t\\t\\ty_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\\n\\t\\t\\ty_train_list.append(y_train)\\n\\t\\t\\ty_val_list.append(y_val)\\n\\n\\t\\t\\t# catch convergence warning\\n\\t\\t\\twith warnings.catch_warnings():\\n\\t\\t\\t\\twarnings.filterwarnings('error', category=exceptions.ConvergenceWarning)\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tclassifier = classifier.fit(X_train, y_train)\\n\\t\\t\\t\\texcept exceptions.ConvergenceWarning:\\n\\t\\t\\t\\t\\tModel.counter -= 1\\n\\t\\t\\t\\t\\traise\\n\\n\\t\\t\\ty_train_pred_list.append(classifier.predict(X_train))\\n\\t\\t\\ty_val_pred_list.append(classifier.predict(X_val))\\n\\t\\t\\ty_train_prob_list.append(classifier.predict_proba(X_train))\\n\\t\\t\\ty_val_prob_list.append(classifier.predict_proba(X_val))\\n\\n\\t\\tif k == X.shape[0]:\\t\\t# leave-one-out\\n\\t\\t\\ty_val = np.hstack(y_val_list)\\n\\t\\t\\ty_val_pred = np.hstack(y_val_pred_list)\\n\\t\\t\\ty_val_prob = np.vstack(y_val_prob_list)\\n\\n\\t\\t\\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\\\\n\\t\\t\\t\\tModelMetrics(classifier, y_val, y_val_pred, y_val_prob, 'loo')\\n\\t\\telse:\\n\\t\\t\\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\\\\n\\t\\t\\t\\tModelMetrics(classifier, y_val_list, y_val_pred_list, y_val_prob_list, 'cv')\",\n \"def run_cross_validation_process_test(info_string, models):\\n\\n batch_size = 64\\n num_fold = 0\\n yfull_test = []\\n x_test_id = []\\n nfolds = len(models)\\n\\n datagen_test = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True,\\n preprocessing_function=pre_processing_image\\n )\\n\\n # print(image_array.shape)\\n x_test, x_test_id = load_images_test()\\n print(len(x_test))\\n image_test_array = np.asarray(x_test, dtype=np.float32)\\n start_time = time.time()\\n print(\\\"Datagen.fit started\\\")\\n datagen_test.fit(image_test_array, augment=False)\\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\\n\\n for i in range(nfolds):\\n model = models[i]\\n num_fold += 1\\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\\n\\n #test_prediction = model.predict_generator(generator=datagen_test.fit(image_test_array, seed=79),\\n # steps=len(image_test_array)/32, max_q_size=20, workers=8, verbose=1)\\n\\n test_prediction = model.predict(image_test_array, batch_size=batch_size, verbose=1)\\n\\n yfull_test.append(test_prediction)\\n\\n test_res = merge_several_folds_mean(yfull_test, nfolds)\\n info_string = 'loss_' + info_string \\\\\\n + '_folds_' + str(nfolds)\\n create_submission(test_res, x_test_id, info_string)\\n d=pd.DataFrame(test_res,columns=FISH_CLASSES)\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\\n\\n for machine in machines:\\n machine.fit(x_train, y_train)\\n\\n trainScores = [machine.score(x_train, y_train) for machine in machines]\\n testScores = [machine.score(x_test, y_test) for machine in machines]\\n\\n plot_score_vs_gamma(trainScores, testScores, gammas)\\n\\n bestGamma = np.argmax(testScores)\\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)\",\n \"def cross_validate(self, X, y):\\n roc_ap = []\\n kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=0)\\n for train_ix, test_ix in kfold.split(X, y):\\n train_X, test_X = X.iloc[train_ix, :], X.iloc[test_ix, :]\\n train_y, test_y = y[train_ix], y[test_ix]\\n self.train(train_X, train_y)\\n roc_ap.append(self.test(test_X, test_y))\\n return roc_ap\",\n \"def run_CV(X,y,model,func, n_splits = 3, how = 'up', categorical = 'label_encoder'):\\n logloss = []\\n skf = StratifiedKFold(n_splits = n_splits, random_state = 144)\\n for i, (train_idx, val_idx) in enumerate(skf.split(X,y)):\\n X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\\n y_train, y_val = y[train_idx], y[val_idx]\\n\\n # # SMOTE\\n # X_train = X_train.drop('poor', axis = 1) # drop target\\n # cat_columns = X_train.select_dtypes(['object']).columns\\n # X_train[cat_columns] = X_train[cat_columns].apply(LabelEncoder().fit_transform)\\n # orig_cols = X_train.columns # SMOTE will return a numpy array. Store the column names here to recreate the dataframe for feature engineering/transforms below\\n # X_train, y_train = SMOTE().fit_sample(X_train,y_train)\\n # # recreate dataframe\\n # X_train = pd.DataFrame(X_train, columns = orig_cols)\\n\\n if how is not None:\\n # resample to balance data\\n X_resampled = resample_data(X_train, how = how)\\n # store the targets now that they are balanced\\n y_train = X_resampled['poor']\\n # drop target from train\\n X_train = X_resampled.drop('poor', axis = 1)\\n X_val.drop('poor', axis = 1, inplace = True)\\n # print(X_val.columns.values)\\n ####### feature engineering goes blow this comment:\\n \\n func(X_train)\\n func(X_val)\\n \\n ###### end feature eng\\n X_train = pre_process_data(X_train, normalize_num='standardize', categorical = categorical)\\n assert X_train.shape[0] == y_train.shape[0]\\n\\n model.fit(X_train, y_train)\\n # standardize X_val to predict\\n X_val = pre_process_data(X_val,normalize_num= 'standardize', enforce_cols=X_train.columns, categorical = categorical)\\n preds = model.predict_proba(X_val)\\n \\n logloss.append(log_loss(y_val, preds[:,1]))\\n \\n return logloss\",\n \"def cross_validate(features, outputs, model): \\n # do k-folds cross validation\\n scores = cross_validation.cross_val_score(model,\\n features,\\n outputs)\\n\\n # get average accuracy\\n return np.average(scores)\",\n \"def cross_validate(self, pre_train=None, **kwargs):\\n \\n inferred = np.nan * np.ones_like(self.labels_array)\\n N_training_set, N_labels = inferred.shape\\n N_stop_at = kwargs.pop(\\\"N\\\", N_training_set)\\n\\n debug = kwargs.pop(\\\"debug\\\", False)\\n \\n kwds = { \\\"threads\\\": self.threads }\\n kwds.update(kwargs)\\n\\n for i in range(N_training_set):\\n \\n training_set = np.ones(N_training_set, dtype=bool)\\n training_set[i] = False\\n\\n # Create a clean model to use so we don't overwrite self.\\n model = self.__class__(\\n self.training_labels[training_set],\\n self.training_fluxes[training_set],\\n self.training_flux_uncertainties[training_set],\\n **kwds)\\n\\n # Initialise and run any pre-training function.\\n for _attribute in self._descriptive_attributes:\\n setattr(model, _attribute[1:], getattr(self, _attribute[1:]))\\n\\n if pre_train is not None:\\n pre_train(self, model)\\n\\n # Train and solve.\\n model.train()\\n\\n try:\\n inferred[i, :] = model.fit(self.training_fluxes[i],\\n self.training_flux_uncertainties[i], full_output=False)\\n\\n except:\\n logger.exception(\\\"Exception during cross-validation on object \\\"\\n \\\"with index {0}:\\\".format(i))\\n if debug: raise\\n\\n if i == N_stop_at + 1:\\n break\\n\\n return inferred[:N_stop_at, :]\",\n \"def algo_CVmetrics(classifier_object, X_train, Y_train):\\r\\n \\r\\n cv = RepeatedStratifiedKFold(n_splits = 5, n_repeats = 3, random_state = seed_custom)\\r\\n \\r\\n metricslist = {'f2': make_scorer(metrics.fbeta_score, beta = 2), \\r\\n 'balacc': make_scorer(metrics.balanced_accuracy_score),\\r\\n 'precision': make_scorer(metrics.precision_score),\\r\\n 'recall': make_scorer(metrics.recall_score)}\\r\\n \\r\\n cv_results = cross_validate(classifier_object, X_train, Y_train, cv = cv, scoring = metricslist, return_estimator = True)\\r\\n \\r\\n f2_mean = np.mean(cv_results['test_f2'])\\r\\n f2_std = np.std(cv_results['test_f2'])\\r\\n \\r\\n balacc_mean = np.mean(cv_results['test_balacc'])\\r\\n balacc_std = np.std(cv_results['test_balacc'])\\r\\n\\r\\n precision_mean = np.mean(cv_results['test_precision'])\\r\\n precision_std = np.std(cv_results['test_precision'])\\r\\n \\r\\n recall_mean = np.mean(cv_results['test_recall'])\\r\\n recall_std = np.std(cv_results['test_recall'])\\r\\n \\r\\n scorebox = pd.DataFrame(np.zeros((1,8)), columns = list(['F2-Score Mean', 'F2-Score STD', 'Balanced Accuracy Mean', 'Balanced Accuracy STD',\\r\\n 'Precision Mean', 'Precision STD', 'Recall Mean', 'Recall STD']))\\r\\n \\r\\n scorebox.iloc[0,0] = f2_mean\\r\\n scorebox.iloc[0,1] = f2_std\\r\\n scorebox.iloc[0,2] = balacc_mean\\r\\n scorebox.iloc[0,3] = balacc_std\\r\\n scorebox.iloc[0,4] = precision_mean\\r\\n scorebox.iloc[0,5] = precision_std\\r\\n scorebox.iloc[0,6] = recall_mean\\r\\n scorebox.iloc[0,7] = recall_std \\r\\n \\r\\n scorebox = np.round(scorebox, 3)\\r\\n \\r\\n print(\\\"Model has a mean CV balanced accuracy of {0}, (Std: {1})\\\".format(round(balacc_mean,3), round(balacc_std,3)))\\r\\n print(\\\"Model has a mean CV F2_Score of {0}, (Std: {1})\\\".format(round(f2_mean,3), round(f2_std,3)))\\r\\n print(\\\"Model has a mean CV Precision of {0}, (Std: {1})\\\".format(round(precision_mean,3), round(precision_std,3)))\\r\\n print(\\\"Model has a mean CV Recall of {0}, (Std: {1})\\\".format(round(recall_mean,3), round(recall_std,3)))\\r\\n \\r\\n return scorebox\",\n \"def _cross_valid_feature(max_fold, num_movies, num_users, lamda, subplt):\\n loss_train_vector = [.0]*31\\n loss_cross_vector = [.0]*31\\n cost_train_per_fold = [.0]*max_fold\\n cost_cross_per_fold = [.0]*max_fold\\n for i in range(1, 31, 1):\\n for k in range(1, max_fold + 1, 1):\\n cost_train_per_fold[k-1], cost_cross_per_fold[k-1] = (\\n _cross_valid_fold(k, num_movies, num_users,\\n i, lamda))\\n loss_train_vector[i] = np.mean(cost_train_per_fold)\\n loss_cross_vector[i] = np.mean(cost_cross_per_fold)\\n\\n # draw the Loss v.s num_feature graph\\n subplt.plot(loss_train_vector, \\\"r\\\")\\n subplt.plot(loss_cross_vector, \\\"b\\\")\\n v1 = np.array(loss_cross_vector)\\n v2 = np.array(loss_train_vector)\\n v3 = v1 + v2\\n sel_feature = np.argmin(v3[1:]) + 1\\n subplt.plot(v3, \\\"g\\\", label=\\\"lambda=\\\"+str(lamda))\\n plt.axis([1, 30, 0, 1.2*max(v3)])\\n return sel_feature\",\n \"def validate_model(classifier, data_path=\\\"data/data.csv\\\", folds=10, n_jobs=2):\\n from sklearn.model_selection import cross_validate\\n\\n folds = 10\\n\\n X, y = convert_data(data_path=data_path)\\n\\n scoring = {'accuracy': 'accuracy',\\n 'recall': 'recall',\\n 'precision': 'precision',\\n 'roc_auc': 'roc_auc'}\\n\\n cv_results = cross_validate(classifier, X, y, cv=folds,\\n return_train_score=False,\\n scoring=scoring, n_jobs=n_jobs)\\n\\n average_recall = sum(cv_results[\\\"test_recall\\\"])/folds\\n average_precision = sum(cv_results[\\\"test_precision\\\"])/folds\\n average_accuracy = sum(cv_results[\\\"test_accuracy\\\"])/folds\\n\\n print(\\\"Precision = {}, Recall = {}, Accuracy = {}\\\".format(\\n average_precision,\\n average_recall,\\n average_accuracy))\",\n \"def _cross_val(self, X, y, classifier, nfolds=10):\\n\\n # Make sure dimensions agree\\n assert X.shape[0] == y.shape[0], \\\"Number of observations should equal\\\" \\\\\\n \\\"number of labels.\\\"\\n\\n # Concatenate data in order to shuffle without changing X-y correspondence\\n data = np.c_[X, y]\\n\\n # Shuffle data (swaps rows when 2D - works OK for us)\\n np.random.seed(42)\\n np.random.shuffle(data)\\n\\n # Split data into (almost) equal folds (returns a list of arrays)\\n # and we cast the list into a numpy array in order to do list indexing\\n data = np.array(np.array_split(data, nfolds))\\n\\n # Do the k-fold cross-validation\\n accs = []\\n for k in range(nfolds):\\n # Get current test set\\n X_k_test = data[k][:, :-1]\\n y_k_test = data[k][:, -1]\\n\\n # Get remaining indices and current training set\\n remaining_idx = [i for i, v in enumerate(data) if i != k]\\n X_k_train = np.vstack(data[remaining_idx])[:, :-1]\\n y_k_train = np.vstack(data[remaining_idx])[:, -1]\\n\\n # Fit and predict with classifier\\n classifier.fit(X_k_train, y_k_train)\\n yhat = classifier.predict(X_k_test)\\n\\n # Store error rate\\n accs.append(self._accuracy(y_k_test, yhat))\\n\\n return np.array(accs)\",\n \"def cross_validation_score(X_data, y_data, model, folds=5):\\n\\n # Shuffle index\\n index = np.random.permutation(len(X_data))\\n\\n fold_size = int(len(X_data) / folds)\\n scores = []\\n for i in range(folds):\\n \\n # Partition Data\\n X_train, X_val = partition_data(X_data[index], folds, i + 1, fold_size)\\n y_train, y_val = partition_data(y_data[index], folds, i + 1, fold_size)\\n\\n # Train Model\\n print(f\\\"Training on Fold: {i + 1}\\\")\\n model.fit(X_train, y_train)\\n\\n # Predict Values on Validation Set\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy\\n score = accuracy_score(y_val, val_pred)\\n scores.append(score)\\n \\n return sum(scores) / len(scores)\",\n \"def stratifier(self, data, labels, classifiers, cv, output_dir):\\n\\t\\tresults_proba = collections.defaultdict(dict)\\n\\t\\tdict_y_test = collections.defaultdict()\\n\\t\\tsss = StratifiedShuffleSplit(n_splits=cv, test_size=0.2, random_state=3)\\n\\t\\tsss.get_n_splits(data, labels)\\n\\t\\ti = 1\\n\\t\\tself.logger.info('Training processing ...')\\n\\t\\tloop = sss.split(data, labels)\\n\\t\\tt = tqdm(loop)\\n\\t\\tl = collections.defaultdict(dict)\\n\\t\\tfor train_index, test_index in t:\\n\\t\\t\\tt.set_description('Cross-validation n°')\\n\\t\\t\\tx_train, x_test = data.values[train_index], data.values[test_index]\\n\\t\\t\\ty_train, y_test = labels[train_index], labels[test_index]\\n\\t\\t\\tdict_y_test[i] = y_test\\n\\t\\t\\tresults_proba, tmp_l = \\\\\\n\\t\\t\\t\\tself.classification(\\n\\t\\t\\t\\t\\ti, classifiers, results_proba, x_train, x_test, y_train, y_test)\\n\\t\\t\\t[l[d].update(tmp_l[d]) for d in tmp_l]\\n\\t\\t\\ti += 1\\n\\t\\t[l[clf].update({'Mean': np.mean(np.asarray(list(l[clf].values())))})\\n\\t\\t for clf in l]\\n\\t\\tlog_cv = pd.DataFrame(l)\\n\\t\\tlog_cv.index.names = ['Cross-validation']\\n\\t\\tlog_cv.to_csv(output_dir + '/Cross-validation_accuracy.csv',\\n\\t\\t index=True, sep='\\\\t')\\n\\t\\tprint('Cross-validation results : \\\\n')\\n\\t\\tprint(log_cv)\\n\\n\\t\\treturn results_proba, dict_y_test, classifiers\",\n \"def cross_validation(self, stock_data):\\n\\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)\",\n \"def crossValidation(training, k, performance):\\n\\n predictions = []\\n accuracy = []\\n\\n for index in range(1, 6):\\n # print index\\n temp = list(range(1, 6))\\n temp.remove(index)\\n # print 'index: ' + str(index) + ', temp: ' + str(temp)\\n\\n for x in range(len(training.get_group(index))):\\n if x % 100 != 0:\\n continue\\n target = training.get_group(index).values.tolist()[x][-1]\\n # if x % 500 == 0:\\n # print 'index: ' + str(index) + ', x: ' + str(x)\\n neighbors = []\\n distances = []\\n for validationSet in temp:\\n getDistances(training.get_group(validationSet).values.tolist(), training.get_group(index).values.tolist()[x], distances)\\n # Sort the distances list by the distance\\n distances.sort(key = lambda item: item[1])\\n # print distances\\n # Select first k closest elements to return as the neighbors\\n for x in range(k):\\n neighbors.append(distances[x][0])\\n\\n result=getResponse(neighbors)\\n\\n # print distances\\n # print neighbors\\n # print result\\n predictions.append(result)\\n # print 'result: ' + str(result)\\n # print 'target: ' + str(target)\\n # print 'result == target: ' + str(result == target)\\n if result == target:\\n accuracy.append((True, target))\\n else:\\n accuracy.append((False, target))\\n\\n count = 0\\n for item in accuracy:\\n if item[0] == True:\\n count += 1\\n\\n # print 'number of instances: ' + str(len(accuracy)) + ' number correct: ' + str(count)\\n\\n count = 0\\n for item in accuracy:\\n if item[0] == True:\\n count += 1\\n\\n # Add the current k-value and its accuracy for this run to dictionary\\n performance[k] = count / len(accuracy)\\n\\n print performance\\n return performance\",\n \"def predict_and_cv_score_regression(self, x_data, y_data, custom_kfold=None):\\n r2_scores = []\\n mse_scores = []\\n for model in self.list_of_models:\\n r2_scores.append(cross_val_score(model, x_data, y_data, cv=custom_kfold, scoring='r2').mean())\\n mse_scores.append(cross_val_score(model, x_data, y_data, cv=custom_kfold, scoring='neg_mean_squared_error').mean())\\n return r2_scores, mse_scores\",\n \"def test_svm(x, y, tune):\\n if tune:\\n params = {'clf__C': stats.uniform(0, 100),\\n 'clf__gamma': stats.uniform(0, 1)}\\n\\n # Perform hyperparameter tuning on C and gamma using randomized searching\\n rand_search = RandomizedSearchCV(create_pipeline(SVC()),\\n n_iter=20,\\n param_distributions=params,\\n n_jobs=-1,\\n cv=5,\\n random_state=2017)\\n rand_search.fit(x, y)\\n print(\\\"best_params: {0}\\\".format(rand_search.best_params_))\\n return rand_search.best_score_ * 100\\n else:\\n # Perform classification without tuning\\n svc = SVC(\\n gamma=0.93121875826256051,\\n C=70.331975797816796\\n )\\n pipeline = create_pipeline(svc)\\n return accuracy(pipeline, x, y)\",\n \"def cross_val_pred_both(model, X_train, y_train, X_test, cv=5, n_class=2, problem_type='infer'):\\n if problem_type == 'infer':\\n problem_type = get_problem_type(y_train)\\n if problem_type == 'classification':\\n pred_train = np.zeros((len(y_train), n_class))\\n pred_test = np.zeros((len(X_test), n_class))\\n else:\\n pred_train = np.zeros(len(y_train))\\n pred_test = np.zeros(len(X_test))\\n \\n if cv > 1:\\n kfold=KFold(len(X_train), n_folds=cv)\\n\\n if problem_type == 'classification':\\n for train_index, test_index in kfold:\\n model.fit(X_train.iloc[train_index], y_train.iloc[train_index])\\n pred_train[test_index] = model.predict_proba(X_train.iloc[test_index])\\n pred_test = pred_test + model.predict_proba(X_test)\\n else:\\n for train_index, test_index in kfold:\\n model.fit(X_train.iloc[train_index], y_train.iloc[train_index])\\n pred_train[test_index] = model.predict(X_train.iloc[test_index])\\n pred_test = pred_test + model.predict(X_test) \\n\\n pred_test = pred_test/float(cv)\\n elif cv == 1:\\n if problem_type == 'classification':\\n model.fit(X_train, y_train)\\n pred_train = model.predict_proba(X_train)\\n pred_test = model.predict_proba(X_test)\\n else:\\n model.fit(X_train, y_train)\\n pred_train = model.predict(X_train)\\n pred_test = model.predict(X_test) \\n return pred_train, pred_test\",\n \"def train(x_train, y_train, x_test, y_test):\\n\\n print(\\\" Nearest centroid : \\\", end='')\\n run(x_train, y_train, x_test, y_test, NearestCentroid())\\n print(\\\" k-NN classifier (k=3) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\\n print(\\\" k-NN classifier (k=7) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\\n print(\\\" Naive Bayes (Gaussian) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, GaussianNB())\\n print(\\\" Random Forest (trees= 5) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\\n print(\\\" Random Forest (trees= 50) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\\n print(\\\" Random Forest (trees=500) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\\n print(\\\" Random Forest (trees=1000): \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\\n print(\\\" LinearSVM (C=0.01) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\\n print(\\\" LinearSVM (C=0.1) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\\n print(\\\" LinearSVM (C=1.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\\n print(\\\" LinearSVM (C=10.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))\",\n \"def svc(n_components=10):\\n\\n train = pandas.read_csv('train.csv')\\n y = train['target'].values\\n X = raw_scaled_features(train)\\n\\n folds = StratifiedKFold(train['target'], 10)\\n \\n for train_indices, test_indices in folds:\\n #print train_indices, test_indices\\n X_train = X[train_indices]\\n y_train = y[train_indices]\\n X_test = X[test_indices]\\n y_test = y[test_indices]\\n\\n pca = PCA(n_components=n_components)\\n X_train = pca.fit_transform(X_train)\\n X_test = pca.transform(X_test)\\n #print X_train.shape\\n\\n svc = SVC(probability=True, verbose=False)\\n svc.fit(X_train, y_train)\\n y_prob = svc.predict_proba(X_test)\\n\\n print log_loss(y_test, y_prob, svc.classes_)\",\n \"def train_and_score_pipeline(pipeline, automl, full_X_train, full_y_train):\\n start = time.time()\\n cv_data = []\\n logger.info(\\\"\\\\tStarting cross validation\\\")\\n X_pd = _convert_woodwork_types_wrapper(full_X_train.to_dataframe())\\n y_pd = _convert_woodwork_types_wrapper(full_y_train.to_series())\\n y_pd_encoded = y_pd\\n # Encode target for classification problems so that we can support float targets. This is okay because we only use split to get the indices to split on\\n if is_classification(automl.problem_type):\\n y_mapping = {original_target: encoded_target for (encoded_target, original_target) in enumerate(y_pd.value_counts().index)}\\n y_pd_encoded = y_pd.map(y_mapping)\\n for i, (train, valid) in enumerate(automl.data_splitter.split(X_pd, y_pd_encoded)):\\n if pipeline.model_family == ModelFamily.ENSEMBLE and i > 0:\\n # Stacked ensembles do CV internally, so we do not run CV here for performance reasons.\\n logger.debug(f\\\"Skipping fold {i} because CV for stacked ensembles is not supported.\\\")\\n break\\n logger.debug(f\\\"\\\\t\\\\tTraining and scoring on fold {i}\\\")\\n X_train, X_valid = full_X_train.iloc[train], full_X_train.iloc[valid]\\n y_train, y_valid = full_y_train.iloc[train], full_y_train.iloc[valid]\\n if is_binary(automl.problem_type) or is_multiclass(automl.problem_type):\\n diff_train = set(np.setdiff1d(full_y_train.to_series(), y_train.to_series()))\\n diff_valid = set(np.setdiff1d(full_y_train.to_series(), y_valid.to_series()))\\n diff_string = f\\\"Missing target values in the training set after data split: {diff_train}. \\\" if diff_train else \\\"\\\"\\n diff_string += f\\\"Missing target values in the validation set after data split: {diff_valid}.\\\" if diff_valid else \\\"\\\"\\n if diff_string:\\n raise Exception(diff_string)\\n objectives_to_score = [automl.objective] + automl.additional_objectives\\n cv_pipeline = None\\n try:\\n logger.debug(f\\\"\\\\t\\\\t\\\\tFold {i}: starting training\\\")\\n cv_pipeline = EngineBase.train_pipeline(pipeline, X_train, y_train, automl.optimize_thresholds, automl.objective)\\n logger.debug(f\\\"\\\\t\\\\t\\\\tFold {i}: finished training\\\")\\n if automl.optimize_thresholds and pipeline.can_tune_threshold_with_objective(automl.objective) and automl.objective.can_optimize_threshold:\\n logger.debug(f\\\"\\\\t\\\\t\\\\tFold {i}: Optimal threshold found ({cv_pipeline.threshold:.3f})\\\")\\n logger.debug(f\\\"\\\\t\\\\t\\\\tFold {i}: Scoring trained pipeline\\\")\\n scores = cv_pipeline.score(X_valid, y_valid, objectives=objectives_to_score)\\n logger.debug(f\\\"\\\\t\\\\t\\\\tFold {i}: {automl.objective.name} score: {scores[automl.objective.name]:.3f}\\\")\\n score = scores[automl.objective.name]\\n except Exception as e:\\n if automl.error_callback is not None:\\n automl.error_callback(exception=e, traceback=traceback.format_tb(sys.exc_info()[2]), automl=automl,\\n fold_num=i, pipeline=pipeline)\\n if isinstance(e, PipelineScoreError):\\n nan_scores = {objective: np.nan for objective in e.exceptions}\\n scores = {**nan_scores, **e.scored_successfully}\\n scores = OrderedDict({o.name: scores[o.name] for o in [automl.objective] + automl.additional_objectives})\\n score = scores[automl.objective.name]\\n else:\\n score = np.nan\\n scores = OrderedDict(zip([n.name for n in automl.additional_objectives], [np.nan] * len(automl.additional_objectives)))\\n\\n ordered_scores = OrderedDict()\\n ordered_scores.update({automl.objective.name: score})\\n ordered_scores.update(scores)\\n ordered_scores.update({\\\"# Training\\\": y_train.shape[0]})\\n ordered_scores.update({\\\"# Validation\\\": y_valid.shape[0]})\\n\\n evaluation_entry = {\\\"all_objective_scores\\\": ordered_scores, \\\"score\\\": score, 'binary_classification_threshold': None}\\n if is_binary(automl.problem_type) and cv_pipeline is not None and cv_pipeline.threshold is not None:\\n evaluation_entry['binary_classification_threshold'] = cv_pipeline.threshold\\n cv_data.append(evaluation_entry)\\n training_time = time.time() - start\\n cv_scores = pd.Series([fold['score'] for fold in cv_data])\\n cv_score_mean = cv_scores.mean()\\n logger.info(f\\\"\\\\tFinished cross validation - mean {automl.objective.name}: {cv_score_mean:.3f}\\\")\\n return {'cv_data': cv_data, 'training_time': training_time, 'cv_scores': cv_scores, 'cv_score_mean': cv_score_mean}\",\n \"def SVM_train(X, y, cv):\\r\\n rev = 10000\\r\\n start_time = time.time()\\r\\n print('\\\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\\r\\n parameters = {\\r\\n 'kernel':('linear', 'poly', 'rbf'),\\r\\n 'C':(1, 5, 10),\\r\\n 'gamma':('scale', 'auto')\\r\\n }\\r\\n print('-'*2+'Grid Search Parameters:')\\r\\n print(parameters)\\r\\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\\r\\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\\r\\n clf.fit(X, y)\\r\\n print('-'*2+'GridSearch Results:')\\r\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\r\\n print(pd.DataFrame(clf.cv_results_))\\r\\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\\r\\n return clf\",\n \"def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \\r\\n\\r\\n score=[]\\r\\n \\r\\n keys = x[key].unique().tolist()\\r\\n \\r\\n\\r\\n\\r\\n for idx, item in enumerate([1,2,3,4,5]):\\r\\n\\r\\n xtrain,xtest = split_camp(x,keys,0.2)\\r\\n \\r\\n model.fit(xtrain[feat],xtrain[target])\\r\\n\\r\\n ypred = model.predict(xtest[feat])\\r\\n \\r\\n ytrue= xtest[target].values \\r\\n \\r\\n if metric == 'mae':\\r\\n score.append(mae(ytrue,ypred))\\r\\n elif metric == 'mse':\\r\\n score.append(mse(ytrue,ypred))\\r\\n elif metric == 'rrmse':\\r\\n score.append(rrmse(ytrue,ypred))\\r\\n\\r\\n else:\\r\\n score.append(rmse(xtest[target].tolist(),ypred))\\r\\n\\r\\n if verbose:\\r\\n print('-'*30)\\r\\n print(f'\\\\nFold {idx} out of 5')\\r\\n print(f'Key {item}')\\r\\n print(f'{metric}: {score[idx]}')\\r\\n\\r\\n \\r\\n\\r\\n if verbose:\\r\\n print(f'\\\\n Overall Score:')\\r\\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\\r\\n\\r\\n\\r\\n return score\",\n \"def kFoldCrossValidation(self, n_splits ):\\n X = self.X\\n y = self.y\\n\\n k_fold = KFold(n_splits)\\n model = self.model\\n\\n for train, test in k_fold.split(X):\\n model.fit(X[train], y[train])\\n p = model.predict( X[test] )\\n # Add line for scores\\n\\n return model #return scores here?\",\n \"def generate_cross_val_score(clf, data, target, cv):\\n return cross_val_score(clf, data, target, cv=cv)\",\n \"def ex_3_b(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train multi-class SVMs with a LINEAR kernel\\n ## Use the sklearn.metrics.confusion_matrix to plot the confusion matrix.\\n ## Find the index for which you get the highest error rate.\\n ## Plot the confusion matrix with plot_confusion_matrix.\\n ## Plot the first 10 occurrences of the most misclassified digit using plot_mnist.\\n ###########\\n\\n labels = range(1, 6)\\n linear = svm.SVC(kernel='linear', C=10, decision_function_shape='ovr')\\n linear.fit(x_train, y_train)\\n y_pred = linear.predict(x_test)\\n cm = confusion_matrix(y_test, y_pred)\\n plot_confusion_matrix(cm, labels)\\n\\n errors = np.zeros(5)\\n for i in range(5):\\n for j in range(5):\\n if i != j:\\n errors[j] += cm[i][j]\\n max_err_label = np.argmax(errors) + 1 # should be the label number corresponding the largest classification error\\n\\n indices = np.nonzero(y_pred == max_err_label)[0].astype(int)\\n sel_err = np.array([], dtype=int) # Numpy indices to select images that are misclassified.\\n for i in indices:\\n if y_test[i] != y_pred[i]:\\n sel_err = np.insert(sel_err, sel_err.size, i)\\n\\n # Plot with mnist plot\\n plot_mnist(x_test[sel_err], y_pred[sel_err], labels=max_err_label, k_plots=10, prefix='Predicted class')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7582216","0.73700595","0.72442365","0.71962374","0.71674687","0.7151614","0.7067812","0.7040971","0.69988185","0.69910026","0.69847065","0.6981253","0.6946461","0.69450456","0.6925203","0.6850364","0.6849873","0.67713803","0.6751911","0.67439026","0.67351866","0.67231154","0.6673554","0.6665873","0.6658403","0.6644636","0.6638484","0.6622259","0.6615798","0.66137666","0.65995675","0.6586183","0.6554893","0.65446526","0.65293336","0.649961","0.64939326","0.6490202","0.6489068","0.6464876","0.64570296","0.6416338","0.6398097","0.6395974","0.6382786","0.6368244","0.6363261","0.6362369","0.6352765","0.6351553","0.63498944","0.6348317","0.63352346","0.6334253","0.6325406","0.6321952","0.631959","0.63172203","0.63157517","0.63120025","0.63001895","0.629911","0.6290287","0.6281068","0.62741387","0.6248211","0.6229202","0.62138575","0.62131035","0.6212083","0.6205722","0.62041515","0.62033844","0.61853653","0.61833185","0.61816","0.6177363","0.6175791","0.61601704","0.6157068","0.6155816","0.61534107","0.61495227","0.6149032","0.614708","0.613881","0.6125785","0.61226994","0.6117591","0.6108215","0.6103038","0.6100842","0.6100011","0.60996085","0.6095943","0.60932416","0.60906684","0.6086734","0.60851276","0.6071295"],"string":"[\n \"0.7582216\",\n \"0.73700595\",\n \"0.72442365\",\n \"0.71962374\",\n \"0.71674687\",\n \"0.7151614\",\n \"0.7067812\",\n \"0.7040971\",\n \"0.69988185\",\n \"0.69910026\",\n \"0.69847065\",\n \"0.6981253\",\n \"0.6946461\",\n \"0.69450456\",\n \"0.6925203\",\n \"0.6850364\",\n \"0.6849873\",\n \"0.67713803\",\n \"0.6751911\",\n \"0.67439026\",\n \"0.67351866\",\n \"0.67231154\",\n \"0.6673554\",\n \"0.6665873\",\n \"0.6658403\",\n \"0.6644636\",\n \"0.6638484\",\n \"0.6622259\",\n \"0.6615798\",\n \"0.66137666\",\n \"0.65995675\",\n \"0.6586183\",\n \"0.6554893\",\n \"0.65446526\",\n \"0.65293336\",\n \"0.649961\",\n \"0.64939326\",\n \"0.6490202\",\n \"0.6489068\",\n \"0.6464876\",\n \"0.64570296\",\n \"0.6416338\",\n \"0.6398097\",\n \"0.6395974\",\n \"0.6382786\",\n \"0.6368244\",\n \"0.6363261\",\n \"0.6362369\",\n \"0.6352765\",\n \"0.6351553\",\n \"0.63498944\",\n \"0.6348317\",\n \"0.63352346\",\n \"0.6334253\",\n \"0.6325406\",\n \"0.6321952\",\n \"0.631959\",\n \"0.63172203\",\n \"0.63157517\",\n \"0.63120025\",\n \"0.63001895\",\n \"0.629911\",\n \"0.6290287\",\n \"0.6281068\",\n \"0.62741387\",\n \"0.6248211\",\n \"0.6229202\",\n \"0.62138575\",\n \"0.62131035\",\n \"0.6212083\",\n \"0.6205722\",\n \"0.62041515\",\n \"0.62033844\",\n \"0.61853653\",\n \"0.61833185\",\n \"0.61816\",\n \"0.6177363\",\n \"0.6175791\",\n \"0.61601704\",\n \"0.6157068\",\n \"0.6155816\",\n \"0.61534107\",\n \"0.61495227\",\n \"0.6149032\",\n \"0.614708\",\n \"0.613881\",\n \"0.6125785\",\n \"0.61226994\",\n \"0.6117591\",\n \"0.6108215\",\n \"0.6103038\",\n \"0.6100842\",\n \"0.6100011\",\n \"0.60996085\",\n \"0.6095943\",\n \"0.60932416\",\n \"0.60906684\",\n \"0.6086734\",\n \"0.60851276\",\n \"0.6071295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61284596"},"document_rank":{"kind":"string","value":"86"}}},{"rowIdx":20274,"cells":{"query":{"kind":"string","value":"Try connecting to the server"},"document":{"kind":"string","value":"def test_connect():\n\n\tprint(\"Testing connecting to the server\")\n\ttry:\n\t\twith socket.socket() as s:\n\t\t\ts.connect((\"localhost\", 8000))\n\t\tprint(\"Connection attempt succeeded.\")\n\t\treturn None\n\texcept socket.error:\n\t\treturn \"Server didn't answer on localhost port 8000. Is it running?\""},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _check_connection(self):\n for _ in range(3):\n try:\n r = get(f\"http://{self.ip}/student/{self.user}\")\n if r.ok:\n break \n except OSError as e:\n print(f\"Connection error:\\n{e}\")\n sleep(2)\n else:\n raise ConnectionError(f\"Can not connect to server with params ip: {self.ip}, user: {self.user}\")","def connect(self, host):\n return False","def connect(self):\n \n try:\n self.__sock.connect((self.__host, self.__port))\n\n except socket.error,e:\n print 'Oops, unable to connect. Try again!',e\n sys.exit(1)","def _check_connect(self) -> bool:\n\n if (self._conn is None):\n if (self._exception):\n raise base_connection.ConnectException(\n \"No connection established\")\n\n else:\n return False\n\n return True","def attempt_to_connect(self):\n if self.server_handler.attempt_connection:\n self.server_handler.attempt_connection = False\n else:\n self.server_handler.attempt_connection = True","def _try_connect(self, wait):\n t = Thread(target=self._establish_connection)\n counter = 0\n t.start()\n while not self._stop_signal and counter < wait:\n time.sleep(1)\n counter += 1\n if self.conn: # connected successfully\n return True\n # if connection failed\n self._dummy_client()\n if self.conn:\n self.conn.close()\n self.conn = None\n return False","def connect(self) -> None:\n print(\"Trying to connect server...\")\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n self.sock.connect((self.SERVER_HOST, self.SERVER_PORT))\n print(\"Connected to server.\")\n self.authenticate()\n encrypted = self.validate_encryption()\n if encrypted is False:\n self.sock.close()\n return None\n\n self.register_username()\n # Create thread for connection\n server_connection = ClientConnection(self)\n server_connection.start()\n # Start conversation\n self.converse()","def connect(self):\n try:\n self.sock.connect((self.hostname, self.port))\n print 'connected to ' + self.hostname\n except socket.gaierror as e:\n print(\"Recieved error when connecting to \" + str((self.hostname, self.port)))\n raise e","def check_server_up(self):\n print \"Connecting to Mongo at %s:%s\" % (self.hostname, self.port)\n try:\n # TODO: update this to use new pymongo Client\n self.api = pymongo.Connection(self.hostname, self.port)\n return True\n except (AutoReconnect, ConnectionFailure), e:\n print e\n return False","def can_connect(test_url):\n try:\n requests.get(test_url)\n except (OSError):#connection error\n logger.warning('couldn\\'t reach server on: {test_url}')\n return False\n return True","def connect(self):\n try:\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.socket.connect(self.address)\n self.socket.setblocking(False)\n return True\n except:\n return False","def status_check(self):\n try:\n client = self.connect()\n client.sys.is_initialized() # make an actual network connection\n return True\n except:\n return False","def connect(self):\n\t\tself._entity_server_connection.attempt_connection()","def _try_connect(self):\n tuya = TuyaApi()\n try:\n tuya.init(\n self._username,\n self._password,\n self._country_code,\n self._platform,\n self._region,\n )\n except (TuyaAPIRateLimitException, TuyaNetException, TuyaServerException):\n return RESULT_CONN_ERROR\n except TuyaAPIException:\n return RESULT_AUTH_FAILED\n\n return RESULT_SUCCESS","def connect_to_server(self):\n\n try:\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n client.connect((self.hostname, self.port))\n return client\n except Exception as e:\n print(\"Can't connect to server: \", e)\n sys.exit()","def _server_started(self):\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n try:\n s.connect((self.host, self.port))\n s.shutdown(2)\n return True\n except:\n return False","def check_connection(self):\n pass","def check_server():\n\n url='{url}/auth'.format(url=config.SERVER_URL)\n while True:\n\n try:\n res=request.urlopen(url,timeout=5).read()\n res=str(res,encoding='utf8')\n if 'connection valid' in res:\n break\n else:\n error_str='error: client-> check_server :' \\\n 'no auth to connect to server,exit process'\n info_manager(error_str,type='KEY')\n os._exit(0)\n except Exception as e:\n err_str='error:client->check_server:cannot ' \\\n 'connect to server; process sleeping'\n info_manager(err_str,type='NORMAL')\n time.sleep(5) # sleep for 1 seconds","def connect(self) -> bool:\n if self._connected:\n self.log.info(\"Already connected\")\n return True\n\n self.mutex.acquire()\n\n self.client.connect(self.host, self.port)\n self.client.loop_start()\n\n self.log.info(f\"Connecting to {self.host}:{self.port} ...\")\n\n timeout = round(time()) + 5\n\n while True:\n\n if round(time()) > timeout:\n self.log.warning(\"Connection timed out!\")\n self.mutex.release()\n return False\n\n if self._connected is not True:\n sleep(0.1)\n continue\n\n if self.connected_rc == 0:\n break\n\n elif self.connected_rc == 1:\n self.log.error(\n \"Connection refused - incorrect protocol version\"\n )\n self.mutex.release()\n return False\n\n elif self.connected_rc == 2:\n self.log.error(\n \"Connection refused - invalid client identifier\"\n )\n self.mutex.release()\n return False\n\n elif self.connected_rc == 3:\n self.log.error(\"Connection refused - server unavailable\")\n self.mutex.release()\n return False\n\n elif self.connected_rc == 4:\n self.log.error(\"Connection refused - bad username or password\")\n self.mutex.release()\n return False\n\n elif self.connected_rc == 5:\n self.log.error(\"Connection refused - not authorized\")\n self.mutex.release()\n return False\n\n self.log.debug(f\"Subscribing to topics: {self.topics}\")\n for topic in self.topics:\n self.client.subscribe(topic, 2)\n\n self.mutex.release()\n self._connected = True\n\n return True","def is_connected():\n \n try:\n socket.create_connection((\"www.google.com\", 80))\n return True\n except OSError:\n pass\n return False","def connect(self) -> bool:\n if self.socket is None:\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.socket.bind((self.host, self.port))\n self.socket.setblocking(False)\n self.socket.listen(1)\n if self.endpoint is None:\n if self.socket is not None:\n try:\n self.endpoint, _ = self.socket.accept()\n self.connected = True\n return True\n except (BlockingIOError, OSError):\n pass\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.socket.bind((self.host, self.port))\n self.socket.setblocking(False)\n self.socket.listen(1)\n return self.connected","def test_connection():\n result = run(\"uname -a\")\n if result.failed:\n _pretty_output(\"Could not connect to remote server. Please check your configuration\")\n abort(\"Cannot continue. Aborting...\")","def _try_connect(_host, _port, _client_id):\n try:\n conn = OpenRGBClient(_host, _port, name=_client_id)\n conn.comms.stop_connection()\n except OSError as exc:\n raise CannotConnect from exc\n\n return True","def _connect(self):\n\n if self.connecting:\n rlog(10, self.name, 'already connecting')\n raise AlreadyConnecting()\n\n if self.connected:\n rlog(10, self.name, 'already connected')\n raise AlreadyConnected()\n\n self.stopped = 0\n self.connecting = True\n self.connectok.clear()\n self.connectlock.acquire()\n\n # create socket\n if self.ipv6:\n rlog(10, self.name, 'creating ipv6 socket')\n self.oldsock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)\n self.ipv6 = 1\n else:\n rlog(10, self.name, 'creating ipv4 socket')\n self.oldsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n assert(self.oldsock)\n\n # optional bind\n server = self.server\n elite = self.cfg['bindhost'] or config['bindhost']\n if elite:\n try:\n self.oldsock.bind((elite, 0))\n except socket.gaierror:\n rlog(10, self.name, \"can't bind to %s\" % elite)\n # resolve the IRC server and pick a random server\n if not server:\n # valid IPv6 ip?\n try: socket.inet_pton(socket.AF_INET6, self.server)\n except socket.error: pass\n else: server = self.server\n if not server: \n # valid IPv4 ip?\n try: socket.inet_pton(socket.AF_INET, self.server)\n except socket.error: pass\n else: server = self.server\n if not server:\n # valid hostname?\n ips = []\n try:\n for item in socket.getaddrinfo(self.server, None):\n if item[0] in [socket.AF_INET, socket.AF_INET6] and item[1] == socket.SOCK_STREAM:\n ip = item[4][0]\n if ip not in ips: ips.append(ip)\n except socket.error: pass\n else: server = random.choice(ips)\n\n # do the connect .. set timeout to 30 sec upon connecting\n rlog(10, self.name, 'connecting to %s (%s)' % (server, self.server))\n self.oldsock.settimeout(5)\n self.oldsock.connect((server, int(self.port)))\n\n # we are connected\n rlog(10, self.name, 'connection ok')\n time.sleep(1)\n self.connected = True\n\n # make file socket\n self.fsock = self.oldsock.makefile(\"r\")\n\n # set blocking\n self.oldsock.setblocking(self.blocking)\n self.fsock._sock.setblocking(self.blocking)\n\n # set socket time out\n if self.blocking:\n socktimeout = self.cfg['socktimeout']\n if not socktimeout:\n socktimeout = 301.0\n else:\n socktimeout = float(socktimeout)\n self.oldsock.settimeout(socktimeout)\n self.fsock._sock.settimeout(socktimeout)\n # enable ssl if set\n if self.ssl:\n rlog(10, self.name, 'ssl enabled')\n self.sock = socket.ssl(self.oldsock) \n else:\n self.sock = self.oldsock\n\n # try to release the outputlock\n try:\n self.outputlock.release()\n except thread.error:\n pass\n\n # start input and output loops\n start_new_thread(self._readloop, ())\n start_new_thread(self._outloop, ())\n\n # logon and start monitor\n self._logon()\n self.nickchanged = 0\n self.reconnectcount = 0\n saymonitor.start()\n return 1","def checkServerThread(self):\r\n\r\n # check if the server is alive\r\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n\r\n result = 1\r\n try:\r\n result = sock.connect_ex((\"dealookup.com\", 80))\r\n except:\r\n result = 1 \r\n\r\n # server is not live \r\n if result != 0:\r\n result = 1\r\n\r\n self.checkResultSignal.emit(result)","def connect(self, addr):\n result = False\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n try:\n self.sock.connect(addr)\n result = True\n except socket.error, msg:\n self.sock = None\n print 'Connect failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]\n\n return result","def _connect(self):\n\n # Get the timeout\n m_timeout = OMPv4.TIMEOUT\n if self.__timeout:\n m_timeout = self.__timeout\n\n # Connect to the server\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.settimeout(m_timeout)\n try:\n sock.connect((self.__host, int(self.__port)))\n except socket.error, e:\n raise ServerError(str(e))\n self.socket = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_TLSv1)\n\n # Authenticate to the server\n self._authenticate(self.__username, self.__password)","def _try_connect(self):\n try:\n return mysql.connect(\n host=self.host,\n database=self.database,\n user=self.user,\n passwd=self.password\n )\n except Error as e:\n raise ConnectionError(f\"Could not connect to {self.connection_string}\") from e","def connecting(self):\r\n \r\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) \r\n try:\r\n ssh.connect(self.hostname,self.port,self.identifier,self.password)\r\n feedback = '***Connection Established***'\r\n return feedback\r\n \r\n except Exception as e:\r\n feedback= '***Connection failed : '+str(e)+'***'\r\n return feedback\r\n sys.exit(1)","def check_connection(self):\n return False","def mpdConnect(client, con_id):\n try:\n client.connect(**con_id)\n except SocketError:\n return False\n return True","def connect(self):\r\n try:\r\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(self.ip))\r\n print (\"connected!\")\r\n except Exception as error:\r\n print (\"connect() - error - {}\".format(error))","def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False","def __CheckConnectStatus(self):\r\n if not self.tn:\r\n print \"Connection is down!\"\r\n return False\r\n else:\r\n print \"Connection is alive!\"\r\n return True","def init_conn(self):\n \n SERVER_ADDRESS = '192.168.0.21'\n PORT = 8018\n SERVER_PASSWORD = \"biratkingofcomedy\" \n connected = False\n \n # check if test module is being run\n if self.testing == 'n': \n while not connected:\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n \n try:\n self.socket.connect((SERVER_ADDRESS, PORT))\n \n # server verification\n self.socket.sendall(self.make_packet(\"DATA\", SERVER_PASSWORD))\n \n response = self.socket.recv(4096)\n \n if response:\n response_hdr, response_msg, response_sdr = self.parse_packet(response)\n \n if response_hdr == \"ERROR\" and response_msg == \"IDENTIFY FAILED\":\n raise Exception(\"PASSWORD FAIL\")\n \n elif response_hdr == \"DATA\" and response_msg == \"CONNECTED\":\n connected = True\n \n else:\n raise Exception(\"CONNECTION FAIL\") \n \n except Exception as e:\n if e == \"PASSWORD FAIL\":\n print(\"DEBUG: server connection failed (invalid credentials)\")\n print(\"DEBUG: quitting\")\n break\n \n else:\n print(e)\n print(\"DEBUG: server connection failed (could not connect), trying again in 10s\")\n time.sleep(10)\n \n else:\n print(\"DEBUG: socket setup skipped\")","async def connect(self):\n\n # Display info message\n log.info(\"connect\")\n\n try:\n\n # SSH?\n if self._protocol == \"ssh\":\n\n # Yes\n\n # Then Connect using SSH\n await self.connectSSH()\n\n # Telnet?\n elif self._protocol == \"telnet\":\n\n # Yes\n\n # Then Connect using Telnet\n await self.connectTelnet()\n\n else:\n\n # Unsupported protocol\n\n # Raise an exception\n raise Exception(f\"connect: unsupported protocol: {self._protocol}\")\n\n except Exception:\n\n # There was a problem with a connection method\n\n # Display info message\n log.info(\"connect: connection error\")\n\n raise","def connect(self):\r\n if self.__socket:\r\n return\r\n try:\r\n # This is the server communicator, try and accept connections.\r\n if self.__server_socket is not None:\r\n self.__socket, _ = self.__server_socket.accept()\r\n self.__socket.setblocking(0)\r\n self.__server_socket.close()\r\n # This is the client communicator, try and connect (quickly).\r\n else:\r\n self.__socket = socket.socket()\r\n self.__socket.settimeout(self.CONNECT_TIMEOUT)\r\n self.__socket.connect((self.__ip, self.__port))\r\n self.__socket.setblocking(0)\r\n self.__get_message()\r\n except socket.error:\r\n # Always close the socket if created, then make it none (this\r\n # way it is evident that a connection was not yet established).\r\n if self.__socket:\r\n self.__socket.close()\r\n self.__socket = None\r\n # Try again in a given interval.\r\n self.__root.after(self.WAIT_PERIOD, self.connect)","def connect(self):\n\n print(\"Connecting to server at {}:{}\".format(self.hostname, self.port))\n\n self._sock = socket.socket()\n self._sock.setblocking(True)\n self._sock.connect((self.hostname, self.port))\n self._sockfile = self._sock.makefile(encoding=\"utf-8\")\n self._connected = True\n\n if self.password:\n self._sendmsg(\"PASS :{}\".format(self.password))\n self._sendmsg(\"NICK {}\".format(self.nickname))\n self._sendmsg(\"USER {} 0 * :ORE Utility Bot\".format(getpass.getuser()))\n if self.ident_password:\n self._sendmsg(\"PRIVMSG NickServ :identify {}\".format(\n self.ident_password))\n self._sendmsg(\"JOIN {}\".format(\",\".join(self.channels)))","def connect(self):\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n try:\n if self.print_send:\n print(' - connecting...')\n self.socket.settimeout(1)\n self.socket.connect(self.host_port)\n if self.print_send:\n print(' - connected')\n except socket.timeout:\n raise Timeout('Timeout connecting to projector')\n except Exception as err:\n raise Error('Connection failed', err)\n self.expect(b'PJ_OK')\n self.send(b'PJREQ')\n self.expect(b'PJACK')","def connect(self):\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.socket.connect((self.host, PORT)) # probably throws errors\n self.connected = True","def test_connection():\r\n try:\r\n connect()\r\n except:\r\n pass\r\n print ('Unable to connect.')\r\n else:\r\n main()","def test_connection(self):\n r = main.List.connection()\n self.assertTrue(r.ping(), \"Connection failed.\")","async def connect(self) -> bool:\n\n if not await self._connection.connect():\n return False\n\n await self._connected.wait()\n if not self._connected_successfully:\n return False\n\n self._events.fire(\"connected\")\n return True","def connectToServer(self):\n self.client = Client(base_url = self.server)\n self.ping()","def _connect(self, client):\n if client.transport.isOpen():\n return True\n\n try:\n client.transport.open()\n return True\n except Thrift.ErrorT, tx:\n if tx.message:\n message = tx.message\n else:\n message = \"Transport error, reconnect\"\n client.transport.close()\n raise ErrorThriftMessage(message)\n except Exception, e:\n client.transport.close()\n\n return False","def connect():\n logging.info('Client connected')","def is_connected():\n import socket\n try:\n host = socket.gethostbyname(\"www.gov.uk\")\n socket.create_connection((host, 80), 2)\n return True\n except:\n pass\n return False","def connect(self):\n try:\n self.ssh = paramiko.SSHClient()\n self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n credentials = self.auth.to_dict()\n credentials.update({'hostname': self.host})\n self.ssh.connect(**credentials)\n self.conn_status = self.CONN_OPEN\n except paramiko.AuthenticationException:\n self.conn_status = self.CONN_FAILED\n except paramiko.ssh_exception.SSHException:\n if self.loop_counter < 3:\n time.sleep(2)\n self.loop_counter += 1\n self.connect()","def check_connection(self):\n try:\n self.mfp.add(2,2)\n logger.info(\"Connection to user API established\")\n except xmlrpclib.ProtocolError:\n logger.error(\"Not possible to connect to MOF+. Check your credentials\")\n exit()\n return","def check_conn():\n try:\n urllib2.urlopen(\"http://www.google.com\", timeout=5)\n return True\n except urllib2.URLError:\n pass\n return False","def __init__(self):\n self.try_to_connect()","def test_connection(self):\n req = requests.get(\"http://{}:{}\".format(self.config.options.get(\"Server\", \"ListenAddress\"),\n self.config.options.get(\"Server\", \"Port\")))\n\n self.assertEqual(req.status_code, 200)","def connect(self):\n if not self.is_connected():\n try:\n self._socket = socket.create_connection(self.address)\n self._socket.setblocking(0) # Set to non-blocking.\n self._reader = process_manager.LineReader(self._socket)\n print \"Connecting successfully\", self.address\n return True\n except socket.error as e:\n print e\n self._socket = None\n return False\n else:\n print \"Already connecting to\", self.address","def CheckIfConnecting(self):\n if self.CheckIfWiredConnecting() or self.CheckIfWirelessConnecting():\n return True\n else:\n return False","def connect(self) -> bool:\n self._last_error = None\n try:\n self._imap = IMAP4_SSL(self._hostname, self._port)\n except IMAP4_SSL.error as e:\n self._imap = None\n self._last_error = e\n return False\n return True","def connect(self):\n sock_version = socket.AF_INET if self.ip_version == 4 else socket.AF_INET6\n with socket.socket(sock_version, socket.SOCK_STREAM) as sock:\n sock.connect((self.server_ip, self.port))\n print(\"Client connected\")\n self.__send_request(\"01\", sock)\n\n while True:\n response = self.__receive_response(sock)\n if len(response) >= 2:\n msg_id_code = int(response[:2])\n if msg_id_code == 2:\n udp_port = self.__request_info_file(response, sock)\n if msg_id_code == 4:\n self.__handle_udp_transfer(self.server_ip, udp_port, sock)\n if msg_id_code == 5:\n print(\"Closing connection\")\n sock.close()\n return 0\n if msg_id_code == 8:\n print(\"Invalid file name. Max size: 15bytes\")\n sock.close()\n return -1","def _connect(self):\n try:\n #print(\"try to connect _connect\")\n sock = gevent.socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.connect(self.remote_address)\n except socket.error as error:\n logger.warning(\"Couldn't connect to %s: %s.\",\n self._repr_remote(), error)\n else:\n self.initialize(sock, self.remote_service_coord)","def test_connection(server_address, server_username=None, server_password=None, verbose=True):\n\n try:\n if server_username is None and server_password is None:\n r = requests.get(url=server_address)\n else:\n r = requests.get(url=server_address, auth=(server_username, server_password))\n if r.ok:\n if verbose:\n print(\"Network connectivity: VERIFIED. Server \" + server_address + \" is reachable!\")\n return True\n else:\n print(\"Something wrong during connection!\")\n return False\n\n except Exception as e:\n print(e)\n return False","def _connect(self):\n try:\n self._si = SmartConnectNoSSL(host=self._host, user=self._username, pwd=self._password)\n except Exception as e:\n self._logger.error(\"Unable to connect to host {0} : {1}\".format(self._host, e))\n self._si = None","def connectToServer(self):\r\n\t\tself.rtspSocket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n\t\ttry:\r\n\t\t\tself.rtspSocket_client.connect((self.serverAddr, self.serverPort))\r\n\t\texcept:\r\n\t\t\tprint(\"Fail to connect to server\")","def connect_to_server(self):\n\n server=os.popen('hostname').read()\n if 'epfl.ch' not in server:\n conn = mds.Connection('tcvdata.epfl.ch')\n conn.openTree('tcv_shot', self.shot)\n self.tree = conn\n print(\"You are in server \"+server+\", so I'll open a connection\")\n else:\n self.tree = mds.Tree('tcv_shot', self.shot)","def connect(self):\n self.conn.connect()","def connect():\n try:\n conn = mysql.connect(host='localhost',\n database='python_mysql',\n user='root',\n password='SQLPASSWORD')\n if conn.server_status is 0:\n print('Connected to MySQL database')\n\n except Error as e:\n print(e)\n\n finally:\n conn.close()","def connect(self, timeout: float = 5) -> bool:\n if not self.connected:\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.socket.settimeout(timeout)\n try:\n self.socket.connect((self.host, self.port))\n self.connected = True\n self.socket.setblocking(False)\n self.endpoint = self.socket\n except ConnectionRefusedError:\n pass\n return self.connected","def connect(self):\n try:\n self._send = 0\n self.socket = socket.socket(socket.AF_INET,\n socket.SOCK_STREAM,\n socket.getprotobyname('tcp'))\n self.socket.connect((self.host, self.port))\n self.socket.recv(self.packet_size)\n except socket.error:\n raise ConnectionError(\n 'Cannot connect to server at %s' % self.name)","async def connect(self, retry=2):\n # pylint: disable=too-many-return-statements\n url = self._endpoint + PLUGWISE_PING_ENDPOINT\n try:\n with async_timeout.timeout(self._timeout):\n resp = await self.websession.get(url,auth=self._auth)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n if retry < 1:\n _LOGGER.error(\"Error connecting to Plugwise\", exc_info=True)\n return False\n return await self.connect(retry - 1)\n\n result = await resp.text()\n if not 'error' in result:\n _LOGGER.error('Connected but expected text not returned, we got %s',result)\n return False\n\n return True","def test_check_connection(self):\n self.assertIsNotNone(app.check_connection())","def isConnected():","def validate_server(self):\n for i in range(60):\n # wait 60s for connecting to ftp server\n plat_comb = get_element('PLATFORM_COMB')\n plat_comb.Expand()\n plat_comb.Click(0, 0)\n if len(plat_comb.GetChildren()):\n log.info('[dl_img] Successfully connect to ftp server')\n return True\n else:\n log.info('checking ftp server connected...{}'.format(i))\n if get_element('ERROR_DIALOG').Exists():\n log.error('There is Error when connecting to ftp server')\n for _ in range(3):\n # if connect to server fail, there will be some error dialogs\n if get_element('ERROR_DIALOG').Exists():\n get_element('ERROR_DIALOG').Close()\n time.sleep(1)\n else:\n self.close_panel()\n return False\n else:\n time.sleep(1)\n continue\n self.close_panel()\n return False","def _check_connection(self):\n if \"_connection\" not in self.__dict__:\n message = \"use connect method before doing operation on this database\"\n raise Exception(message)","def connect():","def connect(self):\n self.client.connect(self.host, self.port)\n self.client.loop_forever()","def connection_init(self, port, ip):\n\t\t# Инициализация сокета и сообщение серверу о нашем появлении\n\t\tself.transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\t\t\n\t\t# Таймаут необходим для освобождения сокета.\n\t\tself.transport.settimeout(5)\n\t\t\n\t\t# Соединяемся, 5 попыток соединения, флаг успеха ставим в True если\n\t\t# удалось\n\t\tconnected = False\n\t\tfor i in range(5):\n\t\t\tclient_log.info(f'Попытка подключения №{i + 1}')\n\t\t\ttry:\n\t\t\t\tself.transport.connect((ip, port))\n\t\t\texcept (OSError, ConnectionRefusedError):\n\t\t\t\tpass\n\t\t\telse:\n\t\t\t\tconnected = True\n\t\t\t\tclient_log.debug(\"Connection established.\")\n\t\t\t\tbreak\n\t\t\ttime.sleep(1)\n\t\t\n\t\t# Если соединится не удалось - исключение\n\t\tif not connected:\n\t\t\tclient_log.critical('Не удалось установить соединение с сервером')\n\t\t\traise ServerError('Не удалось установить соединение с сервером')\n\t\t\n\t\tclient_log.debug('Starting auth dialog.')\n\t\t\n\t\t# Запускаем процедуру авторизации\n\t\t# Получаем хэш пароля\n\t\tpasswd_bytes = self.password.encode('utf-8')\n\t\tsalt = self.username.lower().encode('utf-8')\n\t\tpasswd_hash = hashlib.pbkdf2_hmac('sha512', passwd_bytes, salt, 10000)\n\t\tpasswd_hash_string = binascii.hexlify(passwd_hash)\n\t\t\n\t\tclient_log.debug(f'Passwd hash ready: {passwd_hash_string}')\n\t\t\n\t\t# Получаем публичный ключ и декодируем его из байтов\n\t\tpubkey = self.keys.publickey().export_key().decode('ascii')\n\t\t\n\t\t# Авторизируемся на сервере\n\t\twith socket_lock:\n\t\t\tpresense = {\n\t\t\t\tACTION: PRESENCE,\n\t\t\t\tTIME: time.time(),\n\t\t\t\tUSER: {\n\t\t\t\t\tACCOUNT_NAME: self.username,\n\t\t\t\t\tPUBLIC_KEY: pubkey\n\t\t\t\t}\n\t\t\t}\n\t\t\tclient_log.debug(f\"Presense message = {presense}\")\n\t\t\t# Отправляем серверу приветственное сообщение.\n\t\t\ttry:\n\t\t\t\tsend_message(self.transport, presense)\n\t\t\t\tans = get_message(self.transport)\n\t\t\t\tclient_log.debug(f'Server response = {ans}.')\n\t\t\t\t# Если сервер вернул ошибку, бросаем исключение.\n\t\t\t\tif RESPONSE in ans:\n\t\t\t\t\tif ans[RESPONSE] == 400:\n\t\t\t\t\t\traise ServerError(ans[ERROR])\n\t\t\t\t\telif ans[RESPONSE] == 511:\n\t\t\t\t\t\t# Если всё нормально, то продолжаем процедуру\n\t\t\t\t\t\t# авторизации.\n\t\t\t\t\t\tans_data = ans[DATA]\n\t\t\t\t\t\thash = hmac.new(passwd_hash_string, ans_data.encode('utf-8'), 'MD5')\n\t\t\t\t\t\tdigest = hash.digest()\n\t\t\t\t\t\tmy_ans = RESPONSE_511\n\t\t\t\t\t\tmy_ans[DATA] = binascii.b2a_base64(\n\t\t\t\t\t\t\tdigest).decode('ascii')\n\t\t\t\t\t\tsend_message(self.transport, my_ans)\n\t\t\t\t\t\tself.process_server_ans(get_message(self.transport))\n\t\t\texcept (OSError, json.JSONDecodeError) as err:\n\t\t\t\tclient_log.debug(f'Connection error.', exc_info=err)\n\t\t\t\traise ServerError('Сбой соединения в процессе авторизации.')","async def connect(self):\n try:\n self.reader, self.writer = await asyncio.open_connection(self.host,\n self.port)\n except (asyncio.TimeoutError, ConnectionRefusedError):\n self.log.error(\"Cannot connect to spa at {0}:{1}\".format(self.host,\n self.port))\n return False\n self.connected = True\n return True","def _CheckConnect(self):\n try:\n resp = requests.get(self._target_url, timeout=2)\n if resp.headers['Maximum-Bytes']:\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\n return resp.status_code == 200\n except requests.exceptions.ConnectionError:\n return False\n except Exception as e:\n self.exception('Unexpected test connect failure: %s', str(e))\n return False","def connect_socket(self):\n try:\n self.socket.connect((self.request.host, int(self.request.port)))\n except socket.gaierror:\n raise socket.gaierror(\"Socket connection could not be established\")\n except socket.timeout:\n raise socket.timeout(\"Socket connection timed out\")\n except InterruptedError:\n raise InterruptedError(\"Socket connection has been interrupted by a signal\")","def check_up(addr, p):\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n result = sock.connect_ex((addr, p))\n sock.close()\n if result == 0:\n ans = True\n else:\n ans = False\n return ans","def reconnecting(self) -> bool:","def connect():\n\n\tprint \"In connection state\"\n\n\tglobal cs\n\tglobal state\n\n\tcs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\tcs.connect(('localhost', PORT))\n\tcs.send('Connected')\n\tstate += 1","def connect(self):\n if not self._socket:\n self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self._socket.connect((self.host, self.port))\n self._socket.settimeout(0.0)","def connect(self):\r\n\r\n\t\tprint('Connecting to server')\r\n\r\n\t\tself.t = threading.Thread(target=self.daemon.requestLoop)\r\n\t\tself.t.daemon = True\r\n\t\tself.t.start()\r\n\t\tprint('daemon thread started')\r\n\t\tmessages = self.chat.connect(self.my_uri)\r\n\r\n\t\t#in case the connection is refused:\r\n\t\tif isinstance(messages, bool) and not messages:\r\n\t\t\traise ValueError(f\"Username {self.username} already taken\")\r\n\r\n\t\tprint('Connected')\r\n\r\n\t\t#if the connection is accepted, the last 20 messages are sent\r\n\t\t#those messages will now be printed.\r\n\t\tfor message in messages:\r\n\t\t\tself.incoming_message(message)","def _check_connection() -> bool:\n return bool(subprocess.check_output([\"hostname\", \"-I\"]))","def is_connected():\r\n global connection\r\n if connection is None:\r\n return False\r\n else:\r\n return True","def check_connection():\n r = requests.get('https://www.google.com')\n if r.status_code == 200:\n print (colored(\"Connected.\", 'green'))\n else:\n print (colored(\"Not Connected.\", 'red'))","def connect(self):\n auth = self.botconfig.find('auth')\n logging.info(\"Connecting ...\" )\n if not auth.get('server', None):\n # we don't know the server, but the lib can probably figure it out\n super(SleekBot, self).connect()\n else:\n super(SleekBot, self).connect((auth.attrib['server'], auth.get('port', 5222)))","def _on_connection_error(self, exception):\n print(\"connection failed: {}\".format(exception))\n time.sleep(1)\n self.connect()","def is_connected(self):\n if self.server: return True\n return False","def connect(self) -> None:\n self.terminate()\n self._new_client().connect(\n hostname=self.ip,\n port=self.port,\n username=self.username,\n password=self.password,\n look_for_keys=False,\n allow_agent=False)","def connect_to_server(self):\n\n\t\tself.__logs.append('-- connecting to server ...')\n\t\tself.connect_to_ssh_server.emit(self.__ip.text(), int(self.__port.text()),\\\n\t\t\tself.__username.text(), self.__pwd.text())","def connect(\n self, login, password, authz_id=b\"\", starttls=False,\n authmech=None):\n try:\n self.sock = socket.create_connection((self.srvaddr, self.srvport))\n self.sock.settimeout(Client.read_timeout)\n except socket.error as msg:\n raise Error(\"Connection to server failed: %s\" % str(msg))\n\n if not self.__get_capabilities():\n raise Error(\"Failed to read capabilities from server\")\n if starttls and not self.__starttls():\n return False\n if self.__authenticate(login, password, authz_id, authmech):\n return True\n return False","def check_smtp_server_connection(self):\n try:\n connected = True\n\n while not self.config:\n time.sleep(1)\n\n # Create SMTP server and handshake\n server = smtplib.SMTP(self.config.smtp_host + ':' + self.config.smtp_port)\n server.connect(self.config.smtp_host + ':' + self.config.smtp_port)\n\n self.logger.info(MODULE_NAME + '::check_smtp_server_connection::Successfully '\n 'connected to the configured SMTP server and port at: ' + self.config.smtp_host + ':' + self.config.smtp_port)\n\n server.quit()\n\n return connected\n\n except Exception as e:\n self.logger.error(MODULE_NAME + '::check_smtp_server_connection()::The following '\n 'unhandled exception occurred: ' + e.message)\n connected = False\n return connected","async def async_connect(self):\n # Test the router is accessible.\n try:\n data = await self.connection.async_get_connected_devices()\n self.success_init = data is not None\n except OSError as ex:\n _LOGGER.warning(\n \"Error [%s] connecting %s to %s.\",\n str(ex),\n DOMAIN,\n self.host,\n )\n raise ConnectionError(\"Cannot connect to D-Link router\")\n\n if not self.connection.is_connected:\n _LOGGER.error(\"Error connecting %s to %s\", DOMAIN, self.host)\n raise ConnectionError(\"Cannot connect to D-Link router\")","def open(self):\n try:\n if self.verbose:\n print \"Trying to open connection to Leica at \",self.IP_address,\":\",str(self.port)\n self.leicasocket = socket.socket()\n self.leicasocket.connect((self.IP_address,self.port))\n if self.verbose:\n print(\"Connected.\")\n self.connected=True\n return True\n except:\n if self.verbose:\n print \"Error opening connection to \", self.IP_address\n self.connected=False\n return False","async def connect(self):\n try:\n self._cmd_stream = await self._connect()\n self.inc_counter(\"%s.connected\" % self.objname)\n self.logger.info(\"Connected: %s\", self._extra_info)\n except Exception as e:\n self.logger.error(\"Connect Failed %r\", e)\n self.inc_counter(\"%s.failed\" % self.objname)\n raise e","def _connect(self, conn):\n conn_options = {\n 'quiet': self.quiet,\n 'src_name': \"master\",\n 'dest_name': None,\n 'version': \"5.0.0\",\n 'unique': True,\n 'verbose': self.verbose,\n }\n\n certs_paths = {}\n if 'ssl_ca' in dir(conn) and conn.ssl_ca is not None:\n certs_paths['ssl_ca'] = conn.ssl_ca\n if 'ssl_cert' in dir(conn) and conn.ssl_cert is not None:\n certs_paths['ssl_cert'] = conn.ssl_cert\n if 'ssl_key' in dir(conn) and conn.ssl_key is not None:\n certs_paths['ssl_key'] = conn.ssl_key\n\n conn_options.update(certs_paths)\n\n master_info = \"%s:%s\" % (conn['host'],\n conn['port'])\n master = None\n\n # Clear socket if used with a local server\n if (conn['host'] == 'localhost' or conn['host'] == \"127.0.0.1\" or\n conn['host'] == \"::1\" or conn['host'] == \"[::1]\"):\n conn['unix_socket'] = None\n\n # Increment num_retries if not set when --prompt is used\n if self.prompt_user and self.num_retries == 0:\n self.num_retries += 1\n\n # Attempt to connect to the server given the retry limit\n for i in range(0, self.num_retries + 1):\n try:\n servers = connect_servers(conn, None, conn_options)\n master = servers[0]\n break\n except UtilError, e:\n print \"FAILED.\\n\"\n if i < self.num_retries and self.prompt_user:\n print \"Connection to %s has failed.\\n\" % master_info + \\\n \"Please enter the following information \" + \\\n \"to connect to this server.\"\n conn['user'] = raw_input(\"User name: \")\n conn['passwd'] = getpass.getpass(\"Password: \")\n else:\n # retries expired - re-raise error if still failing\n raise UtilError(e.errmsg)\n\n return (master, master_info)","async def check_connection_status(self):\n while True:\n if not self.connected:\n self.log.error(\"Lost connection to spa, attempting reconnect.\")\n await self.connect()\n await asyncio.sleep(10)\n continue\n if (self.lastupd + 5 * self.sleep_time) < time.time():\n self.log.error(\"Spa stopped responding, requesting panel config.\")\n await self.send_panel_req(0, 1)\n await asyncio.sleep(self.sleep_time)","def Connection(self):\n try:\n system(\n f'netsh advfirewall firewall add rule name=\"Open Port {self.PORT}\" dir=in action=allow protocol=TCP localport={self.PORT} remoteip={self.HOST}')\n with socket() as s: # Create a socket object\n print('Server started!')\n print('Waiting for clients...')\n s.bind((self.HOST, self.PORT)) # Bind to the port\n s.listen(5) # Now wait for client connection.\n self.c, addr = s.accept() # Establish connection with client.\n # Remote client machine connection\n print('Got connection from', addr)\n except error as strerror:\n print(\"Network problems:\", strerror)\n return 0\n return 1","def has_server_connection(driver, server_url):\r\n\r\n OK = True\r\n try:\r\n driver.get(server_url)\r\n # we aim at this element on the chrome default page on 'No internet connection' error\r\n ele = driver.find_element_by_xpath('//*[@id=\"main-message\"]/h1/span')\r\n if ele is not None and ele.text == 'No internet':\r\n printR(' No internet connection')\r\n return not OK\r\n \r\n if requests.get(server_url).status_code != 200:\r\n printR(f' Error connecting to {server_url}')\r\n return not OK\r\n except: \r\n return OK","def _connect_socket(self):\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.sock.connect((self.ip, self.port))\n print(\"Connected to %s at port %d\" % (self.ip, self.port))","def connect(self):\n sock = socket.create_connection((self.host, self.port))\n try:\n self.sock = ssl.wrap_socket(sock, keyfile=self.key_file,\n certfile=self.cert_file,\n cert_reqs=self.cert_reqs,\n ca_certs=self.ca_certs)\n except ssl.SSLError, e:\n raise Error('Error validating SSL certificate for \"' + self.host +\n '\": ' + str(e))\n\n if self.cert_reqs == ssl.CERT_REQUIRED:\n self._VerifyHostName(self.host, self.sock.getpeercert())"],"string":"[\n \"def _check_connection(self):\\n for _ in range(3):\\n try:\\n r = get(f\\\"http://{self.ip}/student/{self.user}\\\")\\n if r.ok:\\n break \\n except OSError as e:\\n print(f\\\"Connection error:\\\\n{e}\\\")\\n sleep(2)\\n else:\\n raise ConnectionError(f\\\"Can not connect to server with params ip: {self.ip}, user: {self.user}\\\")\",\n \"def connect(self, host):\\n return False\",\n \"def connect(self):\\n \\n try:\\n self.__sock.connect((self.__host, self.__port))\\n\\n except socket.error,e:\\n print 'Oops, unable to connect. Try again!',e\\n sys.exit(1)\",\n \"def _check_connect(self) -> bool:\\n\\n if (self._conn is None):\\n if (self._exception):\\n raise base_connection.ConnectException(\\n \\\"No connection established\\\")\\n\\n else:\\n return False\\n\\n return True\",\n \"def attempt_to_connect(self):\\n if self.server_handler.attempt_connection:\\n self.server_handler.attempt_connection = False\\n else:\\n self.server_handler.attempt_connection = True\",\n \"def _try_connect(self, wait):\\n t = Thread(target=self._establish_connection)\\n counter = 0\\n t.start()\\n while not self._stop_signal and counter < wait:\\n time.sleep(1)\\n counter += 1\\n if self.conn: # connected successfully\\n return True\\n # if connection failed\\n self._dummy_client()\\n if self.conn:\\n self.conn.close()\\n self.conn = None\\n return False\",\n \"def connect(self) -> None:\\n print(\\\"Trying to connect server...\\\")\\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n self.sock.connect((self.SERVER_HOST, self.SERVER_PORT))\\n print(\\\"Connected to server.\\\")\\n self.authenticate()\\n encrypted = self.validate_encryption()\\n if encrypted is False:\\n self.sock.close()\\n return None\\n\\n self.register_username()\\n # Create thread for connection\\n server_connection = ClientConnection(self)\\n server_connection.start()\\n # Start conversation\\n self.converse()\",\n \"def connect(self):\\n try:\\n self.sock.connect((self.hostname, self.port))\\n print 'connected to ' + self.hostname\\n except socket.gaierror as e:\\n print(\\\"Recieved error when connecting to \\\" + str((self.hostname, self.port)))\\n raise e\",\n \"def check_server_up(self):\\n print \\\"Connecting to Mongo at %s:%s\\\" % (self.hostname, self.port)\\n try:\\n # TODO: update this to use new pymongo Client\\n self.api = pymongo.Connection(self.hostname, self.port)\\n return True\\n except (AutoReconnect, ConnectionFailure), e:\\n print e\\n return False\",\n \"def can_connect(test_url):\\n try:\\n requests.get(test_url)\\n except (OSError):#connection error\\n logger.warning('couldn\\\\'t reach server on: {test_url}')\\n return False\\n return True\",\n \"def connect(self):\\n try:\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.socket.connect(self.address)\\n self.socket.setblocking(False)\\n return True\\n except:\\n return False\",\n \"def status_check(self):\\n try:\\n client = self.connect()\\n client.sys.is_initialized() # make an actual network connection\\n return True\\n except:\\n return False\",\n \"def connect(self):\\n\\t\\tself._entity_server_connection.attempt_connection()\",\n \"def _try_connect(self):\\n tuya = TuyaApi()\\n try:\\n tuya.init(\\n self._username,\\n self._password,\\n self._country_code,\\n self._platform,\\n self._region,\\n )\\n except (TuyaAPIRateLimitException, TuyaNetException, TuyaServerException):\\n return RESULT_CONN_ERROR\\n except TuyaAPIException:\\n return RESULT_AUTH_FAILED\\n\\n return RESULT_SUCCESS\",\n \"def connect_to_server(self):\\n\\n try:\\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n client.connect((self.hostname, self.port))\\n return client\\n except Exception as e:\\n print(\\\"Can't connect to server: \\\", e)\\n sys.exit()\",\n \"def _server_started(self):\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n try:\\n s.connect((self.host, self.port))\\n s.shutdown(2)\\n return True\\n except:\\n return False\",\n \"def check_connection(self):\\n pass\",\n \"def check_server():\\n\\n url='{url}/auth'.format(url=config.SERVER_URL)\\n while True:\\n\\n try:\\n res=request.urlopen(url,timeout=5).read()\\n res=str(res,encoding='utf8')\\n if 'connection valid' in res:\\n break\\n else:\\n error_str='error: client-> check_server :' \\\\\\n 'no auth to connect to server,exit process'\\n info_manager(error_str,type='KEY')\\n os._exit(0)\\n except Exception as e:\\n err_str='error:client->check_server:cannot ' \\\\\\n 'connect to server; process sleeping'\\n info_manager(err_str,type='NORMAL')\\n time.sleep(5) # sleep for 1 seconds\",\n \"def connect(self) -> bool:\\n if self._connected:\\n self.log.info(\\\"Already connected\\\")\\n return True\\n\\n self.mutex.acquire()\\n\\n self.client.connect(self.host, self.port)\\n self.client.loop_start()\\n\\n self.log.info(f\\\"Connecting to {self.host}:{self.port} ...\\\")\\n\\n timeout = round(time()) + 5\\n\\n while True:\\n\\n if round(time()) > timeout:\\n self.log.warning(\\\"Connection timed out!\\\")\\n self.mutex.release()\\n return False\\n\\n if self._connected is not True:\\n sleep(0.1)\\n continue\\n\\n if self.connected_rc == 0:\\n break\\n\\n elif self.connected_rc == 1:\\n self.log.error(\\n \\\"Connection refused - incorrect protocol version\\\"\\n )\\n self.mutex.release()\\n return False\\n\\n elif self.connected_rc == 2:\\n self.log.error(\\n \\\"Connection refused - invalid client identifier\\\"\\n )\\n self.mutex.release()\\n return False\\n\\n elif self.connected_rc == 3:\\n self.log.error(\\\"Connection refused - server unavailable\\\")\\n self.mutex.release()\\n return False\\n\\n elif self.connected_rc == 4:\\n self.log.error(\\\"Connection refused - bad username or password\\\")\\n self.mutex.release()\\n return False\\n\\n elif self.connected_rc == 5:\\n self.log.error(\\\"Connection refused - not authorized\\\")\\n self.mutex.release()\\n return False\\n\\n self.log.debug(f\\\"Subscribing to topics: {self.topics}\\\")\\n for topic in self.topics:\\n self.client.subscribe(topic, 2)\\n\\n self.mutex.release()\\n self._connected = True\\n\\n return True\",\n \"def is_connected():\\n \\n try:\\n socket.create_connection((\\\"www.google.com\\\", 80))\\n return True\\n except OSError:\\n pass\\n return False\",\n \"def connect(self) -> bool:\\n if self.socket is None:\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.socket.bind((self.host, self.port))\\n self.socket.setblocking(False)\\n self.socket.listen(1)\\n if self.endpoint is None:\\n if self.socket is not None:\\n try:\\n self.endpoint, _ = self.socket.accept()\\n self.connected = True\\n return True\\n except (BlockingIOError, OSError):\\n pass\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.socket.bind((self.host, self.port))\\n self.socket.setblocking(False)\\n self.socket.listen(1)\\n return self.connected\",\n \"def test_connection():\\n result = run(\\\"uname -a\\\")\\n if result.failed:\\n _pretty_output(\\\"Could not connect to remote server. Please check your configuration\\\")\\n abort(\\\"Cannot continue. Aborting...\\\")\",\n \"def _try_connect(_host, _port, _client_id):\\n try:\\n conn = OpenRGBClient(_host, _port, name=_client_id)\\n conn.comms.stop_connection()\\n except OSError as exc:\\n raise CannotConnect from exc\\n\\n return True\",\n \"def _connect(self):\\n\\n if self.connecting:\\n rlog(10, self.name, 'already connecting')\\n raise AlreadyConnecting()\\n\\n if self.connected:\\n rlog(10, self.name, 'already connected')\\n raise AlreadyConnected()\\n\\n self.stopped = 0\\n self.connecting = True\\n self.connectok.clear()\\n self.connectlock.acquire()\\n\\n # create socket\\n if self.ipv6:\\n rlog(10, self.name, 'creating ipv6 socket')\\n self.oldsock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)\\n self.ipv6 = 1\\n else:\\n rlog(10, self.name, 'creating ipv4 socket')\\n self.oldsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\n assert(self.oldsock)\\n\\n # optional bind\\n server = self.server\\n elite = self.cfg['bindhost'] or config['bindhost']\\n if elite:\\n try:\\n self.oldsock.bind((elite, 0))\\n except socket.gaierror:\\n rlog(10, self.name, \\\"can't bind to %s\\\" % elite)\\n # resolve the IRC server and pick a random server\\n if not server:\\n # valid IPv6 ip?\\n try: socket.inet_pton(socket.AF_INET6, self.server)\\n except socket.error: pass\\n else: server = self.server\\n if not server: \\n # valid IPv4 ip?\\n try: socket.inet_pton(socket.AF_INET, self.server)\\n except socket.error: pass\\n else: server = self.server\\n if not server:\\n # valid hostname?\\n ips = []\\n try:\\n for item in socket.getaddrinfo(self.server, None):\\n if item[0] in [socket.AF_INET, socket.AF_INET6] and item[1] == socket.SOCK_STREAM:\\n ip = item[4][0]\\n if ip not in ips: ips.append(ip)\\n except socket.error: pass\\n else: server = random.choice(ips)\\n\\n # do the connect .. set timeout to 30 sec upon connecting\\n rlog(10, self.name, 'connecting to %s (%s)' % (server, self.server))\\n self.oldsock.settimeout(5)\\n self.oldsock.connect((server, int(self.port)))\\n\\n # we are connected\\n rlog(10, self.name, 'connection ok')\\n time.sleep(1)\\n self.connected = True\\n\\n # make file socket\\n self.fsock = self.oldsock.makefile(\\\"r\\\")\\n\\n # set blocking\\n self.oldsock.setblocking(self.blocking)\\n self.fsock._sock.setblocking(self.blocking)\\n\\n # set socket time out\\n if self.blocking:\\n socktimeout = self.cfg['socktimeout']\\n if not socktimeout:\\n socktimeout = 301.0\\n else:\\n socktimeout = float(socktimeout)\\n self.oldsock.settimeout(socktimeout)\\n self.fsock._sock.settimeout(socktimeout)\\n # enable ssl if set\\n if self.ssl:\\n rlog(10, self.name, 'ssl enabled')\\n self.sock = socket.ssl(self.oldsock) \\n else:\\n self.sock = self.oldsock\\n\\n # try to release the outputlock\\n try:\\n self.outputlock.release()\\n except thread.error:\\n pass\\n\\n # start input and output loops\\n start_new_thread(self._readloop, ())\\n start_new_thread(self._outloop, ())\\n\\n # logon and start monitor\\n self._logon()\\n self.nickchanged = 0\\n self.reconnectcount = 0\\n saymonitor.start()\\n return 1\",\n \"def checkServerThread(self):\\r\\n\\r\\n # check if the server is alive\\r\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n\\r\\n result = 1\\r\\n try:\\r\\n result = sock.connect_ex((\\\"dealookup.com\\\", 80))\\r\\n except:\\r\\n result = 1 \\r\\n\\r\\n # server is not live \\r\\n if result != 0:\\r\\n result = 1\\r\\n\\r\\n self.checkResultSignal.emit(result)\",\n \"def connect(self, addr):\\n result = False\\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\n try:\\n self.sock.connect(addr)\\n result = True\\n except socket.error, msg:\\n self.sock = None\\n print 'Connect failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]\\n\\n return result\",\n \"def _connect(self):\\n\\n # Get the timeout\\n m_timeout = OMPv4.TIMEOUT\\n if self.__timeout:\\n m_timeout = self.__timeout\\n\\n # Connect to the server\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.settimeout(m_timeout)\\n try:\\n sock.connect((self.__host, int(self.__port)))\\n except socket.error, e:\\n raise ServerError(str(e))\\n self.socket = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_TLSv1)\\n\\n # Authenticate to the server\\n self._authenticate(self.__username, self.__password)\",\n \"def _try_connect(self):\\n try:\\n return mysql.connect(\\n host=self.host,\\n database=self.database,\\n user=self.user,\\n passwd=self.password\\n )\\n except Error as e:\\n raise ConnectionError(f\\\"Could not connect to {self.connection_string}\\\") from e\",\n \"def connecting(self):\\r\\n \\r\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) \\r\\n try:\\r\\n ssh.connect(self.hostname,self.port,self.identifier,self.password)\\r\\n feedback = '***Connection Established***'\\r\\n return feedback\\r\\n \\r\\n except Exception as e:\\r\\n feedback= '***Connection failed : '+str(e)+'***'\\r\\n return feedback\\r\\n sys.exit(1)\",\n \"def check_connection(self):\\n return False\",\n \"def mpdConnect(client, con_id):\\n try:\\n client.connect(**con_id)\\n except SocketError:\\n return False\\n return True\",\n \"def connect(self):\\r\\n try:\\r\\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(self.ip))\\r\\n print (\\\"connected!\\\")\\r\\n except Exception as error:\\r\\n print (\\\"connect() - error - {}\\\".format(error))\",\n \"def _connect_failed(self):\\n\\t\\tself.root.stdout.write(\\\"Error: Connection Failed!\\\\n\\\")\\n\\t\\tself.client = False\",\n \"def __CheckConnectStatus(self):\\r\\n if not self.tn:\\r\\n print \\\"Connection is down!\\\"\\r\\n return False\\r\\n else:\\r\\n print \\\"Connection is alive!\\\"\\r\\n return True\",\n \"def init_conn(self):\\n \\n SERVER_ADDRESS = '192.168.0.21'\\n PORT = 8018\\n SERVER_PASSWORD = \\\"biratkingofcomedy\\\" \\n connected = False\\n \\n # check if test module is being run\\n if self.testing == 'n': \\n while not connected:\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n \\n try:\\n self.socket.connect((SERVER_ADDRESS, PORT))\\n \\n # server verification\\n self.socket.sendall(self.make_packet(\\\"DATA\\\", SERVER_PASSWORD))\\n \\n response = self.socket.recv(4096)\\n \\n if response:\\n response_hdr, response_msg, response_sdr = self.parse_packet(response)\\n \\n if response_hdr == \\\"ERROR\\\" and response_msg == \\\"IDENTIFY FAILED\\\":\\n raise Exception(\\\"PASSWORD FAIL\\\")\\n \\n elif response_hdr == \\\"DATA\\\" and response_msg == \\\"CONNECTED\\\":\\n connected = True\\n \\n else:\\n raise Exception(\\\"CONNECTION FAIL\\\") \\n \\n except Exception as e:\\n if e == \\\"PASSWORD FAIL\\\":\\n print(\\\"DEBUG: server connection failed (invalid credentials)\\\")\\n print(\\\"DEBUG: quitting\\\")\\n break\\n \\n else:\\n print(e)\\n print(\\\"DEBUG: server connection failed (could not connect), trying again in 10s\\\")\\n time.sleep(10)\\n \\n else:\\n print(\\\"DEBUG: socket setup skipped\\\")\",\n \"async def connect(self):\\n\\n # Display info message\\n log.info(\\\"connect\\\")\\n\\n try:\\n\\n # SSH?\\n if self._protocol == \\\"ssh\\\":\\n\\n # Yes\\n\\n # Then Connect using SSH\\n await self.connectSSH()\\n\\n # Telnet?\\n elif self._protocol == \\\"telnet\\\":\\n\\n # Yes\\n\\n # Then Connect using Telnet\\n await self.connectTelnet()\\n\\n else:\\n\\n # Unsupported protocol\\n\\n # Raise an exception\\n raise Exception(f\\\"connect: unsupported protocol: {self._protocol}\\\")\\n\\n except Exception:\\n\\n # There was a problem with a connection method\\n\\n # Display info message\\n log.info(\\\"connect: connection error\\\")\\n\\n raise\",\n \"def connect(self):\\r\\n if self.__socket:\\r\\n return\\r\\n try:\\r\\n # This is the server communicator, try and accept connections.\\r\\n if self.__server_socket is not None:\\r\\n self.__socket, _ = self.__server_socket.accept()\\r\\n self.__socket.setblocking(0)\\r\\n self.__server_socket.close()\\r\\n # This is the client communicator, try and connect (quickly).\\r\\n else:\\r\\n self.__socket = socket.socket()\\r\\n self.__socket.settimeout(self.CONNECT_TIMEOUT)\\r\\n self.__socket.connect((self.__ip, self.__port))\\r\\n self.__socket.setblocking(0)\\r\\n self.__get_message()\\r\\n except socket.error:\\r\\n # Always close the socket if created, then make it none (this\\r\\n # way it is evident that a connection was not yet established).\\r\\n if self.__socket:\\r\\n self.__socket.close()\\r\\n self.__socket = None\\r\\n # Try again in a given interval.\\r\\n self.__root.after(self.WAIT_PERIOD, self.connect)\",\n \"def connect(self):\\n\\n print(\\\"Connecting to server at {}:{}\\\".format(self.hostname, self.port))\\n\\n self._sock = socket.socket()\\n self._sock.setblocking(True)\\n self._sock.connect((self.hostname, self.port))\\n self._sockfile = self._sock.makefile(encoding=\\\"utf-8\\\")\\n self._connected = True\\n\\n if self.password:\\n self._sendmsg(\\\"PASS :{}\\\".format(self.password))\\n self._sendmsg(\\\"NICK {}\\\".format(self.nickname))\\n self._sendmsg(\\\"USER {} 0 * :ORE Utility Bot\\\".format(getpass.getuser()))\\n if self.ident_password:\\n self._sendmsg(\\\"PRIVMSG NickServ :identify {}\\\".format(\\n self.ident_password))\\n self._sendmsg(\\\"JOIN {}\\\".format(\\\",\\\".join(self.channels)))\",\n \"def connect(self):\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n try:\\n if self.print_send:\\n print(' - connecting...')\\n self.socket.settimeout(1)\\n self.socket.connect(self.host_port)\\n if self.print_send:\\n print(' - connected')\\n except socket.timeout:\\n raise Timeout('Timeout connecting to projector')\\n except Exception as err:\\n raise Error('Connection failed', err)\\n self.expect(b'PJ_OK')\\n self.send(b'PJREQ')\\n self.expect(b'PJACK')\",\n \"def connect(self):\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.socket.connect((self.host, PORT)) # probably throws errors\\n self.connected = True\",\n \"def test_connection():\\r\\n try:\\r\\n connect()\\r\\n except:\\r\\n pass\\r\\n print ('Unable to connect.')\\r\\n else:\\r\\n main()\",\n \"def test_connection(self):\\n r = main.List.connection()\\n self.assertTrue(r.ping(), \\\"Connection failed.\\\")\",\n \"async def connect(self) -> bool:\\n\\n if not await self._connection.connect():\\n return False\\n\\n await self._connected.wait()\\n if not self._connected_successfully:\\n return False\\n\\n self._events.fire(\\\"connected\\\")\\n return True\",\n \"def connectToServer(self):\\n self.client = Client(base_url = self.server)\\n self.ping()\",\n \"def _connect(self, client):\\n if client.transport.isOpen():\\n return True\\n\\n try:\\n client.transport.open()\\n return True\\n except Thrift.ErrorT, tx:\\n if tx.message:\\n message = tx.message\\n else:\\n message = \\\"Transport error, reconnect\\\"\\n client.transport.close()\\n raise ErrorThriftMessage(message)\\n except Exception, e:\\n client.transport.close()\\n\\n return False\",\n \"def connect():\\n logging.info('Client connected')\",\n \"def is_connected():\\n import socket\\n try:\\n host = socket.gethostbyname(\\\"www.gov.uk\\\")\\n socket.create_connection((host, 80), 2)\\n return True\\n except:\\n pass\\n return False\",\n \"def connect(self):\\n try:\\n self.ssh = paramiko.SSHClient()\\n self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n credentials = self.auth.to_dict()\\n credentials.update({'hostname': self.host})\\n self.ssh.connect(**credentials)\\n self.conn_status = self.CONN_OPEN\\n except paramiko.AuthenticationException:\\n self.conn_status = self.CONN_FAILED\\n except paramiko.ssh_exception.SSHException:\\n if self.loop_counter < 3:\\n time.sleep(2)\\n self.loop_counter += 1\\n self.connect()\",\n \"def check_connection(self):\\n try:\\n self.mfp.add(2,2)\\n logger.info(\\\"Connection to user API established\\\")\\n except xmlrpclib.ProtocolError:\\n logger.error(\\\"Not possible to connect to MOF+. Check your credentials\\\")\\n exit()\\n return\",\n \"def check_conn():\\n try:\\n urllib2.urlopen(\\\"http://www.google.com\\\", timeout=5)\\n return True\\n except urllib2.URLError:\\n pass\\n return False\",\n \"def __init__(self):\\n self.try_to_connect()\",\n \"def test_connection(self):\\n req = requests.get(\\\"http://{}:{}\\\".format(self.config.options.get(\\\"Server\\\", \\\"ListenAddress\\\"),\\n self.config.options.get(\\\"Server\\\", \\\"Port\\\")))\\n\\n self.assertEqual(req.status_code, 200)\",\n \"def connect(self):\\n if not self.is_connected():\\n try:\\n self._socket = socket.create_connection(self.address)\\n self._socket.setblocking(0) # Set to non-blocking.\\n self._reader = process_manager.LineReader(self._socket)\\n print \\\"Connecting successfully\\\", self.address\\n return True\\n except socket.error as e:\\n print e\\n self._socket = None\\n return False\\n else:\\n print \\\"Already connecting to\\\", self.address\",\n \"def CheckIfConnecting(self):\\n if self.CheckIfWiredConnecting() or self.CheckIfWirelessConnecting():\\n return True\\n else:\\n return False\",\n \"def connect(self) -> bool:\\n self._last_error = None\\n try:\\n self._imap = IMAP4_SSL(self._hostname, self._port)\\n except IMAP4_SSL.error as e:\\n self._imap = None\\n self._last_error = e\\n return False\\n return True\",\n \"def connect(self):\\n sock_version = socket.AF_INET if self.ip_version == 4 else socket.AF_INET6\\n with socket.socket(sock_version, socket.SOCK_STREAM) as sock:\\n sock.connect((self.server_ip, self.port))\\n print(\\\"Client connected\\\")\\n self.__send_request(\\\"01\\\", sock)\\n\\n while True:\\n response = self.__receive_response(sock)\\n if len(response) >= 2:\\n msg_id_code = int(response[:2])\\n if msg_id_code == 2:\\n udp_port = self.__request_info_file(response, sock)\\n if msg_id_code == 4:\\n self.__handle_udp_transfer(self.server_ip, udp_port, sock)\\n if msg_id_code == 5:\\n print(\\\"Closing connection\\\")\\n sock.close()\\n return 0\\n if msg_id_code == 8:\\n print(\\\"Invalid file name. Max size: 15bytes\\\")\\n sock.close()\\n return -1\",\n \"def _connect(self):\\n try:\\n #print(\\\"try to connect _connect\\\")\\n sock = gevent.socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.connect(self.remote_address)\\n except socket.error as error:\\n logger.warning(\\\"Couldn't connect to %s: %s.\\\",\\n self._repr_remote(), error)\\n else:\\n self.initialize(sock, self.remote_service_coord)\",\n \"def test_connection(server_address, server_username=None, server_password=None, verbose=True):\\n\\n try:\\n if server_username is None and server_password is None:\\n r = requests.get(url=server_address)\\n else:\\n r = requests.get(url=server_address, auth=(server_username, server_password))\\n if r.ok:\\n if verbose:\\n print(\\\"Network connectivity: VERIFIED. Server \\\" + server_address + \\\" is reachable!\\\")\\n return True\\n else:\\n print(\\\"Something wrong during connection!\\\")\\n return False\\n\\n except Exception as e:\\n print(e)\\n return False\",\n \"def _connect(self):\\n try:\\n self._si = SmartConnectNoSSL(host=self._host, user=self._username, pwd=self._password)\\n except Exception as e:\\n self._logger.error(\\\"Unable to connect to host {0} : {1}\\\".format(self._host, e))\\n self._si = None\",\n \"def connectToServer(self):\\r\\n\\t\\tself.rtspSocket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tself.rtspSocket_client.connect((self.serverAddr, self.serverPort))\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tprint(\\\"Fail to connect to server\\\")\",\n \"def connect_to_server(self):\\n\\n server=os.popen('hostname').read()\\n if 'epfl.ch' not in server:\\n conn = mds.Connection('tcvdata.epfl.ch')\\n conn.openTree('tcv_shot', self.shot)\\n self.tree = conn\\n print(\\\"You are in server \\\"+server+\\\", so I'll open a connection\\\")\\n else:\\n self.tree = mds.Tree('tcv_shot', self.shot)\",\n \"def connect(self):\\n self.conn.connect()\",\n \"def connect():\\n try:\\n conn = mysql.connect(host='localhost',\\n database='python_mysql',\\n user='root',\\n password='SQLPASSWORD')\\n if conn.server_status is 0:\\n print('Connected to MySQL database')\\n\\n except Error as e:\\n print(e)\\n\\n finally:\\n conn.close()\",\n \"def connect(self, timeout: float = 5) -> bool:\\n if not self.connected:\\n self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.socket.settimeout(timeout)\\n try:\\n self.socket.connect((self.host, self.port))\\n self.connected = True\\n self.socket.setblocking(False)\\n self.endpoint = self.socket\\n except ConnectionRefusedError:\\n pass\\n return self.connected\",\n \"def connect(self):\\n try:\\n self._send = 0\\n self.socket = socket.socket(socket.AF_INET,\\n socket.SOCK_STREAM,\\n socket.getprotobyname('tcp'))\\n self.socket.connect((self.host, self.port))\\n self.socket.recv(self.packet_size)\\n except socket.error:\\n raise ConnectionError(\\n 'Cannot connect to server at %s' % self.name)\",\n \"async def connect(self, retry=2):\\n # pylint: disable=too-many-return-statements\\n url = self._endpoint + PLUGWISE_PING_ENDPOINT\\n try:\\n with async_timeout.timeout(self._timeout):\\n resp = await self.websession.get(url,auth=self._auth)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n if retry < 1:\\n _LOGGER.error(\\\"Error connecting to Plugwise\\\", exc_info=True)\\n return False\\n return await self.connect(retry - 1)\\n\\n result = await resp.text()\\n if not 'error' in result:\\n _LOGGER.error('Connected but expected text not returned, we got %s',result)\\n return False\\n\\n return True\",\n \"def test_check_connection(self):\\n self.assertIsNotNone(app.check_connection())\",\n \"def isConnected():\",\n \"def validate_server(self):\\n for i in range(60):\\n # wait 60s for connecting to ftp server\\n plat_comb = get_element('PLATFORM_COMB')\\n plat_comb.Expand()\\n plat_comb.Click(0, 0)\\n if len(plat_comb.GetChildren()):\\n log.info('[dl_img] Successfully connect to ftp server')\\n return True\\n else:\\n log.info('checking ftp server connected...{}'.format(i))\\n if get_element('ERROR_DIALOG').Exists():\\n log.error('There is Error when connecting to ftp server')\\n for _ in range(3):\\n # if connect to server fail, there will be some error dialogs\\n if get_element('ERROR_DIALOG').Exists():\\n get_element('ERROR_DIALOG').Close()\\n time.sleep(1)\\n else:\\n self.close_panel()\\n return False\\n else:\\n time.sleep(1)\\n continue\\n self.close_panel()\\n return False\",\n \"def _check_connection(self):\\n if \\\"_connection\\\" not in self.__dict__:\\n message = \\\"use connect method before doing operation on this database\\\"\\n raise Exception(message)\",\n \"def connect():\",\n \"def connect(self):\\n self.client.connect(self.host, self.port)\\n self.client.loop_forever()\",\n \"def connection_init(self, port, ip):\\n\\t\\t# Инициализация сокета и сообщение серверу о нашем появлении\\n\\t\\tself.transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\t\\t\\n\\t\\t# Таймаут необходим для освобождения сокета.\\n\\t\\tself.transport.settimeout(5)\\n\\t\\t\\n\\t\\t# Соединяемся, 5 попыток соединения, флаг успеха ставим в True если\\n\\t\\t# удалось\\n\\t\\tconnected = False\\n\\t\\tfor i in range(5):\\n\\t\\t\\tclient_log.info(f'Попытка подключения №{i + 1}')\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tself.transport.connect((ip, port))\\n\\t\\t\\texcept (OSError, ConnectionRefusedError):\\n\\t\\t\\t\\tpass\\n\\t\\t\\telse:\\n\\t\\t\\t\\tconnected = True\\n\\t\\t\\t\\tclient_log.debug(\\\"Connection established.\\\")\\n\\t\\t\\t\\tbreak\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\n\\t\\t# Если соединится не удалось - исключение\\n\\t\\tif not connected:\\n\\t\\t\\tclient_log.critical('Не удалось установить соединение с сервером')\\n\\t\\t\\traise ServerError('Не удалось установить соединение с сервером')\\n\\t\\t\\n\\t\\tclient_log.debug('Starting auth dialog.')\\n\\t\\t\\n\\t\\t# Запускаем процедуру авторизации\\n\\t\\t# Получаем хэш пароля\\n\\t\\tpasswd_bytes = self.password.encode('utf-8')\\n\\t\\tsalt = self.username.lower().encode('utf-8')\\n\\t\\tpasswd_hash = hashlib.pbkdf2_hmac('sha512', passwd_bytes, salt, 10000)\\n\\t\\tpasswd_hash_string = binascii.hexlify(passwd_hash)\\n\\t\\t\\n\\t\\tclient_log.debug(f'Passwd hash ready: {passwd_hash_string}')\\n\\t\\t\\n\\t\\t# Получаем публичный ключ и декодируем его из байтов\\n\\t\\tpubkey = self.keys.publickey().export_key().decode('ascii')\\n\\t\\t\\n\\t\\t# Авторизируемся на сервере\\n\\t\\twith socket_lock:\\n\\t\\t\\tpresense = {\\n\\t\\t\\t\\tACTION: PRESENCE,\\n\\t\\t\\t\\tTIME: time.time(),\\n\\t\\t\\t\\tUSER: {\\n\\t\\t\\t\\t\\tACCOUNT_NAME: self.username,\\n\\t\\t\\t\\t\\tPUBLIC_KEY: pubkey\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tclient_log.debug(f\\\"Presense message = {presense}\\\")\\n\\t\\t\\t# Отправляем серверу приветственное сообщение.\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tsend_message(self.transport, presense)\\n\\t\\t\\t\\tans = get_message(self.transport)\\n\\t\\t\\t\\tclient_log.debug(f'Server response = {ans}.')\\n\\t\\t\\t\\t# Если сервер вернул ошибку, бросаем исключение.\\n\\t\\t\\t\\tif RESPONSE in ans:\\n\\t\\t\\t\\t\\tif ans[RESPONSE] == 400:\\n\\t\\t\\t\\t\\t\\traise ServerError(ans[ERROR])\\n\\t\\t\\t\\t\\telif ans[RESPONSE] == 511:\\n\\t\\t\\t\\t\\t\\t# Если всё нормально, то продолжаем процедуру\\n\\t\\t\\t\\t\\t\\t# авторизации.\\n\\t\\t\\t\\t\\t\\tans_data = ans[DATA]\\n\\t\\t\\t\\t\\t\\thash = hmac.new(passwd_hash_string, ans_data.encode('utf-8'), 'MD5')\\n\\t\\t\\t\\t\\t\\tdigest = hash.digest()\\n\\t\\t\\t\\t\\t\\tmy_ans = RESPONSE_511\\n\\t\\t\\t\\t\\t\\tmy_ans[DATA] = binascii.b2a_base64(\\n\\t\\t\\t\\t\\t\\t\\tdigest).decode('ascii')\\n\\t\\t\\t\\t\\t\\tsend_message(self.transport, my_ans)\\n\\t\\t\\t\\t\\t\\tself.process_server_ans(get_message(self.transport))\\n\\t\\t\\texcept (OSError, json.JSONDecodeError) as err:\\n\\t\\t\\t\\tclient_log.debug(f'Connection error.', exc_info=err)\\n\\t\\t\\t\\traise ServerError('Сбой соединения в процессе авторизации.')\",\n \"async def connect(self):\\n try:\\n self.reader, self.writer = await asyncio.open_connection(self.host,\\n self.port)\\n except (asyncio.TimeoutError, ConnectionRefusedError):\\n self.log.error(\\\"Cannot connect to spa at {0}:{1}\\\".format(self.host,\\n self.port))\\n return False\\n self.connected = True\\n return True\",\n \"def _CheckConnect(self):\\n try:\\n resp = requests.get(self._target_url, timeout=2)\\n if resp.headers['Maximum-Bytes']:\\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\\n return resp.status_code == 200\\n except requests.exceptions.ConnectionError:\\n return False\\n except Exception as e:\\n self.exception('Unexpected test connect failure: %s', str(e))\\n return False\",\n \"def connect_socket(self):\\n try:\\n self.socket.connect((self.request.host, int(self.request.port)))\\n except socket.gaierror:\\n raise socket.gaierror(\\\"Socket connection could not be established\\\")\\n except socket.timeout:\\n raise socket.timeout(\\\"Socket connection timed out\\\")\\n except InterruptedError:\\n raise InterruptedError(\\\"Socket connection has been interrupted by a signal\\\")\",\n \"def check_up(addr, p):\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n result = sock.connect_ex((addr, p))\\n sock.close()\\n if result == 0:\\n ans = True\\n else:\\n ans = False\\n return ans\",\n \"def reconnecting(self) -> bool:\",\n \"def connect():\\n\\n\\tprint \\\"In connection state\\\"\\n\\n\\tglobal cs\\n\\tglobal state\\n\\n\\tcs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\tcs.connect(('localhost', PORT))\\n\\tcs.send('Connected')\\n\\tstate += 1\",\n \"def connect(self):\\n if not self._socket:\\n self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self._socket.connect((self.host, self.port))\\n self._socket.settimeout(0.0)\",\n \"def connect(self):\\r\\n\\r\\n\\t\\tprint('Connecting to server')\\r\\n\\r\\n\\t\\tself.t = threading.Thread(target=self.daemon.requestLoop)\\r\\n\\t\\tself.t.daemon = True\\r\\n\\t\\tself.t.start()\\r\\n\\t\\tprint('daemon thread started')\\r\\n\\t\\tmessages = self.chat.connect(self.my_uri)\\r\\n\\r\\n\\t\\t#in case the connection is refused:\\r\\n\\t\\tif isinstance(messages, bool) and not messages:\\r\\n\\t\\t\\traise ValueError(f\\\"Username {self.username} already taken\\\")\\r\\n\\r\\n\\t\\tprint('Connected')\\r\\n\\r\\n\\t\\t#if the connection is accepted, the last 20 messages are sent\\r\\n\\t\\t#those messages will now be printed.\\r\\n\\t\\tfor message in messages:\\r\\n\\t\\t\\tself.incoming_message(message)\",\n \"def _check_connection() -> bool:\\n return bool(subprocess.check_output([\\\"hostname\\\", \\\"-I\\\"]))\",\n \"def is_connected():\\r\\n global connection\\r\\n if connection is None:\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def check_connection():\\n r = requests.get('https://www.google.com')\\n if r.status_code == 200:\\n print (colored(\\\"Connected.\\\", 'green'))\\n else:\\n print (colored(\\\"Not Connected.\\\", 'red'))\",\n \"def connect(self):\\n auth = self.botconfig.find('auth')\\n logging.info(\\\"Connecting ...\\\" )\\n if not auth.get('server', None):\\n # we don't know the server, but the lib can probably figure it out\\n super(SleekBot, self).connect()\\n else:\\n super(SleekBot, self).connect((auth.attrib['server'], auth.get('port', 5222)))\",\n \"def _on_connection_error(self, exception):\\n print(\\\"connection failed: {}\\\".format(exception))\\n time.sleep(1)\\n self.connect()\",\n \"def is_connected(self):\\n if self.server: return True\\n return False\",\n \"def connect(self) -> None:\\n self.terminate()\\n self._new_client().connect(\\n hostname=self.ip,\\n port=self.port,\\n username=self.username,\\n password=self.password,\\n look_for_keys=False,\\n allow_agent=False)\",\n \"def connect_to_server(self):\\n\\n\\t\\tself.__logs.append('-- connecting to server ...')\\n\\t\\tself.connect_to_ssh_server.emit(self.__ip.text(), int(self.__port.text()),\\\\\\n\\t\\t\\tself.__username.text(), self.__pwd.text())\",\n \"def connect(\\n self, login, password, authz_id=b\\\"\\\", starttls=False,\\n authmech=None):\\n try:\\n self.sock = socket.create_connection((self.srvaddr, self.srvport))\\n self.sock.settimeout(Client.read_timeout)\\n except socket.error as msg:\\n raise Error(\\\"Connection to server failed: %s\\\" % str(msg))\\n\\n if not self.__get_capabilities():\\n raise Error(\\\"Failed to read capabilities from server\\\")\\n if starttls and not self.__starttls():\\n return False\\n if self.__authenticate(login, password, authz_id, authmech):\\n return True\\n return False\",\n \"def check_smtp_server_connection(self):\\n try:\\n connected = True\\n\\n while not self.config:\\n time.sleep(1)\\n\\n # Create SMTP server and handshake\\n server = smtplib.SMTP(self.config.smtp_host + ':' + self.config.smtp_port)\\n server.connect(self.config.smtp_host + ':' + self.config.smtp_port)\\n\\n self.logger.info(MODULE_NAME + '::check_smtp_server_connection::Successfully '\\n 'connected to the configured SMTP server and port at: ' + self.config.smtp_host + ':' + self.config.smtp_port)\\n\\n server.quit()\\n\\n return connected\\n\\n except Exception as e:\\n self.logger.error(MODULE_NAME + '::check_smtp_server_connection()::The following '\\n 'unhandled exception occurred: ' + e.message)\\n connected = False\\n return connected\",\n \"async def async_connect(self):\\n # Test the router is accessible.\\n try:\\n data = await self.connection.async_get_connected_devices()\\n self.success_init = data is not None\\n except OSError as ex:\\n _LOGGER.warning(\\n \\\"Error [%s] connecting %s to %s.\\\",\\n str(ex),\\n DOMAIN,\\n self.host,\\n )\\n raise ConnectionError(\\\"Cannot connect to D-Link router\\\")\\n\\n if not self.connection.is_connected:\\n _LOGGER.error(\\\"Error connecting %s to %s\\\", DOMAIN, self.host)\\n raise ConnectionError(\\\"Cannot connect to D-Link router\\\")\",\n \"def open(self):\\n try:\\n if self.verbose:\\n print \\\"Trying to open connection to Leica at \\\",self.IP_address,\\\":\\\",str(self.port)\\n self.leicasocket = socket.socket()\\n self.leicasocket.connect((self.IP_address,self.port))\\n if self.verbose:\\n print(\\\"Connected.\\\")\\n self.connected=True\\n return True\\n except:\\n if self.verbose:\\n print \\\"Error opening connection to \\\", self.IP_address\\n self.connected=False\\n return False\",\n \"async def connect(self):\\n try:\\n self._cmd_stream = await self._connect()\\n self.inc_counter(\\\"%s.connected\\\" % self.objname)\\n self.logger.info(\\\"Connected: %s\\\", self._extra_info)\\n except Exception as e:\\n self.logger.error(\\\"Connect Failed %r\\\", e)\\n self.inc_counter(\\\"%s.failed\\\" % self.objname)\\n raise e\",\n \"def _connect(self, conn):\\n conn_options = {\\n 'quiet': self.quiet,\\n 'src_name': \\\"master\\\",\\n 'dest_name': None,\\n 'version': \\\"5.0.0\\\",\\n 'unique': True,\\n 'verbose': self.verbose,\\n }\\n\\n certs_paths = {}\\n if 'ssl_ca' in dir(conn) and conn.ssl_ca is not None:\\n certs_paths['ssl_ca'] = conn.ssl_ca\\n if 'ssl_cert' in dir(conn) and conn.ssl_cert is not None:\\n certs_paths['ssl_cert'] = conn.ssl_cert\\n if 'ssl_key' in dir(conn) and conn.ssl_key is not None:\\n certs_paths['ssl_key'] = conn.ssl_key\\n\\n conn_options.update(certs_paths)\\n\\n master_info = \\\"%s:%s\\\" % (conn['host'],\\n conn['port'])\\n master = None\\n\\n # Clear socket if used with a local server\\n if (conn['host'] == 'localhost' or conn['host'] == \\\"127.0.0.1\\\" or\\n conn['host'] == \\\"::1\\\" or conn['host'] == \\\"[::1]\\\"):\\n conn['unix_socket'] = None\\n\\n # Increment num_retries if not set when --prompt is used\\n if self.prompt_user and self.num_retries == 0:\\n self.num_retries += 1\\n\\n # Attempt to connect to the server given the retry limit\\n for i in range(0, self.num_retries + 1):\\n try:\\n servers = connect_servers(conn, None, conn_options)\\n master = servers[0]\\n break\\n except UtilError, e:\\n print \\\"FAILED.\\\\n\\\"\\n if i < self.num_retries and self.prompt_user:\\n print \\\"Connection to %s has failed.\\\\n\\\" % master_info + \\\\\\n \\\"Please enter the following information \\\" + \\\\\\n \\\"to connect to this server.\\\"\\n conn['user'] = raw_input(\\\"User name: \\\")\\n conn['passwd'] = getpass.getpass(\\\"Password: \\\")\\n else:\\n # retries expired - re-raise error if still failing\\n raise UtilError(e.errmsg)\\n\\n return (master, master_info)\",\n \"async def check_connection_status(self):\\n while True:\\n if not self.connected:\\n self.log.error(\\\"Lost connection to spa, attempting reconnect.\\\")\\n await self.connect()\\n await asyncio.sleep(10)\\n continue\\n if (self.lastupd + 5 * self.sleep_time) < time.time():\\n self.log.error(\\\"Spa stopped responding, requesting panel config.\\\")\\n await self.send_panel_req(0, 1)\\n await asyncio.sleep(self.sleep_time)\",\n \"def Connection(self):\\n try:\\n system(\\n f'netsh advfirewall firewall add rule name=\\\"Open Port {self.PORT}\\\" dir=in action=allow protocol=TCP localport={self.PORT} remoteip={self.HOST}')\\n with socket() as s: # Create a socket object\\n print('Server started!')\\n print('Waiting for clients...')\\n s.bind((self.HOST, self.PORT)) # Bind to the port\\n s.listen(5) # Now wait for client connection.\\n self.c, addr = s.accept() # Establish connection with client.\\n # Remote client machine connection\\n print('Got connection from', addr)\\n except error as strerror:\\n print(\\\"Network problems:\\\", strerror)\\n return 0\\n return 1\",\n \"def has_server_connection(driver, server_url):\\r\\n\\r\\n OK = True\\r\\n try:\\r\\n driver.get(server_url)\\r\\n # we aim at this element on the chrome default page on 'No internet connection' error\\r\\n ele = driver.find_element_by_xpath('//*[@id=\\\"main-message\\\"]/h1/span')\\r\\n if ele is not None and ele.text == 'No internet':\\r\\n printR(' No internet connection')\\r\\n return not OK\\r\\n \\r\\n if requests.get(server_url).status_code != 200:\\r\\n printR(f' Error connecting to {server_url}')\\r\\n return not OK\\r\\n except: \\r\\n return OK\",\n \"def _connect_socket(self):\\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.sock.connect((self.ip, self.port))\\n print(\\\"Connected to %s at port %d\\\" % (self.ip, self.port))\",\n \"def connect(self):\\n sock = socket.create_connection((self.host, self.port))\\n try:\\n self.sock = ssl.wrap_socket(sock, keyfile=self.key_file,\\n certfile=self.cert_file,\\n cert_reqs=self.cert_reqs,\\n ca_certs=self.ca_certs)\\n except ssl.SSLError, e:\\n raise Error('Error validating SSL certificate for \\\"' + self.host +\\n '\\\": ' + str(e))\\n\\n if self.cert_reqs == ssl.CERT_REQUIRED:\\n self._VerifyHostName(self.host, self.sock.getpeercert())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74671197","0.7376107","0.7224917","0.71801555","0.71454126","0.7106595","0.6992818","0.69693106","0.69635016","0.6934962","0.69222325","0.69027525","0.68996257","0.68846506","0.68738174","0.68378454","0.6834296","0.6821374","0.6818732","0.67999405","0.67837626","0.67306036","0.6715676","0.66929346","0.6690253","0.6685374","0.6675358","0.66749024","0.66686386","0.66675687","0.66269994","0.66238934","0.6623511","0.6603503","0.6603312","0.65669775","0.6544343","0.6537495","0.6531772","0.652934","0.65215105","0.6519703","0.6507896","0.64949554","0.6478336","0.6466799","0.64587206","0.6454757","0.645111","0.6444851","0.6443567","0.644058","0.6431709","0.64282805","0.64279443","0.6415273","0.641051","0.6410224","0.64020675","0.63987416","0.6380196","0.6378896","0.6378079","0.63621676","0.63616765","0.63410795","0.6338579","0.63264686","0.63257486","0.632096","0.63037956","0.6302337","0.6297266","0.6292639","0.6292198","0.6290168","0.628871","0.6274876","0.6265226","0.62612796","0.62600076","0.62596714","0.6246723","0.6243167","0.62373596","0.6229257","0.62282515","0.62273455","0.6214697","0.6212218","0.6209677","0.62070835","0.6206439","0.61858106","0.6183995","0.6179864","0.6178955","0.61693335","0.61669356","0.6163075"],"string":"[\n \"0.74671197\",\n \"0.7376107\",\n \"0.7224917\",\n \"0.71801555\",\n \"0.71454126\",\n \"0.7106595\",\n \"0.6992818\",\n \"0.69693106\",\n \"0.69635016\",\n \"0.6934962\",\n \"0.69222325\",\n \"0.69027525\",\n \"0.68996257\",\n \"0.68846506\",\n \"0.68738174\",\n \"0.68378454\",\n \"0.6834296\",\n \"0.6821374\",\n \"0.6818732\",\n \"0.67999405\",\n \"0.67837626\",\n \"0.67306036\",\n \"0.6715676\",\n \"0.66929346\",\n \"0.6690253\",\n \"0.6685374\",\n \"0.6675358\",\n \"0.66749024\",\n \"0.66686386\",\n \"0.66675687\",\n \"0.66269994\",\n \"0.66238934\",\n \"0.6623511\",\n \"0.6603503\",\n \"0.6603312\",\n \"0.65669775\",\n \"0.6544343\",\n \"0.6537495\",\n \"0.6531772\",\n \"0.652934\",\n \"0.65215105\",\n \"0.6519703\",\n \"0.6507896\",\n \"0.64949554\",\n \"0.6478336\",\n \"0.6466799\",\n \"0.64587206\",\n \"0.6454757\",\n \"0.645111\",\n \"0.6444851\",\n \"0.6443567\",\n \"0.644058\",\n \"0.6431709\",\n \"0.64282805\",\n \"0.64279443\",\n \"0.6415273\",\n \"0.641051\",\n \"0.6410224\",\n \"0.64020675\",\n \"0.63987416\",\n \"0.6380196\",\n \"0.6378896\",\n \"0.6378079\",\n \"0.63621676\",\n \"0.63616765\",\n \"0.63410795\",\n \"0.6338579\",\n \"0.63264686\",\n \"0.63257486\",\n \"0.632096\",\n \"0.63037956\",\n \"0.6302337\",\n \"0.6297266\",\n \"0.6292639\",\n \"0.6292198\",\n \"0.6290168\",\n \"0.628871\",\n \"0.6274876\",\n \"0.6265226\",\n \"0.62612796\",\n \"0.62600076\",\n \"0.62596714\",\n \"0.6246723\",\n \"0.6243167\",\n \"0.62373596\",\n \"0.6229257\",\n \"0.62282515\",\n \"0.62273455\",\n \"0.6214697\",\n \"0.6212218\",\n \"0.6209677\",\n \"0.62070835\",\n \"0.6206439\",\n \"0.61858106\",\n \"0.6183995\",\n \"0.6179864\",\n \"0.6178955\",\n \"0.61693335\",\n \"0.61669356\",\n \"0.6163075\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7139742"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":20275,"cells":{"query":{"kind":"string","value":"The server should accept a POST and return the 'nessage' field"},"document":{"kind":"string","value":"def test_POST():\n\tprint(\"Testing POST request.\")\n\tmsg = random.choice([\"Hellow!\", \"Hi!! you\", \"Greetings!!!\"])\n\turi = \"http://localhost:8000/\"\n\n\ttry:\n\t\tr = requests.post(uri, data={'message': msg})\n\texcept requests.RequestException as e:\n\t\treturn (f\"Couldn't communicate with the server. ({e}), If it's running, take a look at its output. \")\n\n\tif r.status_code == 501:\n\t\treturn (\"The server returned status code 501 Not Implemented. \\\n\t\t\tThis means it doesn't know how to handle a POST request. \\\n\t\t\tIs the correct server code running?\")\n\n\telif r.status_code != 200:\n\t\treturn(f\"The server returned status code {r.status_code} instead of a 200 OK\")\n\n\telif r.text != msg:\n\t\treturn(f\"The server sent a 200 OK response, but the content differed. \\\n\t\t\tI expected {msg}, but it sent {r.text}\")\n\telse:\n\t\tprint(\"POST request succeeded\")\n\t\treturn None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def post(self):\n return write_msg(request.json)","def render_POST(self, request):\n\t\tprint request.args[\"message\"][0]\n\t\tself.jabberClient.sendMessage(request.args[\"message\"][0])\n\t\treturn ''","def post(self):\n try:\n msgId = int(request.form['text'])\n except ValueError:\n return {\"text\": \"please enter a valid integer as msg Id.\"}\n msg = str(read_msg(msgId))\n return {\"text\": msg}","def post(self):\n user = request.form['user_name']\n text = request.form['text']\n return {\"text\": 'msg sent successfully.\\ntext:'\n + text + '\\nuser:' + user}","def post(self):\n try:\n msg_json = json.loads(request.form['text'])\n except json.decoder.JSONDecodeError:\n return {\"text\": \"Failed to send msg. Incorrect json format.\"}\n msgId = write_msg(msg_json)\n responseText = 'successfully created msg ' \\\n 'with id: ' + msgId\n return {\"text\": responseText}","def input_post(): #TODO, error handling for privacy checks\n\n message = request.form['message']\n page_token = session['page']['access_token']\n resp = utils.post_message(message, page_token, session['visibility'])\n return render_template('success.html', post_id = resp['id'])","def post_data():\n return json.loads('{\"success\":true, \"message\":\"Data created (but not really)\" }')","def get_message(post_request):\n lst = ['stripped-text', 'stripped-signature']\n for value in lst:\n if value in post_request.POST:\n return post_request.POST.get(value)\n\n return post_request.POST.get('body-plain')","def post(self):\n r = request.get_json()['text']\n # Recupero dalla richiesta il JSON che mi è stato inviato\n # e salvo il valore contenuto \n # sotto la chiave text su una variabile r.\n # In reguito ritorno r in formato stringa.\n # In quanto il valore di ritorno deve essere una stringa.\n return str(r)","def post(self):\n send_slack_log('Entered /slack/post_msg')\n send_slack_log('Request info:')\n send_slack_log(str(request.form))\n # unknown request.form\n trigger_id = request.form['trigger_id']\n channel_id = request.form['channel_id']\n response = open_form(channel_id,\n trigger_id,\n config['slack_post_form_path'])\n send_slack_log('Response info:')\n send_slack_log(str(response))\n return 'Please enter the new msg information in the form'","def post(self):\n text = 'HELLO from socnet API Server!'\n return push_to_mattermost(text)","def on_post(self, req, resp):\n self._set_default_response(resp)\n\n string = req.media.get('string')\n if string is None:\n resp.body = \"\"\"{ \"result\": \"error: request payload must contain a JSON object with a 'string' attribute\" }\"\"\"\n else:\n resp.status = falcon.HTTP_200\n result = \"pass\" if self._validate(string) else \"fail\"\n resp.body = json.dumps({'result': result})","def post(self):\n send_slack_log('Entered /slack/get_msg')\n send_slack_log('Request info:')\n send_slack_log(str(request.form))\n msg_id = request.form['text']\n channel_id = request.form['channel_id']\n try:\n id = int(msg_id)\n except ValueError:\n return \"Invalid Msg ID: \" + str(msg_id)\n text = read_msg(id)\n formated_msg = slack_format_msg(text)\n response = send_json_to_slack_channel(formated_msg, channel_id)\n send_slack_log('Response info:')\n send_slack_log(response)\n return \"Msg \" + str(id) + \" fetched\"","def post_flow_form(self, req, **_kwargs):\n if req.POST:\n res = Response()\n s = self.api.process_flow_message(req.json)\n res.text = s if PYTHON3 else unicode(s, \"utf-8\")\n return res\n return Response(status=400) # bad request","def post(self):","def api_message():\n\n if request.headers['Content-Type'] == 'text/plain':\n # Data sent is stored in request.data\n return 'Text message: ' + request.data\n elif request.headers['Content-Type'] == 'application/json':\n return 'JSON message: ' + json.dumps(request.json)\n else:\n return '415 Unsupported Media Type'","def essay_post_new():\n \n text0 = request.form['text']\n essay = {}\n status = 200\n \n if (app.debug is True):\n essay = Flask_process_text(text0) \n else:\n try:\n essay = Flask_process_text(text0) \n except Exception as e:\n ## Any unsupported exceptions coming from code\n ## TODO: get a better error message (not revealing internal error) \n status = 500\n essay = { 'error' : { \n 'status' : status,\n 'msg' : e.message}}\n \n return jsonify(essay) , status","def post():\n pass","def get_message():\n # get params from the POST request\n # try\n print(\"zeeeeeeeeeeeeeee\", request.data.decode())\n user_id = request.json['user_id']\n bot_id = request.json['bot_id'] # ex: 5005\n message = request.json['message']\n # query the concerned bot\n bot_url = \"http://localhost:\" + str(bot_id) + \"/webhooks/rest/webhook\"\n params = {\"sender\": user_id, \"message\": message}\n result = http_json_request(params, bot_url)\n new_msg = \"\"\n pile_run = deepcopy(result)\n while len(pile_run) > 0:\n msg = pile_run.pop(0)\n if \"buttons\" in msg:\n params[\"message\"] = msg[\"buttons\"][0][\"payload\"]\n pile_run.extend(http_json_request(params, bot_url))\n elif \"custom\" in msg:\n message += \"<{}>\\n\".format(msg[\"custom\"][\"type\"])\n else:\n new_msg += \"{}\\n\".format(msg[\"text\"])\n return new_msg\n # except Exception as err:\n # print(\"Erreur dans get_message() :\", err)\n # return \"Error\"","def message():\n if request.method == 'POST':\n db.log_msg(request.form['text'], request.cookies.get('username'))\n return db.get_all_messages()","async def render_post(self, request):\n self._hx711.tare()\n return Message(code=CHANGED)","def post(self, request):\n serlializer = self.serlializer_class(data=request.data)\n\n if serlializer.is_valid():\n name = serlializer.validated_data.get('name')\n message = f'Hello {name}'\n return Response({'message': message})\n else:\n return Response(serlializer.errors, status=status.HTTP_400_BAD_REQUEST)","def post(self):\n\n\t\treturn MessageStore.create(api.payload), 201","def post(self, request):\n serializer = self.serializer_class(data=request.data)\n if serializer.is_valid():\n name = serializer.validated_data.get('name')\n message = f'Hello {name}'\n return Response({'Message':message})\n else:\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def post(self, request):\n serializer = self.serializer_class(data=request.data) # Retrieves the configured serializer class and passes the content of the POST\n\n if serializer.is_valid(): # Checking if the data POSTed as input is valid according to the serializers\n name = serializer.validated_data.get('name') # Retrieving the name field in the request\n message = f'Hello {name}'\n return Response({'message': message})\n else:\n return Response(\n serializer.errors,\n status=status.HTTP_400_BAD_REQUEST\n )","def post():\n value = request.form['test']\n return 'Hello world ' + value","def post(self,request):\n serializer = self.serializer_class(data=request.data)\n\n if serializer.is_valid():\n name = serializer.validated_data.get('name')\n surname = serializer.validated_data.get('surname')\n message = f'Hello {name} {surname}'\n return Response({'message':message})\n else:\n return Response(\n serializer.errors,\n status = status.HTTP_400_BAD_REQUEST\n )","async def post(request):\n data = request.text\n return text(data)","def http_method_post():\n return 'POST'","def handle_post_msg(body):\r\n request = json.loads(body)\r\n type = request['type']\r\n subtype = request['subtype']\r\n if type == 'get':\r\n if subtype == 'job':\r\n job = {'job':get_next_job()}\r\n return webServer.add_json_successfull_status(job)\r\n elif subtype == 'tasks':\r\n res = []\r\n for task in tasks:\r\n res.append(task.get_task())\r\n res = {'tasks':res}\r\n return webServer.add_json_successfull_status(res)\r\n\r\n elif type == 'post':\r\n if subtype == 'result':\r\n start_point = request['start_point']\r\n end_point = request['end_point']\r\n found_keyword_bool = request['found_keyword_bool']\r\n keyword_found = request['keyword_found']\r\n task_id = request['task_id']\r\n if found_keyword_bool:\r\n for task in tasks:\r\n if task.id == task_id:\r\n task.set_finished()\r\n task.keyword_found = keyword_found\r\n return webServer.make_json_status(1, \"Result delivered successfully\")\r\n return webServer.make_json_status(0, \"Couldn't find task\")\r\n\r\n elif type == 'create':\r\n if subtype == 'task':\r\n start_point = request['start_point']\r\n end_point = request['end_point']\r\n keyword = request['keyword']\r\n chars = request['chars']\r\n searchwidth = request['searchwidth']\r\n algorithm = request['algorithm']\r\n tasks.append(Task(start_point,end_point,keyword,chars,searchwidth,algorithm,gen_task_id(tasks)))\r\n return webServer.make_json_status(1, \"Successfully created new task\")\r\n\r\n elif type == 'test':\r\n if subtype == 'post':\r\n return webServer.make_json_status(1, \"Successful\")\r\n\r\n #If correct type cannot be found\r\n return webServer.make_json_status(0, \"Task Failed\")","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self, request): # not possible without serializer\n\n serializer = self.serializer_class(data = request.data)\n\n # Validation\n if serializer.is_valid():\n name = serializer.validated_data.get('name')\n message = f'Hello {name}' \n return Response({'message':message})\n else:\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def msg(self):\n if \"msg\" in self._json:\n return self._json[\"msg\"]\n elif \"detail\" in self._json:\n return self._json[\"detail\"]\n else:\n return self._json","def get_destination_and_message(post_request):\n\n #Your code here\n pass","def post(self):\n send_slack_log('Entered /slack/submit')\n send_slack_log('Request info:')\n send_slack_log(str(request.form))\n if request.form.get('payload') is None:\n send_slack_log('Invalid request: no payload')\n return\n else:\n return handle_interaction(json.loads(request.form['payload']))","def post(self, request):\n serializer = self.serializer_class(data=request.data)\n\n if serializer.is_valid():\n name=serializer.validated_data.get('name')\n message = f'Hello {name}'\n return Response({'message':message})\n else:\n return Response(\n serializer.errors,\n status=status.HTTP_400_BAD_REQUEST\n )","def message(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'message')\r\n return http.Request('GET', url), parsers.parse_json","def post(self):\n return self._post","def post_group_form(self, req, **_kwargs):\n if req.POST:\n res = Response()\n s = self.api.process_group_message(req.json)\n res.text = s if PYTHON3 else unicode(s, \"utf-8\")\n return res\n return Response(status=400) # bad request","def post(self, request):\n pass","def process_post_result(resp):\n resp_json = resp.json()\n if 'message' in resp_json:\n message = resp_json['message']\n print_info(f'{message}.')\n return\n\n raise Exception(f'{response_message(resp_json)}')","def POST(self):\n\t\t\n\t\tjson_data = web.data()\t\t# Get the POST data sent from Webex Teams\n\t\t#print(\"\\nWEBHOOK POST RECEIVED:\")\n\t\t#print(json_data, \"\\n\")\n\n\t\twebhook_obj = Webhook(json_data)\t\t\t\t\t# Create a Webhook object from the JSON data\n\t\troom = api.rooms.get(webhook_obj.data.roomId)\t\t# Get the room details\n\t\tmessage = api.messages.get(webhook_obj.data.id)\t\t# Get the message details\n\n\t\t# Ignore messages bot itself sent\n\t\tif message.personId == me.id:\n\t\t\treturn 'OK'\n\t\telse:\t# Message was sent by someone else; parse message and respond.\n\t\t\tperson = api.people.get(message.personId)\t\t\t# Get the sender's details\n\t\t\t\n\t\t\tprint(\"NEW MESSAGE IN ROOM '{}'\".format(room.title))\n\t\t\tprint(\"FROM '{}'\".format(person.displayName))\n\t\t\tprint(\"MESSAGE '{}'\\n\".format(message.text))\n\n\t\t\t#Test message sent\n\t\t\t#response = 'Message received {}'.format(mention(person.emails[0]))\t\t\n\t\t\t#api.messages.create(room.id, markdown=response)\n\t\t\tactionSelector(api, message, teams)\t\t\t\t#Depending on message defines action to perform\t\t\n\t\t\t\n\t\treturn 'OK'","def post(self, *args, **kwargs):\n return self.handle_post_request()","def post_meter_form(self, req, **_kwargs):\n if req.POST:\n res = Response()\n s = self.api.process_meter_message(req.json)\n res.text = s if PYTHON3 else unicode(s, \"utf-8\")\n return res\n return Response(status=400) # bad request","def post_data(request):\n if is_post(request):\n return request.POST\n return None","def parse_post(request):\n\n fp = StringIO(request.raw_body)\n\n headers = {}\n headers['content-type'] = request.message.get('content-type')\n headers['content-length'] = request.message.get('content-length')\n\n environ = {}\n environ['REQUEST_METHOD'] = request.method\n\n boundary = request.message.get('boundary')\n\n post = cgi.FieldStorage( fp = fp\n , headers = headers\n , outerboundary = boundary\n , environ = environ\n , keep_blank_values = True\n , strict_parsing = False\n )\n\n return post","def sms_ahoy_reply():\n # Start our response\n resp = MessagingResponse()\n if request.method == 'POST':\n msg = request.form['Body']\n joke = re.search(r'(.*)joke(.*)', msg, re.I)\n greet = re.search(r'(.*)[hi|hey|hello](.*)', msg, re.I)\n quote = re.search(r'(.*)quote(.*)', msg, re.I)\n # joke = re.search(r'(.*)joke(.*)', msg, re.I)\n\n if joke: resp.message(\"I wanted to look for my watch but I couldn't find the time!\")\n elif quote: resp.message(\"A great player is the one who makes the game look easy!\")\n elif greet: resp.message(\"Greetings! I am your assistant!\")\n\n # Add a message\n else: resp.message(\"Ahoy! You said, '\" + msg + \"'\")\n print(request.form)\n\n else: resp.message(\"Greetings! I am your assistant!\") \n\n return str(resp)","def post(self,request):\n\n serializer = self.serializer_class(data=request.data)\n\n if serializer.is_valid():\n name = serializer.validated_data.get('name')\n message = f'Hello {name}'\n return Response ({'message': message})\n else:\n return Response(serializer.errors,status = status.HTTP_400_BAD_REQUEST)","def do_POST(self):\r\n self._send_handler_response('POST')","def getMessage():\n return message","def test_receive_telegram_POST(self):\n\n response = self.client.post(\n reverse('transcript:record_telegram'),\n content_type='application/json',\n data='''\n {\n \"update_id\":10000,\n \"message\":{\n \"date\":1441645532,\n \"chat\":{\n \"last_name\":\"Test Lastname\",\n \"id\":1111111,\n \"type\": \"private\",\n \"first_name\":\"Test\",\n \"username\":\"Test\"\n },\n \"message_id\":1365,\n \"from\":{\n \"last_name\":\"Test Lastname\",\n \"id\":1111111,\n \"first_name\":\"Test\",\n \"username\":\"Test\"\n },\n \"text\":\"/start\"\n }\n }''')\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.content, b\"OK\")\n self.assertEqual(Message.objects.count(), 1)","async def post(self):\n await self.handle_request(self.messages_new_api, 1)","def post(self):\n data = request.json\n return analyze_text(data)","def api_sendessage():\n message = request.args.get('message')\n send_lyrics(message)\n # stash_lyrics(message)\n return jsonify(status=\"success\")","def post(self):\n data = request.json\n return save_new_post(data=data)","def post(self):\n user_id = request.json.get('user_id')\n message_id = request.json.get('message_id')\n message_date = request.json.get('message_date')\n person_nmae = request.json.get('person_name')\n message_text = request.json.get('message_text')\n message_url = request.json.get('message_url')\n channel_id = request.json.get('channel_id')\n return post_new_parrot(user_id, user_id, message_id, message_date,\n person_nmae, message_text, message_url, channel_id)","def post(self):\n send_slack_log('Entered /slack/update_msg')\n send_slack_log('Request info:')\n send_slack_log(str(request.form))\n trigger_id = request.form['trigger_id']\n channel_id = request.form['channel_id']\n response = open_form(channel_id,\n trigger_id,\n config['slack_update_form_path'])\n send_slack_log('Response info:')\n send_slack_log(str(response))\n return 'Please enter the updated msg information in the form'","def post(self):\n user_id = request.args.get('user_id')\n firstname = request.args.get('firstname')\n return post_new_etunimi(user_id, firstname=firstname)","def test_post(self):\n return self.doRequest(self.url, method=\"POST\", body=self.input)","def test_set_post(client):\n global get_message\n url = 'http://127.0.0.1:5000/process'\n question = {\n 'message': 'Bonjour, je veux des informations sur la tour Eiffel ?'\n }\n res = requests.post(url, data=question) # POST request question\n get_message = question['message']\n assert res.status_code == 200\n assert get_message == question['message']","def post(self):\n deferred.run(self.request.body)","def render_POST(self, request):","def do_POST(self, request, response):\n # Store data\n self.data = to_str(request.read_data())\n\n # Respond\n if self.error:\n response.send_content(404, 'Not active', 'text/plain')\n\n else:\n response.send_content(200, 'OK', 'text/plain')","def post_contents(self):\r\n return self._post","def manual_json_post():\n form = JSONForm()\n is_dict = None\n dict_error = None\n if request.method == 'POST':\n parsed_dict = json_post_to_dict(form)\n\n if parsed_dict is None:\n dict_error = \"JSON message was improperly formatted.\"\n is_dict = False\n current_app.logger.warning('JSON Form Message '\n 'Exception: %s', dict_error)\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n json_post = Machine.flatten(parsed_dict)\n flattened_accepted_json = Machine.flatten(ACCEPTED_JSON)\n data = Machine.from_json(json_post)\n to_json_data = data.to_json()\n\n if not Machine.is_valid_datetime(json_post):\n dict_error = (\"Missing datetime or Datetime is not \"\n \"in the correct format.\")\n is_dict = False\n current_app.logger.warning('JSON Form Message '\n 'Exception: %s', dict_error)\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n missing_data, invalid_sensors = Machine.invalid_data(\n json_post, flattened_accepted_json)\n\n if len(missing_data) > 0:\n dict_error = (\"Missing data from sensors. \"\n \"A sensor may have been removed from the network. \"\n \"Missing data: \" + str(missing_data))\n is_dict = False\n current_app.logger.warning('JSON Form Message '\n 'Exception: %s', dict_error)\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n if len(invalid_sensors) > 0:\n dict_error = (\"Invalid or extra sensors. \"\n \"A sensor may have been added to the network. \"\n \"Invalid: \" + str(invalid_sensors))\n is_dict = False\n current_app.logger.warning('JSON Form Message '\n 'Exception: %s', dict_error)\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n \"\"\"\n Set datetime key in cache if it doesn't already exist.\n Try to commit it to the database if it wasn't in cache already.\n \"\"\"\n try:\n if cache.get(json_post['datetime']) is None:\n cache.set(json_post['datetime'], to_json_data,\n timeout=current_app.config['REDIS_CACHE_TIMEOUT'])\n try:\n db.session.add(data)\n db.session.commit()\n except sqlalchemy.exc.IntegrityError:\n is_dict = False\n dict_error = (\n \"There was a unique constraint error,\"\n \" this datetime already appears in the database.\")\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n else:\n is_dict = False\n dict_error = (\"The datetime already appears in the cache.\"\n \" There was a unique constraint error.\")\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n except RedisError as e:\n print(e)\n print('Redis port may be closed, the redis server does '\n 'not appear to be running.')\n is_dict = False\n dict_error = (\"Redis port may be closed.\")\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n dict_error = None\n is_dict = True\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)\n\n return render_template('json_post.html',\n form=form,\n is_dict=is_dict,\n error=dict_error)","def _post(self, *args, **kwargs):\n return self._request('post', *args, **kwargs)","def post(self, *args, **kwargs):\n as_text = kwargs.pop('as_text', True)\n kwargs['follow_redirects'] = kwargs.get('follow_redirects', True)\n response = self.app.post(*args, **kwargs)\n if as_text:\n return response.get_data(as_text=True)\n return response","def get_post(self, tg_channel_id, tg_msg_id):\n \n data = {'chat_id' : tg_channel_id,\n 'message_id': tg_msg_id\n }\n result = self._send_data('getMessage', data)\n if result.error:\n print(result.error_info)\n pass\n\n if result.update:\n return result.update","def message(self) -> str:\n return self.fields.get('msg', self.raw_string)","def message_post(self, data, system):\r\n\r\n event_info = dict()\r\n event_info['problem_id'] = self.location_string\r\n event_info['student_id'] = system.anonymous_student_id\r\n event_info['survey_responses'] = data\r\n _ = self.system.service(self, \"i18n\").ugettext\r\n\r\n survey_responses = event_info['survey_responses']\r\n for tag in ['feedback', 'submission_id', 'grader_id', 'score']:\r\n if tag not in survey_responses:\r\n # This is a student_facing_error\r\n return {\r\n 'success': False,\r\n # Translators: 'tag' is one of 'feedback', 'submission_id',\r\n # 'grader_id', or 'score'. They are categories that a student\r\n # responds to when filling out a post-assessment survey\r\n # of his or her grade from an openended problem.\r\n 'msg': _(\"Could not find needed tag {tag_name} in the \"\r\n \"survey responses. Please try submitting \"\r\n \"again.\").format(tag_name=tag)\r\n }\r\n try:\r\n submission_id = int(survey_responses['submission_id'])\r\n grader_id = int(survey_responses['grader_id'])\r\n feedback = str(survey_responses['feedback'].encode('ascii', 'ignore'))\r\n score = int(survey_responses['score'])\r\n except:\r\n # This is a dev_facing_error\r\n error_message = (\r\n \"Could not parse submission id, grader id, \"\r\n \"or feedback from message_post ajax call. \"\r\n \"Here is the message data: {0}\".format(survey_responses)\r\n )\r\n log.exception(error_message)\r\n # This is a student_facing_error\r\n return {\r\n 'success': False,\r\n 'msg': _(\r\n \"There was an error saving your feedback. Please \"\r\n \"contact course staff.\"\r\n )\r\n }\r\n\r\n xqueue = system.get('xqueue')\r\n if xqueue is None:\r\n return {'success': False, 'msg': _(\"Couldn't submit feedback.\")}\r\n qinterface = xqueue['interface']\r\n qtime = datetime.strftime(datetime.now(UTC), xqueue_interface.dateformat)\r\n anonymous_student_id = system.anonymous_student_id\r\n queuekey = xqueue_interface.make_hashkey(str(system.seed) + qtime +\r\n anonymous_student_id +\r\n str(len(self.child_history)))\r\n\r\n xheader = xqueue_interface.make_xheader(\r\n lms_callback_url=xqueue['construct_callback'](),\r\n lms_key=queuekey,\r\n queue_name=self.message_queue_name\r\n )\r\n\r\n student_info = {\r\n 'anonymous_student_id': anonymous_student_id,\r\n 'submission_time': qtime,\r\n }\r\n contents = {\r\n 'feedback': feedback,\r\n 'submission_id': submission_id,\r\n 'grader_id': grader_id,\r\n 'score': score,\r\n 'student_info': json.dumps(student_info),\r\n }\r\n\r\n error, error_message = qinterface.send_to_queue(\r\n header=xheader,\r\n body=json.dumps(contents)\r\n )\r\n\r\n # Convert error to a success value\r\n success = True\r\n message = _(\"Successfully saved your feedback.\")\r\n if error:\r\n success = False\r\n message = _(\"Unable to save your feedback. Please try again later.\")\r\n log.error(\"Unable to send feedback to grader. location: {0}, error_message: {1}\".format(\r\n self.location_string, error_message\r\n ))\r\n else:\r\n self.child_state = self.DONE\r\n\r\n # This is a student_facing_message\r\n return {'success': success, 'msg': message}","def incoming_sms():\n txt = request.form['Body']\n\n # remove leading and trailing white space and make lowercase\n txt = txt.strip()\n txt = txt.lower()\n\n # handle random searches differently than breed searches\n if txt == 'random' or txt == 'dog':\n url = get_dogs.get_random_dog()\n else:\n url = get_dogs.request_breed(txt)\n \n resp = MessagingResponse()\n if url:\n resp.message(url)\n else:\n resp.message(\"Sorry! We couldn't find a dog matching that query. Please try \\\n a more general search term.\")\n return str(resp)","def verify_post_data ( ):\n # check every field is present\n try:\n request.json[ 'source_lang' ]\n request.json[ 'target_lang' ]\n request.json[ 'text' ]\n\n TranslatorApp.verify_rpc_value ( request.json )\n\n except KeyError: # All the values are not present\n # 400 Bad Request\n abort ( 400, \"All mandatory fields are not provided\" )\n except ValueError as err:\n # 422 Unprocessable Entity\n abort ( 422, \"Unprocessable value: {0}\".format ( err.args ) )\n except BadRequest:\n # 400 Bad Request\n abort ( 400, \"Provided values are having malformed syntax\" )","def post(self, *args, **kwargs):\n return self._hit(\"POST\", *args, **kwargs)","def submitPost(self):\n headers, params, proxy = self.getHeaderParamProxyInfo()\n try:\n resp = requests.post(self.FullURL, data=self.PostData, headers=headers, params=params, proxies=proxy, verify=False)\n return str(resp.content)\n except ConnectionError as ce:\n try:\n self.postErrorMessage('[-] Cannot connect to {url}. Server response is {resp} Server error code is {code}'.\n format(url=self.FullURL, resp=ce.message[0], code=ce.message[1][0]))\n except:\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\n except:\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)","def post(self):\n # Step 1: Get posted data by the user\n postedData = request.get_json()\n\n # Step 2: Get the data\n username = postedData[\"username\"]\n password = postedData[\"password\"]\n\n # Step 3: Verify the username and password match\n correct_pw = verifyPw(username, password)\n if not correct_pw:\n retJson = {\n \"status\": 302\n }\n return jsonify(retJson) \n\n # Step 4: Verify user has enough tokens\n tokens = getTokens(username)\n if tokens <= 0:\n retJson = {\n \"status\": 301\n }\n return jsonify(retJson)\n\n # Step 5: Take one token away, retrieve the sentence and return 200 OK\n SELECTION_CRITERIA = {\n \"Username\": username\n }\n UPDATED_DATA = {\n \"Tokens\": tokens - 1\n }\n users.update(SELECTION_CRITERIA,{\"$set\":UPDATED_DATA})\n\n sentence = users.find(SELECTION_CRITERIA)[0][\"Sentence\"]\n\n retJson = {\n \"status\": 200,\n \"message\": sentence\n }\n return jsonify(retJson)","def post(self):\n # by default post is not supported\n return False","def _handle_post_request(self):\n form = cgi.FieldStorage(\n fp=self.rfile,\n headers=self.headers,\n environ={'REQUEST_METHOD': 'POST'})\n\n if self.path == '/URLRequest':\n # First we check, whether the formular has been filled by\n # something behaving like a bot\n if form.has_key('URL'):\n self._send_homepage('<p class=\"warning\">Please check your input</p>')\n return\n else:\n url = form['real_URL'].value if form.has_key('real_URL') else None\n tmp = self._insert_url_to_db(url)\n if tmp:\n try:\n blocked = self._db.is_hash_blocked(tmp)\n if tmp < 0:\n self._send_database_problem()\n return\n elif blocked:\n self._send_blocked_page(blocked[3])\n return\n else:\n self._send_return_page(tmp)\n return\n except YuDatabaseError:\n self._send_database_problem()\n return\n else:\n # There was a general issue with URL\n self._send_homepage('''<p class=\"warning\">Please check your input.</p>''')\n return\n elif self.path == '/ContactUs':\n if form.has_key('URL'):\n # Here we might have a bot who likes to send the webmaster some spam\n # who most likely will be not amused about.\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail NOT sent',\n msg='There was an issue with your request. Are you a bot? '\n '<a href=\"/ContactUs\">Please try again</a>.')\n else:\n try:\n email = form['email'].value\n subj = form['subject'].value\n descr = form['request'].value\n if self._send_mail(subj, descr, email):\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail sent',\n msg=\"Your request has been sent. You will receive an answer soon.\")\n else:\n self._send_internal_server_error()\n return\n except KeyError:\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail NOT sent',\n msg='It appers you did not fill out all needed fields.\\\n <a href=\"/ContactUs\">Please try again</a>.')\n\n elif self.path == '/Show':\n short_url = form['ShortURL'].value if form.has_key('ShortURL') else None\n if short_url != None and short_url.find(\"yaturl.net\") > -1:\n tmp = short_url.rfind(\"/\")\n if tmp > -1 and short_url != \"\":\n tmp = tmp + 1\n short_url = short_url[tmp:]\n if short_url != None and short_url.isalnum():\n try:\n result = self._db.get_link_from_db(short_url)\n except YuDatabaseError:\n self._send_database_problem()\n return\n template_filename = self._get_config_template('showpage')\n if result:\n new_url = '<p><a href=\"%(result)s\">%(result)s</a></p>' % \\\n {'result': result}\n else:\n new_url = '<p class=\"warning\">No URL found for this string. Please double check your\\\n <a href=\"/ShowURL\">input and try again</a></p>'\n\n stats = self._db.get_statistics_for_hash(short_url)\n\n text = read_template(\n template_filename,\n title=SERVER_NAME,\n header=SERVER_NAME,\n msg=new_url,\n stat=stats,\n statspage=\"/stats/\" + short_url)\n else:\n self._send_404()\n return\n\n else:\n self._send_404()\n return\n\n self._send_response(text, 200)","def render_POST(self, request):\n jsonPayload = request.content.read()\n jsonParsed = json.loads(jsonPayload)\n\n if self.explode:\n request.setResponseCode(500)\n return \"sadness for you, today.\"\n\n if jsonParsed[\"Type\"] == \"pre-hook\" and self.pre:\n return self._renderPreHook(request, jsonParsed)\n elif jsonParsed[\"Type\"] == \"post-hook\" and self.post:\n return self._renderPostHook(request, jsonParsed)","def post(self):\n dic = escape.json_decode(self.request.body)\n saveEditor(dic)\n # useful code goes here\n self.write(json.dumps({'status': 'ok', 'sent': dic}))\n self.finish()","def post(self, request):\n serializer = self.serializer_class(data=request.data)\n if serializer.is_valid():\n name = serializer.validated_data.get('name')\n return Response({\"code\": 0, \"result\": f'Hi {name}'})\n\n return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)","def text_reply(msg):\n if msg['Type'] != TEXT:\n # sanitize the text field so that we can assume it always contains string.\n # and this is also to avoid infinite loop during serialization in the persist function\n msg['Text'] = msg['Type']\n\n to_user_id_name = msg['ToUserName']\n from_user_id_name = msg['FromUserName']\n\n if is_my_outgoing_msg(msg):\n handle_outgoing_msg(msg, to_user_id_name)\n else: # this is an incoming message from my friend\n handle_incoming_msg(msg, from_user_id_name)","def _process_message(self, response):\n message = str()\n try:\n message = response.json()\n except (simplejson.JSONDecodeError, ValueError) as e:\n message = response.text\n return message","def create(self, request):\n message = decode(request.data['weirdtext'], request.data['original_words'])\n return JsonResponse({\"ok\": \"Successfully decoded the message\", \"decoded_message\": message})","def post(self):\n self.get_or_post(method='POST')","def post(self):\n data = request.json\n create_ue(data)\n return None, 201","def post(self , request):\r\n serializer = serializers.helloSerializer(data = request.data)\r\n\r\n\r\n # validate the data :\r\n if serializer.is_valid():\r\n name = serializer.data.get('name')\r\n message = 'Hello {0}'.format(name)\r\n\r\n #return message with name in json format ## IN RESPONSE OBJ\r\n return Response({'message': message})\r\n # if data not valid\r\n else:\r\n\r\n # HTTP_400_BAD_REQUEST is standard statues code for bad request\r\n return Response(serializer.errors , status = status.HTTP_400_BAD_REQUEST)","def post(self):\n send_slack_log('Entered /slack/filter_msgs')\n send_slack_log('Request info:')\n send_slack_log(str(request.form))\n trigger_id = request.form['trigger_id']\n channel_id = request.form['channel_id']\n response = open_form(channel_id,\n trigger_id,\n config['slack_filter_form_path'])\n send_slack_log('Response info:')\n send_slack_log(str(response))\n return 'Please enter msgs filtering information in the form'"],"string":"[\n \"def post(self):\\n return write_msg(request.json)\",\n \"def render_POST(self, request):\\n\\t\\tprint request.args[\\\"message\\\"][0]\\n\\t\\tself.jabberClient.sendMessage(request.args[\\\"message\\\"][0])\\n\\t\\treturn ''\",\n \"def post(self):\\n try:\\n msgId = int(request.form['text'])\\n except ValueError:\\n return {\\\"text\\\": \\\"please enter a valid integer as msg Id.\\\"}\\n msg = str(read_msg(msgId))\\n return {\\\"text\\\": msg}\",\n \"def post(self):\\n user = request.form['user_name']\\n text = request.form['text']\\n return {\\\"text\\\": 'msg sent successfully.\\\\ntext:'\\n + text + '\\\\nuser:' + user}\",\n \"def post(self):\\n try:\\n msg_json = json.loads(request.form['text'])\\n except json.decoder.JSONDecodeError:\\n return {\\\"text\\\": \\\"Failed to send msg. Incorrect json format.\\\"}\\n msgId = write_msg(msg_json)\\n responseText = 'successfully created msg ' \\\\\\n 'with id: ' + msgId\\n return {\\\"text\\\": responseText}\",\n \"def input_post(): #TODO, error handling for privacy checks\\n\\n message = request.form['message']\\n page_token = session['page']['access_token']\\n resp = utils.post_message(message, page_token, session['visibility'])\\n return render_template('success.html', post_id = resp['id'])\",\n \"def post_data():\\n return json.loads('{\\\"success\\\":true, \\\"message\\\":\\\"Data created (but not really)\\\" }')\",\n \"def get_message(post_request):\\n lst = ['stripped-text', 'stripped-signature']\\n for value in lst:\\n if value in post_request.POST:\\n return post_request.POST.get(value)\\n\\n return post_request.POST.get('body-plain')\",\n \"def post(self):\\n r = request.get_json()['text']\\n # Recupero dalla richiesta il JSON che mi è stato inviato\\n # e salvo il valore contenuto \\n # sotto la chiave text su una variabile r.\\n # In reguito ritorno r in formato stringa.\\n # In quanto il valore di ritorno deve essere una stringa.\\n return str(r)\",\n \"def post(self):\\n send_slack_log('Entered /slack/post_msg')\\n send_slack_log('Request info:')\\n send_slack_log(str(request.form))\\n # unknown request.form\\n trigger_id = request.form['trigger_id']\\n channel_id = request.form['channel_id']\\n response = open_form(channel_id,\\n trigger_id,\\n config['slack_post_form_path'])\\n send_slack_log('Response info:')\\n send_slack_log(str(response))\\n return 'Please enter the new msg information in the form'\",\n \"def post(self):\\n text = 'HELLO from socnet API Server!'\\n return push_to_mattermost(text)\",\n \"def on_post(self, req, resp):\\n self._set_default_response(resp)\\n\\n string = req.media.get('string')\\n if string is None:\\n resp.body = \\\"\\\"\\\"{ \\\"result\\\": \\\"error: request payload must contain a JSON object with a 'string' attribute\\\" }\\\"\\\"\\\"\\n else:\\n resp.status = falcon.HTTP_200\\n result = \\\"pass\\\" if self._validate(string) else \\\"fail\\\"\\n resp.body = json.dumps({'result': result})\",\n \"def post(self):\\n send_slack_log('Entered /slack/get_msg')\\n send_slack_log('Request info:')\\n send_slack_log(str(request.form))\\n msg_id = request.form['text']\\n channel_id = request.form['channel_id']\\n try:\\n id = int(msg_id)\\n except ValueError:\\n return \\\"Invalid Msg ID: \\\" + str(msg_id)\\n text = read_msg(id)\\n formated_msg = slack_format_msg(text)\\n response = send_json_to_slack_channel(formated_msg, channel_id)\\n send_slack_log('Response info:')\\n send_slack_log(response)\\n return \\\"Msg \\\" + str(id) + \\\" fetched\\\"\",\n \"def post_flow_form(self, req, **_kwargs):\\n if req.POST:\\n res = Response()\\n s = self.api.process_flow_message(req.json)\\n res.text = s if PYTHON3 else unicode(s, \\\"utf-8\\\")\\n return res\\n return Response(status=400) # bad request\",\n \"def post(self):\",\n \"def api_message():\\n\\n if request.headers['Content-Type'] == 'text/plain':\\n # Data sent is stored in request.data\\n return 'Text message: ' + request.data\\n elif request.headers['Content-Type'] == 'application/json':\\n return 'JSON message: ' + json.dumps(request.json)\\n else:\\n return '415 Unsupported Media Type'\",\n \"def essay_post_new():\\n \\n text0 = request.form['text']\\n essay = {}\\n status = 200\\n \\n if (app.debug is True):\\n essay = Flask_process_text(text0) \\n else:\\n try:\\n essay = Flask_process_text(text0) \\n except Exception as e:\\n ## Any unsupported exceptions coming from code\\n ## TODO: get a better error message (not revealing internal error) \\n status = 500\\n essay = { 'error' : { \\n 'status' : status,\\n 'msg' : e.message}}\\n \\n return jsonify(essay) , status\",\n \"def post():\\n pass\",\n \"def get_message():\\n # get params from the POST request\\n # try\\n print(\\\"zeeeeeeeeeeeeeee\\\", request.data.decode())\\n user_id = request.json['user_id']\\n bot_id = request.json['bot_id'] # ex: 5005\\n message = request.json['message']\\n # query the concerned bot\\n bot_url = \\\"http://localhost:\\\" + str(bot_id) + \\\"/webhooks/rest/webhook\\\"\\n params = {\\\"sender\\\": user_id, \\\"message\\\": message}\\n result = http_json_request(params, bot_url)\\n new_msg = \\\"\\\"\\n pile_run = deepcopy(result)\\n while len(pile_run) > 0:\\n msg = pile_run.pop(0)\\n if \\\"buttons\\\" in msg:\\n params[\\\"message\\\"] = msg[\\\"buttons\\\"][0][\\\"payload\\\"]\\n pile_run.extend(http_json_request(params, bot_url))\\n elif \\\"custom\\\" in msg:\\n message += \\\"<{}>\\\\n\\\".format(msg[\\\"custom\\\"][\\\"type\\\"])\\n else:\\n new_msg += \\\"{}\\\\n\\\".format(msg[\\\"text\\\"])\\n return new_msg\\n # except Exception as err:\\n # print(\\\"Erreur dans get_message() :\\\", err)\\n # return \\\"Error\\\"\",\n \"def message():\\n if request.method == 'POST':\\n db.log_msg(request.form['text'], request.cookies.get('username'))\\n return db.get_all_messages()\",\n \"async def render_post(self, request):\\n self._hx711.tare()\\n return Message(code=CHANGED)\",\n \"def post(self, request):\\n serlializer = self.serlializer_class(data=request.data)\\n\\n if serlializer.is_valid():\\n name = serlializer.validated_data.get('name')\\n message = f'Hello {name}'\\n return Response({'message': message})\\n else:\\n return Response(serlializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def post(self):\\n\\n\\t\\treturn MessageStore.create(api.payload), 201\",\n \"def post(self, request):\\n serializer = self.serializer_class(data=request.data)\\n if serializer.is_valid():\\n name = serializer.validated_data.get('name')\\n message = f'Hello {name}'\\n return Response({'Message':message})\\n else:\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def post(self, request):\\n serializer = self.serializer_class(data=request.data) # Retrieves the configured serializer class and passes the content of the POST\\n\\n if serializer.is_valid(): # Checking if the data POSTed as input is valid according to the serializers\\n name = serializer.validated_data.get('name') # Retrieving the name field in the request\\n message = f'Hello {name}'\\n return Response({'message': message})\\n else:\\n return Response(\\n serializer.errors,\\n status=status.HTTP_400_BAD_REQUEST\\n )\",\n \"def post():\\n value = request.form['test']\\n return 'Hello world ' + value\",\n \"def post(self,request):\\n serializer = self.serializer_class(data=request.data)\\n\\n if serializer.is_valid():\\n name = serializer.validated_data.get('name')\\n surname = serializer.validated_data.get('surname')\\n message = f'Hello {name} {surname}'\\n return Response({'message':message})\\n else:\\n return Response(\\n serializer.errors,\\n status = status.HTTP_400_BAD_REQUEST\\n )\",\n \"async def post(request):\\n data = request.text\\n return text(data)\",\n \"def http_method_post():\\n return 'POST'\",\n \"def handle_post_msg(body):\\r\\n request = json.loads(body)\\r\\n type = request['type']\\r\\n subtype = request['subtype']\\r\\n if type == 'get':\\r\\n if subtype == 'job':\\r\\n job = {'job':get_next_job()}\\r\\n return webServer.add_json_successfull_status(job)\\r\\n elif subtype == 'tasks':\\r\\n res = []\\r\\n for task in tasks:\\r\\n res.append(task.get_task())\\r\\n res = {'tasks':res}\\r\\n return webServer.add_json_successfull_status(res)\\r\\n\\r\\n elif type == 'post':\\r\\n if subtype == 'result':\\r\\n start_point = request['start_point']\\r\\n end_point = request['end_point']\\r\\n found_keyword_bool = request['found_keyword_bool']\\r\\n keyword_found = request['keyword_found']\\r\\n task_id = request['task_id']\\r\\n if found_keyword_bool:\\r\\n for task in tasks:\\r\\n if task.id == task_id:\\r\\n task.set_finished()\\r\\n task.keyword_found = keyword_found\\r\\n return webServer.make_json_status(1, \\\"Result delivered successfully\\\")\\r\\n return webServer.make_json_status(0, \\\"Couldn't find task\\\")\\r\\n\\r\\n elif type == 'create':\\r\\n if subtype == 'task':\\r\\n start_point = request['start_point']\\r\\n end_point = request['end_point']\\r\\n keyword = request['keyword']\\r\\n chars = request['chars']\\r\\n searchwidth = request['searchwidth']\\r\\n algorithm = request['algorithm']\\r\\n tasks.append(Task(start_point,end_point,keyword,chars,searchwidth,algorithm,gen_task_id(tasks)))\\r\\n return webServer.make_json_status(1, \\\"Successfully created new task\\\")\\r\\n\\r\\n elif type == 'test':\\r\\n if subtype == 'post':\\r\\n return webServer.make_json_status(1, \\\"Successful\\\")\\r\\n\\r\\n #If correct type cannot be found\\r\\n return webServer.make_json_status(0, \\\"Task Failed\\\")\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self, request): # not possible without serializer\\n\\n serializer = self.serializer_class(data = request.data)\\n\\n # Validation\\n if serializer.is_valid():\\n name = serializer.validated_data.get('name')\\n message = f'Hello {name}' \\n return Response({'message':message})\\n else:\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def msg(self):\\n if \\\"msg\\\" in self._json:\\n return self._json[\\\"msg\\\"]\\n elif \\\"detail\\\" in self._json:\\n return self._json[\\\"detail\\\"]\\n else:\\n return self._json\",\n \"def get_destination_and_message(post_request):\\n\\n #Your code here\\n pass\",\n \"def post(self):\\n send_slack_log('Entered /slack/submit')\\n send_slack_log('Request info:')\\n send_slack_log(str(request.form))\\n if request.form.get('payload') is None:\\n send_slack_log('Invalid request: no payload')\\n return\\n else:\\n return handle_interaction(json.loads(request.form['payload']))\",\n \"def post(self, request):\\n serializer = self.serializer_class(data=request.data)\\n\\n if serializer.is_valid():\\n name=serializer.validated_data.get('name')\\n message = f'Hello {name}'\\n return Response({'message':message})\\n else:\\n return Response(\\n serializer.errors,\\n status=status.HTTP_400_BAD_REQUEST\\n )\",\n \"def message(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'message')\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def post(self):\\n return self._post\",\n \"def post_group_form(self, req, **_kwargs):\\n if req.POST:\\n res = Response()\\n s = self.api.process_group_message(req.json)\\n res.text = s if PYTHON3 else unicode(s, \\\"utf-8\\\")\\n return res\\n return Response(status=400) # bad request\",\n \"def post(self, request):\\n pass\",\n \"def process_post_result(resp):\\n resp_json = resp.json()\\n if 'message' in resp_json:\\n message = resp_json['message']\\n print_info(f'{message}.')\\n return\\n\\n raise Exception(f'{response_message(resp_json)}')\",\n \"def POST(self):\\n\\t\\t\\n\\t\\tjson_data = web.data()\\t\\t# Get the POST data sent from Webex Teams\\n\\t\\t#print(\\\"\\\\nWEBHOOK POST RECEIVED:\\\")\\n\\t\\t#print(json_data, \\\"\\\\n\\\")\\n\\n\\t\\twebhook_obj = Webhook(json_data)\\t\\t\\t\\t\\t# Create a Webhook object from the JSON data\\n\\t\\troom = api.rooms.get(webhook_obj.data.roomId)\\t\\t# Get the room details\\n\\t\\tmessage = api.messages.get(webhook_obj.data.id)\\t\\t# Get the message details\\n\\n\\t\\t# Ignore messages bot itself sent\\n\\t\\tif message.personId == me.id:\\n\\t\\t\\treturn 'OK'\\n\\t\\telse:\\t# Message was sent by someone else; parse message and respond.\\n\\t\\t\\tperson = api.people.get(message.personId)\\t\\t\\t# Get the sender's details\\n\\t\\t\\t\\n\\t\\t\\tprint(\\\"NEW MESSAGE IN ROOM '{}'\\\".format(room.title))\\n\\t\\t\\tprint(\\\"FROM '{}'\\\".format(person.displayName))\\n\\t\\t\\tprint(\\\"MESSAGE '{}'\\\\n\\\".format(message.text))\\n\\n\\t\\t\\t#Test message sent\\n\\t\\t\\t#response = 'Message received {}'.format(mention(person.emails[0]))\\t\\t\\n\\t\\t\\t#api.messages.create(room.id, markdown=response)\\n\\t\\t\\tactionSelector(api, message, teams)\\t\\t\\t\\t#Depending on message defines action to perform\\t\\t\\n\\t\\t\\t\\n\\t\\treturn 'OK'\",\n \"def post(self, *args, **kwargs):\\n return self.handle_post_request()\",\n \"def post_meter_form(self, req, **_kwargs):\\n if req.POST:\\n res = Response()\\n s = self.api.process_meter_message(req.json)\\n res.text = s if PYTHON3 else unicode(s, \\\"utf-8\\\")\\n return res\\n return Response(status=400) # bad request\",\n \"def post_data(request):\\n if is_post(request):\\n return request.POST\\n return None\",\n \"def parse_post(request):\\n\\n fp = StringIO(request.raw_body)\\n\\n headers = {}\\n headers['content-type'] = request.message.get('content-type')\\n headers['content-length'] = request.message.get('content-length')\\n\\n environ = {}\\n environ['REQUEST_METHOD'] = request.method\\n\\n boundary = request.message.get('boundary')\\n\\n post = cgi.FieldStorage( fp = fp\\n , headers = headers\\n , outerboundary = boundary\\n , environ = environ\\n , keep_blank_values = True\\n , strict_parsing = False\\n )\\n\\n return post\",\n \"def sms_ahoy_reply():\\n # Start our response\\n resp = MessagingResponse()\\n if request.method == 'POST':\\n msg = request.form['Body']\\n joke = re.search(r'(.*)joke(.*)', msg, re.I)\\n greet = re.search(r'(.*)[hi|hey|hello](.*)', msg, re.I)\\n quote = re.search(r'(.*)quote(.*)', msg, re.I)\\n # joke = re.search(r'(.*)joke(.*)', msg, re.I)\\n\\n if joke: resp.message(\\\"I wanted to look for my watch but I couldn't find the time!\\\")\\n elif quote: resp.message(\\\"A great player is the one who makes the game look easy!\\\")\\n elif greet: resp.message(\\\"Greetings! I am your assistant!\\\")\\n\\n # Add a message\\n else: resp.message(\\\"Ahoy! You said, '\\\" + msg + \\\"'\\\")\\n print(request.form)\\n\\n else: resp.message(\\\"Greetings! I am your assistant!\\\") \\n\\n return str(resp)\",\n \"def post(self,request):\\n\\n serializer = self.serializer_class(data=request.data)\\n\\n if serializer.is_valid():\\n name = serializer.validated_data.get('name')\\n message = f'Hello {name}'\\n return Response ({'message': message})\\n else:\\n return Response(serializer.errors,status = status.HTTP_400_BAD_REQUEST)\",\n \"def do_POST(self):\\r\\n self._send_handler_response('POST')\",\n \"def getMessage():\\n return message\",\n \"def test_receive_telegram_POST(self):\\n\\n response = self.client.post(\\n reverse('transcript:record_telegram'),\\n content_type='application/json',\\n data='''\\n {\\n \\\"update_id\\\":10000,\\n \\\"message\\\":{\\n \\\"date\\\":1441645532,\\n \\\"chat\\\":{\\n \\\"last_name\\\":\\\"Test Lastname\\\",\\n \\\"id\\\":1111111,\\n \\\"type\\\": \\\"private\\\",\\n \\\"first_name\\\":\\\"Test\\\",\\n \\\"username\\\":\\\"Test\\\"\\n },\\n \\\"message_id\\\":1365,\\n \\\"from\\\":{\\n \\\"last_name\\\":\\\"Test Lastname\\\",\\n \\\"id\\\":1111111,\\n \\\"first_name\\\":\\\"Test\\\",\\n \\\"username\\\":\\\"Test\\\"\\n },\\n \\\"text\\\":\\\"/start\\\"\\n }\\n }''')\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.content, b\\\"OK\\\")\\n self.assertEqual(Message.objects.count(), 1)\",\n \"async def post(self):\\n await self.handle_request(self.messages_new_api, 1)\",\n \"def post(self):\\n data = request.json\\n return analyze_text(data)\",\n \"def api_sendessage():\\n message = request.args.get('message')\\n send_lyrics(message)\\n # stash_lyrics(message)\\n return jsonify(status=\\\"success\\\")\",\n \"def post(self):\\n data = request.json\\n return save_new_post(data=data)\",\n \"def post(self):\\n user_id = request.json.get('user_id')\\n message_id = request.json.get('message_id')\\n message_date = request.json.get('message_date')\\n person_nmae = request.json.get('person_name')\\n message_text = request.json.get('message_text')\\n message_url = request.json.get('message_url')\\n channel_id = request.json.get('channel_id')\\n return post_new_parrot(user_id, user_id, message_id, message_date,\\n person_nmae, message_text, message_url, channel_id)\",\n \"def post(self):\\n send_slack_log('Entered /slack/update_msg')\\n send_slack_log('Request info:')\\n send_slack_log(str(request.form))\\n trigger_id = request.form['trigger_id']\\n channel_id = request.form['channel_id']\\n response = open_form(channel_id,\\n trigger_id,\\n config['slack_update_form_path'])\\n send_slack_log('Response info:')\\n send_slack_log(str(response))\\n return 'Please enter the updated msg information in the form'\",\n \"def post(self):\\n user_id = request.args.get('user_id')\\n firstname = request.args.get('firstname')\\n return post_new_etunimi(user_id, firstname=firstname)\",\n \"def test_post(self):\\n return self.doRequest(self.url, method=\\\"POST\\\", body=self.input)\",\n \"def test_set_post(client):\\n global get_message\\n url = 'http://127.0.0.1:5000/process'\\n question = {\\n 'message': 'Bonjour, je veux des informations sur la tour Eiffel ?'\\n }\\n res = requests.post(url, data=question) # POST request question\\n get_message = question['message']\\n assert res.status_code == 200\\n assert get_message == question['message']\",\n \"def post(self):\\n deferred.run(self.request.body)\",\n \"def render_POST(self, request):\",\n \"def do_POST(self, request, response):\\n # Store data\\n self.data = to_str(request.read_data())\\n\\n # Respond\\n if self.error:\\n response.send_content(404, 'Not active', 'text/plain')\\n\\n else:\\n response.send_content(200, 'OK', 'text/plain')\",\n \"def post_contents(self):\\r\\n return self._post\",\n \"def manual_json_post():\\n form = JSONForm()\\n is_dict = None\\n dict_error = None\\n if request.method == 'POST':\\n parsed_dict = json_post_to_dict(form)\\n\\n if parsed_dict is None:\\n dict_error = \\\"JSON message was improperly formatted.\\\"\\n is_dict = False\\n current_app.logger.warning('JSON Form Message '\\n 'Exception: %s', dict_error)\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n json_post = Machine.flatten(parsed_dict)\\n flattened_accepted_json = Machine.flatten(ACCEPTED_JSON)\\n data = Machine.from_json(json_post)\\n to_json_data = data.to_json()\\n\\n if not Machine.is_valid_datetime(json_post):\\n dict_error = (\\\"Missing datetime or Datetime is not \\\"\\n \\\"in the correct format.\\\")\\n is_dict = False\\n current_app.logger.warning('JSON Form Message '\\n 'Exception: %s', dict_error)\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n missing_data, invalid_sensors = Machine.invalid_data(\\n json_post, flattened_accepted_json)\\n\\n if len(missing_data) > 0:\\n dict_error = (\\\"Missing data from sensors. \\\"\\n \\\"A sensor may have been removed from the network. \\\"\\n \\\"Missing data: \\\" + str(missing_data))\\n is_dict = False\\n current_app.logger.warning('JSON Form Message '\\n 'Exception: %s', dict_error)\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n if len(invalid_sensors) > 0:\\n dict_error = (\\\"Invalid or extra sensors. \\\"\\n \\\"A sensor may have been added to the network. \\\"\\n \\\"Invalid: \\\" + str(invalid_sensors))\\n is_dict = False\\n current_app.logger.warning('JSON Form Message '\\n 'Exception: %s', dict_error)\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n \\\"\\\"\\\"\\n Set datetime key in cache if it doesn't already exist.\\n Try to commit it to the database if it wasn't in cache already.\\n \\\"\\\"\\\"\\n try:\\n if cache.get(json_post['datetime']) is None:\\n cache.set(json_post['datetime'], to_json_data,\\n timeout=current_app.config['REDIS_CACHE_TIMEOUT'])\\n try:\\n db.session.add(data)\\n db.session.commit()\\n except sqlalchemy.exc.IntegrityError:\\n is_dict = False\\n dict_error = (\\n \\\"There was a unique constraint error,\\\"\\n \\\" this datetime already appears in the database.\\\")\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n else:\\n is_dict = False\\n dict_error = (\\\"The datetime already appears in the cache.\\\"\\n \\\" There was a unique constraint error.\\\")\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n except RedisError as e:\\n print(e)\\n print('Redis port may be closed, the redis server does '\\n 'not appear to be running.')\\n is_dict = False\\n dict_error = (\\\"Redis port may be closed.\\\")\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n dict_error = None\\n is_dict = True\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\\n\\n return render_template('json_post.html',\\n form=form,\\n is_dict=is_dict,\\n error=dict_error)\",\n \"def _post(self, *args, **kwargs):\\n return self._request('post', *args, **kwargs)\",\n \"def post(self, *args, **kwargs):\\n as_text = kwargs.pop('as_text', True)\\n kwargs['follow_redirects'] = kwargs.get('follow_redirects', True)\\n response = self.app.post(*args, **kwargs)\\n if as_text:\\n return response.get_data(as_text=True)\\n return response\",\n \"def get_post(self, tg_channel_id, tg_msg_id):\\n \\n data = {'chat_id' : tg_channel_id,\\n 'message_id': tg_msg_id\\n }\\n result = self._send_data('getMessage', data)\\n if result.error:\\n print(result.error_info)\\n pass\\n\\n if result.update:\\n return result.update\",\n \"def message(self) -> str:\\n return self.fields.get('msg', self.raw_string)\",\n \"def message_post(self, data, system):\\r\\n\\r\\n event_info = dict()\\r\\n event_info['problem_id'] = self.location_string\\r\\n event_info['student_id'] = system.anonymous_student_id\\r\\n event_info['survey_responses'] = data\\r\\n _ = self.system.service(self, \\\"i18n\\\").ugettext\\r\\n\\r\\n survey_responses = event_info['survey_responses']\\r\\n for tag in ['feedback', 'submission_id', 'grader_id', 'score']:\\r\\n if tag not in survey_responses:\\r\\n # This is a student_facing_error\\r\\n return {\\r\\n 'success': False,\\r\\n # Translators: 'tag' is one of 'feedback', 'submission_id',\\r\\n # 'grader_id', or 'score'. They are categories that a student\\r\\n # responds to when filling out a post-assessment survey\\r\\n # of his or her grade from an openended problem.\\r\\n 'msg': _(\\\"Could not find needed tag {tag_name} in the \\\"\\r\\n \\\"survey responses. Please try submitting \\\"\\r\\n \\\"again.\\\").format(tag_name=tag)\\r\\n }\\r\\n try:\\r\\n submission_id = int(survey_responses['submission_id'])\\r\\n grader_id = int(survey_responses['grader_id'])\\r\\n feedback = str(survey_responses['feedback'].encode('ascii', 'ignore'))\\r\\n score = int(survey_responses['score'])\\r\\n except:\\r\\n # This is a dev_facing_error\\r\\n error_message = (\\r\\n \\\"Could not parse submission id, grader id, \\\"\\r\\n \\\"or feedback from message_post ajax call. \\\"\\r\\n \\\"Here is the message data: {0}\\\".format(survey_responses)\\r\\n )\\r\\n log.exception(error_message)\\r\\n # This is a student_facing_error\\r\\n return {\\r\\n 'success': False,\\r\\n 'msg': _(\\r\\n \\\"There was an error saving your feedback. Please \\\"\\r\\n \\\"contact course staff.\\\"\\r\\n )\\r\\n }\\r\\n\\r\\n xqueue = system.get('xqueue')\\r\\n if xqueue is None:\\r\\n return {'success': False, 'msg': _(\\\"Couldn't submit feedback.\\\")}\\r\\n qinterface = xqueue['interface']\\r\\n qtime = datetime.strftime(datetime.now(UTC), xqueue_interface.dateformat)\\r\\n anonymous_student_id = system.anonymous_student_id\\r\\n queuekey = xqueue_interface.make_hashkey(str(system.seed) + qtime +\\r\\n anonymous_student_id +\\r\\n str(len(self.child_history)))\\r\\n\\r\\n xheader = xqueue_interface.make_xheader(\\r\\n lms_callback_url=xqueue['construct_callback'](),\\r\\n lms_key=queuekey,\\r\\n queue_name=self.message_queue_name\\r\\n )\\r\\n\\r\\n student_info = {\\r\\n 'anonymous_student_id': anonymous_student_id,\\r\\n 'submission_time': qtime,\\r\\n }\\r\\n contents = {\\r\\n 'feedback': feedback,\\r\\n 'submission_id': submission_id,\\r\\n 'grader_id': grader_id,\\r\\n 'score': score,\\r\\n 'student_info': json.dumps(student_info),\\r\\n }\\r\\n\\r\\n error, error_message = qinterface.send_to_queue(\\r\\n header=xheader,\\r\\n body=json.dumps(contents)\\r\\n )\\r\\n\\r\\n # Convert error to a success value\\r\\n success = True\\r\\n message = _(\\\"Successfully saved your feedback.\\\")\\r\\n if error:\\r\\n success = False\\r\\n message = _(\\\"Unable to save your feedback. Please try again later.\\\")\\r\\n log.error(\\\"Unable to send feedback to grader. location: {0}, error_message: {1}\\\".format(\\r\\n self.location_string, error_message\\r\\n ))\\r\\n else:\\r\\n self.child_state = self.DONE\\r\\n\\r\\n # This is a student_facing_message\\r\\n return {'success': success, 'msg': message}\",\n \"def incoming_sms():\\n txt = request.form['Body']\\n\\n # remove leading and trailing white space and make lowercase\\n txt = txt.strip()\\n txt = txt.lower()\\n\\n # handle random searches differently than breed searches\\n if txt == 'random' or txt == 'dog':\\n url = get_dogs.get_random_dog()\\n else:\\n url = get_dogs.request_breed(txt)\\n \\n resp = MessagingResponse()\\n if url:\\n resp.message(url)\\n else:\\n resp.message(\\\"Sorry! We couldn't find a dog matching that query. Please try \\\\\\n a more general search term.\\\")\\n return str(resp)\",\n \"def verify_post_data ( ):\\n # check every field is present\\n try:\\n request.json[ 'source_lang' ]\\n request.json[ 'target_lang' ]\\n request.json[ 'text' ]\\n\\n TranslatorApp.verify_rpc_value ( request.json )\\n\\n except KeyError: # All the values are not present\\n # 400 Bad Request\\n abort ( 400, \\\"All mandatory fields are not provided\\\" )\\n except ValueError as err:\\n # 422 Unprocessable Entity\\n abort ( 422, \\\"Unprocessable value: {0}\\\".format ( err.args ) )\\n except BadRequest:\\n # 400 Bad Request\\n abort ( 400, \\\"Provided values are having malformed syntax\\\" )\",\n \"def post(self, *args, **kwargs):\\n return self._hit(\\\"POST\\\", *args, **kwargs)\",\n \"def submitPost(self):\\n headers, params, proxy = self.getHeaderParamProxyInfo()\\n try:\\n resp = requests.post(self.FullURL, data=self.PostData, headers=headers, params=params, proxies=proxy, verify=False)\\n return str(resp.content)\\n except ConnectionError as ce:\\n try:\\n self.postErrorMessage('[-] Cannot connect to {url}. Server response is {resp} Server error code is {code}'.\\n format(url=self.FullURL, resp=ce.message[0], code=ce.message[1][0]))\\n except:\\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\\n except:\\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\",\n \"def post(self):\\n # Step 1: Get posted data by the user\\n postedData = request.get_json()\\n\\n # Step 2: Get the data\\n username = postedData[\\\"username\\\"]\\n password = postedData[\\\"password\\\"]\\n\\n # Step 3: Verify the username and password match\\n correct_pw = verifyPw(username, password)\\n if not correct_pw:\\n retJson = {\\n \\\"status\\\": 302\\n }\\n return jsonify(retJson) \\n\\n # Step 4: Verify user has enough tokens\\n tokens = getTokens(username)\\n if tokens <= 0:\\n retJson = {\\n \\\"status\\\": 301\\n }\\n return jsonify(retJson)\\n\\n # Step 5: Take one token away, retrieve the sentence and return 200 OK\\n SELECTION_CRITERIA = {\\n \\\"Username\\\": username\\n }\\n UPDATED_DATA = {\\n \\\"Tokens\\\": tokens - 1\\n }\\n users.update(SELECTION_CRITERIA,{\\\"$set\\\":UPDATED_DATA})\\n\\n sentence = users.find(SELECTION_CRITERIA)[0][\\\"Sentence\\\"]\\n\\n retJson = {\\n \\\"status\\\": 200,\\n \\\"message\\\": sentence\\n }\\n return jsonify(retJson)\",\n \"def post(self):\\n # by default post is not supported\\n return False\",\n \"def _handle_post_request(self):\\n form = cgi.FieldStorage(\\n fp=self.rfile,\\n headers=self.headers,\\n environ={'REQUEST_METHOD': 'POST'})\\n\\n if self.path == '/URLRequest':\\n # First we check, whether the formular has been filled by\\n # something behaving like a bot\\n if form.has_key('URL'):\\n self._send_homepage('<p class=\\\"warning\\\">Please check your input</p>')\\n return\\n else:\\n url = form['real_URL'].value if form.has_key('real_URL') else None\\n tmp = self._insert_url_to_db(url)\\n if tmp:\\n try:\\n blocked = self._db.is_hash_blocked(tmp)\\n if tmp < 0:\\n self._send_database_problem()\\n return\\n elif blocked:\\n self._send_blocked_page(blocked[3])\\n return\\n else:\\n self._send_return_page(tmp)\\n return\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n else:\\n # There was a general issue with URL\\n self._send_homepage('''<p class=\\\"warning\\\">Please check your input.</p>''')\\n return\\n elif self.path == '/ContactUs':\\n if form.has_key('URL'):\\n # Here we might have a bot who likes to send the webmaster some spam\\n # who most likely will be not amused about.\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail NOT sent',\\n msg='There was an issue with your request. Are you a bot? '\\n '<a href=\\\"/ContactUs\\\">Please try again</a>.')\\n else:\\n try:\\n email = form['email'].value\\n subj = form['subject'].value\\n descr = form['request'].value\\n if self._send_mail(subj, descr, email):\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail sent',\\n msg=\\\"Your request has been sent. You will receive an answer soon.\\\")\\n else:\\n self._send_internal_server_error()\\n return\\n except KeyError:\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail NOT sent',\\n msg='It appers you did not fill out all needed fields.\\\\\\n <a href=\\\"/ContactUs\\\">Please try again</a>.')\\n\\n elif self.path == '/Show':\\n short_url = form['ShortURL'].value if form.has_key('ShortURL') else None\\n if short_url != None and short_url.find(\\\"yaturl.net\\\") > -1:\\n tmp = short_url.rfind(\\\"/\\\")\\n if tmp > -1 and short_url != \\\"\\\":\\n tmp = tmp + 1\\n short_url = short_url[tmp:]\\n if short_url != None and short_url.isalnum():\\n try:\\n result = self._db.get_link_from_db(short_url)\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n template_filename = self._get_config_template('showpage')\\n if result:\\n new_url = '<p><a href=\\\"%(result)s\\\">%(result)s</a></p>' % \\\\\\n {'result': result}\\n else:\\n new_url = '<p class=\\\"warning\\\">No URL found for this string. Please double check your\\\\\\n <a href=\\\"/ShowURL\\\">input and try again</a></p>'\\n\\n stats = self._db.get_statistics_for_hash(short_url)\\n\\n text = read_template(\\n template_filename,\\n title=SERVER_NAME,\\n header=SERVER_NAME,\\n msg=new_url,\\n stat=stats,\\n statspage=\\\"/stats/\\\" + short_url)\\n else:\\n self._send_404()\\n return\\n\\n else:\\n self._send_404()\\n return\\n\\n self._send_response(text, 200)\",\n \"def render_POST(self, request):\\n jsonPayload = request.content.read()\\n jsonParsed = json.loads(jsonPayload)\\n\\n if self.explode:\\n request.setResponseCode(500)\\n return \\\"sadness for you, today.\\\"\\n\\n if jsonParsed[\\\"Type\\\"] == \\\"pre-hook\\\" and self.pre:\\n return self._renderPreHook(request, jsonParsed)\\n elif jsonParsed[\\\"Type\\\"] == \\\"post-hook\\\" and self.post:\\n return self._renderPostHook(request, jsonParsed)\",\n \"def post(self):\\n dic = escape.json_decode(self.request.body)\\n saveEditor(dic)\\n # useful code goes here\\n self.write(json.dumps({'status': 'ok', 'sent': dic}))\\n self.finish()\",\n \"def post(self, request):\\n serializer = self.serializer_class(data=request.data)\\n if serializer.is_valid():\\n name = serializer.validated_data.get('name')\\n return Response({\\\"code\\\": 0, \\\"result\\\": f'Hi {name}'})\\n\\n return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)\",\n \"def text_reply(msg):\\n if msg['Type'] != TEXT:\\n # sanitize the text field so that we can assume it always contains string.\\n # and this is also to avoid infinite loop during serialization in the persist function\\n msg['Text'] = msg['Type']\\n\\n to_user_id_name = msg['ToUserName']\\n from_user_id_name = msg['FromUserName']\\n\\n if is_my_outgoing_msg(msg):\\n handle_outgoing_msg(msg, to_user_id_name)\\n else: # this is an incoming message from my friend\\n handle_incoming_msg(msg, from_user_id_name)\",\n \"def _process_message(self, response):\\n message = str()\\n try:\\n message = response.json()\\n except (simplejson.JSONDecodeError, ValueError) as e:\\n message = response.text\\n return message\",\n \"def create(self, request):\\n message = decode(request.data['weirdtext'], request.data['original_words'])\\n return JsonResponse({\\\"ok\\\": \\\"Successfully decoded the message\\\", \\\"decoded_message\\\": message})\",\n \"def post(self):\\n self.get_or_post(method='POST')\",\n \"def post(self):\\n data = request.json\\n create_ue(data)\\n return None, 201\",\n \"def post(self , request):\\r\\n serializer = serializers.helloSerializer(data = request.data)\\r\\n\\r\\n\\r\\n # validate the data :\\r\\n if serializer.is_valid():\\r\\n name = serializer.data.get('name')\\r\\n message = 'Hello {0}'.format(name)\\r\\n\\r\\n #return message with name in json format ## IN RESPONSE OBJ\\r\\n return Response({'message': message})\\r\\n # if data not valid\\r\\n else:\\r\\n\\r\\n # HTTP_400_BAD_REQUEST is standard statues code for bad request\\r\\n return Response(serializer.errors , status = status.HTTP_400_BAD_REQUEST)\",\n \"def post(self):\\n send_slack_log('Entered /slack/filter_msgs')\\n send_slack_log('Request info:')\\n send_slack_log(str(request.form))\\n trigger_id = request.form['trigger_id']\\n channel_id = request.form['channel_id']\\n response = open_form(channel_id,\\n trigger_id,\\n config['slack_filter_form_path'])\\n send_slack_log('Response info:')\\n send_slack_log(str(response))\\n return 'Please enter msgs filtering information in the form'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.700399","0.69622856","0.6937624","0.690975","0.6692679","0.6602576","0.64796257","0.6373835","0.63503146","0.63502765","0.6258975","0.62196815","0.6202336","0.61453116","0.61423415","0.6071141","0.60104567","0.60015494","0.5992528","0.5970044","0.5967731","0.5951863","0.59493035","0.59403354","0.5931459","0.5921817","0.59145224","0.5912737","0.5890504","0.5887369","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58546734","0.58439183","0.5834118","0.58260095","0.5823888","0.57710636","0.5770315","0.5754752","0.57426614","0.5742156","0.5740482","0.5739127","0.57380575","0.572896","0.5700796","0.569797","0.5692415","0.56834215","0.5668115","0.5668071","0.5661378","0.5655943","0.562513","0.56065506","0.5593329","0.5580056","0.55743575","0.557046","0.55655575","0.5550535","0.5541061","0.5540184","0.552661","0.5515398","0.5508119","0.5501866","0.54957676","0.5494823","0.54905295","0.5465804","0.5462217","0.54512304","0.5443969","0.5432976","0.5413713","0.5411172","0.5410275","0.54074645","0.5404004","0.5401242","0.54005635","0.53993","0.5395079","0.5380561","0.5379306","0.5364726","0.53641737"],"string":"[\n \"0.700399\",\n \"0.69622856\",\n \"0.6937624\",\n \"0.690975\",\n \"0.6692679\",\n \"0.6602576\",\n \"0.64796257\",\n \"0.6373835\",\n \"0.63503146\",\n \"0.63502765\",\n \"0.6258975\",\n \"0.62196815\",\n \"0.6202336\",\n \"0.61453116\",\n \"0.61423415\",\n \"0.6071141\",\n \"0.60104567\",\n \"0.60015494\",\n \"0.5992528\",\n \"0.5970044\",\n \"0.5967731\",\n \"0.5951863\",\n \"0.59493035\",\n \"0.59403354\",\n \"0.5931459\",\n \"0.5921817\",\n \"0.59145224\",\n \"0.5912737\",\n \"0.5890504\",\n \"0.5887369\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58546734\",\n \"0.58439183\",\n \"0.5834118\",\n \"0.58260095\",\n \"0.5823888\",\n \"0.57710636\",\n \"0.5770315\",\n \"0.5754752\",\n \"0.57426614\",\n \"0.5742156\",\n \"0.5740482\",\n \"0.5739127\",\n \"0.57380575\",\n \"0.572896\",\n \"0.5700796\",\n \"0.569797\",\n \"0.5692415\",\n \"0.56834215\",\n \"0.5668115\",\n \"0.5668071\",\n \"0.5661378\",\n \"0.5655943\",\n \"0.562513\",\n \"0.56065506\",\n \"0.5593329\",\n \"0.5580056\",\n \"0.55743575\",\n \"0.557046\",\n \"0.55655575\",\n \"0.5550535\",\n \"0.5541061\",\n \"0.5540184\",\n \"0.552661\",\n \"0.5515398\",\n \"0.5508119\",\n \"0.5501866\",\n \"0.54957676\",\n \"0.5494823\",\n \"0.54905295\",\n \"0.5465804\",\n \"0.5462217\",\n \"0.54512304\",\n \"0.5443969\",\n \"0.5432976\",\n \"0.5413713\",\n \"0.5411172\",\n \"0.5410275\",\n \"0.54074645\",\n \"0.5404004\",\n \"0.5401242\",\n \"0.54005635\",\n \"0.53993\",\n \"0.5395079\",\n \"0.5380561\",\n \"0.5379306\",\n \"0.5364726\",\n \"0.53641737\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57780945"},"document_rank":{"kind":"string","value":"48"}}},{"rowIdx":20276,"cells":{"query":{"kind":"string","value":"Fit the linear regression coefficients. This function will solve a linear regression with Gaussian priors on the coefficients."},"document":{"kind":"string","value":"def _fit_coefficients(\n self, cadence_mask=None, prior_mu=None, prior_sigma=None, propagate_errors=False\n ):\n\n # If prior_mu is specified, prior_sigma must be specified\n if not ((prior_mu is None) & (prior_sigma is None)) | (\n (prior_mu is not None) & (prior_sigma is not None)\n ):\n raise ValueError(\"Please specify both `prior_mu` and `prior_sigma`\")\n\n # Default cadence mask\n if cadence_mask is None:\n cadence_mask = np.ones(len(self.lc.flux.value), bool)\n\n # If flux errors are not all finite numbers, then default to array of ones\n if np.all(~np.isfinite(self.lc.flux_err.value)):\n flux_err = np.ones(cadence_mask.sum())\n else:\n flux_err = self.lc.flux_err.value[cadence_mask]\n\n # Retrieve the design matrix (X) as a numpy array\n X = self.dmc.X[cadence_mask]\n if isinstance(X, np.ndarray):\n # Compute `X^T cov^-1 X + 1/prior_sigma^2`\n sigma_w_inv = X.T.dot(X / flux_err[:, None] ** 2)\n # Compute `X^T cov^-1 y + prior_mu/prior_sigma^2`\n B = np.dot(X.T, self.lc.flux.value[cadence_mask] / flux_err ** 2)\n\n elif issparse(X):\n sigma_f_inv = csr_matrix(1 / flux_err[:, None] ** 2)\n # Compute `X^T cov^-1 X + 1/prior_sigma^2`\n sigma_w_inv = X.T.dot(X.multiply(sigma_f_inv))\n # Compute `X^T cov^-1 y + prior_mu/prior_sigma^2`\n B = X.T.dot((self.lc.flux[cadence_mask] / flux_err ** 2))\n sigma_w_inv = sigma_w_inv.toarray()\n\n if prior_sigma is not None:\n sigma_w_inv = sigma_w_inv + np.diag(1.0 / prior_sigma ** 2)\n if prior_sigma is not None:\n B = B + (prior_mu / prior_sigma ** 2)\n\n # Solve for weights w\n w = np.linalg.solve(sigma_w_inv, B).T\n if propagate_errors:\n w_err = np.linalg.inv(sigma_w_inv)\n else:\n w_err = np.zeros(len(w)) * np.nan\n\n return w, w_err"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def linear_fit(x, y):\n x = np.array(x)\n y = np.array(y)\n \n invalid_idx = np.isnan(x) | np.isinf(x) | np.isnan(y) | np.isinf(y)\n x = x[~invalid_idx]\n y = y[~invalid_idx]\n\n covs = sm.add_constant(x, prepend=True)\n model = sm.OLS(y, covs)\n result = model.fit()\n return result.params, result.rsquared","def lsq_coefficients(x, y, fit_intercept=False):\n if fit_intercept:\n x = np.vstack([x, np.ones(len(x))]).T\n else:\n x = np.vstack([x, np.zeros(len(x))]).T\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)","def fit(self, X, y):\n # If solver is 'lstsq' use ordinary least squares optimization method.\n if self.solver == 'lstsq':\n # Make sure inputs are numpy arrays.\n X = np.array(X)\n y = np.array(y)\n # Add x_0 = 1 to each instance for the bias term.\n X = np.c_[np.ones((X.shape[0], 1)), X]\n # Scipy implementation of least squares.\n self.coef_, residues, rank, singular = lstsq(X, y)\n\n return self\n\n elif self.solver == 'bgd': \n super(LinearRegression, self).fit(X, y)","def fit(self,X,y):\n\n d = X.shape[1]\n # 1. sketch the data\n self.B,a = self._sketch(X,method=self.fd_mode)\n #H = B.T@B + (self.alpha+a)*np.eye(d)\n #self.H = H\n self.H_inv = self._get_inv() #np.linalg.pinv(H)\n self.coef_ = self.H_inv@(X.T@y) #np.linalg.solve(H, X.T@y)\n self.is_fitted = True","def fit_mult_linear(X,y):\n # TODO complete the following code\n nsamp,natt=X.shape\n\n ones=np.ones((nsamp,1))\n X_orig=X\n X=np.hstack((ones,X_orig))\n X.shape\n Xt=np.transpose(X)\n\n beta = np.dot(np.linalg.inv(np.dot(Xt,X)),np.dot(Xt,y))\n return beta","def least_sqr_fit(self,x, y):\n A = np.array([ x, np.ones(len(x))])\n # linearly generated sequence\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\n return lined , a","def fit_polynomial_regression(self, x_train, y_train):\n x_poly = self.poly_reg.fit_transform(x_train)\n self.lin_reg.fit(x_poly, y_train)","def fit(self, X):","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def regr_ols_sklearn(Y, X, **param):\r\n clf = linear_model.LinearRegression(fit_intercept=True)\r\n clf.fit()\r\n # clf.coef_ now contains coef\r","def fit(self, X, y, **params):\n\n assert isinstance(X, pd.DataFrame)\n assert isinstance(y, pd.DataFrame)\n assert X.shape[0] == y.shape[0]\n\n # Fit the linear regressors (feature = f(covariates))\n self.regressors = {c: LinearRegression(**params).fit(y.values, X[c].values) for c in X.columns}\n\n # Store the covariates\n self.covariates = y\n\n return self","def fit(self, X, y, **params):\n\n assert isinstance(X, pd.DataFrame)\n assert isinstance(y, pd.DataFrame)\n assert X.shape[0] == y.shape[0]\n\n # Fit the linear regressor (feature = f(covariates))\n self.regressors = {c: LinearRegression(**params).fit(y.values, X[c].values) for c in X.columns}\n\n # Store the covariates\n self.covariates = y\n\n return self","def fit(self, X, y):\n self.x_values = X\n self.y_values = y\n self.gradient_descent(self.coefficients, X, y)","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n #least square fitting(minimizes raw data and fit)\n return p","def linearfit(x,y):\n fit = np.polyfit(x,y,1)\n fit_fn = np.poly1d(fit)\n yy = fit_fn(x) \n \n return yy","def fit(self, X,y):\n pass","def fit(self, x: np.ndarray, y: np.ndarray) -> LinearRegression:\n # TODO: fit weights to x and y\n raise NotImplementedError('LinearRegression fit function not implemented')","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: ravel(gaussian(*p)(*indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fit(self, x, y):\n extra_ones = np.array([1.0 for i in range(len(x))],dtype='f').reshape(-1,1) # create an extra column of ones (neutral elements)\n \n x = np.concatenate((extra_ones,x),1) # append extra ones to x with axis 1 because we want a matrix \n xt = x.transpose()\n \n # multiply matrices\n self.betas = np.linalg.inv(xt.dot(x)).dot(xt).dot(y)","def fit(x, a, p, b):\n return a * (p ** x) + b","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = leastsq(errorfunction, params)\n return p","def _fit(self, _X, _y):\n\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\n solver='saga', n_jobs=self.n_jobs)\n self.model.fit(_X, _y)","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, Y):\n ...","def brute_leastsquare_fit(fun, x_data, y_data,weight_data=None,p_names=None,p_min_max_steps_dict=None,\r\n const_params=[], visualize=False):\r\n \r\n if p_names == None or p_min_max_steps_dict==None:\r\n raise Exception ('p_names and p_min_max_steps must be given!'+ \r\n 'structure of p_min_max_steps_dict: {\"pname0\":[min0,max0,brute_steps0]}')\r\n \r\n params = Parameters() ### initialize LMfit parameters\r\n for p_name in p_names:\r\n min_val=p_min_max_steps_dict[p_name][0]\r\n max_val=p_min_max_steps_dict[p_name][1]\r\n steps=p_min_max_steps_dict[p_name][2]\r\n params.add(p_name,value=min_val,\r\n min=min_val,\r\n max=max_val,\r\n brute_step=(max_val-min_val)/(steps-1))\r\n \r\n ### define function to be minimized for fit \r\n \r\n def cost_function_fit(p=params):\r\n def minimize_fun(pars):\r\n \r\n v=pars.valuesdict()\r\n arglist=[]\r\n for p_name in p_names:\r\n arglist.append(v[p_name])\r\n \r\n for const_param in const_params:\r\n arglist.append(const_param)\r\n \r\n ret=np.array((fun(x_data,*arglist)-y_data),dtype=float)\r\n if weight_data is not None:\r\n ret=ret*np.sqrt(weight_data)\r\n return(ret)\r\n brute_result=lmfit.minimize(minimize_fun,params,method='brute',nan_policy='omit')\r\n best_result=copy.deepcopy(brute_result)\r\n for candidate in brute_result.candidates[0:5]:\r\n trial = lmfit.minimize(minimize_fun, params=candidate.params,method='leastsq',nan_policy='omit')\r\n if trial.chisqr < best_result.chisqr:\r\n best_result = trial\r\n \r\n return((best_result,brute_result))\r\n \r\n best_result,brute_result = cost_function_fit()\r\n arg_list=[]\r\n for p_name in p_names:\r\n arg_list.append(best_result.params.valuesdict()[p_name])\r\n for const_param in const_params:\r\n arg_list.append(const_param)\r\n \r\n \r\n if visualize == True:\r\n plot_brute_leastsquares_results(brute_result,leastsq_fit_result=best_result)\r\n plt.figure()\r\n plt.plot(x_data,y_data,label='data',color='blue')\r\n plt.plot(x_data,fun(x_data,*arg_list),label='Fit',color='red')\r\n plt.title(best_result.params.valuesdict())\r\n plt.show()\r\n return (arg_list[0:len(p_names)])","def fit(self, X, y, **fit_params):\n ...","def fit_gaussian(x, y, z):\n\n def sym_gaussian(p):\n \"\"\"\n Returns a Gaussian function:\n a**2 * exp(-((x - x_0)**2 + (y - y_0)**2) / (2 * sigma**2))\n p = [a, x_0, y_0, sigma]\n \"\"\"\n a, x_0, y_0, sigma = p\n return a**2 \\\n * np.exp(-((x - x_0)**2 + (y - y_0)**2) / (2.0 * sigma**2))\n\n def sym_gaussian_resids(p):\n \"\"\"Residuals to be sent into leastsq\"\"\"\n return z - sym_gaussian(p)\n\n def guess_fit_gaussian():\n \"\"\"\n return a, x_0, y_0, and sigma based on computing moments of data\n \"\"\"\n a = z.max()\n\n # Compute moments\n total = z.sum()\n x_0 = np.dot(x, z) / total\n y_0 = np.dot(y, z) / total\n\n # Approximate sigmas\n sigma_x = np.dot(x**2, z) / total\n sigma_y = np.dot(y**2, z) / total\n sigma = np.sqrt(sigma_x * sigma_y)\n\n # Return guess\n return (a, x_0, y_0, sigma)\n\n # Get guess\n p0 = guess_fit_gaussian()\n\n # Perform optimization using nonlinear least squares\n popt, junk_output, info_dict, mesg, ier = \\\n scipy.optimize.leastsq(sym_gaussian_resids, p0, full_output=True)\n\n # Check to make sure leastsq was successful. If not, return centroid\n # estimate.\n if ier in (1, 2, 3, 4):\n return (popt[0]**2, popt[1], popt[2], popt[3])\n else:\n return p0","def fitgaussian(self, data):\n params = self.moments(data)\n errorfunction = lambda p: ravel(self.Gauss(*p)(*indices(data.shape)) - data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fit(self, x):\n pass","def fit(self, x, y):\n x = np.array(x, 'float64')\n y = np.array(y, 'float64')\n\n xy = x * y\n xx = x * x\n yy = y * y\n\n a = np.dot(np.sum(y), np.sum(xx)) - np.dot(np.sum(x), np.sum(xy))\n b = x.shape[0] * np.sum(xy) - np.dot(np.sum(x), np.sum(y))\n c = x.shape[0] * np.sum(xx) - np.dot(np.sum(x), np.sum(x))\n\n self.coef_ = np.array([a/c, b/c])\n self.__trained = True\n\n return self","def fit(self, X, y, l2regularize = None ) :\n\n X = self.generate_polynomial_features(X) # map features\n\n ### ========== TODO : START ========== ###\n # part e: implement closed-form solution\n # hint: use np.dot(...) and np.linalg.pinv(...)\n # be sure to update self.coef_ with your solution\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\n\n\n ### ========== TODO : END ========== ###\n\n return self","def fit(self, X, y):\r\n newWeight = [0.0] * self.size\r\n w = [0.0] * len(X)\r\n val = self.predict_prob(X) \r\n grad = [(y-1.0) * i[1] for i in X] \r\n grad1 = float((math.exp(-math.fsum((self.weight[f]*v for f, v in X)))) * val)\r\n grad2 = [i[1] * -1 * grad1 for i in X] \r\n for i in range(len(w)):\r\n w[i] = (grad[i] - grad2[i])\r\n \r\n w = [i*self.eta for i in w]\r\n for i in range(len(X)):\r\n newWeight[i] = self.weight[X[i][0]] -w[i]\r\n \r\n self.weight = newWeight[:]\r\n \r\n pass","def fit(self, X, y=..., **fit_params):\n ...","def fit_linear(self, h, m):\n susceptibility, coercivity, r, p, se = scipy.stats.linregress(h, m)\n return coercivity/susceptibility, susceptibility","def fit(self,X,y):\n X = np.c_[np.ones(X.shape[0]),X]\n all_parameters = np.linalg.inv(X.T@X)@X.T@y\n self.intercept = all_parameters[0]\n self.theta = all_parameters[1:]","def LinearLeastSquaresFit(x,y):\n \n xavg = np.zeros(len(x),float) #<x> average\n xavg = sum(x)/len(x)\n \n yavg = np.zeros(len(y),float) #<y> average\n yavg = sum(y)/len(y)\n \n x2avg = np.zeros(len(x),float) #<x^2> average\n x2avg = sum(x**2)/len(x)\n \n xyavg = np.zeros(len(x),float) #<xy> average\n xyavg = sum(x*y)/len(x)\n \n m = (xyavg - xavg*yavg)/(x2avg-xavg**2) #slope\n b = (x2avg*yavg-xavg*xyavg)/(x2avg-xavg**2) #intercept\n \n d = np.zeros(len(x),float)\n for n in range(len(x)):\n d[n] = y[n] -(m*x[n]+b)\n \n x2 = np.zeros(len(x),float)\n for n in range(len(x)):\n x2[n] = sum(d[n]**2)\n \n \n d2avg = np.zeros(len(d),float) #<d^2> average\n d2avg = sum(x2)/float(len(x))\n \n Dm = sqrt((1/float(len(x)-2))*(d2avg/(x2avg-xavg**2))) #slope error\n Db = sqrt((1/float(len(x)-2))*((d2avg*x2avg)/(x2avg-xavg**2))) # intercept error\n print \"slope=\", m, \"Slope Error=\", Dm,\"Intercept=\", b, \"Intercept Error=\", Db\n return \"slope=\", m, \"Slope Error=\", Dm,\"Intercept=\", b, \"Intercept Error=\",Db","def fit(X):\n n = len(X) - 1\n xx = np.ones((n, 2))\n xx[:,1] = X[:-1]\n xx_trans = xx.transpose()\n yy = X[1:]\n coeffs = dot(dot(inv(dot(xx_trans, xx)), xx_trans), yy)\n betahat, alphahat = coeffs\n uhat = yy - dot(xx, coeffs)\n sigma2hat = dot(uhat, uhat) / n\n return betahat, alphahat, np.sqrt(sigma2hat)","def fit(self, X, Y, **fit_params):\n ...","def fit(self, X, Y, **fit_params):\n ...","def fit(x_array, y_array, function, A_start):\n param = (x_array, y_array, function)\n\n A_final, cov_x, infodict, mesg, ier = leastsq(minimize, A_start, args=param, full_output=True)#, warning=True)\n \n return A_final","def fit_least_squares(input_data, output_data):\n # This function's code follows the formula for finding the weights\n # that create the least mean-squared error, which is:\n # w = (((y_t)x)(inv((x_t)x))_t)\n\n xtx = numpy.matmul(numpy.transpose(input_data),input_data)\n xtx_inv = numpy.linalg.inv(xtx)\n ytx = numpy.matmul(numpy.transpose(output_data),input_data)\n\n return LinearModel(numpy.transpose(numpy.matmul(ytx,xtx_inv)))","def fit(self, X, y=None):\n #import pdb\n #pdb.set_trace()\n return self.partial_fit(X, y)","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def fit(self, x, y):\n # *** START CODE HERE ***\n num_examples = x.shape[0]\n num_features = x.shape[1]\n iteration = 1\n if self.theta == None:\n self.theta = np.zeros((num_features,))\n while iteration <= self.max_iter:\n h_theta = np.dot(x, self.theta)\n g_theta = self.sigmoid(h_theta)\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\n d_theta = - np.linalg.solve(H, J_prime)\n self.theta += d_theta\n if np.linalg.norm(d_theta, 1) < self.eps:\n break\n if self.verbose:\n print(\"Loss value: \", J_cost)\n iteration += 1\n # *** END CODE HERE ***","def linear_regression(x, y):\n #print(\"Fitting\", y, \"\\nagainst\", x)\n matrix = np.vstack( [x, np.ones_like(x)] ).T\n slope, intercept = np.linalg.lstsq(matrix,y)[0]\n #print(\"gives slope=\", slope, \"intercept=\", intercept)\n return (slope, intercept)","def fit(self, kernel=GaussianKernel(sigma=1.0), regularizer=1.0, sparsifiers=None):\n\n self.q = np.array((regularizer + kernel(self.x[0], self.x[0])) ** (-1))\n self.coefficients = np.array([self.q * self.y[0]])\n self.coefficient_history = [self.coefficients]\n\n self._estimate = np.zeros(self.y.shape)\n self.support_vectors = np.array([self.x[0]]).reshape(-1, 1)\n self.error_history = [0]\n\n self.kernel = kernel\n\n for i in range(1, self.n):\n self.regressor = self.x[i]\n\n self.h = kernel(self.support_vectors, self.regressor).T\n self.z = np.dot(self.q, self.h)\n self.r = regularizer + kernel(self.x[i], self.x[i]) - np.dot(self.z, self.h)\n\n self.estimate[i] = np.dot(self.h.T, self.coefficients)\n self.error = self.y[i] - self.estimate[i]\n self.error_history.append(self.error)\n\n self.coefficients -= self.z * self.r ** (-1) * self.error\n self.coefficient_history.append(self.coefficients)\n\n if sparsifiers:\n for sparsifier in sparsifiers:\n sparsifier.apply(self)\n\n else:\n self.q = self.q * self.r + np.outer(self.z, self.z.T)\n q_row = np.asarray(-self.z).reshape(-1, 1).T\n q_col = np.asarray(-self.z).reshape(-1, 1)\n q_end = np.array([1]).reshape(-1, 1)\n\n self.q = np.append(self.q, q_row, axis=0)\n self.q = np.append(self.q, np.concatenate((q_col, q_end), axis=0), axis=1)\n self.q = self.r ** (-1) * self.q\n\n self.support_vectors = np.vstack((self.support_vectors, self.regressor.reshape(1, -1)))\n self.coefficients = np.append(self.coefficients, self.r ** (-1) * self.error)","def linear_regression(features, values):\n clf = SGDRegressor(n_iter=100)\n clf.fit(features,values)\n print(clf.score(features,values))\n intercept = clf.intercept_ \n params = clf.coef_\n \n return intercept, params","def _lin_regress(self, y, x, bias=True):\n n_samples = x.shape[0]\n x = self.make_polynomial(x[:, np.newaxis], fit_intercept=bias)\n l = np.linalg.cholesky(x.T @ x)\n v = solve_triangular(l, x.T @ y, lower=True)\n coefs = solve_triangular(l.T, v)\n pred = x @ coefs\n resid = y - pred\n rss = resid @ resid\n ddof = n_samples - (1 + bias)\n return rss, ddof","def fit(self) -> LinearRegressionParams:\n result = self.__m.fit()\n self._intercept, *self._coef = result.params\n self._pvalues = result.f_pvalue\n self._f_statistics = result.fvalue\n self._r_squared = result.rsquared\n\n return LinearRegressionParams(\n Coef=self._coef,\n Intercept=self._intercept,\n pvalues=self._pvalues,\n F_statistics=self._f_statistics,\n R_square=self._r_squared\n )","def quadratic_fit(self, xy, W):\n\t\t# first construct the independent matrix\n\t\ty = xy[:,1]\n\t\tx = xy[:,0]\n\t\tX = np.column_stack([np.ones(len(x)),\n\t\t\t\t\t\t\tx, np.power(x,2)])\n\n\t\twls_model = sm.WLS(y, X, weights = 1.0/W)\t\n\t\twls_model_results = wls_model.fit()\n\t\t[c,b,a] = wls_model_results.params\t\n\t\treturn [a,b,c]","def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \"TSExp\":\n b_0 = y[-1] / y[-2]\n a_0 = 0.1\n c_0 = 0\n guess = np.asarray([a_0, b_0, c_0], dtype=float)\n\n try:\n popt = scipy.optimize.curve_fit(\n self._func, X.ravel(), y, p0=guess, check_finite=False\n )[0]\n\n self.a, self.b, self.c = popt\n\n self._fitted = True\n\n except RuntimeError:\n self._fitted = False\n\n return self","def linearRegression(x,y,f1,l1,f2,l2):\n n = len(x)\n sumx = 0.0 # sum_n(x_i)\n sumy = 0.0 # sum_n(y_i)\n sumxx = 0.0 # sum_n(x_i*x_i)\n sumxy = 0.0 # sum_n(x_i*y_i)\n count = 0\n for i2 in range(f2,l2+1):\n for i1 in range(f1,l1+1):\n xi = x[i2][i1]\n yi = y[i2][i1]\n sumx += xi\n sumy += yi\n sumxx += xi*xi\n sumxy += xi*yi\n count += 1\n beta = (sumxy-sumx*sumy/count)/(sumxx-sumx*sumx/count)\n alpha = (sumy-beta*sumx)/count\n #z = zerofloat(n)\n #for i in range(n):\n # if null is None or x[i]!=null:\n # z[i] = alpha+beta*x[i]\n #print 'slope =',beta\n #return z\n return beta","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\n data)\n #scipy rihjt\n # Levenberg-Marquadt algorithm -> leastsq\n #bnds = None\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n \n #least square fitting(minimizes raw data and fit)\n\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\n #print(\"pass case\")\n return(p)\n else:\n print(\"failed case\")\n print(\"height1\", p[0],\"height2\", p[5], \"X\", p[1],\"Y\", p[2],\"Y1\", p[6], \"Y2\", p[7])\n print(\"bounding error\" + str(numero)) \n\n return p","def fit(self, X, y):\n # compute W, b\n # pull W from the normal distribution, and b from 0->2 pi\n\n self.N, d = X.shape\n\n # weights go from R^d -> R^D\n self.W = rng.normal(loc=0, scale=1, size=(self.D, d))\n # bias is in R, need D terms\n self.b = rng.uniform(0, 2*np.pi, size=self.D)\n\n self.Z = self.compute_features(X)\n \n self._fit(y)\n self.fitted = True\n\n # now solve the least-squares problem:\n # min_w ||Z'w - y||_2^2 + \\lambda ||w||_2^2\n\n # done via linear equation solver, eg:\n # A x = b to solve x\n # use cholesky solver: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.cho_solve.html\n\n # self.L = cholesky(self.kernel, lower=True)\n # self.alpha = cho_solve((self.L, True), y)","def fit(self, X, y): \n # initial values set by set_params when objet was initialised\n _, D = X.shape \n wb_init = np.zeros(D+1) # initial guess for weight vector\n w, b = self.get_params() # set_params inits to zero vector for wb\n wb_init[:-1] = w # self.w0\n wb_init[-1] = b # self.b0\n\n wb_opt, _, _ = fmin_l_bfgs_b(func = self.objective, \n x0 = wb_init, \n fprime = self.objective_grad, \n args = (X,y))\n \n self.set_params(wb_opt[:-1], wb_opt[-1])\n return","def fit(self, X, y):\n self.model = self._initialize_model(X, y)\n self.model.optimize()","def fit(self, X):\n raise NotImplementedError","def fit(self, data):\n x, y = np.asarray(data, dtype=float)\n\n # Quadratic part of design matrix [eqn. 15] from (*)\n D1 = np.mat(np.vstack([x**2, x*y, y**2])).T\n # Linear part of design matrix [eqn. 16] from (*)\n D2 = np.mat(np.vstack([x, y, np.ones(len(x))])).T\n\n # forming scatter matrix [eqn. 17] from (*)\n S1 = D1.T*D1\n S2 = D1.T*D2\n S3 = D2.T*D2\n\n # Constraint matrix [eqn. 18]\n C1 = np.mat('0. 0. 2.; 0. -1. 0.; 2. 0. 0.')\n\n # Reduced scatter matrix [eqn. 29]\n M = C1.I*(S1-S2*S3.I*S2.T)\n\n # M*|a b c >=l|a b c >. Find eigenvalues and eigenvectors from this equation [eqn. 28]\n eval, evec = np.linalg.eig(M)\n\n # eigenvector must meet constraint 4ac - b^2 to be valid.\n cond = 4*np.multiply(evec[0, :], evec[2, :]) - \\\n np.power(evec[1, :], 2)\n a1 = evec[:, np.nonzero(cond.A > 0)[1]]\n\n # |d f g> = -S3^(-1)*S2^(T)*|a b c> [eqn. 24]\n a2 = -S3.I*S2.T*a1\n\n # eigenvectors |a b c d f g>\n self.coef = np.vstack([a1, a2])\n self._save_parameters()","def predict_proba(X, fit_intercept, coeffs):\n if fit_intercept:\n coeffs_0 = coeffs[0]\n coeffs = coeffs[1:]\n else:\n coeffs_0 = 0\n u = coeffs_0 + X.dot(coeffs)\n return QNEM.logistic_grad(u)","def fit_function_LS(data, params, z, fn):\n result = params\n errorfunction = lambda p: fn(*p)(z) - data\n good = True\n [result, cov_x, infodict, mesg, success] = (\n scipy.optimize.leastsq(\n errorfunction, params, full_output = 1, maxfev = 500\n )\n )\n err = errorfunction(result)\n err = scipy.sum(err * err)\n if (success < 1) or (success > 4):\n print( \"Fitting problem!\", success, mesg)\n good = False\n return [result, cov_x, infodict, good]","def fitbivarGaussian(data):\n params = bivarParams(data)\n errorfunction = lambda p: ravel(bivarGaussian(*p)(*indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def gaussfit(x, y, nterms=\"none\"):\n\n z = lambda x, A1, A2: (x - A1) / A2\n\n if nterms in [\"none\", 3]:\n gauss = lambda x, A0, A1, A2: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n p0 = [max(y), 1, 1]\n elif nterms in [\"constant\", 4]:\n gauss = lambda x, A0, A1, A2, A3: A0 * np.exp(-z(x, A1, A2) ** 2 / 2) + A3\n p0 = [max(y), 1, 1, 0]\n elif nterms in [\"linear\", 5]:\n gauss = (\n lambda x, A0, A1, A2, A3, A4: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n + A3\n + A4 * x\n )\n p0 = [max(y), 1, 1, 0, 0]\n\n elif nterms in [\"quadratic\", 6]:\n gauss = (\n lambda x, A0, A1, A2, A3, A4, A5: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n + A3\n + A4 * x\n + A5 * x ** 2\n )\n p0 = [max(y), 1, 1, 0, 0, 0]\n\n popt, _ = curve_fit(gauss, x, y, p0=p0)\n return gauss(x, *popt), popt","def regression_fit(self, x, y, deg):\n return np.polyfit(x, y, deg=deg)","def fit(self, x, y):\r\n\r\n self.train_x = x\r\n self.train_y = y\r\n self.__find_psi__()","def fit(self, X, y):\n # Make sure inputs are numpy arrays.\n X = np.array(X)\n y = np.array(y)\n # Add x_0 = 1 to each instance for the bias term.\n X = np.c_[np.ones((X.shape[0], 1)), X]\n # Store number of samples and features in variables.\n n_samples, n_features = np.shape(X)\n self.training_errors = []\n # Initialize weights randomly from normal distribution.\n self.coef_ = np.random.randn(n_features, 1)\n # Batch gradient descent for number iterations = n_iter.\n for _ in range(self.n_iter):\n y_preds = X.dot(self.coef_)\n # Penalty term if regularized (don't include bias term).\n regularization = self.regularization(self.coef_[1:])\n # Calculate mse + penalty term if regularized.\n cost_function = mean_squared_error(y, y_preds) + regularization\n if cost_function > self.threshold:\n break\n self.training_errors.append(cost_function) \n # Regularization term of gradients (don't include bias term).\n gradient_reg = self.regularization.grad(self.coef_[1:])\n # Gradients of loss function.\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\n gradients += gradient_reg\n # Update the weights.\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\n\n return self","def nnRegression(data):","def fit(self, X, y):\n return BaseRegressor.fit(self, X, y)","def fit_gp_regression(self, start=None, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n\n results = self.mle_parameters(start=start)\n\n logger.info(\"Results of the GP fitting: \")\n logger.info(results)\n\n sol = results['solution']\n\n self.update_value_parameters(sol)\n\n return self","def fit_cpe(self, x, y):\n self.cpe_model = LogisticRegressionCV(solver='liblinear')\n self.cpe_model.fit(x, y)","def linearReg(x,y):\n X=np.array(x).reshape(-1,1)\n Y=np.array(y).reshape(-1,1)\n x_shape = X.shape\n num_var = x_shape[1] \n yintercept = 0\n slope = 0\n progress = []\n #intialize the parameter\n weight_matrix = np.random.normal(-1,1,(num_var,1))\n yintercept = np.random.rand(1)\n #cost minmization\n for i in range(200):\n dcostdm = np.sum(np.multiply(((np.matmul(X,weight_matrix)+ yintercept)-Y),X))*2/x_shape[0] #w.r.t to the weight\n dcostdc = np.sum(((np.matmul(X,weight_matrix)+yintercept)-Y))*2/x_shape[0] #partial derivative of cost w.r.t the intercept\n weight_matrix -= 0.1*dcostdm \n #updating the weights with the calculated gradients\n yintercept -= 0.1*dcostdc #updating the weights with the calculated gradients\n progress.append(np.array((weight_matrix,yintercept)))\n slope = weight_matrix\n return (slope[-1],yintercept)","def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\"\"):\n if domain is not None:\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\n else:\n fitdatax=xdata\n fitdatay=ydata\n if fitparams is None: \n fitparams=[0.,0.,0.,0.]\n fitparams[0]=fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[2]=fitdatax[0]\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\n #print fitparams\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\n label=label)\n return p1","def nnls_fit(self):\n\n def sprod(a,b): #simplecting inner product between two Pauli operators\n return int(not a.commutes(b))\n\n F1 = [] #First list of terms\n F2 = [] #List of term pairs\n fidelities = [] # list of fidelities from fits\n\n for datum in self._term_data.values():\n F1.append(datum.pauli)\n fidelities.append(datum.fidelity)\n #If the Pauli is conjugate to another term in the model, a degeneracy is present\n if self._issingle(datum):\n F2.append(datum.pauli)\n else:\n pair = datum.pair\n F2.append(pair)\n\n #create commutativity matrices\n M1 = [[sprod(a,b) for a in F1] for b in F1]\n M2 = [[sprod(a,b) for a in F1] for b in F2]\n\n #check to make sure that there is no degeneracy\n if np.linalg.matrix_rank(np.add(M1,M2)) != len(F1):\n raise Exception(\"Matrix is not full rank, something went wrong!\")\n \n #perform least-squares estimate of model coefficients and return as noisemodel \n coeffs,_ = nnls(np.add(M1,M2), -np.log(fidelities)) \n self.noisemodel = NoiseModel(self.layer._cliff_layer, F1, coeffs)","def gp_lc_fit(x_data, y_data, yerr_data=0.0, kernel=\"matern52\"):\n\n # define the objective function (negative log-likelihood in this case)\n def neg_log_like(params):\n \"\"\"Negative log-likelihood.\"\"\"\n gp.set_parameter_vector(params)\n log_like = gp.log_likelihood(y, quiet=True)\n if np.isfinite(log_like):\n return -log_like\n else:\n return np.inf\n\n # and the gradient of the objective function\n def grad_neg_log_like(params):\n \"\"\"Gradient of the negative log-likelihood.\"\"\"\n gp.set_parameter_vector(params)\n return -gp.grad_log_likelihood(y, quiet=True)\n\n x, y, yerr = np.copy(x_data), np.copy(y_data), np.copy(yerr_data)\n x_min, x_max = x.min(), x.max()\n\n y_norm = y.max()\n y /= y_norm\n yerr /= y_norm\n\n var, length_scale = np.var(y), np.diff(x).max()\n\n if kernel == \"matern52\":\n ker = var * Matern52Kernel(length_scale**2)\n elif kernel == \"matern32\":\n ker = var * Matern32Kernel(length_scale**2)\n elif kernel == \"squaredexp\":\n ker = var * ExpSquaredKernel(length_scale**2)\n else:\n raise ValueError(f'\"{kernel}\" is not a valid kernel.')\n\n gp = george.GP(kernel=ker, fit_mean=True)\n # initial guess\n gp.compute(x, yerr)\n\n # optimization routine for hyperparameters\n p0 = gp.get_parameter_vector()\n results = scipy.optimize.minimize(\n neg_log_like, p0, jac=grad_neg_log_like, method=\"L-BFGS-B\"\n )\n gp.set_parameter_vector(results.x)\n\n step = 0.05 # days\n x_pred = np.arange(x_min, x_max + step, step)\n\n mean, var = gp.predict(y, x_pred, return_var=True)\n std = np.sqrt(var)\n\n x_pred, y_pred, yerr_pred = x_pred, mean * y_norm, std * y_norm\n\n return x_pred, y_pred, yerr_pred","def fit_regression(\n polynomials,\n abscissas,\n evals,\n model=None,\n retall=False,\n):\n logger = logging.getLogger(__name__)\n abscissas = numpy.asarray(abscissas)\n if len(abscissas.shape) == 1:\n abscissas = abscissas.reshape(1, *abscissas.shape)\n evals = numpy.array(evals)\n\n poly_evals = polynomials(*abscissas).T\n shape = evals.shape[1:]\n if shape:\n evals = evals.reshape(evals.shape[0], int(numpy.prod(evals.shape[1:])))\n\n if model is None:\n uhat = linalg.lstsq(poly_evals, evals)[0]\n\n else:\n try:\n from sklearn.base import BaseEstimator\n except ImportError:\n raise ValueError(\n \"arg model != None requires that scikit-learn is installed\")\n\n if not isinstance(model, BaseEstimator):\n raise ValueError(\"model not recognized; \"\n \"Optional[sklearn.base.BaseEstimator] expected\")\n if hasattr(model, \"fit_intercept\"):\n assert not model.fit_intercept, (\n \"model %s must have fit_intercept=False\" % model.__class__.__name__)\n uhat = model.fit(poly_evals, evals).coef_.T\n\n if shape:\n evals = evals.reshape(evals.shape[0], *shape)\n\n approx_model = numpoly.sum((polynomials*uhat.T), -1)\n approx_model = approx_model.reshape(shape)\n\n if retall == 1:\n return approx_model, uhat\n if retall == 2:\n return approx_model, uhat, poly_evals\n return approx_model","def linear_regression(x_train, t_train, basis, bias,reg_lambda=0, degree=1, mu=0, s=1):\n \n # Construct the design matrix.\n # Pass the required parameters to this function\n \n phi = design_matrix(x_train,basis,degree,bias,mu,s) \n #print(x_train.shape) \n # Learning Coefficients\n if reg_lambda > 0:\n I=np.identity((phi.shape[1]),dtype=int)\n inv = np.linalg.inv((reg_lambda*I)+(phi.T@phi))\n w = inv@(phi.T@t_train) \n # regularized regression\n else:\n # no regularization \n w = np.linalg.pinv(phi)@t_train\n \n pred_train=phi@w\n train_err = np.sqrt((np.square(pred_train-t_train)).mean())\n return (w, train_err)","def fit(self, X, y):\n assert X.shape[0] == y.shape[0]\n\n intercept = np.ones((X.shape[0], 1))\n X = np.concatenate((X, intercept), axis=1)\n\n self.theta = np.random.randn(X.shape[1], 1)\n theta_updated = True\n while theta_updated:\n theta_updated = False\n for i in range(X.shape[0]):\n x, yy = X[i, :], y[i]\n # if label yy and sign of decision function do not agree\n # sample x on wrong side of the hyperplane\n if yy * (np.dot(self.theta.T, x.reshape(-1, 1))) <= 0:\n # -y * theta.T * x / d theta = -y*x\n # parameter := parameter - alpha * gradient\n parameter_gradient = -yy * x.reshape(-1, 1)\n self.theta = self.theta - parameter_gradient\n theta_updated = True","def fit(ydata):\n xdata = np.linspace(0,len(ydata),num = len(ydata))\n popt, pcov = curve_fit(func, xdata, ydata)\n #returns the parameters of the fitting\n return popt","def fit(self, X, y):\n if isinstance(self.gamma, str):\n if self.gamma == 'scale':\n self._gamma = 1. / (X.shape[1] * X.var()) if X.var() != 0 else 1.0\n \n elif self.gamma == 'auto':\n self._gamma = 1. / X.shape[1]\n \n else:\n msg = (\"The gamma can only be 'auto' or 'scale'.\")\n raise ValueError(msg)\n else:\n self._gamma = self.gamma\n \n self.kwargs = {'degree' : self.degree, 'gamma' : self._gamma, 'coef0' : self.coef0}\n \n X, y = np.asarray(X), np.asarray(y, dtype=np.int64)\n \n n_samples, n_features = X.shape\n\n # Gram Matrix\n K = np.zeros(shape = (n_samples, n_samples))\n for i in range(n_samples):\n for j in range(n_samples):\n K[i][j] = self.kernel_function(X[i], X[j], **self.kwargs)\n \n P = cvxopt.matrix(np.outer(y,y) * K)\n q = cvxopt.matrix(np.ones(n_samples) * -1)\n A = cvxopt.matrix(y, (1, n_samples), 'd')\n b = cvxopt.matrix(0.0)\n \n tmp1 = np.diag(np.ones(n_samples) * -1)\n tmp2 = np.identity(n_samples)\n G = cvxopt.matrix(np.vstack((tmp1, tmp2)))\n tmp1 = np.zeros(n_samples)\n tmp2 = np.ones(n_samples) * self.C\n h = cvxopt.matrix(np.hstack((tmp1, tmp2)))\n \n cvxopt.solvers.options['show_progress'] = False\n # solve QP problem\n solution = cvxopt.solvers.qp(P, q, G, h, A, b)\n\n # Lagrange multipliers\n a = np.ravel(solution['x'])\n\n # Support vectors have non zero lagrange multipliers\n sv = a > 1e-5\n ind = np.arange(len(a))[sv]\n self.a = a[sv]\n self.sv = X[sv]\n self.sv_y = y[sv]\n# print(\"%d support vectors out of %d points\" % (len(self.a), n_samples))\n\n # Intercept\n self.b = 0\n for n in range(len(self.a)):\n self.b += self.sv_y[n]\n self.b -= np.sum(self.a * self.sv_y * K[ind[n],sv])\n self.b /= len(self.a)\n\n # Weight vector\n if self.kernel == 'linear':\n self.w = np.zeros(n_features)\n for n in range(len(self.a)):\n self.w += self.a[n] * self.sv_y[n] * self.sv[n]\n else:\n self.w = None\n \n return self","def fit(self, x):\n raise NotImplementedError()","def fit_power(eigvals_rot):\n\n\n L = eigvals_rot\n\n # Consider only the first 50 eigenvalues, otherwise the\n # curve fitting could be excessively driven by the right\n # tail of the distribution, which has very low values.\n L = L[0:50]\n\n # Define the fitting function for L\n def powerfunc(x, amp, exponent):\n return amp * (x ** exponent)\n\n # Define a number of x points corresponding to len(L)\n xL = np.arange(len(L)) + 1\n\n # Perform curve fitting\n popt, _ = curve_fit(powerfunc, xL, L, method='lm')\n\n # Calculate the distance from the origin, which is interpreted\n # as the elbow point\n x = np.linspace(1, 50, 1000)\n y = powerfunc(x, *popt)\n\n d = np.sqrt(x**2 + y**2)\n i0 = np.where(d == np.min(d))\n\n x0 = x[np.squeeze(i0)]\n # y0 = y[np.squeeze(i0)]\n\n # Establish the number of principal components on the basis of this\n npc = np.int(np.round(x0))\n return npc","def fit_poly(data, error_func, degree=4): \n\n # generate initial guss for polynomial model (all coeffs = 1)\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\n\n # plot intial guess\n x = np.linspace(-5, 5, 21)\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\"Initial guess\")\n\n # call optimizer to minimize error function\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\n \n # convert optimal result into a poly1d object\n return np.poly1d(result.x)","def test_linear_fit_fixed_parameter(self):\n init_model = models.Polynomial1D(degree=2, c1=1)\n init_model.c1.fixed = True\n\n x = np.arange(10)\n y = 2 + x + 0.5 * x * x\n\n fitter = LinearLSQFitter()\n fitted_model = fitter(init_model, x, y)\n assert_allclose(fitted_model.parameters, [2.0, 1.0, 0.5], atol=1e-14)","def fit_moffat(z, x, y):\n input_params = [15000.0, 5.0, 5.0, 5.0, 5.0]\n fit_params, success = optimize.leastsq(moffat_residuals, input_params, \n args=(z, x, y), maxfev=10000)\n return fit_params","def linear(self, verbose=0):\n\n # Output linear regression summary with coefficients and p-values\n # if desired\n if verbose != 0:\n model = sm.OLS(self.y_train, sm.add_constant(self.X_train)).fit()\n print(model.summary())\n\n linear_regressor = LinearRegression(fit_intercept=True, normalize=False,\n copy_X=True)\n linear_score = np.mean(cross_val_score(\n estimator=linear_regressor, X=self.X_train, y=self.y_train,\n cv=5, scoring=self.scorer))\n print('Linear score: ' + str(linear_score))\n return linear_regressor","def computeRegression(Xin, Yin, Xtest, noise, ls, sv):\n\n # compute kernels\n K = kernel_sqExp(Xin, Xin, ls=ls, sv=sv)\n Kstar = kernel_sqExp(Xin, Xtest, ls=ls, sv=sv)\n Kstarstar = kernel_sqExp(Xtest, Xtest, ls=ls, sv=sv)\n\n # compute mean based on training input points\n n1 = np.shape(K)[0]\n offSet = 1e-3\n L = np.linalg.cholesky(K + noise*np.eye(n1) + offSet*np.eye(n1))\n alpha = np.linalg.solve(L.T, np.linalg.solve(L,Yin))\n f_mean = np.dot(Kstar.T,alpha) # mean of points\n \n # compute resulting covariance of predictive distribution\n v = np.linalg.solve(L, Kstar)\n cov = Kstarstar - np.dot(v.T,v)\n \n # compute log of marginal likelihood\n #lML = -0.5*np.dot(Yin.T,alpha) - np.sum(np.log(L)) - (n1/2*np.log(2*math.pi))\n lML_dataFit = -0.5*np.dot(Yin.T,alpha)\n lML_complexity = -np.sum(np.log(L))\n lML_normalize = -(n1/2*np.log(2*math.pi))\n lML_details = [lML_dataFit, lML_complexity, lML_normalize]\n lML = lML_dataFit[0] + lML_complexity + lML_normalize \n \n return f_mean, cov, lML , lML_details","def fit(self, X, y):\n \n # Create a copy of X that has a column for the intercept if the user\n # wants one.\n X_copy = self._add_intercept(X)\n \n # Fit the model coefficients using SVD.\n self._fit_svd(X_copy, y, alpha=0.0)\n \n # Calculate model statistics.\n self._calculate_model_stats_ols(X, y)\n \n return","def linear_regression(self, x_data, y_data, mask = None, ax = None):\n if mask is None:\n mask = full(len(y_data), True, dtype=bool)\n poly = poly1d(polyfit(x_data[mask], y_data[mask], 1))\n\n if ax is not None:\n ax.plot(x_data, polyval(poly, x_data), \"--r\",\\\n label = \"Slope: %.2f\" %(poly[1]))\n return poly","def partial_fit(self, X, y=..., **fit_params):\n ..."],"string":"[\n \"def linear_fit(x, y):\\n x = np.array(x)\\n y = np.array(y)\\n \\n invalid_idx = np.isnan(x) | np.isinf(x) | np.isnan(y) | np.isinf(y)\\n x = x[~invalid_idx]\\n y = y[~invalid_idx]\\n\\n covs = sm.add_constant(x, prepend=True)\\n model = sm.OLS(y, covs)\\n result = model.fit()\\n return result.params, result.rsquared\",\n \"def lsq_coefficients(x, y, fit_intercept=False):\\n if fit_intercept:\\n x = np.vstack([x, np.ones(len(x))]).T\\n else:\\n x = np.vstack([x, np.zeros(len(x))]).T\\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)\",\n \"def fit(self, X, y):\\n # If solver is 'lstsq' use ordinary least squares optimization method.\\n if self.solver == 'lstsq':\\n # Make sure inputs are numpy arrays.\\n X = np.array(X)\\n y = np.array(y)\\n # Add x_0 = 1 to each instance for the bias term.\\n X = np.c_[np.ones((X.shape[0], 1)), X]\\n # Scipy implementation of least squares.\\n self.coef_, residues, rank, singular = lstsq(X, y)\\n\\n return self\\n\\n elif self.solver == 'bgd': \\n super(LinearRegression, self).fit(X, y)\",\n \"def fit(self,X,y):\\n\\n d = X.shape[1]\\n # 1. sketch the data\\n self.B,a = self._sketch(X,method=self.fd_mode)\\n #H = B.T@B + (self.alpha+a)*np.eye(d)\\n #self.H = H\\n self.H_inv = self._get_inv() #np.linalg.pinv(H)\\n self.coef_ = self.H_inv@(X.T@y) #np.linalg.solve(H, X.T@y)\\n self.is_fitted = True\",\n \"def fit_mult_linear(X,y):\\n # TODO complete the following code\\n nsamp,natt=X.shape\\n\\n ones=np.ones((nsamp,1))\\n X_orig=X\\n X=np.hstack((ones,X_orig))\\n X.shape\\n Xt=np.transpose(X)\\n\\n beta = np.dot(np.linalg.inv(np.dot(Xt,X)),np.dot(Xt,y))\\n return beta\",\n \"def least_sqr_fit(self,x, y):\\n A = np.array([ x, np.ones(len(x))])\\n # linearly generated sequence\\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\\n return lined , a\",\n \"def fit_polynomial_regression(self, x_train, y_train):\\n x_poly = self.poly_reg.fit_transform(x_train)\\n self.lin_reg.fit(x_poly, y_train)\",\n \"def fit(self, X):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def regr_ols_sklearn(Y, X, **param):\\r\\n clf = linear_model.LinearRegression(fit_intercept=True)\\r\\n clf.fit()\\r\\n # clf.coef_ now contains coef\\r\",\n \"def fit(self, X, y, **params):\\n\\n assert isinstance(X, pd.DataFrame)\\n assert isinstance(y, pd.DataFrame)\\n assert X.shape[0] == y.shape[0]\\n\\n # Fit the linear regressors (feature = f(covariates))\\n self.regressors = {c: LinearRegression(**params).fit(y.values, X[c].values) for c in X.columns}\\n\\n # Store the covariates\\n self.covariates = y\\n\\n return self\",\n \"def fit(self, X, y, **params):\\n\\n assert isinstance(X, pd.DataFrame)\\n assert isinstance(y, pd.DataFrame)\\n assert X.shape[0] == y.shape[0]\\n\\n # Fit the linear regressor (feature = f(covariates))\\n self.regressors = {c: LinearRegression(**params).fit(y.values, X[c].values) for c in X.columns}\\n\\n # Store the covariates\\n self.covariates = y\\n\\n return self\",\n \"def fit(self, X, y):\\n self.x_values = X\\n self.y_values = y\\n self.gradient_descent(self.coefficients, X, y)\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n #least square fitting(minimizes raw data and fit)\\n return p\",\n \"def linearfit(x,y):\\n fit = np.polyfit(x,y,1)\\n fit_fn = np.poly1d(fit)\\n yy = fit_fn(x) \\n \\n return yy\",\n \"def fit(self, X,y):\\n pass\",\n \"def fit(self, x: np.ndarray, y: np.ndarray) -> LinearRegression:\\n # TODO: fit weights to x and y\\n raise NotImplementedError('LinearRegression fit function not implemented')\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: ravel(gaussian(*p)(*indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fit(self, x, y):\\n extra_ones = np.array([1.0 for i in range(len(x))],dtype='f').reshape(-1,1) # create an extra column of ones (neutral elements)\\n \\n x = np.concatenate((extra_ones,x),1) # append extra ones to x with axis 1 because we want a matrix \\n xt = x.transpose()\\n \\n # multiply matrices\\n self.betas = np.linalg.inv(xt.dot(x)).dot(xt).dot(y)\",\n \"def fit(x, a, p, b):\\n return a * (p ** x) + b\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = leastsq(errorfunction, params)\\n return p\",\n \"def _fit(self, _X, _y):\\n\\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\\n solver='saga', n_jobs=self.n_jobs)\\n self.model.fit(_X, _y)\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, Y):\\n ...\",\n \"def brute_leastsquare_fit(fun, x_data, y_data,weight_data=None,p_names=None,p_min_max_steps_dict=None,\\r\\n const_params=[], visualize=False):\\r\\n \\r\\n if p_names == None or p_min_max_steps_dict==None:\\r\\n raise Exception ('p_names and p_min_max_steps must be given!'+ \\r\\n 'structure of p_min_max_steps_dict: {\\\"pname0\\\":[min0,max0,brute_steps0]}')\\r\\n \\r\\n params = Parameters() ### initialize LMfit parameters\\r\\n for p_name in p_names:\\r\\n min_val=p_min_max_steps_dict[p_name][0]\\r\\n max_val=p_min_max_steps_dict[p_name][1]\\r\\n steps=p_min_max_steps_dict[p_name][2]\\r\\n params.add(p_name,value=min_val,\\r\\n min=min_val,\\r\\n max=max_val,\\r\\n brute_step=(max_val-min_val)/(steps-1))\\r\\n \\r\\n ### define function to be minimized for fit \\r\\n \\r\\n def cost_function_fit(p=params):\\r\\n def minimize_fun(pars):\\r\\n \\r\\n v=pars.valuesdict()\\r\\n arglist=[]\\r\\n for p_name in p_names:\\r\\n arglist.append(v[p_name])\\r\\n \\r\\n for const_param in const_params:\\r\\n arglist.append(const_param)\\r\\n \\r\\n ret=np.array((fun(x_data,*arglist)-y_data),dtype=float)\\r\\n if weight_data is not None:\\r\\n ret=ret*np.sqrt(weight_data)\\r\\n return(ret)\\r\\n brute_result=lmfit.minimize(minimize_fun,params,method='brute',nan_policy='omit')\\r\\n best_result=copy.deepcopy(brute_result)\\r\\n for candidate in brute_result.candidates[0:5]:\\r\\n trial = lmfit.minimize(minimize_fun, params=candidate.params,method='leastsq',nan_policy='omit')\\r\\n if trial.chisqr < best_result.chisqr:\\r\\n best_result = trial\\r\\n \\r\\n return((best_result,brute_result))\\r\\n \\r\\n best_result,brute_result = cost_function_fit()\\r\\n arg_list=[]\\r\\n for p_name in p_names:\\r\\n arg_list.append(best_result.params.valuesdict()[p_name])\\r\\n for const_param in const_params:\\r\\n arg_list.append(const_param)\\r\\n \\r\\n \\r\\n if visualize == True:\\r\\n plot_brute_leastsquares_results(brute_result,leastsq_fit_result=best_result)\\r\\n plt.figure()\\r\\n plt.plot(x_data,y_data,label='data',color='blue')\\r\\n plt.plot(x_data,fun(x_data,*arg_list),label='Fit',color='red')\\r\\n plt.title(best_result.params.valuesdict())\\r\\n plt.show()\\r\\n return (arg_list[0:len(p_names)])\",\n \"def fit(self, X, y, **fit_params):\\n ...\",\n \"def fit_gaussian(x, y, z):\\n\\n def sym_gaussian(p):\\n \\\"\\\"\\\"\\n Returns a Gaussian function:\\n a**2 * exp(-((x - x_0)**2 + (y - y_0)**2) / (2 * sigma**2))\\n p = [a, x_0, y_0, sigma]\\n \\\"\\\"\\\"\\n a, x_0, y_0, sigma = p\\n return a**2 \\\\\\n * np.exp(-((x - x_0)**2 + (y - y_0)**2) / (2.0 * sigma**2))\\n\\n def sym_gaussian_resids(p):\\n \\\"\\\"\\\"Residuals to be sent into leastsq\\\"\\\"\\\"\\n return z - sym_gaussian(p)\\n\\n def guess_fit_gaussian():\\n \\\"\\\"\\\"\\n return a, x_0, y_0, and sigma based on computing moments of data\\n \\\"\\\"\\\"\\n a = z.max()\\n\\n # Compute moments\\n total = z.sum()\\n x_0 = np.dot(x, z) / total\\n y_0 = np.dot(y, z) / total\\n\\n # Approximate sigmas\\n sigma_x = np.dot(x**2, z) / total\\n sigma_y = np.dot(y**2, z) / total\\n sigma = np.sqrt(sigma_x * sigma_y)\\n\\n # Return guess\\n return (a, x_0, y_0, sigma)\\n\\n # Get guess\\n p0 = guess_fit_gaussian()\\n\\n # Perform optimization using nonlinear least squares\\n popt, junk_output, info_dict, mesg, ier = \\\\\\n scipy.optimize.leastsq(sym_gaussian_resids, p0, full_output=True)\\n\\n # Check to make sure leastsq was successful. If not, return centroid\\n # estimate.\\n if ier in (1, 2, 3, 4):\\n return (popt[0]**2, popt[1], popt[2], popt[3])\\n else:\\n return p0\",\n \"def fitgaussian(self, data):\\n params = self.moments(data)\\n errorfunction = lambda p: ravel(self.Gauss(*p)(*indices(data.shape)) - data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fit(self, x):\\n pass\",\n \"def fit(self, x, y):\\n x = np.array(x, 'float64')\\n y = np.array(y, 'float64')\\n\\n xy = x * y\\n xx = x * x\\n yy = y * y\\n\\n a = np.dot(np.sum(y), np.sum(xx)) - np.dot(np.sum(x), np.sum(xy))\\n b = x.shape[0] * np.sum(xy) - np.dot(np.sum(x), np.sum(y))\\n c = x.shape[0] * np.sum(xx) - np.dot(np.sum(x), np.sum(x))\\n\\n self.coef_ = np.array([a/c, b/c])\\n self.__trained = True\\n\\n return self\",\n \"def fit(self, X, y, l2regularize = None ) :\\n\\n X = self.generate_polynomial_features(X) # map features\\n\\n ### ========== TODO : START ========== ###\\n # part e: implement closed-form solution\\n # hint: use np.dot(...) and np.linalg.pinv(...)\\n # be sure to update self.coef_ with your solution\\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\\n\\n\\n ### ========== TODO : END ========== ###\\n\\n return self\",\n \"def fit(self, X, y):\\r\\n newWeight = [0.0] * self.size\\r\\n w = [0.0] * len(X)\\r\\n val = self.predict_prob(X) \\r\\n grad = [(y-1.0) * i[1] for i in X] \\r\\n grad1 = float((math.exp(-math.fsum((self.weight[f]*v for f, v in X)))) * val)\\r\\n grad2 = [i[1] * -1 * grad1 for i in X] \\r\\n for i in range(len(w)):\\r\\n w[i] = (grad[i] - grad2[i])\\r\\n \\r\\n w = [i*self.eta for i in w]\\r\\n for i in range(len(X)):\\r\\n newWeight[i] = self.weight[X[i][0]] -w[i]\\r\\n \\r\\n self.weight = newWeight[:]\\r\\n \\r\\n pass\",\n \"def fit(self, X, y=..., **fit_params):\\n ...\",\n \"def fit_linear(self, h, m):\\n susceptibility, coercivity, r, p, se = scipy.stats.linregress(h, m)\\n return coercivity/susceptibility, susceptibility\",\n \"def fit(self,X,y):\\n X = np.c_[np.ones(X.shape[0]),X]\\n all_parameters = np.linalg.inv(X.T@X)@X.T@y\\n self.intercept = all_parameters[0]\\n self.theta = all_parameters[1:]\",\n \"def LinearLeastSquaresFit(x,y):\\n \\n xavg = np.zeros(len(x),float) #<x> average\\n xavg = sum(x)/len(x)\\n \\n yavg = np.zeros(len(y),float) #<y> average\\n yavg = sum(y)/len(y)\\n \\n x2avg = np.zeros(len(x),float) #<x^2> average\\n x2avg = sum(x**2)/len(x)\\n \\n xyavg = np.zeros(len(x),float) #<xy> average\\n xyavg = sum(x*y)/len(x)\\n \\n m = (xyavg - xavg*yavg)/(x2avg-xavg**2) #slope\\n b = (x2avg*yavg-xavg*xyavg)/(x2avg-xavg**2) #intercept\\n \\n d = np.zeros(len(x),float)\\n for n in range(len(x)):\\n d[n] = y[n] -(m*x[n]+b)\\n \\n x2 = np.zeros(len(x),float)\\n for n in range(len(x)):\\n x2[n] = sum(d[n]**2)\\n \\n \\n d2avg = np.zeros(len(d),float) #<d^2> average\\n d2avg = sum(x2)/float(len(x))\\n \\n Dm = sqrt((1/float(len(x)-2))*(d2avg/(x2avg-xavg**2))) #slope error\\n Db = sqrt((1/float(len(x)-2))*((d2avg*x2avg)/(x2avg-xavg**2))) # intercept error\\n print \\\"slope=\\\", m, \\\"Slope Error=\\\", Dm,\\\"Intercept=\\\", b, \\\"Intercept Error=\\\", Db\\n return \\\"slope=\\\", m, \\\"Slope Error=\\\", Dm,\\\"Intercept=\\\", b, \\\"Intercept Error=\\\",Db\",\n \"def fit(X):\\n n = len(X) - 1\\n xx = np.ones((n, 2))\\n xx[:,1] = X[:-1]\\n xx_trans = xx.transpose()\\n yy = X[1:]\\n coeffs = dot(dot(inv(dot(xx_trans, xx)), xx_trans), yy)\\n betahat, alphahat = coeffs\\n uhat = yy - dot(xx, coeffs)\\n sigma2hat = dot(uhat, uhat) / n\\n return betahat, alphahat, np.sqrt(sigma2hat)\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(x_array, y_array, function, A_start):\\n param = (x_array, y_array, function)\\n\\n A_final, cov_x, infodict, mesg, ier = leastsq(minimize, A_start, args=param, full_output=True)#, warning=True)\\n \\n return A_final\",\n \"def fit_least_squares(input_data, output_data):\\n # This function's code follows the formula for finding the weights\\n # that create the least mean-squared error, which is:\\n # w = (((y_t)x)(inv((x_t)x))_t)\\n\\n xtx = numpy.matmul(numpy.transpose(input_data),input_data)\\n xtx_inv = numpy.linalg.inv(xtx)\\n ytx = numpy.matmul(numpy.transpose(output_data),input_data)\\n\\n return LinearModel(numpy.transpose(numpy.matmul(ytx,xtx_inv)))\",\n \"def fit(self, X, y=None):\\n #import pdb\\n #pdb.set_trace()\\n return self.partial_fit(X, y)\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def fit(self, x, y):\\n # *** START CODE HERE ***\\n num_examples = x.shape[0]\\n num_features = x.shape[1]\\n iteration = 1\\n if self.theta == None:\\n self.theta = np.zeros((num_features,))\\n while iteration <= self.max_iter:\\n h_theta = np.dot(x, self.theta)\\n g_theta = self.sigmoid(h_theta)\\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\\n d_theta = - np.linalg.solve(H, J_prime)\\n self.theta += d_theta\\n if np.linalg.norm(d_theta, 1) < self.eps:\\n break\\n if self.verbose:\\n print(\\\"Loss value: \\\", J_cost)\\n iteration += 1\\n # *** END CODE HERE ***\",\n \"def linear_regression(x, y):\\n #print(\\\"Fitting\\\", y, \\\"\\\\nagainst\\\", x)\\n matrix = np.vstack( [x, np.ones_like(x)] ).T\\n slope, intercept = np.linalg.lstsq(matrix,y)[0]\\n #print(\\\"gives slope=\\\", slope, \\\"intercept=\\\", intercept)\\n return (slope, intercept)\",\n \"def fit(self, kernel=GaussianKernel(sigma=1.0), regularizer=1.0, sparsifiers=None):\\n\\n self.q = np.array((regularizer + kernel(self.x[0], self.x[0])) ** (-1))\\n self.coefficients = np.array([self.q * self.y[0]])\\n self.coefficient_history = [self.coefficients]\\n\\n self._estimate = np.zeros(self.y.shape)\\n self.support_vectors = np.array([self.x[0]]).reshape(-1, 1)\\n self.error_history = [0]\\n\\n self.kernel = kernel\\n\\n for i in range(1, self.n):\\n self.regressor = self.x[i]\\n\\n self.h = kernel(self.support_vectors, self.regressor).T\\n self.z = np.dot(self.q, self.h)\\n self.r = regularizer + kernel(self.x[i], self.x[i]) - np.dot(self.z, self.h)\\n\\n self.estimate[i] = np.dot(self.h.T, self.coefficients)\\n self.error = self.y[i] - self.estimate[i]\\n self.error_history.append(self.error)\\n\\n self.coefficients -= self.z * self.r ** (-1) * self.error\\n self.coefficient_history.append(self.coefficients)\\n\\n if sparsifiers:\\n for sparsifier in sparsifiers:\\n sparsifier.apply(self)\\n\\n else:\\n self.q = self.q * self.r + np.outer(self.z, self.z.T)\\n q_row = np.asarray(-self.z).reshape(-1, 1).T\\n q_col = np.asarray(-self.z).reshape(-1, 1)\\n q_end = np.array([1]).reshape(-1, 1)\\n\\n self.q = np.append(self.q, q_row, axis=0)\\n self.q = np.append(self.q, np.concatenate((q_col, q_end), axis=0), axis=1)\\n self.q = self.r ** (-1) * self.q\\n\\n self.support_vectors = np.vstack((self.support_vectors, self.regressor.reshape(1, -1)))\\n self.coefficients = np.append(self.coefficients, self.r ** (-1) * self.error)\",\n \"def linear_regression(features, values):\\n clf = SGDRegressor(n_iter=100)\\n clf.fit(features,values)\\n print(clf.score(features,values))\\n intercept = clf.intercept_ \\n params = clf.coef_\\n \\n return intercept, params\",\n \"def _lin_regress(self, y, x, bias=True):\\n n_samples = x.shape[0]\\n x = self.make_polynomial(x[:, np.newaxis], fit_intercept=bias)\\n l = np.linalg.cholesky(x.T @ x)\\n v = solve_triangular(l, x.T @ y, lower=True)\\n coefs = solve_triangular(l.T, v)\\n pred = x @ coefs\\n resid = y - pred\\n rss = resid @ resid\\n ddof = n_samples - (1 + bias)\\n return rss, ddof\",\n \"def fit(self) -> LinearRegressionParams:\\n result = self.__m.fit()\\n self._intercept, *self._coef = result.params\\n self._pvalues = result.f_pvalue\\n self._f_statistics = result.fvalue\\n self._r_squared = result.rsquared\\n\\n return LinearRegressionParams(\\n Coef=self._coef,\\n Intercept=self._intercept,\\n pvalues=self._pvalues,\\n F_statistics=self._f_statistics,\\n R_square=self._r_squared\\n )\",\n \"def quadratic_fit(self, xy, W):\\n\\t\\t# first construct the independent matrix\\n\\t\\ty = xy[:,1]\\n\\t\\tx = xy[:,0]\\n\\t\\tX = np.column_stack([np.ones(len(x)),\\n\\t\\t\\t\\t\\t\\t\\tx, np.power(x,2)])\\n\\n\\t\\twls_model = sm.WLS(y, X, weights = 1.0/W)\\t\\n\\t\\twls_model_results = wls_model.fit()\\n\\t\\t[c,b,a] = wls_model_results.params\\t\\n\\t\\treturn [a,b,c]\",\n \"def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \\\"TSExp\\\":\\n b_0 = y[-1] / y[-2]\\n a_0 = 0.1\\n c_0 = 0\\n guess = np.asarray([a_0, b_0, c_0], dtype=float)\\n\\n try:\\n popt = scipy.optimize.curve_fit(\\n self._func, X.ravel(), y, p0=guess, check_finite=False\\n )[0]\\n\\n self.a, self.b, self.c = popt\\n\\n self._fitted = True\\n\\n except RuntimeError:\\n self._fitted = False\\n\\n return self\",\n \"def linearRegression(x,y,f1,l1,f2,l2):\\n n = len(x)\\n sumx = 0.0 # sum_n(x_i)\\n sumy = 0.0 # sum_n(y_i)\\n sumxx = 0.0 # sum_n(x_i*x_i)\\n sumxy = 0.0 # sum_n(x_i*y_i)\\n count = 0\\n for i2 in range(f2,l2+1):\\n for i1 in range(f1,l1+1):\\n xi = x[i2][i1]\\n yi = y[i2][i1]\\n sumx += xi\\n sumy += yi\\n sumxx += xi*xi\\n sumxy += xi*yi\\n count += 1\\n beta = (sumxy-sumx*sumy/count)/(sumxx-sumx*sumx/count)\\n alpha = (sumy-beta*sumx)/count\\n #z = zerofloat(n)\\n #for i in range(n):\\n # if null is None or x[i]!=null:\\n # z[i] = alpha+beta*x[i]\\n #print 'slope =',beta\\n #return z\\n return beta\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\\n data)\\n #scipy rihjt\\n # Levenberg-Marquadt algorithm -> leastsq\\n #bnds = None\\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n \\n #least square fitting(minimizes raw data and fit)\\n\\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\\n #print(\\\"pass case\\\")\\n return(p)\\n else:\\n print(\\\"failed case\\\")\\n print(\\\"height1\\\", p[0],\\\"height2\\\", p[5], \\\"X\\\", p[1],\\\"Y\\\", p[2],\\\"Y1\\\", p[6], \\\"Y2\\\", p[7])\\n print(\\\"bounding error\\\" + str(numero)) \\n\\n return p\",\n \"def fit(self, X, y):\\n # compute W, b\\n # pull W from the normal distribution, and b from 0->2 pi\\n\\n self.N, d = X.shape\\n\\n # weights go from R^d -> R^D\\n self.W = rng.normal(loc=0, scale=1, size=(self.D, d))\\n # bias is in R, need D terms\\n self.b = rng.uniform(0, 2*np.pi, size=self.D)\\n\\n self.Z = self.compute_features(X)\\n \\n self._fit(y)\\n self.fitted = True\\n\\n # now solve the least-squares problem:\\n # min_w ||Z'w - y||_2^2 + \\\\lambda ||w||_2^2\\n\\n # done via linear equation solver, eg:\\n # A x = b to solve x\\n # use cholesky solver: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.cho_solve.html\\n\\n # self.L = cholesky(self.kernel, lower=True)\\n # self.alpha = cho_solve((self.L, True), y)\",\n \"def fit(self, X, y): \\n # initial values set by set_params when objet was initialised\\n _, D = X.shape \\n wb_init = np.zeros(D+1) # initial guess for weight vector\\n w, b = self.get_params() # set_params inits to zero vector for wb\\n wb_init[:-1] = w # self.w0\\n wb_init[-1] = b # self.b0\\n\\n wb_opt, _, _ = fmin_l_bfgs_b(func = self.objective, \\n x0 = wb_init, \\n fprime = self.objective_grad, \\n args = (X,y))\\n \\n self.set_params(wb_opt[:-1], wb_opt[-1])\\n return\",\n \"def fit(self, X, y):\\n self.model = self._initialize_model(X, y)\\n self.model.optimize()\",\n \"def fit(self, X):\\n raise NotImplementedError\",\n \"def fit(self, data):\\n x, y = np.asarray(data, dtype=float)\\n\\n # Quadratic part of design matrix [eqn. 15] from (*)\\n D1 = np.mat(np.vstack([x**2, x*y, y**2])).T\\n # Linear part of design matrix [eqn. 16] from (*)\\n D2 = np.mat(np.vstack([x, y, np.ones(len(x))])).T\\n\\n # forming scatter matrix [eqn. 17] from (*)\\n S1 = D1.T*D1\\n S2 = D1.T*D2\\n S3 = D2.T*D2\\n\\n # Constraint matrix [eqn. 18]\\n C1 = np.mat('0. 0. 2.; 0. -1. 0.; 2. 0. 0.')\\n\\n # Reduced scatter matrix [eqn. 29]\\n M = C1.I*(S1-S2*S3.I*S2.T)\\n\\n # M*|a b c >=l|a b c >. Find eigenvalues and eigenvectors from this equation [eqn. 28]\\n eval, evec = np.linalg.eig(M)\\n\\n # eigenvector must meet constraint 4ac - b^2 to be valid.\\n cond = 4*np.multiply(evec[0, :], evec[2, :]) - \\\\\\n np.power(evec[1, :], 2)\\n a1 = evec[:, np.nonzero(cond.A > 0)[1]]\\n\\n # |d f g> = -S3^(-1)*S2^(T)*|a b c> [eqn. 24]\\n a2 = -S3.I*S2.T*a1\\n\\n # eigenvectors |a b c d f g>\\n self.coef = np.vstack([a1, a2])\\n self._save_parameters()\",\n \"def predict_proba(X, fit_intercept, coeffs):\\n if fit_intercept:\\n coeffs_0 = coeffs[0]\\n coeffs = coeffs[1:]\\n else:\\n coeffs_0 = 0\\n u = coeffs_0 + X.dot(coeffs)\\n return QNEM.logistic_grad(u)\",\n \"def fit_function_LS(data, params, z, fn):\\n result = params\\n errorfunction = lambda p: fn(*p)(z) - data\\n good = True\\n [result, cov_x, infodict, mesg, success] = (\\n scipy.optimize.leastsq(\\n errorfunction, params, full_output = 1, maxfev = 500\\n )\\n )\\n err = errorfunction(result)\\n err = scipy.sum(err * err)\\n if (success < 1) or (success > 4):\\n print( \\\"Fitting problem!\\\", success, mesg)\\n good = False\\n return [result, cov_x, infodict, good]\",\n \"def fitbivarGaussian(data):\\n params = bivarParams(data)\\n errorfunction = lambda p: ravel(bivarGaussian(*p)(*indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def gaussfit(x, y, nterms=\\\"none\\\"):\\n\\n z = lambda x, A1, A2: (x - A1) / A2\\n\\n if nterms in [\\\"none\\\", 3]:\\n gauss = lambda x, A0, A1, A2: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n p0 = [max(y), 1, 1]\\n elif nterms in [\\\"constant\\\", 4]:\\n gauss = lambda x, A0, A1, A2, A3: A0 * np.exp(-z(x, A1, A2) ** 2 / 2) + A3\\n p0 = [max(y), 1, 1, 0]\\n elif nterms in [\\\"linear\\\", 5]:\\n gauss = (\\n lambda x, A0, A1, A2, A3, A4: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n + A3\\n + A4 * x\\n )\\n p0 = [max(y), 1, 1, 0, 0]\\n\\n elif nterms in [\\\"quadratic\\\", 6]:\\n gauss = (\\n lambda x, A0, A1, A2, A3, A4, A5: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n + A3\\n + A4 * x\\n + A5 * x ** 2\\n )\\n p0 = [max(y), 1, 1, 0, 0, 0]\\n\\n popt, _ = curve_fit(gauss, x, y, p0=p0)\\n return gauss(x, *popt), popt\",\n \"def regression_fit(self, x, y, deg):\\n return np.polyfit(x, y, deg=deg)\",\n \"def fit(self, x, y):\\r\\n\\r\\n self.train_x = x\\r\\n self.train_y = y\\r\\n self.__find_psi__()\",\n \"def fit(self, X, y):\\n # Make sure inputs are numpy arrays.\\n X = np.array(X)\\n y = np.array(y)\\n # Add x_0 = 1 to each instance for the bias term.\\n X = np.c_[np.ones((X.shape[0], 1)), X]\\n # Store number of samples and features in variables.\\n n_samples, n_features = np.shape(X)\\n self.training_errors = []\\n # Initialize weights randomly from normal distribution.\\n self.coef_ = np.random.randn(n_features, 1)\\n # Batch gradient descent for number iterations = n_iter.\\n for _ in range(self.n_iter):\\n y_preds = X.dot(self.coef_)\\n # Penalty term if regularized (don't include bias term).\\n regularization = self.regularization(self.coef_[1:])\\n # Calculate mse + penalty term if regularized.\\n cost_function = mean_squared_error(y, y_preds) + regularization\\n if cost_function > self.threshold:\\n break\\n self.training_errors.append(cost_function) \\n # Regularization term of gradients (don't include bias term).\\n gradient_reg = self.regularization.grad(self.coef_[1:])\\n # Gradients of loss function.\\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\\n gradients += gradient_reg\\n # Update the weights.\\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\\n\\n return self\",\n \"def nnRegression(data):\",\n \"def fit(self, X, y):\\n return BaseRegressor.fit(self, X, y)\",\n \"def fit_gp_regression(self, start=None, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n\\n results = self.mle_parameters(start=start)\\n\\n logger.info(\\\"Results of the GP fitting: \\\")\\n logger.info(results)\\n\\n sol = results['solution']\\n\\n self.update_value_parameters(sol)\\n\\n return self\",\n \"def fit_cpe(self, x, y):\\n self.cpe_model = LogisticRegressionCV(solver='liblinear')\\n self.cpe_model.fit(x, y)\",\n \"def linearReg(x,y):\\n X=np.array(x).reshape(-1,1)\\n Y=np.array(y).reshape(-1,1)\\n x_shape = X.shape\\n num_var = x_shape[1] \\n yintercept = 0\\n slope = 0\\n progress = []\\n #intialize the parameter\\n weight_matrix = np.random.normal(-1,1,(num_var,1))\\n yintercept = np.random.rand(1)\\n #cost minmization\\n for i in range(200):\\n dcostdm = np.sum(np.multiply(((np.matmul(X,weight_matrix)+ yintercept)-Y),X))*2/x_shape[0] #w.r.t to the weight\\n dcostdc = np.sum(((np.matmul(X,weight_matrix)+yintercept)-Y))*2/x_shape[0] #partial derivative of cost w.r.t the intercept\\n weight_matrix -= 0.1*dcostdm \\n #updating the weights with the calculated gradients\\n yintercept -= 0.1*dcostdc #updating the weights with the calculated gradients\\n progress.append(np.array((weight_matrix,yintercept)))\\n slope = weight_matrix\\n return (slope[-1],yintercept)\",\n \"def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\\\"\\\"):\\n if domain is not None:\\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\\n else:\\n fitdatax=xdata\\n fitdatay=ydata\\n if fitparams is None: \\n fitparams=[0.,0.,0.,0.]\\n fitparams[0]=fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[2]=fitdatax[0]\\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\\n #print fitparams\\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\\n label=label)\\n return p1\",\n \"def nnls_fit(self):\\n\\n def sprod(a,b): #simplecting inner product between two Pauli operators\\n return int(not a.commutes(b))\\n\\n F1 = [] #First list of terms\\n F2 = [] #List of term pairs\\n fidelities = [] # list of fidelities from fits\\n\\n for datum in self._term_data.values():\\n F1.append(datum.pauli)\\n fidelities.append(datum.fidelity)\\n #If the Pauli is conjugate to another term in the model, a degeneracy is present\\n if self._issingle(datum):\\n F2.append(datum.pauli)\\n else:\\n pair = datum.pair\\n F2.append(pair)\\n\\n #create commutativity matrices\\n M1 = [[sprod(a,b) for a in F1] for b in F1]\\n M2 = [[sprod(a,b) for a in F1] for b in F2]\\n\\n #check to make sure that there is no degeneracy\\n if np.linalg.matrix_rank(np.add(M1,M2)) != len(F1):\\n raise Exception(\\\"Matrix is not full rank, something went wrong!\\\")\\n \\n #perform least-squares estimate of model coefficients and return as noisemodel \\n coeffs,_ = nnls(np.add(M1,M2), -np.log(fidelities)) \\n self.noisemodel = NoiseModel(self.layer._cliff_layer, F1, coeffs)\",\n \"def gp_lc_fit(x_data, y_data, yerr_data=0.0, kernel=\\\"matern52\\\"):\\n\\n # define the objective function (negative log-likelihood in this case)\\n def neg_log_like(params):\\n \\\"\\\"\\\"Negative log-likelihood.\\\"\\\"\\\"\\n gp.set_parameter_vector(params)\\n log_like = gp.log_likelihood(y, quiet=True)\\n if np.isfinite(log_like):\\n return -log_like\\n else:\\n return np.inf\\n\\n # and the gradient of the objective function\\n def grad_neg_log_like(params):\\n \\\"\\\"\\\"Gradient of the negative log-likelihood.\\\"\\\"\\\"\\n gp.set_parameter_vector(params)\\n return -gp.grad_log_likelihood(y, quiet=True)\\n\\n x, y, yerr = np.copy(x_data), np.copy(y_data), np.copy(yerr_data)\\n x_min, x_max = x.min(), x.max()\\n\\n y_norm = y.max()\\n y /= y_norm\\n yerr /= y_norm\\n\\n var, length_scale = np.var(y), np.diff(x).max()\\n\\n if kernel == \\\"matern52\\\":\\n ker = var * Matern52Kernel(length_scale**2)\\n elif kernel == \\\"matern32\\\":\\n ker = var * Matern32Kernel(length_scale**2)\\n elif kernel == \\\"squaredexp\\\":\\n ker = var * ExpSquaredKernel(length_scale**2)\\n else:\\n raise ValueError(f'\\\"{kernel}\\\" is not a valid kernel.')\\n\\n gp = george.GP(kernel=ker, fit_mean=True)\\n # initial guess\\n gp.compute(x, yerr)\\n\\n # optimization routine for hyperparameters\\n p0 = gp.get_parameter_vector()\\n results = scipy.optimize.minimize(\\n neg_log_like, p0, jac=grad_neg_log_like, method=\\\"L-BFGS-B\\\"\\n )\\n gp.set_parameter_vector(results.x)\\n\\n step = 0.05 # days\\n x_pred = np.arange(x_min, x_max + step, step)\\n\\n mean, var = gp.predict(y, x_pred, return_var=True)\\n std = np.sqrt(var)\\n\\n x_pred, y_pred, yerr_pred = x_pred, mean * y_norm, std * y_norm\\n\\n return x_pred, y_pred, yerr_pred\",\n \"def fit_regression(\\n polynomials,\\n abscissas,\\n evals,\\n model=None,\\n retall=False,\\n):\\n logger = logging.getLogger(__name__)\\n abscissas = numpy.asarray(abscissas)\\n if len(abscissas.shape) == 1:\\n abscissas = abscissas.reshape(1, *abscissas.shape)\\n evals = numpy.array(evals)\\n\\n poly_evals = polynomials(*abscissas).T\\n shape = evals.shape[1:]\\n if shape:\\n evals = evals.reshape(evals.shape[0], int(numpy.prod(evals.shape[1:])))\\n\\n if model is None:\\n uhat = linalg.lstsq(poly_evals, evals)[0]\\n\\n else:\\n try:\\n from sklearn.base import BaseEstimator\\n except ImportError:\\n raise ValueError(\\n \\\"arg model != None requires that scikit-learn is installed\\\")\\n\\n if not isinstance(model, BaseEstimator):\\n raise ValueError(\\\"model not recognized; \\\"\\n \\\"Optional[sklearn.base.BaseEstimator] expected\\\")\\n if hasattr(model, \\\"fit_intercept\\\"):\\n assert not model.fit_intercept, (\\n \\\"model %s must have fit_intercept=False\\\" % model.__class__.__name__)\\n uhat = model.fit(poly_evals, evals).coef_.T\\n\\n if shape:\\n evals = evals.reshape(evals.shape[0], *shape)\\n\\n approx_model = numpoly.sum((polynomials*uhat.T), -1)\\n approx_model = approx_model.reshape(shape)\\n\\n if retall == 1:\\n return approx_model, uhat\\n if retall == 2:\\n return approx_model, uhat, poly_evals\\n return approx_model\",\n \"def linear_regression(x_train, t_train, basis, bias,reg_lambda=0, degree=1, mu=0, s=1):\\n \\n # Construct the design matrix.\\n # Pass the required parameters to this function\\n \\n phi = design_matrix(x_train,basis,degree,bias,mu,s) \\n #print(x_train.shape) \\n # Learning Coefficients\\n if reg_lambda > 0:\\n I=np.identity((phi.shape[1]),dtype=int)\\n inv = np.linalg.inv((reg_lambda*I)+(phi.T@phi))\\n w = inv@(phi.T@t_train) \\n # regularized regression\\n else:\\n # no regularization \\n w = np.linalg.pinv(phi)@t_train\\n \\n pred_train=phi@w\\n train_err = np.sqrt((np.square(pred_train-t_train)).mean())\\n return (w, train_err)\",\n \"def fit(self, X, y):\\n assert X.shape[0] == y.shape[0]\\n\\n intercept = np.ones((X.shape[0], 1))\\n X = np.concatenate((X, intercept), axis=1)\\n\\n self.theta = np.random.randn(X.shape[1], 1)\\n theta_updated = True\\n while theta_updated:\\n theta_updated = False\\n for i in range(X.shape[0]):\\n x, yy = X[i, :], y[i]\\n # if label yy and sign of decision function do not agree\\n # sample x on wrong side of the hyperplane\\n if yy * (np.dot(self.theta.T, x.reshape(-1, 1))) <= 0:\\n # -y * theta.T * x / d theta = -y*x\\n # parameter := parameter - alpha * gradient\\n parameter_gradient = -yy * x.reshape(-1, 1)\\n self.theta = self.theta - parameter_gradient\\n theta_updated = True\",\n \"def fit(ydata):\\n xdata = np.linspace(0,len(ydata),num = len(ydata))\\n popt, pcov = curve_fit(func, xdata, ydata)\\n #returns the parameters of the fitting\\n return popt\",\n \"def fit(self, X, y):\\n if isinstance(self.gamma, str):\\n if self.gamma == 'scale':\\n self._gamma = 1. / (X.shape[1] * X.var()) if X.var() != 0 else 1.0\\n \\n elif self.gamma == 'auto':\\n self._gamma = 1. / X.shape[1]\\n \\n else:\\n msg = (\\\"The gamma can only be 'auto' or 'scale'.\\\")\\n raise ValueError(msg)\\n else:\\n self._gamma = self.gamma\\n \\n self.kwargs = {'degree' : self.degree, 'gamma' : self._gamma, 'coef0' : self.coef0}\\n \\n X, y = np.asarray(X), np.asarray(y, dtype=np.int64)\\n \\n n_samples, n_features = X.shape\\n\\n # Gram Matrix\\n K = np.zeros(shape = (n_samples, n_samples))\\n for i in range(n_samples):\\n for j in range(n_samples):\\n K[i][j] = self.kernel_function(X[i], X[j], **self.kwargs)\\n \\n P = cvxopt.matrix(np.outer(y,y) * K)\\n q = cvxopt.matrix(np.ones(n_samples) * -1)\\n A = cvxopt.matrix(y, (1, n_samples), 'd')\\n b = cvxopt.matrix(0.0)\\n \\n tmp1 = np.diag(np.ones(n_samples) * -1)\\n tmp2 = np.identity(n_samples)\\n G = cvxopt.matrix(np.vstack((tmp1, tmp2)))\\n tmp1 = np.zeros(n_samples)\\n tmp2 = np.ones(n_samples) * self.C\\n h = cvxopt.matrix(np.hstack((tmp1, tmp2)))\\n \\n cvxopt.solvers.options['show_progress'] = False\\n # solve QP problem\\n solution = cvxopt.solvers.qp(P, q, G, h, A, b)\\n\\n # Lagrange multipliers\\n a = np.ravel(solution['x'])\\n\\n # Support vectors have non zero lagrange multipliers\\n sv = a > 1e-5\\n ind = np.arange(len(a))[sv]\\n self.a = a[sv]\\n self.sv = X[sv]\\n self.sv_y = y[sv]\\n# print(\\\"%d support vectors out of %d points\\\" % (len(self.a), n_samples))\\n\\n # Intercept\\n self.b = 0\\n for n in range(len(self.a)):\\n self.b += self.sv_y[n]\\n self.b -= np.sum(self.a * self.sv_y * K[ind[n],sv])\\n self.b /= len(self.a)\\n\\n # Weight vector\\n if self.kernel == 'linear':\\n self.w = np.zeros(n_features)\\n for n in range(len(self.a)):\\n self.w += self.a[n] * self.sv_y[n] * self.sv[n]\\n else:\\n self.w = None\\n \\n return self\",\n \"def fit(self, x):\\n raise NotImplementedError()\",\n \"def fit_power(eigvals_rot):\\n\\n\\n L = eigvals_rot\\n\\n # Consider only the first 50 eigenvalues, otherwise the\\n # curve fitting could be excessively driven by the right\\n # tail of the distribution, which has very low values.\\n L = L[0:50]\\n\\n # Define the fitting function for L\\n def powerfunc(x, amp, exponent):\\n return amp * (x ** exponent)\\n\\n # Define a number of x points corresponding to len(L)\\n xL = np.arange(len(L)) + 1\\n\\n # Perform curve fitting\\n popt, _ = curve_fit(powerfunc, xL, L, method='lm')\\n\\n # Calculate the distance from the origin, which is interpreted\\n # as the elbow point\\n x = np.linspace(1, 50, 1000)\\n y = powerfunc(x, *popt)\\n\\n d = np.sqrt(x**2 + y**2)\\n i0 = np.where(d == np.min(d))\\n\\n x0 = x[np.squeeze(i0)]\\n # y0 = y[np.squeeze(i0)]\\n\\n # Establish the number of principal components on the basis of this\\n npc = np.int(np.round(x0))\\n return npc\",\n \"def fit_poly(data, error_func, degree=4): \\n\\n # generate initial guss for polynomial model (all coeffs = 1)\\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\\n\\n # plot intial guess\\n x = np.linspace(-5, 5, 21)\\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\\\"Initial guess\\\")\\n\\n # call optimizer to minimize error function\\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\\n \\n # convert optimal result into a poly1d object\\n return np.poly1d(result.x)\",\n \"def test_linear_fit_fixed_parameter(self):\\n init_model = models.Polynomial1D(degree=2, c1=1)\\n init_model.c1.fixed = True\\n\\n x = np.arange(10)\\n y = 2 + x + 0.5 * x * x\\n\\n fitter = LinearLSQFitter()\\n fitted_model = fitter(init_model, x, y)\\n assert_allclose(fitted_model.parameters, [2.0, 1.0, 0.5], atol=1e-14)\",\n \"def fit_moffat(z, x, y):\\n input_params = [15000.0, 5.0, 5.0, 5.0, 5.0]\\n fit_params, success = optimize.leastsq(moffat_residuals, input_params, \\n args=(z, x, y), maxfev=10000)\\n return fit_params\",\n \"def linear(self, verbose=0):\\n\\n # Output linear regression summary with coefficients and p-values\\n # if desired\\n if verbose != 0:\\n model = sm.OLS(self.y_train, sm.add_constant(self.X_train)).fit()\\n print(model.summary())\\n\\n linear_regressor = LinearRegression(fit_intercept=True, normalize=False,\\n copy_X=True)\\n linear_score = np.mean(cross_val_score(\\n estimator=linear_regressor, X=self.X_train, y=self.y_train,\\n cv=5, scoring=self.scorer))\\n print('Linear score: ' + str(linear_score))\\n return linear_regressor\",\n \"def computeRegression(Xin, Yin, Xtest, noise, ls, sv):\\n\\n # compute kernels\\n K = kernel_sqExp(Xin, Xin, ls=ls, sv=sv)\\n Kstar = kernel_sqExp(Xin, Xtest, ls=ls, sv=sv)\\n Kstarstar = kernel_sqExp(Xtest, Xtest, ls=ls, sv=sv)\\n\\n # compute mean based on training input points\\n n1 = np.shape(K)[0]\\n offSet = 1e-3\\n L = np.linalg.cholesky(K + noise*np.eye(n1) + offSet*np.eye(n1))\\n alpha = np.linalg.solve(L.T, np.linalg.solve(L,Yin))\\n f_mean = np.dot(Kstar.T,alpha) # mean of points\\n \\n # compute resulting covariance of predictive distribution\\n v = np.linalg.solve(L, Kstar)\\n cov = Kstarstar - np.dot(v.T,v)\\n \\n # compute log of marginal likelihood\\n #lML = -0.5*np.dot(Yin.T,alpha) - np.sum(np.log(L)) - (n1/2*np.log(2*math.pi))\\n lML_dataFit = -0.5*np.dot(Yin.T,alpha)\\n lML_complexity = -np.sum(np.log(L))\\n lML_normalize = -(n1/2*np.log(2*math.pi))\\n lML_details = [lML_dataFit, lML_complexity, lML_normalize]\\n lML = lML_dataFit[0] + lML_complexity + lML_normalize \\n \\n return f_mean, cov, lML , lML_details\",\n \"def fit(self, X, y):\\n \\n # Create a copy of X that has a column for the intercept if the user\\n # wants one.\\n X_copy = self._add_intercept(X)\\n \\n # Fit the model coefficients using SVD.\\n self._fit_svd(X_copy, y, alpha=0.0)\\n \\n # Calculate model statistics.\\n self._calculate_model_stats_ols(X, y)\\n \\n return\",\n \"def linear_regression(self, x_data, y_data, mask = None, ax = None):\\n if mask is None:\\n mask = full(len(y_data), True, dtype=bool)\\n poly = poly1d(polyfit(x_data[mask], y_data[mask], 1))\\n\\n if ax is not None:\\n ax.plot(x_data, polyval(poly, x_data), \\\"--r\\\",\\\\\\n label = \\\"Slope: %.2f\\\" %(poly[1]))\\n return poly\",\n \"def partial_fit(self, X, y=..., **fit_params):\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6792636","0.6785291","0.6730444","0.6671837","0.66564393","0.66392154","0.66048634","0.6589059","0.6574239","0.6574239","0.6574239","0.656269","0.65618896","0.6551248","0.6550165","0.65029776","0.64471906","0.6393028","0.638561","0.63669246","0.63662094","0.63563156","0.63480806","0.63480806","0.6322349","0.6304993","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.62945694","0.6291293","0.62842","0.62791926","0.6275968","0.62676716","0.62551343","0.6181614","0.61272466","0.6123665","0.611517","0.6111378","0.61056435","0.6080127","0.60776067","0.6074051","0.6074051","0.6072045","0.6067369","0.6066513","0.60497385","0.6047977","0.60299087","0.6026179","0.6026004","0.6023472","0.6011875","0.6001497","0.59982425","0.59918326","0.598858","0.5984624","0.59807986","0.5974396","0.5963029","0.5963005","0.59625715","0.59584236","0.5952272","0.59502","0.5944369","0.59373194","0.59270465","0.5921472","0.590513","0.5904511","0.5903418","0.5902898","0.59027034","0.59006464","0.58984494","0.589532","0.5889546","0.58858556","0.5863629","0.5859494","0.5848856","0.5831633","0.5818051","0.5813591","0.58079946","0.5803603","0.57991064","0.57966423","0.5791662","0.5789516"],"string":"[\n \"0.6792636\",\n \"0.6785291\",\n \"0.6730444\",\n \"0.6671837\",\n \"0.66564393\",\n \"0.66392154\",\n \"0.66048634\",\n \"0.6589059\",\n \"0.6574239\",\n \"0.6574239\",\n \"0.6574239\",\n \"0.656269\",\n \"0.65618896\",\n \"0.6551248\",\n \"0.6550165\",\n \"0.65029776\",\n \"0.64471906\",\n \"0.6393028\",\n \"0.638561\",\n \"0.63669246\",\n \"0.63662094\",\n \"0.63563156\",\n \"0.63480806\",\n \"0.63480806\",\n \"0.6322349\",\n \"0.6304993\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.62945694\",\n \"0.6291293\",\n \"0.62842\",\n \"0.62791926\",\n \"0.6275968\",\n \"0.62676716\",\n \"0.62551343\",\n \"0.6181614\",\n \"0.61272466\",\n \"0.6123665\",\n \"0.611517\",\n \"0.6111378\",\n \"0.61056435\",\n \"0.6080127\",\n \"0.60776067\",\n \"0.6074051\",\n \"0.6074051\",\n \"0.6072045\",\n \"0.6067369\",\n \"0.6066513\",\n \"0.60497385\",\n \"0.6047977\",\n \"0.60299087\",\n \"0.6026179\",\n \"0.6026004\",\n \"0.6023472\",\n \"0.6011875\",\n \"0.6001497\",\n \"0.59982425\",\n \"0.59918326\",\n \"0.598858\",\n \"0.5984624\",\n \"0.59807986\",\n \"0.5974396\",\n \"0.5963029\",\n \"0.5963005\",\n \"0.59625715\",\n \"0.59584236\",\n \"0.5952272\",\n \"0.59502\",\n \"0.5944369\",\n \"0.59373194\",\n \"0.59270465\",\n \"0.5921472\",\n \"0.590513\",\n \"0.5904511\",\n \"0.5903418\",\n \"0.5902898\",\n \"0.59027034\",\n \"0.59006464\",\n \"0.58984494\",\n \"0.589532\",\n \"0.5889546\",\n \"0.58858556\",\n \"0.5863629\",\n \"0.5859494\",\n \"0.5848856\",\n \"0.5831633\",\n \"0.5818051\",\n \"0.5813591\",\n \"0.58079946\",\n \"0.5803603\",\n \"0.57991064\",\n \"0.57966423\",\n \"0.5791662\",\n \"0.5789516\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20277,"cells":{"query":{"kind":"string","value":"Find the best fit correction for the light curve."},"document":{"kind":"string","value":"def correct(\n self,\n design_matrix_collection,\n cadence_mask=None,\n sigma=5,\n niters=5,\n propagate_errors=False,\n ):\n if not isinstance(design_matrix_collection, DesignMatrixCollection):\n if isinstance(design_matrix_collection, SparseDesignMatrix):\n design_matrix_collection = SparseDesignMatrixCollection(\n [design_matrix_collection]\n )\n elif isinstance(design_matrix_collection, DesignMatrix):\n design_matrix_collection = DesignMatrixCollection(\n [design_matrix_collection]\n )\n\n # Validate the design matrix. Emits a warning if the matrix has low rank.\n design_matrix_collection.validate()\n self.design_matrix_collection = design_matrix_collection\n\n if cadence_mask is None:\n self.cadence_mask = np.ones(len(self.lc.time), bool)\n else:\n self.cadence_mask = cadence_mask\n\n # Create an outlier mask using iterative sigma clipping\n self.outlier_mask = np.zeros_like(self.cadence_mask)\n for count in range(niters):\n tmp_cadence_mask = self.cadence_mask & ~self.outlier_mask\n coefficients, coefficients_err = self._fit_coefficients(\n cadence_mask=tmp_cadence_mask,\n prior_mu=self.dmc.prior_mu,\n prior_sigma=self.dmc.prior_sigma,\n propagate_errors=propagate_errors,\n )\n model = np.ma.masked_array(\n data=self.dmc.X.dot(coefficients), mask=~tmp_cadence_mask\n )\n model = u.Quantity(model, unit=self.lc.flux.unit)\n residuals = self.lc.flux - model\n if isinstance(residuals, Masked):\n # Workaround for https://github.com/astropy/astropy/issues/14360\n # in passing MaskedQuantity to sigma_clip, by converting it to Quantity.\n # We explicitly fill masked values with `np.nan` here to ensure they are masked during sigma clipping.\n # To handle unlikely edge case, convert int to float to ensure filing `np.nan` work.\n # The conversion is acceptable because only the mask of the sigma_clip() result is used.\n if np.issubdtype(residuals.dtype, np.int_):\n residuals = residuals.astype(float)\n residuals = residuals.filled(np.nan)\n with warnings.catch_warnings(): # Ignore warnings due to NaNs\n warnings.simplefilter(\"ignore\", AstropyUserWarning)\n self.outlier_mask |= sigma_clip(residuals, sigma=sigma).mask\n log.debug(\n \"correct(): iteration {}: clipped {} cadences\"\n \"\".format(count, self.outlier_mask.sum())\n )\n\n self.coefficients = coefficients\n self.coefficients_err = coefficients_err\n\n model_flux = self.dmc.X.dot(coefficients)\n model_flux -= np.median(model_flux)\n if propagate_errors:\n with warnings.catch_warnings():\n # ignore \"RuntimeWarning: covariance is not symmetric positive-semidefinite.\"\n warnings.simplefilter(\"ignore\", RuntimeWarning)\n samples = np.asarray(\n [\n self.dmc.X.dot(\n np.random.multivariate_normal(\n coefficients, coefficients_err\n )\n )\n for idx in range(100)\n ]\n ).T\n model_err = np.abs(\n np.percentile(samples, [16, 84], axis=1)\n - np.median(samples, axis=1)[:, None].T\n ).mean(axis=0)\n else:\n model_err = np.zeros(len(model_flux))\n self.model_lc = LightCurve(\n time=self.lc.time,\n flux=u.Quantity(model_flux, unit=self.lc.flux.unit),\n flux_err=u.Quantity(model_err, unit=self.lc.flux.unit),\n )\n self.corrected_lc = self.lc.copy()\n self.corrected_lc.flux = self.lc.flux - self.model_lc.flux\n self.corrected_lc.flux_err = (self.lc.flux_err ** 2 + model_err ** 2) ** 0.5\n self.diagnostic_lightcurves = self._create_diagnostic_lightcurves()\n return self.corrected_lc"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _get_lip_best(self) -> float:\n pass","def test_intra_power_law_fit2(self):\n\t\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\n\t\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, sparsify=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\n\t\tactual_alpha = details.alpha[0]\n\t\t#actual_best_fit = details.best_fit[0]\n\t\t#print(actual_alpha,actual_best_fit)\n\n\n\t\texpected_alpha = 2.719 # close to exact ?\n\t\t#expected_best_fit = LOG_NORMAL\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=2)\n\t\t#self.assertEqual(actual_best_fit, expected_best_fit)","def get_lip_best(self) -> float:\n if self._fitted:\n if self._ready_lip_best:\n return self._lip_best\n else:\n lip_best = self._get_lip_best()\n self._set(\"_lip_best\", lip_best)\n self._set(\"_ready_lip_best\", True)\n return lip_best\n else:\n raise ValueError(\"call ``fit`` before calling ``get_lip_best``\")","def test_intra_power_law_fit(self):\n\n\t\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\n\t\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, randomize=False, vectors=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\n\t\tactual_alpha = details.alpha[0]\n\t\t#actual_best_fit = details.best_fit[0]\n\t\t#print(actual_alpha,actual_best_fit)\n\n\t\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\n\t\t#expected_best_fit = LOG_NORMAL\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)\n\t\t#self.assertEqual(actual_best_fit, expected_best_fit)","def fitGammaFun(self, x, y):\n minGamma = 0.8\n maxGamma = 20.0\n gammaGuess = 2.0\n y = numpy.asarray(y)\n minLum = y[0]\n maxLum = y[-1]\n if self.eq == 4:\n aGuess = old_div(minLum, 5.0)\n kGuess = (maxLum - aGuess)**(old_div(1.0, gammaGuess)) - aGuess\n guess = [gammaGuess, aGuess, kGuess]\n bounds = [[0.8, 5.0], [0.00001, minLum - 0.00001], [2, 200]]\n else:\n guess = [gammaGuess]\n bounds = [[0.8, 5.0]]\n # gamma = optim.fmin(self.fitGammaErrFun, guess, (x, y, minLum, maxLum))\n # gamma = optim.fminbound(self.fitGammaErrFun,\n # minGamma, maxGamma,\n # args=(x,y, minLum, maxLum))\n params = optim.fmin_tnc(self.fitGammaErrFun, numpy.array(guess),\n approx_grad=True,\n args=(x, y, minLum, maxLum),\n bounds=bounds, messages=0)\n return minLum, maxLum, params","def _model_fit_term(self):\r\n if self.likelihood.YYT is None:\r\n tmp, _ = dtrtrs(self.L, np.asfortranarray(self.likelihood.Y), lower=1)\r\n return -0.5 * np.sum(np.square(tmp))\r\n # return -0.5 * np.sum(np.square(np.dot(self.Li, self.likelihood.Y)))\r\n else:\r\n return -0.5 * np.sum(np.multiply(self.Ki, self.likelihood.YYT))","def _residual_edp(self, params):\n data = self.F**2\n model = np.absolute(self._model())**2\n sigma = self.sigma\n return (data[self.mask]-model[self.mask]) / sigma[self.mask] \n \n # The following three lines do not reproduce Sun's results, which proves\n # that the fits were done through intensity, not form factor.\n #data = self.F\n #model = np.absolute(self._model())\n #return (data - model) ","def hangerqs_old(fitparams):\n return abs(fitparams[1]/fitparams[2]), abs(fitparams[1])/(1-abs(fitparams[2]))","def test_fit(self, model):\r\n fit = model/np.linalg.norm(model, axis=1, keepdims=True)\r\n if self.white:\r\n sources = self.sources.dot(self.zca_matrix)\r\n sources /= np.linalg.norm(sources, axis=1, keepdims=True)\r\n else:\r\n sources = self.sources\r\n allthedots = sources.dot(fit.T)\r\n # how close is the closest model source to each true source?\r\n bestfits = np.max(np.abs(allthedots), axis=1)\r\n return np.median(bestfits)","def guess_fit_parameters(self):\n\n def errfcn(pars):\n lnl = -self._lnprob(pars)\n p = list(pars)\n p.append(lnl)\n logging.info(p)\n return lnl if np.isfinite(lnl) else np.sign(lnl) * 9e9\n\n if self.vary_bin_frac:\n initial_pars = [0.5, 0.5]\n bounds_list = [[0.0, 1.0], [0, 0.999]]\n else:\n initial_pars = [0.5]\n bounds_list = [[0, 0.999]]\n out = minimize(errfcn, initial_pars, bounds=bounds_list)\n self.guess_pars = out.x\n return out.x","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def check_and_fit(x, y, flag='L', threshold=1000):\n \n confidence_index = len(x)\n if IsLaneFound is False:\n threshold =500\n if confidence_index < threshold:\n fit = None\n foundFlag = False\n else:\n fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)\n foundFlag = True\n return fit, foundFlag, confidence_index","def _model_fit_term(self):\n if self.likelihood.YYT is None:\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\n else:\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))","def BestFit(self,initialParameterValues = None, method = None, fixedParams=None):\n\n if fixedParams:\n if not isinstance(fixedParams, list):\n fixedParams=[fixedParams]\n #Check now if the name is correct\n l_index=[]\n for index, par in enumerate(fixedParams):\n pName, pValue = par\n if pName not in self.theory.parameterNameList0:\n print \"%s is not a valid name. Ignored\" %pName\n l_index.append(index)\n if l_index:\n for i in l_index:\n fixedParams.pop(i)\n\n self.theory.SetFixedParams(fixedParams)\n\n if initialParameterValues is None:\n initialParameterValues = self.theory.initialParameterValues\n #d = numpy.ones(len(initialParamaeterValues))\n start_time = time.time()\n if method is None or method == 'lm':\n out = scipy.optimize.minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\n elif method == 'boldAccel':\n initialParameterValues=numpy.array(initialParameterValues)\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\n elif method == 'bold':\n initialParameterValues = numpy.array(initialParameterValues)\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\n elif method == 'lm_accel':\n initialParameterValues=numpy.array(initialParameterValues)\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\n else:\n print \"fitting method is not included\"\n out = None\n end_time = time.time()\n print \"fitting took (mins)\", (end_time-start_time)/60.\n print \"number of function evals:\", f_counter\n \n if fixedParams:\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\n self.theory.SetFixedParams()\n else:\n outputParameterValues = out[0]\n\n\n return outputParameterValues, out","def lorentzfit(x, y, peak=1., center=0., std=.1):\r\n def res(p, y, x):\r\n top1, m1, std1 = p\r\n y_fit = mm.lorentz(x, top1, m1, std1)\r\n err = y - y_fit\r\n return err\r\n p = [peak, center, std] # Initial guesses for leastsq\r\n plsq = leastsq(res, p, args = (y, x), maxfev=2000)\r\n \r\n return plsq[0]","def BestFit(self,initialParameterValues=None, method=None , fixedParams=None):\n\n if fixedParams:\n if not isinstance(fixedParams, list):\n fixedParams=[fixedParams]\n #Check now if the name is correct\n l_index=[]\n for index, par in enumerate(fixedParams):\n pName, pValue = par\n if pName not in self.theory.parameterNameList0:\n print \"%s is not a valid name. Ignored\" %pName\n l_index.append(index)\n if l_index:\n for i in l_index:\n fixedParams.pop(i)\n self.SetFixedParams(fixedParams)\n\n if initialParameterValues is None:\n initialParameterValues = self.theory.initialParameterValues\n #d = numpy.ones(len(initialParameterValues))\n start_time = time.time()\n if method is None or method == 'lm':\n out = minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\n elif method == 'boldAccel':\n initialParameterValues=numpy.array(initialParameterValues)\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\n elif method == 'bold':\n initialParameterValues = numpy.array(initialParameterValues)\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\n elif method == 'lm_accel':\n initialParameterValues=numpy.array(initialParameterValues)\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\n else:\n print \"fitting method is not included\"\n end_time = time.time()\n print \"fitting took time (mins): \", (end_time-start_time)/60.\n print \"number of function_calls:\", f_counter\n \n if fixedParams:\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\n else:\n outputParameterValues = out[0]\n\n return outputParameterValues, out","def vct_resistance_correction(\n data: pd.DataFrame, data_TT_MDL: pd.DataFrame\n) -> pd.DataFrame:\n df_resistance = data.groupby(by=\"test type\").get_group(\"resistance\")\n result1 = least_squares(\n fun=error, x0=[0], kwargs={\"y\": df_resistance[\"fx\"], \"u\": df_resistance[\"u\"]}\n )\n\n data[\"fx\"] -= res(result1.x, u=data[\"u\"])\n\n R_m = data_TT_MDL[\"Rm [N]\"]\n fx = -R_m\n result2 = least_squares(\n fun=error,\n x0=result1.x,\n kwargs={\"y\": fx, \"u\": fx.index},\n )\n\n R_factor = 1.14\n # R_factor = 1.14 * 1.43\n data[\"fx\"] += R_factor * res(result2.x, u=data[\"u\"])\n\n return data","def STRidge(X0, y, lam, maxit, tol, normalize=0, print_results=False):\n\n n, d = X0.shape\n X = np.zeros((n, d), dtype=np.complex64)\n # First normalize data\n if normalize != 0:\n Mreg = np.zeros((d, 1))\n for i in range(0, d):\n Mreg[i] = 1.0 / (np.linalg.norm(X0[:, i], normalize))\n X[:, i] = Mreg[i] * X0[:, i]\n else:\n X = X0\n\n # Get the standard ridge estimate\n if lam != 0:\n w = np.linalg.lstsq(X.T.dot(X) + lam * np.eye(d), X.T.dot(y))[0]\n else:\n w = np.linalg.lstsq(X, y)[0]\n num_relevant = d\n biginds = np.where(abs(w) > tol)[0]\n\n # Threshold and continue\n for j in range(maxit):\n\n # Figure out which items to cut out\n smallinds = np.where(abs(w) < tol)[0]\n new_biginds = [i for i in range(d) if i not in smallinds]\n\n # If nothing changes then stop\n if num_relevant == len(new_biginds):\n break\n else:\n num_relevant = len(new_biginds)\n\n # Also make sure we didn't just lose all the coefficients\n if len(new_biginds) == 0:\n if j == 0:\n # if print_results: print \"Tolerance too high - all coefficients set below tolerance\"\n return w\n else:\n break\n biginds = new_biginds\n\n # Otherwise get a new guess\n w[smallinds] = 0\n if lam != 0:\n w[biginds] = \\\n np.linalg.lstsq(X[:, biginds].T.dot(X[:, biginds]) + lam * np.eye(len(biginds)), X[:, biginds].T.dot(y))[0]\n else:\n w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\n\n # Now that we have the sparsity pattern, use standard least squares to get w\n if biginds != []: w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\n\n if normalize != 0:\n return np.multiply(Mreg, w)\n else:\n return w","def fitGammaErrFun(self, params, x, y, minLum, maxLum):\n if self.eq == 4:\n gamma, a, k = params\n _m = gammaFun(x, minLum, maxLum, gamma, eq=self.eq, a=a, k=k)\n model = numpy.asarray(_m)\n else:\n gamma = params[0]\n _m = gammaFun(x, minLum, maxLum, gamma, eq=self.eq)\n model = numpy.asarray(_m)\n SSQ = numpy.sum((model - y)**2)\n return SSQ","def get_duct_linear_heat_loss_coefficient() -> float:\n return 0.49","def _find_cutoff(self):\n cutoff = 1\n while ((self.linear_rstar_unnorm(cutoff) -\n self.turing_rstar_unnorm(cutoff))**2\n > self.approx_turing_variance(cutoff)):\n cutoff += 1\n return cutoff","def r_sq(data, fit):\n ss_res = np.sum((data - fit) ** 2)\n ss_tot = np.sum((data - np.mean(data)) ** 2)\n\n return 1 - (ss_res / ss_tot)","def sharpness_penalty(self):\n # This polynomial function gives the gain for peaking filter which achieves 18 dB / octave max derivative\n # The polynomial estimate is accurate in the vicinity of 18 dB / octave\n gain_limit = -0.09503189270199464 + 20.575128011847003 * (1 / self.q)\n # Scaled sigmoid function as penalty coefficient\n x = self.gain / gain_limit - 1\n sharpness_penalty_coefficient = 1 / (1 + np.e ** (-x * 100))\n return np.mean(np.square(self.fr * sharpness_penalty_coefficient))","def linfit(x, y, yerror, pinit=[0,0]):\n x = np.array(x)\n y = np.array(y)\n if (type(yerror) != list and type(yerror) != np.ndarray):\n yerror = np.ones(len(x)) * yerror\n fitfunc = lambda p, x: p[1] + p[0]*x\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\n p = out[0]\n covar = out[1]\n return(p)","def fit_sky(self):\n min_value = self.data.min()\n ring_model = models.Ring2D(\n min_value, self.x, self.y, self._box * 0.4, width=self._box * 0.4\n )\n ring_model.r_in.fixed = True\n ring_model.width.fixed = True\n ring_model.x_0.fixed = True\n ring_model.y_0.fixed = True\n fit_p = fitting.LevMarLSQFitter()\n return fit_p(ring_model, self._XGrid, self._YGrid, self.data).amplitude","def lightness_correction(self):\n points = self.color_lookup_table_points\n lightness_max_value = math.sqrt(3 * (255**2))\n deadpool = list()\n for index, point in enumerate(points[0]):\n point = self.get_value_tuple(index)\n lightness = int(math.sqrt(point[0]**2 + point[1]**2 + point[2]**2) * 255 / lightness_max_value)\n if not self.to_dark < lightness < self.to_bright:\n deadpool.append(index)\n self.color_lookup_table_points = (np.delete(points[0], deadpool),\n np.delete(points[1], deadpool),\n np.delete(points[2], deadpool))\n self.point_count = len(self.color_lookup_table_points[0])","def least_squares_SGD(y, tx, initial_w, max_iters, gamma, debug = False):\n losses, ws = stochastic_gradient_descent(y, tx, initial_w, 1, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\n return get_last_ans(ws, losses)","def least_squares_GD(y, tx, initial_w, max_iters, gamma, debug = False):\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\n return get_last_ans(ws, losses)","def _get_reference_fit(self, img):\n bw_img = 255 * (img >= self.contrast)\n fit = [center_on_box(bw_img, self.radius, self.min_ref, *ref) for ref in self.refzone]\n meanfit = num.mean(num.ma.masked_array(fit, fit == -9999), axis=0).astype('i')\n if meanfit[0] is num.ma.masked:\n raise StandardError('At least one reference box match required')\n\n return meanfit, fit","def w0FromFingerPrint(y, fitInfo, param, N=200, weights=1, lowerBounds=[-1e3, -1e3, 1e-3, 1e-3, 1e-3, 1e-3, 1e-3], upperBounds = [1e3, 1e3, 1e4, 1e4, 1e3, 1e4, 1e4]):\n \n fitInfo = np.asarray(fitInfo)\n param = np.asarray(param)\n lowerBounds = np.asarray(lowerBounds)\n upperBounds = np.asarray(upperBounds)\n \n fitparamStart = param[fitInfo==1]\n fixedparam = param[fitInfo==0]\n lowerBounds = lowerBounds[fitInfo==1]\n upperBounds = upperBounds[fitInfo==1]\n \n fitresult = least_squares(fitfunW0FromFingerPrint, fitparamStart, args=(fixedparam, fitInfo, y, N, weights), bounds=(lowerBounds, upperBounds))\n \n return fitresult","def fit():\n pass","def measure_curvature(ploty, left_fitx, right_fitx):\n \n ym_per_pix = 30/720 # meters per pixel in y dimension\n xm_per_pix = 3.7/700 # meters per pixel in x dimension\n \n left_fitx = left_fitx[::-1]\n right_fitx = right_fitx[::-1]\n \n left_fit_cr = np.polyfit(ploty*ym_per_pix, left_fitx*xm_per_pix, 2)\n right_fit_cr = np.polyfit(ploty*ym_per_pix, right_fitx*xm_per_pix, 2)\n \n y_eval = np.max(ploty)\n \n \n left_curverad = (1+(2*left_fit_cr[0]*y_eval*ym_per_pix+left_fit_cr[1])**2)**(3/2)/(2*np.abs(left_fit_cr[0])) \n right_curverad = (1+(2*right_fit_cr[0]*y_eval*ym_per_pix+right_fit_cr[1])**2)**(3/2)/(2*np.abs(right_fit_cr[0])) \n \n return left_curverad, right_curverad","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\n data)\n #scipy rihjt\n # Levenberg-Marquadt algorithm -> leastsq\n #bnds = None\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n \n #least square fitting(minimizes raw data and fit)\n\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\n #print(\"pass case\")\n return(p)\n else:\n print(\"failed case\")\n print(\"height1\", p[0],\"height2\", p[5], \"X\", p[1],\"Y\", p[2],\"Y1\", p[6], \"Y2\", p[7])\n print(\"bounding error\" + str(numero)) \n\n return p","def find_single_fit_range(lorentz_params):\n f0 = lorentz_params[1]\n FWHM = lorentz_params[2]\n return (f0 - 4 * FWHM, f0 - 2 * FWHM, f0 + 2 * FWHM, f0 + 4 * FWHM)","def fitSingleLorentzian(data, expectedQ, lookahead, delta, backgroundData = None, svgWindowLength = 11, svgOrder= 5):\n f=data[:,0]\n t=data[:,3]\n\n if backgroundData == None:\n r=data[:,2]\n elif len(backgroundData) == len(r=data[:,2]):\n r=data[:,2]-backgroundData\n else:\n print \"Length of Background Data is not equal Length of r\"\n return\n\n\n\n #apply SVG filter to make peak detection easier\n fr=signal.savgol_filter(r,svgWindowLength,svgOrder)\n _max, _min = pd.peakdetect(fr, None, lookahead, delta)\n\n #create lists of locations of max/min, values of xmax/xmin and ymax/ymin\n fmi = [p[0] for p in _max]\n fni= [p[0] for p in _min]\n fm = [f[p[0]] for p in _max]\n rm = [p[1] for p in _max]\n fn = [f[p[0]] for p in _min]\n rn = [p[1] for p in _min]\n\n limitToBigPeak=True\n #change Q to fwhm based on first detected peak location\n\n fwhm=fm[0]/expectedQ\n paramList=[]\n\n #if limitToBigPeak is true, will only try to fit maximum peak. Good if only\n #looking at single resonance peak. Problematic if there is a larger BG peak\n #which gets fit.\n if limitToBigPeak == True:\n max_value = max(rm)\n max_index = rm.index(max_value)\n paramList=[fm[max_index], rm[max_index]*fwhm, fwhm]\n else:\n for i in xrange(len(fmi)):\n paramList+=[fm[i], rm[i]*fwhm/2*math.pi, fwhm]\n\n #fits data to a single lorentzian with a linear background. Parameters are limited\n #in how much they vary so initial choice is vital to a good fit\n\n out = lmLorFit(f, r, paramList, ctr_range = 1.2, amp_range = 2 , sig_range= 2)\n fittedfwhm = out.params['lo0_fwhm'].value\n fittedAmp = out.params['lo0_amplitude'].value\n fittedCenter = out.params['lo0_center'].value\n fittedQ=fittedCenter/fittedfwhm\n\n \"\"\"Returns output fit as will as list of important fitting parameters\"\"\"\n return out, [fittedCenter, fittedAmp, fittedfwhm, fittedQ]","def ellipse_dist_ratio_poly(self, theta, lwr):\n\n \"\"\"\n\n Params for FWD fit\n array([ 9.99999989e-01, 8.10852195e+07, 1.95444928e+00, 7.96543026e-02])\n this one is un-needed, since it's approximation y = 1\n\n Params for FWD_DIAG fit\n array([-0.00650758, 0.57761793, 0.35369061, 1.87834152])\n\n Params for ORTHOG fit\n array([-0.02014989, 5.7007518 , -0.83345416, 0.97711175])\n\n Params for BCK_DIAG fit\n array([-0.01608705, 9.44079769, -0.92071169, 0.89094967])\n\n Params for BCK fit\n array([ -0.01451187, 10.92674105, -0.93514904, 0.87868538])\n \"\"\"\n\n #fitting function\n def f(x,params):\n return params[0] + (1.0 / (params[1]*(x+params[2])**params[3]))\n\n #force float math, in case theta is an integer\n theta = float(theta)\n\n #into an angle index form:\n t = abs(int(4.0*theta/np.pi))\n\n if (t == 0) or (t == 8):\n return 1.0\n elif (t == 1) or (t == 7):\n #forward diagonal\n return f(lwr, [-0.00650758, 0.57761793, 0.35369061, 1.87834152])\n elif (t == 2) or (t == 6):\n #orthogonal\n return f(lwr, [-0.02014989, 5.7007518 , -0.83345416, 0.97711175])\n elif (t == 3) or (t == 5):\n #backward diagonal\n return f(lwr, [-0.01608705, 9.44079769, -0.92071169, 0.89094967])\n elif t == 4:\n #backward\n return f(lwr, [ -0.01451187, 10.92674105, -0.93514904, 0.87868538])\n else:\n #hmmm... TODO\n return 0.0","def merge_lightcurve_fits(options):\n import numpy\n import astropy\n import os\n import JLA_library as JLA\n from astropy.table import Table, MaskedColumn, vstack\n from scipy.optimize import leastsq\n\n params = JLA.build_dictionary(options.config)\n\n # ---------------- JLA ------------------------\n lightCurveFits = JLA.get_full_path(params['JLAlightCurveFits'])\n f=open(lightCurveFits)\n header=f.readlines()\n f.close()\n names=header[0].strip('#').split()\n\n # I imagine that the tables package in astropy could also be used to read the ascii input file\n SNeSpec = Table(numpy.genfromtxt(lightCurveFits,\n skip_header=1,\n dtype='S12,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8',\n names=names))\n\n nSNeSpec=len(SNeSpec)\n print 'There are %d SNe from the spectrscopically confirmed sample' % (nSNeSpec)\n\n # Add an extra column to the table\n SNeSpec['source']=['JLA']*nSNeSpec\n\n # -------------- Malmquist bias fits\n malmBias={}\n\n if options.bias:\n # Compute the bias correction\n bias = numpy.genfromtxt(JLA.get_full_path(params['biasPolynomial']),\n skip_header=3,\n usecols=(0, 1, 2, 3),\n dtype='S10,f8,f8,f8',\n names=['sample', 'redshift', 'bias', 'e_bias'])\n\n for sample in numpy.unique(bias['sample']):\n selection=(bias['sample']==sample)\n guess=[0,0,0]\n \n plsq=leastsq(residuals, guess, args=(bias[selection]['bias'],\n bias[selection]['redshift'],\n bias[selection]['e_bias'],\n 'poly'), full_output=1)\n\n if plsq[4] in [1,2,3,4]:\n print 'Solution for %s found' % (sample)\n malmBias[sample]=plsq[0]\n\n\n # ---------------- Shuvo's sample aka JLA++ ------------------------\n # Photometrically identified SNe in Shuvo's sample, if the parameter exists\n if params['photLightCurveFits']!='None':\n lightCurveFits = JLA.get_full_path(params['photLightCurveFits'])\n SNePhot=Table.read(lightCurveFits, format='fits')\n nSNePhot=len(SNePhot)\n\n print 'There are %d SNe from the photometric sample' % (nSNePhot)\n\n # Converting from Shuvo's names to thosed used by JLA\n conversion={'name':'name_adj', 'zcmb':None, 'zhel':'z', 'dz':None, 'mb':'mb', 'dmb':'emb', 'x1':'x1', 'dx1':'ex1', 'color':'c', 'dcolor':'ec', '3rdvar':'col27', 'd3rdvar':'d3rdvar', 'tmax':None, 'dtmax':None, 'cov_m_s':'cov_m_x1', 'cov_m_c':'cov_m_c', 'cov_s_c':'cov_x1_c', 'set':None, 'ra':'col4', 'dec':'col5', 'biascor':None}\n\n # Add the uncertainty in the mass column\n SNePhot['d3rdvar']=(SNePhot['col29']+SNePhot['col28'])/2. - SNePhot['col27']\n\n # Remove columns that are not listed in conversion\n \n for colname in SNePhot.colnames:\n if colname not in conversion.values():\n SNePhot.remove_column(colname)\n \n for key in conversion.keys():\n # Rename the column if it does not already exist\n if conversion[key]!=None and conversion[key]!=key:\n SNePhot.rename_column(conversion[key], key)\n elif conversion[key]==None:\n # Create it, mask it, and fill all values\n SNePhot[key]=MaskedColumn(numpy.zeros(nSNePhot), numpy.ones(nSNePhot,bool))\n SNePhot[key].fill_value=-99 # does not work as expected, so we set it explicitly in the next line\n SNePhot[key]=-99.9\n else:\n # Do nothing if the column already exists\n pass\n\n # Compute the bias correction\n for i,SN in enumerate(SNePhot):\n if 'SDSS' in SN['name']:\n SNePhot['biascor'][i]=poly(SN['zhel'],malmBias['SDSS'])\n else:\n SNePhot['biascor'][i]=poly(SN['zhel'],malmBias['SNLS'])\n\n # Add the source column\n SNePhot['source']=\"Phot_Uddin\" \n\n # ---------------------- CfA4 ----------------------------------\n if params['CfA4LightCurveFits']!='None':\n lightCurveFits = JLA.get_full_path(params['CfA4LightCurveFits'])\n f=open(lightCurveFits)\n header=f.readlines()\n f.close()\n names=header[0].strip('#').split(',') \n\n SNeCfA4=Table(numpy.genfromtxt(lightCurveFits,\n skip_header=1,\n dtype='S12,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8',\n names=names,delimiter=','))\n\n nSNeCfA4=len(SNeCfA4) \n \n conversion={'name':'name', 'zcmb':None, 'zhel':'z', 'dz':None, 'mb':'mb', 'dmb':'emb', 'x1':'x1', 'dx1':'ex1', 'color':'c', 'dcolor':'ec', '3rdvar':None, 'd3rdvar':None, 'tmax':None, 'dtmax':None, 'cov_m_s':'cov_m_x1', 'cov_m_c':'cov_m_c', 'cov_s_c':'cov_x1_c', 'set':None, 'ra':None, 'dec':None, 'biascor':None}\n\n # Remove columns that are not listed in conversion\n \n for colname in SNeCfA4.colnames:\n if colname not in conversion.values():\n SNeCfA4.remove_column(colname)\n \n for key in conversion.keys():\n # Rename the column if it does not already exist\n if conversion[key]!=None and conversion[key]!=key:\n SNeCfA4.rename_column(conversion[key], key)\n elif conversion[key]==None:\n # Create it, mask it, and fill all values\n SNeCfA4[key]=MaskedColumn(numpy.zeros(nSNeCfA4), numpy.ones(nSNeCfA4,bool))\n SNeCfA4[key].fill_value=-99 # does not work as expected, so we set it explicitly in the next line\n SNeCfA4[key]=-99.9\n else:\n # Do nothing if the column already exists\n pass\n\n # Add the source column\n SNeCfA4['source']=\"CfA4\" \n\n # We also need to gather information on the host mass, the host mass uncertainty, CMB redshift and Malmquist bias\n CfA4lightcurves=[]\n CfA4_lcDirectories=params['CfA4MassesAndCMBz'].split(',')\n for lcDir in CfA4_lcDirectories:\n listing=os.listdir(JLA.get_full_path(lcDir))\n for lc in listing:\n CfA4lightcurves.append(JLA.get_full_path(lcDir)+lc)\n\n for i,SN in enumerate(SNeCfA4):\n for lc in CfA4lightcurves:\n if SN['name'][2:] in lc:\n keywords=getKeywords(lc)\n SNeCfA4[i]['zcmb']=keywords['REDSHIFT_CMB']\n SNeCfA4[i]['3rdvar']=keywords['HOSTGAL_LOGMASS']\n SNeCfA4[i]['d3rdvar']=keywords['e_HOSTGAL_LOGMASS']\n SNeCfA4[i]['ra']=keywords['RA']\n SNeCfA4[i]['dec']=keywords['DECL']\n if SNeCfA4[i]['3rdvar'] < 0:\n SNeCfA4[i]['3rdvar']=-99.9\n SNeCfA4[i]['d3rdvar']=-99.9\n\n # Compute the bias correction\n SNeCfA4['biascor']=poly(SNeCfA4['zcmb'],malmBias['nearby'])\n\n try:\n SNe=vstack([SNeSpec,SNePhot,SNeCfA4])\n except:\n SNe=SNeSpec\n\n# print len(SNe),len(numpy.unique(SNe['name']))\n\n # Write out the result as a FITS table\n date = JLA.get_date()\n SNe.write('%s_%s.fits' % (options.output, date), format='fits', overwrite=True)\n\n return","def fit_langevin(self, h, m):\n # get guess for magnitude and frequency\n msatguess = max(m)\n bguess = 4.0 * (ma.pi * 1439.5315)**2.0 * 151 / ( 1.9872e-3 *298 )\n Bopt, Bcov = curve_fit(self.langevin, h, m, p0 = [ msatguess, bguess, 0] )\n A = Bopt[0]\n B = Bopt[1]\n C = Bopt[2]\n A_std = np.sqrt(np.diag(Bcov))[0]\n B_std = np.sqrt(np.diag(Bcov))[1]\n C_std = np.sqrt(np.diag(Bcov))[2]\n AB_std = Bcov[0,1]\n m_fit = self.langevin(h, A, B, C )\n susceptibility = self.langevin_derivative( 0, A, B, C )\n return A, B, C, susceptibility","def fit(init_params, data):\n snrs, ras, decs = data.transpose()\n errorfunction = lambda p: np.ravel(observed_snr(*p)(ras, decs) - snrs)\n if debug:\n output = opt.leastsq(errorfunction, init_params, maxfev=10000, full_output=1)\n print output[-1], output[-2]\n p = output[0]\n else:\n p, success = opt.leastsq(errorfunction, init_params, maxfev=10000)\n return p","def get_resolution(testdata):\n diffs = np.transpose([testdata[1:, 0], np.diff(testdata[:, 0])])\n resolutions = ud.safedivide(diffs[:, 0], diffs[:, 1])\n # popt, pcov = scipy.optimize.curve_fit(fit_line, diffs[:, 0], resolutions, maxfev=1000000)\n # fitLine = fit_line(diffs[:, 0], *popt)\n # fitMax = np.max(fitLine)\n # fitMin = np.min(fitLine)\n # diffs_new = diffs[(1.2 * fitMin < resolutions) & (resolutions < 1.2 * fitMax)]\n # resolutions_new = resolutions[(1.2 * fitMin < resolutions) & (resolutions < 1.2 * fitMax)]\n # popt2, pcov2 = scipy.optimize.curve_fit(fit_line, diffs_new[:, 0], resolutions_new, maxfev=1000000)\n # plt.figure()\n # plt.plot(diffs[:,0], resolutions)\n # plt.plot(diffs[:, 0], fit_line(diffs[:, 0], *popt2), 'r-')\n # plt.show()\n # Currently use A * m ^1.5 (0.5?)\n # Maybe use a*M^b\n # return popt2\n return np.median(resolutions)","def get_thresh(amp,c): \n #Helper functions for fitting the psychometric curve, need to be\n #defined within the local scope, so that they can grok the data:\n \n def weib_fit(pars):\n thresh,slope = pars\n return weibull(x,thresh,slope,guess,flake)\n\n def err_func(pars):\n return y-weib_fit(pars)\n\n #Throw away the None's:\n hit_amps = amp[c==1]\n miss_amps = amp[c==0]\n\n # Get rid of floating point error:\n hit_amps = defloaterrorize(hit_amps)\n miss_amps = defloaterrorize(miss_amps)\n\n all_amps = np.hstack([hit_amps,miss_amps])\n stim_intensities = np.unique(all_amps)\n\n n_correct = [len(np.where(hit_amps==i)[0]) for i in stim_intensities]\n n_trials = [len(np.where(all_amps==i)[0]) for i in stim_intensities]\n Data = zip(stim_intensities,n_correct,n_trials)\n x = []\n y = []\n n = []\n for idx,this in enumerate(Data):\n #Take only cases where there were at least n_up observations:\n if n_trials[idx]>=self.n_up:\n #Contrast values: \n x = np.hstack([x,this[2] * [this[0]]])\n #% correct:\n y = np.hstack([y,this[2] * [this[1]/float(this[2])]])\n\n initial = np.mean(x),slope\n this_fit , msg = leastsq(err_func,initial)\n return this_fit,x,y","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def get_keff(self, take_final=False):\n \n # find max in rec (or final value, don't force as default)\n if take_final:\n _rec_max = self.rec_curve[-1, 1]\n else:\n _rec_max = numpy.max(self.rec_curve[:, 1])\n \n _rec_min = self.rec_curve[0, 1] \n #Bit of a cheat - take the first point. Will be wrong in the case of \n #very fast recovery compared to 1st interval. But in this case, _rec_min and _rec_max \n #should be similar and caught below\n \n if _rec_min > 0.95 * _rec_max:\n print (\"No recovery because too little desensitization (fast limit)\")\n print (\"Setting k_eff = 1000\")\n self.k_eff = 1000 #We could certainly not measure a rate this fast\n \n else:\n _half_rec_amp = _rec_max - 0.5 * (_rec_max - _rec_min)\n _near_idx = (numpy.abs(self.rec_curve[:, 1] - _half_rec_amp)).argmin()\n _near_value = self.rec_curve [_near_idx, 1]\n\n #interpolate\n #must be a smarter way to combine the two possibilities?\n if _near_value > _half_rec_amp:\n #true half time was before our nearest neighbor\n _left = self.rec_curve[_near_idx - 1, 1]\n _right = self.rec_curve[_near_idx, 1]\n _tl = self.rec_curve[_near_idx - 1, 0]\n _tr = self.rec_curve[_near_idx, 0]\n #inverse of time difference scaled by normalized (point-threshold distance)\n self.k_eff = 1 / (_tr - (_tr - _tl) * float(_right - _half_rec_amp)/(_right - _left))\n\n elif _near_value < _half_rec_amp:\n #true half time was after our nearest neighbor\n _left = self.rec_curve[_near_idx, 1]\n _right = self.rec_curve[_near_idx + 1, 1]\n _tl = self.rec_curve[_near_idx, 0]\n _tr = self.rec_curve[_near_idx + 1, 0]\n #as above rearranged to approach from below.\n self.k_eff = 1 / (_tl + (_tr - _tl) * float(_half_rec_amp - _left)/(_right - _left))\n\n elif _near_value == _half_rec_amp:\n\n self.k_eff = 1 / self.rec_curve[near_hi_idx, 0]","def calibration(self) -> int:","def _curvature(self):\n y_eval = self.left_fitx.shape[0] - 10\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.left_fit[0]))\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.right_fit[0]))\n return left_curverad, right_curverad","def get_tol_2d():\r\n return geometry.gmGetXyTol()","def best_fit(self, **kwargs):\n n_fit_p = len(self.fit_parameters)\n n_wc = len(self.fit_wc_names)\n if n_fit_p + n_wc == 1:\n def f(x):\n return -self.log_likelihood([x])\n opt = scipy.optimize.minimize_scalar(f, **kwargs)\n else:\n def f(x):\n return -self.log_likelihood(x)\n if 'x0' not in kwargs:\n x0 = np.zeros(n_fit_p + n_wc)\n if n_fit_p > 1:\n x0[:n_fit_p] = self.get_central_fit_parameters\n opt = minimize_robust(f, x0, **kwargs)\n else:\n opt = minimize_robust(f, **kwargs)\n if not opt.success:\n raise ValueError(\"Optimization failed.\")\n else:\n return {'x': opt.x, 'log_likelihood': -opt.fun}","def STRidge(X0, y, lam, maxit, tol, normalize=2):\n\n n, d = X0.shape\n X = np.zeros((n, d), dtype=np.float64)\n # First normalize data\n if normalize != 0:\n Mreg = np.zeros((d, 1))\n for i in range(0, d):\n Mreg[i] = 1.0 / (np.linalg.norm(X0[:, i], normalize))\n X[:, i] = Mreg[i] * X0[:, i]\n else:\n X = X0\n\n # Get the standard ridge esitmate\n if lam != 0:\n w = np.linalg.lstsq(X.T.dot(X) + lam * np.eye(d), X.T.dot(y), rcond=None)[0]\n else:\n w = np.linalg.lstsq(X, y)[0]\n num_relevant = d\n biginds = np.where(abs(w) > tol)[0]\n\n # Threshold and continue\n for j in range(maxit):\n if j == maxit - 1:\n warnings.warn('Maxit in STRidge is not large enough and has stopped Regression at this point')\n\n # Figure out which items to cut out\n smallinds = np.where(abs(w) < tol)[0]\n new_biginds = [i for i in range(d) if i not in smallinds]\n\n # If nothing changes then stop\n if num_relevant == len(new_biginds):\n break\n else:\n num_relevant = len(new_biginds)\n\n # Also make sure we didn't just lose all the coefficients\n if len(new_biginds) == 0:\n if j == 0:\n # if print_results: print \"Tolerance too high - all coefficients set below tolerance\"\n return w\n else:\n break\n biginds = new_biginds\n\n # Otherwise get a new guess\n w[smallinds] = 0\n if lam != 0:\n w[biginds] = \\\n np.linalg.lstsq(X[:, biginds].T.dot(X[:, biginds]) + lam * np.eye(len(biginds)), X[:, biginds].T.dot(y), rcond=None)[0]\n else:\n w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\n\n # Now that we have the sparsity pattern, use standard least squares to get w\n if biginds != []: w[biginds] = np.linalg.lstsq(X[:, biginds], y, rcond=None)[0]\n\n if normalize != 0:\n return np.multiply(Mreg, w)\n else:\n return w","def compute(self):\n # update parameters with the values of widgets\n initguess = str(self.ptext.toPlainText())\n if not self.checkUserInput(initguess):\n return\n stguess = initguess.replace('\\n', ',')\n # update self.parmVal\n self.guessToParms(stguess)\n try:\n self.parent.app.setOverrideCursor(Qt.WaitCursor)\n result = least_squares(self.residuals, self.parmVal, bounds=self.bounds,\n args=(self.data[1], self.data[0]))\n self.parent.app.restoreOverrideCursor()\n except ValueError as err:\n errmsg = \"Fitting process failure:\\n{0}\".format(err)\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\n return\n RMSE = np.sqrt(np.sum(np.square(result.fun)) / len(self.data[1]))\n msg = \"Initial guess : \\n{0}\\n\".format(initguess)\n msg += \"Number of peaks = {0:d}\\n\".format(self.npeaks)\n logmsg = msg + 'Fitting results:\\n'\n res = np.reshape(result.x, (self.npeaks, self.maxparm))\n strres = self.resToStr(res)\n logmsg += '[xm, amp, fwhm, asym, m] = \\n{0}\\n'.format(strres)\n rmsemsg = 'RMSE = {0:g}\\n\\n'.format(RMSE)\n msg += rmsemsg\n logmsg += rmsemsg\n self.parmVal = result.x\n\n # Show results in log windows\n self.log.setText(msg)\n self.log.moveCursor(QtGui.QTextCursor.End)\n self.saveToLogFile(logmsg)\n self.data[2] = self.fitfunc(self.data[0], result.x)\n self.data[3] = self.data[2] - self.data[1] - self.diffshift\n\n self.updatePlot()\n self.updateParmsEdit()","def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\n\n # useful display and computational data\n y_fitted = poly_fit(x_data)\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\n x_fitted_display = np.linspace(min_x_display, max_x_display)\n y_fitted_display = poly_fit(x_fitted_display)\n\n # goodness of fit indicators\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\n R2 = 1.0 - SSE/SST # R squared\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\n\n fig = plt.figure()\n ax = fig.add_subplot(1, 2, 1)\n\n # plot of the fitted polynomial itself\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\n ax.scatter(x_data, y_data, color='C7')\n ax.set(title=\"Fitted polynomial (deg{}) for \\'{}\\'\".format(poly_fit.order, fit_name), xlabel=\"x\", ylabel=\"y\")\n\n # histogram of residuals\n ax2 = fig.add_subplot(1, 2, 2)\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\n ax2.set(title=\"Histogram of residuals\", xlabel=\"Residual value $y_k - \\\\widehat{y_k}$\", ylabel=\"Count\")\n\n # display of fit indicators\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\n\n fig.tight_layout()\n fig.subplots_adjust(bottom=0.2)\n\n figurefiles.save_in_perfs_fits_folder(fig, \"Polyfit_{}_order_{}.pdf\".format(fit_name, poly_fit.order))","def get_normfactor(self, full_well=FULL_WELL):\n\n max_value = np.amax(self.data)\n normfactor = full_well/max_value\n\n return normfactor","def _UpdateCriteria(self):\n grad = self.traj.grad[-1]\n disp = self.traj.coords[-1] - self.traj.coords[-2]\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\n self.grad_max = numpy.amax(grad)\n self.disp_max = numpy.amax(disp)\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\n self.disp_rms = math.sqrt(numpy.mean(disp**2))","def guess_fit_gaussian():\n a = z.max()\n\n # Compute moments\n total = z.sum()\n x_0 = np.dot(x, z) / total\n y_0 = np.dot(y, z) / total\n\n # Approximate sigmas\n sigma_x = np.dot(x**2, z) / total\n sigma_y = np.dot(y**2, z) / total\n sigma = np.sqrt(sigma_x * sigma_y)\n\n # Return guess\n return (a, x_0, y_0, sigma)","def get_fit(self) -> np.poly1d:\n if self.log_fits is not None:\n return next(self.log_fits)\n x = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\n .to_list()\n )\n y = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\n .to_list()\n )\n if self.orientation == Orientation.UP_DOWN:\n fit = np.polyfit(x, y, 1)\n else:\n fit = np.polyfit(y, x, 1)\n return np.poly1d(fit)","def makeFit(self):\n if not self.fitModel.params:\n return\n cs = self.spectrum\n self.worker.make_model_curve(cs, allData=csi.allLoadedItems)\n\n dfparams = cs.fitParams\n lcfRes = dfparams['lcf_result']\n self.fitR.setText('R={0:.5g}'.format(lcfRes['R']))\n self.updateFitResults()\n self.fitReady.emit()","def _lowess_robustify_fit(x_copy, y_copy, fitted, weights, k, n):\n nn_indices = [0,k]\n X = np.ones((k,2))\n\n residual_weights = np.copy(y_copy)\n residual_weights.shape = (n,)\n residual_weights -= fitted\n residual_weights = np.absolute(residual_weights)#, out=residual_weights)\n s = np.median(residual_weights)\n residual_weights /= (6*s)\n too_big = residual_weights>=1\n _lowess_bisquare(residual_weights)\n residual_weights[too_big] = 0\n\n\n for i in range(n):\n total_weights = weights[i,:] * np.sqrt(residual_weights[nn_indices[0]:\n nn_indices[1]])\n\n X[:,1] = x_copy[nn_indices[0]:nn_indices[1]]\n y_i = total_weights * y_copy[nn_indices[0]:nn_indices[1]]\n total_weights.shape = (k,1)\n\n beta = lstsq(total_weights * X, y_i, rcond=-1)[0]\n\n fitted[i] = beta[0] + beta[1] * x_copy[i]\n\n _lowess_update_nn(x_copy, nn_indices, i+1)","def fit(x_array, y_array, function, A_start):\n param = (x_array, y_array, function)\n\n A_final, cov_x, infodict, mesg, ier = leastsq(minimize, A_start, args=param, full_output=True)#, warning=True)\n \n return A_final","def _accept_fit(self, fit, curvature):\n self.detected = True\n self.current_fit.append(fit)\n self.best_fit = np.average(self.current_fit, axis=0)\n if 10000 > curvature > 100:\n self.radius_of_curvature.append(curvature)\n self.best_curvature = np.average(self.radius_of_curvature)","def _find_best_threshold(self, num_of_steps=20, verbose=False):\n xmin = self.x.min()\n xmax = self.x.max()\n step = (xmax - xmin)/num_of_steps\n \n lower_th = None\n lower_IR = 1\n\n # for each potential threshold\n for threshold in np.arange(xmin+step, xmax, step):\n IR = self._compute_isometric_ratio(threshold)\n \n if IR < lower_IR:\n lower_IR = IR\n lower_th = threshold\n \n self.threshold = lower_th\n if verbose:\n print(f'\\tThreshold:\\t\\t{lower_th}\\n\\tIsometric Ratio:\\t{lower_IR}')","def polyfit(x, y, yerror, pinit=[0,0,0,0]):\n x = np.array(x)\n y = np.array(y)\n pinit[2] = np.mean(y)\n pinit[3] = x[len(x)/2]\n if (type(yerror) != list and type(yerror) != np.ndarray):\n yerror = np.ones(len(x)) * yerror\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\n p = out[0]\n covar = out[1]\n return(p)","def fit_focus(self) -> Tuple[float, float]:\n\n # get data\n focus = [d[\"focus\"] for d in self._data]\n xfwhm = [d[\"x\"] for d in self._data]\n xsig = [d[\"xerr\"] for d in self._data]\n yfwhm = [d[\"y\"] for d in self._data]\n ysig = [d[\"yerr\"] for d in self._data]\n\n # fit focus\n try:\n xfoc, xerr = fit_hyperbola(focus, xfwhm, xsig)\n yfoc, yerr = fit_hyperbola(focus, yfwhm, ysig)\n\n # weighted mean\n xerr = np.sqrt(xerr)\n yerr = np.sqrt(yerr)\n foc = (xfoc / xerr + yfoc / yerr) / (1.0 / xerr + 1.0 / yerr)\n err = 2.0 / (1.0 / xerr + 1.0 / yerr)\n except (RuntimeError, RuntimeWarning):\n raise ValueError(\"Could not find best focus.\")\n\n # get min and max foci\n min_focus = np.min(focus)\n max_focus = np.max(focus)\n if foc < min_focus or foc > max_focus:\n raise ValueError(\"New focus out of bounds: {0:.3f}+-{1:.3f}mm.\".format(foc, err))\n\n # return it\n return float(foc), float(err)","def fit(self):\n\n fitdata = np.polyfit(self.v**(-2./3.), self.e, 3, full=True)\n ssr = fitdata[1]\n sst = np.sum((self.e - np.average(self.e))**2.)\n residuals0 = ssr/sst\n deriv0 = np.poly1d(fitdata[0])\n deriv1 = np.polyder(deriv0, 1)\n deriv2 = np.polyder(deriv1, 1)\n deriv3 = np.polyder(deriv2, 1)\n\n self.v0 = None\n for x in np.roots(deriv1):\n if x > 0 and deriv2(x) > 0:\n self.v0 = x**(-3./2.)\n break\n\n if self.v0 is None:\n raise ValueError('No minimum!')\n\n derivV2 = 4./9. * x**5. * deriv2(x)\n derivV3 = (-20./9. * x**(13./2.) * deriv2(x) -\n 8./27. * x**(15./2.) * deriv3(x))\n bulk_modulus0 = derivV2 / x**(3./2.)\n bulk_deriv0 = -1 - x**(-3./2.) * derivV3 / derivV2\n\n self.e0 = deriv0(x)\n self.B0 = bulk_modulus0\n self.B1 = bulk_deriv0\n\n return self.v0, self.e0, self.B0, self.B1, residuals0","def recovery(self):\n\n def exponential(time, tau):\n\n time = list(map(lambda x: float(x), time))\n exponent = np.exp(-np.divide(time, tau))\n return (1 - exponent)\n \n \n initial_guess = [55]\n \n tau = []\n for i in range(self.n_cols):\n current = self.screened_data.iloc[:,i]\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\n tau.append(popt[0][0])\n\n print('Median: ', np.median(tau))\n print('Min: ', np.min(tau))\n print('Max: ', np.max(tau))\n return 0\n\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\n for i in range(len(popt)):\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\n plt.xlabel('Time (ms)')\n plt.ylabel('Normalized Current')\n plt.title('Recovery from Inactivation')\n plt.legend()\n plt.savefig('recovery_exponential_fit.png')\n return popt","def find_k(model, data, tol = 1e-3):\n\n # Store the quantities that never change\n pow_mod = 10 ** model\n\n # Make the array x_k 10 times finer than the tolerance\n step = tol * 0.1\n k_arr = np.arange(0, 1 + step, step)\n\n # Get the x_k array\n x_k = np.array([(1 - k_arr) + k_arr * p for p in pow_mod]).T\n\n # And now the really useful arrays\n coef = (pow_mod - 1)/x_k * 2/np.log(10)\n log_x_k = np.log10(x_k)\n\n # Start with the extremes\n k0 = k_arr[0:1]\n k1 = k_arr[-1:]\n km = (k0 + k1) * 0.5\n\n first = True\n while True:\n\n # Each of the gradients\n gradm = get_one_gradient(k_arr, coef, log_x_k, data, km)\n if first:\n # If first time, we have to calculate everything\n grad0 = get_one_gradient(k_arr, coef, log_x_k, data, k0)\n grad1 = get_one_gradient(k_arr, coef, log_x_k, data, k1)\n\n first = False\n else:\n # Otherwise we can use the previous calculation\n grad0 = (sum0 * gradm + dif0 * grad0) * 0.5\n grad1 = (sum1 * gradm + dif1 * grad1) * 0.5\n\n # Get signs\n sign0 = np.sign(grad0)\n signm = np.sign(gradm)\n sign1 = np.sign(grad1)\n\n # Get differences\n sum0 = np.abs(signm + sign0)\n dif0 = np.abs(signm - sign0)\n sum1 = np.abs(signm + sign1)\n dif1 = np.abs(signm - sign1)\n\n # Vectorized change\n k0 = (sum0 * km + dif0 * k0) * 0.5\n k1 = (sum1 * km + dif1 * k1) * 0.5\n\n # Get the middle point\n new_km = (k0 + k1) * 0.5\n\n # Check if converged\n dif = np.abs(new_km[0] - km[0])\n if dif < tol:\n return new_km\n\n # Update\n km = new_km","def overall_sensitivity(self):\n if self.mod1:\n s = torch.max(torch.max(self.weight, -1)[0], -1)[0].item()\n else:\n s = torch.max(torch.sqrt(torch.sum(self.weight * self.weight, -1)))[0].item()\n s *= np.sqrt(2. / np.e)\n return s","def find_best_fit_gaussian(self, also_use_scipy=True, save=True, fix_mean=False, x_y=None):\n if x_y is None:\n x, y = self.get_local_maxes()\n else:\n x, y = x_y\n y_max = np.max(y)\n amplitude = np.max(y)\n mean = np.sum(x * y) / np.sum(y)\n sigma = np.sqrt(np.abs(np.sum(y * (x - mean) ** 2) / np.sum(y)))\n\n if also_use_scipy:\n if fix_mean is not False:\n # TODO: Allow fixed mean optimisation\n pass\n else:\n # fit_params is (amplitude, mean, sigma)\n gaussian_fit = lambda fit_params, x: fit_params[0] * np.exp(\n -(x - fit_params[1]) ** 2 / (2 * fit_params[2] ** 2))\n err_func = lambda fit_params, x, y: gaussian_fit(fit_params, x) - y # Distance to the target function\n initial_parameters = [y_max, mean, sigma] # Initial guess for the parameters\n fitted_params, success = optimize.leastsq(err_func, initial_parameters[:], args=(x, y))\n # print(fitted_params, success)\n\n if save:\n self.config['gaussian_fit_amplitude'] = str(fitted_params[0])\n self.config['gaussian_fit_mean'] = str(fitted_params[1])\n self.config['gaussian_fit_sigma'] = str(fitted_params[2])\n\n return fitted_params, (amplitude, mean, sigma)\n\n else:\n # calculate gaussian fit from points\n return amplitude, mean, sigma","def correct(self) -> float:\n return self._coreEstimation[DetailedMaskType.CorrectMask]","def fitTranslation(data, target, xtol=1e-5, maxfev=0, verbose=0):\n\n def obj(x):\n dataT = data + x\n d = ( ( dataT - target ) ** 2.0 ).sum(1)\n return d\n\n x0 = scipy.array([0.0, 0.0, 0.0])\n\n if verbose:\n rms0 = scipy.sqrt(obj(x0).mean())\n print 'initial RMS:', rms0\n\n xOpt = leastsq(obj, x0, xtol=xtol, maxfev=maxfev)[0]\n\n if verbose:\n rmsOpt = scipy.sqrt(obj(xOpt).mean())\n print 'final RMS:', rmsOpt\n\n dataFitted = data + xOpt\n return xOpt, dataFitted","def fit(self,\n x: np.ndarray,\n y: np.ndarray,\n init_guess: np.ndarray = None) -> np.ndarray:\n\n self.x = x\n self.y = y\n if init_guess is not None:\n self.init_guess = init_guess\n\n if init_guess is None:\n raise Exception(\"Initial guess needs to be provided\")\n\n self.coefficients = self.init_guess\n rmse_prev = np.inf\n for k in range(self.max_iter):\n residual = self.get_residual()\n jacobian = self._calculate_jacobian(self.coefficients, step=10 ** (-6))\n self.coefficients = self.coefficients - self._calculate_pseudoinverse(jacobian) @ residual\n rmse = np.sqrt(np.sum(residual ** 2))\n logger.info(f\"Round {k}: RMSE {rmse}\")\n if self.tolerance_difference is not None:\n diff = np.abs(rmse_prev - rmse)\n if diff < self.tolerance_difference:\n logger.info(\"RMSE difference between iterations smaller than tolerance. Fit terminated.\")\n return self.coefficients\n if rmse < self.tolerance:\n logger.info(\"RMSE error smaller than tolerance. Fit terminated.\")\n return self.coefficients\n rmse_prev = rmse\n logger.info(\"Max number of iterations reached. Fit didn't converge.\")\n\n return self.coefficients","def solve(self):\n max_iter = 1000\n iter_count = 0\n yhat = self.predict()\n loss = self.cross_entropy(yhat)\n gradloss = self.cross_entropy_gradient(yhat)\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\n alpha = 1.0\n slope = la.norm(gradloss)**2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n while loss_new < loss + 1e-4 * alpha * slope:\n alpha = alpha / 2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n self.beta = beta_new\n loss = loss_new\n gradloss = self.cross_entropy_gradient(yhat)\n iter_count += 1","def brute_leastsquare_fit(fun, x_data, y_data,weight_data=None,p_names=None,p_min_max_steps_dict=None,\r\n const_params=[], visualize=False):\r\n \r\n if p_names == None or p_min_max_steps_dict==None:\r\n raise Exception ('p_names and p_min_max_steps must be given!'+ \r\n 'structure of p_min_max_steps_dict: {\"pname0\":[min0,max0,brute_steps0]}')\r\n \r\n params = Parameters() ### initialize LMfit parameters\r\n for p_name in p_names:\r\n min_val=p_min_max_steps_dict[p_name][0]\r\n max_val=p_min_max_steps_dict[p_name][1]\r\n steps=p_min_max_steps_dict[p_name][2]\r\n params.add(p_name,value=min_val,\r\n min=min_val,\r\n max=max_val,\r\n brute_step=(max_val-min_val)/(steps-1))\r\n \r\n ### define function to be minimized for fit \r\n \r\n def cost_function_fit(p=params):\r\n def minimize_fun(pars):\r\n \r\n v=pars.valuesdict()\r\n arglist=[]\r\n for p_name in p_names:\r\n arglist.append(v[p_name])\r\n \r\n for const_param in const_params:\r\n arglist.append(const_param)\r\n \r\n ret=np.array((fun(x_data,*arglist)-y_data),dtype=float)\r\n if weight_data is not None:\r\n ret=ret*np.sqrt(weight_data)\r\n return(ret)\r\n brute_result=lmfit.minimize(minimize_fun,params,method='brute',nan_policy='omit')\r\n best_result=copy.deepcopy(brute_result)\r\n for candidate in brute_result.candidates[0:5]:\r\n trial = lmfit.minimize(minimize_fun, params=candidate.params,method='leastsq',nan_policy='omit')\r\n if trial.chisqr < best_result.chisqr:\r\n best_result = trial\r\n \r\n return((best_result,brute_result))\r\n \r\n best_result,brute_result = cost_function_fit()\r\n arg_list=[]\r\n for p_name in p_names:\r\n arg_list.append(best_result.params.valuesdict()[p_name])\r\n for const_param in const_params:\r\n arg_list.append(const_param)\r\n \r\n \r\n if visualize == True:\r\n plot_brute_leastsquares_results(brute_result,leastsq_fit_result=best_result)\r\n plt.figure()\r\n plt.plot(x_data,y_data,label='data',color='blue')\r\n plt.plot(x_data,fun(x_data,*arg_list),label='Fit',color='red')\r\n plt.title(best_result.params.valuesdict())\r\n plt.show()\r\n return (arg_list[0:len(p_names)])","def get_last_fit(flag='L'):\n if flag == 'L':\n return l_coeff_queue[-1]\n else:\n return r_coeff_queue[-1]","def abs_robust_loss(diff, eps=0.01, q=0.4):\n return torch.pow((torch.abs(diff) + eps), q)","def minimum_spanning_arborescence(sol):","def get_Curvature(self):\n #return str(np.mean([self.line_l.get_CurveRad(), self.line_r.get_CurveRad()]))\n y = np.linspace(0,719, 10)\n x = self.center_poly(y)\n fit_scaled = np.polyfit(y*self.line_l.y_pxm,x*self.line_l.x_pxm, deg=2)\n curverad = ((1 + (2 * fit_scaled[0] * 600 + fit_scaled[1]) ** 2) ** 1.5) / np.absolute(2 * fit_scaled[0])\n\n if len(self.curve_buffer) > 15:\n self.curve_buffer.pop(0)\n\n self.curve_buffer.append(curverad)\n _, self.curve_buffer = self.line_l.remove_outliers(self.curve_buffer,[None]*len(self.curve_buffer), m=3)\n buff_mean= np.mean(self.curve_buffer)\n #print(\"Buf Mean: \" +str(buff_mean))\n #outlier = np.abs(buff_mean - curverad) > np.std(self.curve_buffer)*2\n if curverad > 4000.0:\n buff_mean = \"Straight Lane\"\n else:\n buff_mean = str(int(buff_mean)) + \" m\"\n\n return buff_mean","def get_gev_fit(data):\n md = mode(data)[0][0]\n std = np.std(data)\n # first try with loc=mode\n shape, loc, scale = gev.fit(data, loc=md)\n # if bad try again with mean\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\n else:\n print('GEV fit with mode')\n # if still bad (ugh), try again with mode - std\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=md-std)\n else:\n print('GEV fit with mean')\n if loc > md+std:\n print('GEV fit with c=0')\n shape, loc, scale = gev.fit(data, 0)\n else:\n print('GEV fit with mode minus std deviation')\n return shape, loc, scale","def get_gev_fit(data):\n md = mode(data)[0][0]\n std = np.std(data)\n # first try with loc=mode\n shape, loc, scale = gev.fit(data, loc=md)\n # if bad try again with mean\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\n else:\n print('GEV fit with mode')\n # if still bad (ugh), try again with mode - std\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=md-std)\n else:\n print('GEV fit with mean')\n if loc > md+std:\n print('GEV fit with c=0')\n shape, loc, scale = gev.fit(data, 0)\n else:\n print('GEV fit with mode minus std deviation')\n return shape, loc, scale","def get_gev_fit(data):\n md = mode(data)[0][0]\n std = np.std(data)\n # first try with loc=mode\n shape, loc, scale = gev.fit(data, loc=md)\n # if bad try again with mean\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\n else:\n print('GEV fit with mode')\n # if still bad (ugh), try again with mode - std\n if loc > md+std:\n shape, loc, scale = gev.fit(data, loc=md-std)\n else:\n print('GEV fit with mean')\n if loc > md+std:\n print('GEV fit with c=0')\n shape, loc, scale = gev.fit(data, 0)\n else:\n print('GEV fit with mode minus std deviation')\n return shape, loc, scale","def _compute_distance_residual(undist_x, undist_y, fit_poly_x, fit_poly_y):\n dist = np.sqrt((undist_x - fit_poly_x)**2 + (undist_y - fit_poly_y)**2)\n max_resid = dist.max()\n return max_resid","def fit_polynomial(self, ym_per_pix, xm_per_pix):\r\n\r\n # Fit a second order polynomial\r\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\r\n\r\n # Fit a second order polynomial (in meters)\r\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\r\n\r\n # calculate the curvature (in meters)\r\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\r\n\r\n # flag that a polynomial is found\r\n self.detected = True","def best_params(self):\n return self.X[np.argmax(self.y.numpy())]","def get_autofocus_ratio(self, x):\n\n # sample designs from the prior\n z = tf.random.normal([tf.shape(x)[0], self.latent_size])\n q_dx = self.q_vae.decoder.get_distribution(z, training=False)\n p_dx = self.p_vae.decoder.get_distribution(z, training=False)\n\n # evaluate the score and importance weights\n log_w = q_dx.log_prob(x)[..., tf.newaxis] - \\\n p_dx.log_prob(x)[..., tf.newaxis]\n while len(log_w.shape) > 2:\n log_w = tf.reduce_sum(log_w, axis=1)\n return tf.math.exp(log_w)","def test_extended_truncated_power_law_fit(self):\n\t\t\n\t\t#TODO: fix this; low priority\n\t\tdetails= self.watcher.analyze(layers=[self.fc1_layer], pl_package=POWERLAW_PACKAGE, fit=E_TPL)\n\t\tactual_alpha = details.alpha[0]\n\t\tactual_Lambda = details.Lambda[0]\n\n\t\tself.assertTrue(actual_Lambda > -1) #Lambda must be set for TPL\n\t\t\n\t\t# these numbers have not been independently verified yet\n\t\texpected_alpha = 2.3\n\t\texpected_Lambda = 0.006069\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=2)\n\t\tself.assertAlmostEqual(actual_Lambda,expected_Lambda, places=2)","def Solve(self):\n if self.verbose:\n print(\"{0:>6s}{1:>16s}{2:>16s}{3:>16s}\".format(\"iter\", \"energy\", \"rms error\", \"max error\"))\n guess = self.polarization_matrix.dot(self.F)\n\n for k in range(1, self.max_iterations):\n F = self.F + self.interaction_matrix.dot(guess)\n\n (guess, difference) = self.Step(guess, F, k)\n\n # error is RMS in the difference\n rms_err = numpy.std(difference)\n max_err = numpy.max(difference)\n\n energy = -0.5 * self.F.dot(guess)\n if self.verbose:\n print(\"{0:6d}{1:16.8f}{2:16.8f}{3:16.8f}\".format(k, energy, rms_err, max_err))\n\n # according to:\n # Scalmani G et al. Theo. Chem. Account. 2004, (111), 90 - 100, DOI: 10.1007/s00214-003-0527-2\n #\n # we use a convergence threshold on both the RMS and MAX of the residual\n if rms_err < self.threshold and max_err < self.threshold:\n break\n\n # destroy matrices to conserve memory\n self.polarization_matrix = None\n self.interaction_matrix = None\n return guess","def _fit_point_lens(self):\n\n def chi2_fun(theta, event, parameters_to_fit):\n \"\"\"\n for a given event set attributes from parameters_to_fit\n (list of str) to values from theta list\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n chi2 = event.get_chi2()\n if chi2 < chi2_fun.best_chi2:\n chi2_fun.best_chi2 = chi2\n return chi2\n chi2_fun.best_chi2 = 1.e10\n\n def jacobian(theta, event, parameters_to_fit):\n \"\"\"\n Calculate chi^2 gradient (also called Jacobian).\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n return event.chi2_gradient(parameters_to_fit)\n\n if self._event_PSPL is None:\n self._set_event_PSPL()\n\n parameters_to_fit = [\"t_0\", \"u_0\", \"t_E\"]\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\n\n failed = False\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n failed = True\n\n if failed:\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n pass\n# XXX what if fit failed (i.e., .success is False)?\n\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2","def fit(self, x):\n pass","def get_heuristic_corrections(self, tile_key):\n\n if (len(self.foc_est[tile_key]) > 1\n and len(self.astgx_est[tile_key]) > 1\n and len(self.astgy_est[tile_key]) > 1):\n\n wd_corr = (self.heuristic_calibration[0]\n * (self.foc_est[tile_key][0] - self.foc_est[tile_key][1]))\n a1 = (self.heuristic_calibration[1]\n * (self.astgx_est[tile_key][0] - self.astgx_est[tile_key][1]))\n a2 = (self.heuristic_calibration[2]\n * (self.astgy_est[tile_key][0] - self.astgy_est[tile_key][1]))\n\n ax_corr = a1 * cos(self.rot_angle) - a2 * sin(self.rot_angle)\n ay_corr = a1 * sin(self.rot_angle) + a2 * cos(self.rot_angle)\n ax_corr *= self.scale_factor\n ay_corr *= self.scale_factor\n # Are results within permissible range?\n within_range = (abs(wd_corr/1000) <= self.max_wd_diff\n and abs(ax_corr) <= self.max_sx_diff\n and abs(ay_corr) <= self.max_sy_diff)\n if within_range:\n # Store corrections for this tile:\n self.wd_stig_corr[tile_key] = [wd_corr/1000, ax_corr, ay_corr]\n else:\n self.wd_stig_corr[tile_key] = [0, 0, 0]\n\n return wd_corr, ax_corr, ay_corr, within_range\n else:\n return None, None, None, False","def Train(R, Ut, lam, d_tol, maxit=10, STR_iters=10, l0_penalty=1, normalize=2, split=0.8,\n print_best_tol=False, sparse='STR'):\n\n # Split data into 80% training and 20% test, then search for the best tolderance.\n # np.random.seed(0) # for consistancy\n n, _ = R.shape\n #train = np.random.choice(n, int(n * split), replace=False)\n #test = [i for i in np.arange(n) if i not in train]\n TrainR = R#[train, :]\n TestR = R#[test, :]\n TrainY = Ut#[train, :]\n TestY = Ut#[test, :]\n D = TrainR.shape[1]\n\n # Set up the initial tolerance and l0 penalty\n d_tol = float(d_tol)\n tol = d_tol\n if l0_penalty == None: l0_penalty = 0.001 * np.linalg.cond(R)\n\n # Get the standard least squares estimator\n w = np.zeros((D, 1))\n\n # check\n # print(np.nan in TrainR)\n # print(np.inf in TrainR)\n\n def AIC(w, err):\n k = 0\n for item in w:\n if item != 0:\n k += 1\n\n return 2*k+2*np.log(err)\n\n w_best = np.linalg.lstsq(TrainR, TrainY)[0]\n data_err_best = np.linalg.norm(TestY - TestR.dot(w_best), 2)\n err_best = np.linalg.norm(TestY - TestR.dot(w_best), 2) + l0_penalty * np.count_nonzero(w_best)\n aic_best = AIC(w_best[:, 0], data_err_best)\n tol_best = 0\n\n if sparse == 'STR':\n # Now increase tolerance until test performance decreases\n for iter in range(maxit):\n\n # Get a set of coefficients and error\n w = STRidge(R, Ut, lam, STR_iters, tol, normalize=normalize)\n err = np.linalg.norm(TestY - TestR.dot(w), 2) + l0_penalty * np.count_nonzero(w)\n data_err = np.linalg.norm(TestY - TestR.dot(w), 2)\n\n # Has the accuracy improved?\n aic = AIC(w[:, 0], data_err)\n if aic <= aic_best:\n aic_best = aic\n err_best = err\n w_best = w\n data_err_best = data_err\n tol_best = tol\n tol = tol + d_tol\n else:\n tol = max([0, tol - 2 * d_tol])\n d_tol = 2 * d_tol / (maxit - iter)\n tol = tol + d_tol\n\n if print_best_tol: print(\"Optimal tolerance:\", tol_best)\n\n elif sparse == 'Lasso':\n w = Lasso(R, Ut, lam, w=np.array([0]), maxit=maxit*10, normalize=normalize)\n err = np.linalg.norm(Ut - R.dot(w), 2) + l0_penalty * np.count_nonzero(w)\n data_err = np.linalg.norm(Ut - R.dot(w), 2)\n\n if err <= err_best:\n err_best = err\n w_best = w\n data_err_best = data_err\n\n return w_best, err_best, data_err_best, aic_best","def get_correction(d, a, hfov, img_x):\n\n width = 2 * d*math.tan((hfov/2)*math.pi/180) # in meters\n one_meter = img_x / width\n return int(a*one_meter)","def curve_fit():\n x_west, z_west, x_east, z_east = roof_measurements()\n \n # find best curve fit for west roof section\n param_west, param_cov_west = optimize.curve_fit(test_func, x_west, z_west)\n print(param_west)\n \n # z = 7.29944696 + (1.27415518*x) + (-0.0680139854*x**2) + (0.00152035861*x**3)\n \n z_west_fitted = test_func(x_west,*param_west)\n \n # mirror curve for east roof section\n z_east_fitted = np.flip(z_west_fitted,axis=0)\n \n # create array for both west and east roof sections\n x_whole_roof = np.concatenate((x_west, x_east), axis=0)\n z_whole_roof = np.concatenate((z_west_fitted, z_east_fitted), axis=0)\n\n # plot roof\n plt.plot(x_whole_roof, z_whole_roof, '-', color ='blue', label=\"roof curve\") \n plt.axis('equal') # make axes square\n plt.show() \n\n return param_west","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def fit_function_to_data(distance, light):\n params, _ = curve_fit(objective_func, distance, light)\n a, b, c = params\n print(\"y = (\",a,\"(^x-\",b,\")) +\",c)\n x_line = np.arange(min(distance), max(distance))\n y_line = objective_func(x_line, a, b, c)\n return a, b, c","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n #least square fitting(minimizes raw data and fit)\n return p","def _predict_adaptive_lasso(self, X, predictors, target, gamma=1.0):\r\n\t\tlr = LinearRegression()\r\n\t\tlr.fit(X[:, predictors], X[:, target])\r\n\t\tweight = np.power(np.abs(lr.coef_), gamma)\r\n\t\treg = LassoLarsIC(criterion='bic')\r\n\t\treg.fit(X[:, predictors] * weight, X[:, target])\r\n\t\treturn reg.coef_ * weight","def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\n #epsx = (1/2)*(eps1+eps2)\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))","def initial_guess(self):\n\n x0 = [self.material_model.isotropic_matrix.c1, self.material_model.isotropic_matrix.c2]\n\n if not self.material_model.is_isotropic:\n # c5 is scaled in the optimisation function\n x0.append(self.material_model.fibres.c5 / c5_factor)\n\n if self.include_lm:\n x0.append(self.material_model.fibres.lm)\n\n return np.asarray(x0)","def _partial_min_solution(self, j):\n beta_without_j = np.delete(self.betas, j, axis=0)\n X_without_j = np.delete(self.X, j, axis=0)\n X_j = self.X[j] # these are the X values for the jth feature in the model\n # Make predictions and obtain residuals on the full set of Ys, without the effect of the jth predictor included\n R_without_j = (self.Y - (beta_without_j.T @ X_without_j))\n c_j = 2/self.n * (X_j @ R_without_j) # This quantity is described in the notes\n # The following if statements are due to the subgradient of the L1 penality\n if abs(c_j) <= self.lam: # this step is what causes the lasso to shrink coefficients to 0 based on lambda\n return 0\n a_j = 2 * sum(X_j**2) # also described in notes\n if c_j < -self.lam:\n return (c_j + self.lam) / (a_j / self.n)\n elif c_j > self.lam:\n return (c_j - self.lam) / (a_j / self.n)","def calc_error(self):\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit","def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\n \n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\n# epsx = (1/2)*(eps1+eps2)\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))"],"string":"[\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def test_intra_power_law_fit2(self):\\n\\t\\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\\n\\t\\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, sparsify=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\\n\\t\\tactual_alpha = details.alpha[0]\\n\\t\\t#actual_best_fit = details.best_fit[0]\\n\\t\\t#print(actual_alpha,actual_best_fit)\\n\\n\\n\\t\\texpected_alpha = 2.719 # close to exact ?\\n\\t\\t#expected_best_fit = LOG_NORMAL\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=2)\\n\\t\\t#self.assertEqual(actual_best_fit, expected_best_fit)\",\n \"def get_lip_best(self) -> float:\\n if self._fitted:\\n if self._ready_lip_best:\\n return self._lip_best\\n else:\\n lip_best = self._get_lip_best()\\n self._set(\\\"_lip_best\\\", lip_best)\\n self._set(\\\"_ready_lip_best\\\", True)\\n return lip_best\\n else:\\n raise ValueError(\\\"call ``fit`` before calling ``get_lip_best``\\\")\",\n \"def test_intra_power_law_fit(self):\\n\\n\\t\\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\\n\\t\\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, randomize=False, vectors=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\\n\\t\\tactual_alpha = details.alpha[0]\\n\\t\\t#actual_best_fit = details.best_fit[0]\\n\\t\\t#print(actual_alpha,actual_best_fit)\\n\\n\\t\\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\\n\\t\\t#expected_best_fit = LOG_NORMAL\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)\\n\\t\\t#self.assertEqual(actual_best_fit, expected_best_fit)\",\n \"def fitGammaFun(self, x, y):\\n minGamma = 0.8\\n maxGamma = 20.0\\n gammaGuess = 2.0\\n y = numpy.asarray(y)\\n minLum = y[0]\\n maxLum = y[-1]\\n if self.eq == 4:\\n aGuess = old_div(minLum, 5.0)\\n kGuess = (maxLum - aGuess)**(old_div(1.0, gammaGuess)) - aGuess\\n guess = [gammaGuess, aGuess, kGuess]\\n bounds = [[0.8, 5.0], [0.00001, minLum - 0.00001], [2, 200]]\\n else:\\n guess = [gammaGuess]\\n bounds = [[0.8, 5.0]]\\n # gamma = optim.fmin(self.fitGammaErrFun, guess, (x, y, minLum, maxLum))\\n # gamma = optim.fminbound(self.fitGammaErrFun,\\n # minGamma, maxGamma,\\n # args=(x,y, minLum, maxLum))\\n params = optim.fmin_tnc(self.fitGammaErrFun, numpy.array(guess),\\n approx_grad=True,\\n args=(x, y, minLum, maxLum),\\n bounds=bounds, messages=0)\\n return minLum, maxLum, params\",\n \"def _model_fit_term(self):\\r\\n if self.likelihood.YYT is None:\\r\\n tmp, _ = dtrtrs(self.L, np.asfortranarray(self.likelihood.Y), lower=1)\\r\\n return -0.5 * np.sum(np.square(tmp))\\r\\n # return -0.5 * np.sum(np.square(np.dot(self.Li, self.likelihood.Y)))\\r\\n else:\\r\\n return -0.5 * np.sum(np.multiply(self.Ki, self.likelihood.YYT))\",\n \"def _residual_edp(self, params):\\n data = self.F**2\\n model = np.absolute(self._model())**2\\n sigma = self.sigma\\n return (data[self.mask]-model[self.mask]) / sigma[self.mask] \\n \\n # The following three lines do not reproduce Sun's results, which proves\\n # that the fits were done through intensity, not form factor.\\n #data = self.F\\n #model = np.absolute(self._model())\\n #return (data - model) \",\n \"def hangerqs_old(fitparams):\\n return abs(fitparams[1]/fitparams[2]), abs(fitparams[1])/(1-abs(fitparams[2]))\",\n \"def test_fit(self, model):\\r\\n fit = model/np.linalg.norm(model, axis=1, keepdims=True)\\r\\n if self.white:\\r\\n sources = self.sources.dot(self.zca_matrix)\\r\\n sources /= np.linalg.norm(sources, axis=1, keepdims=True)\\r\\n else:\\r\\n sources = self.sources\\r\\n allthedots = sources.dot(fit.T)\\r\\n # how close is the closest model source to each true source?\\r\\n bestfits = np.max(np.abs(allthedots), axis=1)\\r\\n return np.median(bestfits)\",\n \"def guess_fit_parameters(self):\\n\\n def errfcn(pars):\\n lnl = -self._lnprob(pars)\\n p = list(pars)\\n p.append(lnl)\\n logging.info(p)\\n return lnl if np.isfinite(lnl) else np.sign(lnl) * 9e9\\n\\n if self.vary_bin_frac:\\n initial_pars = [0.5, 0.5]\\n bounds_list = [[0.0, 1.0], [0, 0.999]]\\n else:\\n initial_pars = [0.5]\\n bounds_list = [[0, 0.999]]\\n out = minimize(errfcn, initial_pars, bounds=bounds_list)\\n self.guess_pars = out.x\\n return out.x\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def check_and_fit(x, y, flag='L', threshold=1000):\\n \\n confidence_index = len(x)\\n if IsLaneFound is False:\\n threshold =500\\n if confidence_index < threshold:\\n fit = None\\n foundFlag = False\\n else:\\n fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)\\n foundFlag = True\\n return fit, foundFlag, confidence_index\",\n \"def _model_fit_term(self):\\n if self.likelihood.YYT is None:\\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\\n else:\\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))\",\n \"def BestFit(self,initialParameterValues = None, method = None, fixedParams=None):\\n\\n if fixedParams:\\n if not isinstance(fixedParams, list):\\n fixedParams=[fixedParams]\\n #Check now if the name is correct\\n l_index=[]\\n for index, par in enumerate(fixedParams):\\n pName, pValue = par\\n if pName not in self.theory.parameterNameList0:\\n print \\\"%s is not a valid name. Ignored\\\" %pName\\n l_index.append(index)\\n if l_index:\\n for i in l_index:\\n fixedParams.pop(i)\\n\\n self.theory.SetFixedParams(fixedParams)\\n\\n if initialParameterValues is None:\\n initialParameterValues = self.theory.initialParameterValues\\n #d = numpy.ones(len(initialParamaeterValues))\\n start_time = time.time()\\n if method is None or method == 'lm':\\n out = scipy.optimize.minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\\n elif method == 'boldAccel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n elif method == 'bold':\\n initialParameterValues = numpy.array(initialParameterValues)\\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\\n elif method == 'lm_accel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\\n else:\\n print \\\"fitting method is not included\\\"\\n out = None\\n end_time = time.time()\\n print \\\"fitting took (mins)\\\", (end_time-start_time)/60.\\n print \\\"number of function evals:\\\", f_counter\\n \\n if fixedParams:\\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\\n self.theory.SetFixedParams()\\n else:\\n outputParameterValues = out[0]\\n\\n\\n return outputParameterValues, out\",\n \"def lorentzfit(x, y, peak=1., center=0., std=.1):\\r\\n def res(p, y, x):\\r\\n top1, m1, std1 = p\\r\\n y_fit = mm.lorentz(x, top1, m1, std1)\\r\\n err = y - y_fit\\r\\n return err\\r\\n p = [peak, center, std] # Initial guesses for leastsq\\r\\n plsq = leastsq(res, p, args = (y, x), maxfev=2000)\\r\\n \\r\\n return plsq[0]\",\n \"def BestFit(self,initialParameterValues=None, method=None , fixedParams=None):\\n\\n if fixedParams:\\n if not isinstance(fixedParams, list):\\n fixedParams=[fixedParams]\\n #Check now if the name is correct\\n l_index=[]\\n for index, par in enumerate(fixedParams):\\n pName, pValue = par\\n if pName not in self.theory.parameterNameList0:\\n print \\\"%s is not a valid name. Ignored\\\" %pName\\n l_index.append(index)\\n if l_index:\\n for i in l_index:\\n fixedParams.pop(i)\\n self.SetFixedParams(fixedParams)\\n\\n if initialParameterValues is None:\\n initialParameterValues = self.theory.initialParameterValues\\n #d = numpy.ones(len(initialParameterValues))\\n start_time = time.time()\\n if method is None or method == 'lm':\\n out = minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\\n elif method == 'boldAccel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n elif method == 'bold':\\n initialParameterValues = numpy.array(initialParameterValues)\\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\\n elif method == 'lm_accel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\\n else:\\n print \\\"fitting method is not included\\\"\\n end_time = time.time()\\n print \\\"fitting took time (mins): \\\", (end_time-start_time)/60.\\n print \\\"number of function_calls:\\\", f_counter\\n \\n if fixedParams:\\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\\n else:\\n outputParameterValues = out[0]\\n\\n return outputParameterValues, out\",\n \"def vct_resistance_correction(\\n data: pd.DataFrame, data_TT_MDL: pd.DataFrame\\n) -> pd.DataFrame:\\n df_resistance = data.groupby(by=\\\"test type\\\").get_group(\\\"resistance\\\")\\n result1 = least_squares(\\n fun=error, x0=[0], kwargs={\\\"y\\\": df_resistance[\\\"fx\\\"], \\\"u\\\": df_resistance[\\\"u\\\"]}\\n )\\n\\n data[\\\"fx\\\"] -= res(result1.x, u=data[\\\"u\\\"])\\n\\n R_m = data_TT_MDL[\\\"Rm [N]\\\"]\\n fx = -R_m\\n result2 = least_squares(\\n fun=error,\\n x0=result1.x,\\n kwargs={\\\"y\\\": fx, \\\"u\\\": fx.index},\\n )\\n\\n R_factor = 1.14\\n # R_factor = 1.14 * 1.43\\n data[\\\"fx\\\"] += R_factor * res(result2.x, u=data[\\\"u\\\"])\\n\\n return data\",\n \"def STRidge(X0, y, lam, maxit, tol, normalize=0, print_results=False):\\n\\n n, d = X0.shape\\n X = np.zeros((n, d), dtype=np.complex64)\\n # First normalize data\\n if normalize != 0:\\n Mreg = np.zeros((d, 1))\\n for i in range(0, d):\\n Mreg[i] = 1.0 / (np.linalg.norm(X0[:, i], normalize))\\n X[:, i] = Mreg[i] * X0[:, i]\\n else:\\n X = X0\\n\\n # Get the standard ridge estimate\\n if lam != 0:\\n w = np.linalg.lstsq(X.T.dot(X) + lam * np.eye(d), X.T.dot(y))[0]\\n else:\\n w = np.linalg.lstsq(X, y)[0]\\n num_relevant = d\\n biginds = np.where(abs(w) > tol)[0]\\n\\n # Threshold and continue\\n for j in range(maxit):\\n\\n # Figure out which items to cut out\\n smallinds = np.where(abs(w) < tol)[0]\\n new_biginds = [i for i in range(d) if i not in smallinds]\\n\\n # If nothing changes then stop\\n if num_relevant == len(new_biginds):\\n break\\n else:\\n num_relevant = len(new_biginds)\\n\\n # Also make sure we didn't just lose all the coefficients\\n if len(new_biginds) == 0:\\n if j == 0:\\n # if print_results: print \\\"Tolerance too high - all coefficients set below tolerance\\\"\\n return w\\n else:\\n break\\n biginds = new_biginds\\n\\n # Otherwise get a new guess\\n w[smallinds] = 0\\n if lam != 0:\\n w[biginds] = \\\\\\n np.linalg.lstsq(X[:, biginds].T.dot(X[:, biginds]) + lam * np.eye(len(biginds)), X[:, biginds].T.dot(y))[0]\\n else:\\n w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\\n\\n # Now that we have the sparsity pattern, use standard least squares to get w\\n if biginds != []: w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\\n\\n if normalize != 0:\\n return np.multiply(Mreg, w)\\n else:\\n return w\",\n \"def fitGammaErrFun(self, params, x, y, minLum, maxLum):\\n if self.eq == 4:\\n gamma, a, k = params\\n _m = gammaFun(x, minLum, maxLum, gamma, eq=self.eq, a=a, k=k)\\n model = numpy.asarray(_m)\\n else:\\n gamma = params[0]\\n _m = gammaFun(x, minLum, maxLum, gamma, eq=self.eq)\\n model = numpy.asarray(_m)\\n SSQ = numpy.sum((model - y)**2)\\n return SSQ\",\n \"def get_duct_linear_heat_loss_coefficient() -> float:\\n return 0.49\",\n \"def _find_cutoff(self):\\n cutoff = 1\\n while ((self.linear_rstar_unnorm(cutoff) -\\n self.turing_rstar_unnorm(cutoff))**2\\n > self.approx_turing_variance(cutoff)):\\n cutoff += 1\\n return cutoff\",\n \"def r_sq(data, fit):\\n ss_res = np.sum((data - fit) ** 2)\\n ss_tot = np.sum((data - np.mean(data)) ** 2)\\n\\n return 1 - (ss_res / ss_tot)\",\n \"def sharpness_penalty(self):\\n # This polynomial function gives the gain for peaking filter which achieves 18 dB / octave max derivative\\n # The polynomial estimate is accurate in the vicinity of 18 dB / octave\\n gain_limit = -0.09503189270199464 + 20.575128011847003 * (1 / self.q)\\n # Scaled sigmoid function as penalty coefficient\\n x = self.gain / gain_limit - 1\\n sharpness_penalty_coefficient = 1 / (1 + np.e ** (-x * 100))\\n return np.mean(np.square(self.fr * sharpness_penalty_coefficient))\",\n \"def linfit(x, y, yerror, pinit=[0,0]):\\n x = np.array(x)\\n y = np.array(y)\\n if (type(yerror) != list and type(yerror) != np.ndarray):\\n yerror = np.ones(len(x)) * yerror\\n fitfunc = lambda p, x: p[1] + p[0]*x\\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\\n p = out[0]\\n covar = out[1]\\n return(p)\",\n \"def fit_sky(self):\\n min_value = self.data.min()\\n ring_model = models.Ring2D(\\n min_value, self.x, self.y, self._box * 0.4, width=self._box * 0.4\\n )\\n ring_model.r_in.fixed = True\\n ring_model.width.fixed = True\\n ring_model.x_0.fixed = True\\n ring_model.y_0.fixed = True\\n fit_p = fitting.LevMarLSQFitter()\\n return fit_p(ring_model, self._XGrid, self._YGrid, self.data).amplitude\",\n \"def lightness_correction(self):\\n points = self.color_lookup_table_points\\n lightness_max_value = math.sqrt(3 * (255**2))\\n deadpool = list()\\n for index, point in enumerate(points[0]):\\n point = self.get_value_tuple(index)\\n lightness = int(math.sqrt(point[0]**2 + point[1]**2 + point[2]**2) * 255 / lightness_max_value)\\n if not self.to_dark < lightness < self.to_bright:\\n deadpool.append(index)\\n self.color_lookup_table_points = (np.delete(points[0], deadpool),\\n np.delete(points[1], deadpool),\\n np.delete(points[2], deadpool))\\n self.point_count = len(self.color_lookup_table_points[0])\",\n \"def least_squares_SGD(y, tx, initial_w, max_iters, gamma, debug = False):\\n losses, ws = stochastic_gradient_descent(y, tx, initial_w, 1, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\\n return get_last_ans(ws, losses)\",\n \"def least_squares_GD(y, tx, initial_w, max_iters, gamma, debug = False):\\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\\n return get_last_ans(ws, losses)\",\n \"def _get_reference_fit(self, img):\\n bw_img = 255 * (img >= self.contrast)\\n fit = [center_on_box(bw_img, self.radius, self.min_ref, *ref) for ref in self.refzone]\\n meanfit = num.mean(num.ma.masked_array(fit, fit == -9999), axis=0).astype('i')\\n if meanfit[0] is num.ma.masked:\\n raise StandardError('At least one reference box match required')\\n\\n return meanfit, fit\",\n \"def w0FromFingerPrint(y, fitInfo, param, N=200, weights=1, lowerBounds=[-1e3, -1e3, 1e-3, 1e-3, 1e-3, 1e-3, 1e-3], upperBounds = [1e3, 1e3, 1e4, 1e4, 1e3, 1e4, 1e4]):\\n \\n fitInfo = np.asarray(fitInfo)\\n param = np.asarray(param)\\n lowerBounds = np.asarray(lowerBounds)\\n upperBounds = np.asarray(upperBounds)\\n \\n fitparamStart = param[fitInfo==1]\\n fixedparam = param[fitInfo==0]\\n lowerBounds = lowerBounds[fitInfo==1]\\n upperBounds = upperBounds[fitInfo==1]\\n \\n fitresult = least_squares(fitfunW0FromFingerPrint, fitparamStart, args=(fixedparam, fitInfo, y, N, weights), bounds=(lowerBounds, upperBounds))\\n \\n return fitresult\",\n \"def fit():\\n pass\",\n \"def measure_curvature(ploty, left_fitx, right_fitx):\\n \\n ym_per_pix = 30/720 # meters per pixel in y dimension\\n xm_per_pix = 3.7/700 # meters per pixel in x dimension\\n \\n left_fitx = left_fitx[::-1]\\n right_fitx = right_fitx[::-1]\\n \\n left_fit_cr = np.polyfit(ploty*ym_per_pix, left_fitx*xm_per_pix, 2)\\n right_fit_cr = np.polyfit(ploty*ym_per_pix, right_fitx*xm_per_pix, 2)\\n \\n y_eval = np.max(ploty)\\n \\n \\n left_curverad = (1+(2*left_fit_cr[0]*y_eval*ym_per_pix+left_fit_cr[1])**2)**(3/2)/(2*np.abs(left_fit_cr[0])) \\n right_curverad = (1+(2*right_fit_cr[0]*y_eval*ym_per_pix+right_fit_cr[1])**2)**(3/2)/(2*np.abs(right_fit_cr[0])) \\n \\n return left_curverad, right_curverad\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\\n data)\\n #scipy rihjt\\n # Levenberg-Marquadt algorithm -> leastsq\\n #bnds = None\\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n \\n #least square fitting(minimizes raw data and fit)\\n\\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\\n #print(\\\"pass case\\\")\\n return(p)\\n else:\\n print(\\\"failed case\\\")\\n print(\\\"height1\\\", p[0],\\\"height2\\\", p[5], \\\"X\\\", p[1],\\\"Y\\\", p[2],\\\"Y1\\\", p[6], \\\"Y2\\\", p[7])\\n print(\\\"bounding error\\\" + str(numero)) \\n\\n return p\",\n \"def find_single_fit_range(lorentz_params):\\n f0 = lorentz_params[1]\\n FWHM = lorentz_params[2]\\n return (f0 - 4 * FWHM, f0 - 2 * FWHM, f0 + 2 * FWHM, f0 + 4 * FWHM)\",\n \"def fitSingleLorentzian(data, expectedQ, lookahead, delta, backgroundData = None, svgWindowLength = 11, svgOrder= 5):\\n f=data[:,0]\\n t=data[:,3]\\n\\n if backgroundData == None:\\n r=data[:,2]\\n elif len(backgroundData) == len(r=data[:,2]):\\n r=data[:,2]-backgroundData\\n else:\\n print \\\"Length of Background Data is not equal Length of r\\\"\\n return\\n\\n\\n\\n #apply SVG filter to make peak detection easier\\n fr=signal.savgol_filter(r,svgWindowLength,svgOrder)\\n _max, _min = pd.peakdetect(fr, None, lookahead, delta)\\n\\n #create lists of locations of max/min, values of xmax/xmin and ymax/ymin\\n fmi = [p[0] for p in _max]\\n fni= [p[0] for p in _min]\\n fm = [f[p[0]] for p in _max]\\n rm = [p[1] for p in _max]\\n fn = [f[p[0]] for p in _min]\\n rn = [p[1] for p in _min]\\n\\n limitToBigPeak=True\\n #change Q to fwhm based on first detected peak location\\n\\n fwhm=fm[0]/expectedQ\\n paramList=[]\\n\\n #if limitToBigPeak is true, will only try to fit maximum peak. Good if only\\n #looking at single resonance peak. Problematic if there is a larger BG peak\\n #which gets fit.\\n if limitToBigPeak == True:\\n max_value = max(rm)\\n max_index = rm.index(max_value)\\n paramList=[fm[max_index], rm[max_index]*fwhm, fwhm]\\n else:\\n for i in xrange(len(fmi)):\\n paramList+=[fm[i], rm[i]*fwhm/2*math.pi, fwhm]\\n\\n #fits data to a single lorentzian with a linear background. Parameters are limited\\n #in how much they vary so initial choice is vital to a good fit\\n\\n out = lmLorFit(f, r, paramList, ctr_range = 1.2, amp_range = 2 , sig_range= 2)\\n fittedfwhm = out.params['lo0_fwhm'].value\\n fittedAmp = out.params['lo0_amplitude'].value\\n fittedCenter = out.params['lo0_center'].value\\n fittedQ=fittedCenter/fittedfwhm\\n\\n \\\"\\\"\\\"Returns output fit as will as list of important fitting parameters\\\"\\\"\\\"\\n return out, [fittedCenter, fittedAmp, fittedfwhm, fittedQ]\",\n \"def ellipse_dist_ratio_poly(self, theta, lwr):\\n\\n \\\"\\\"\\\"\\n\\n Params for FWD fit\\n array([ 9.99999989e-01, 8.10852195e+07, 1.95444928e+00, 7.96543026e-02])\\n this one is un-needed, since it's approximation y = 1\\n\\n Params for FWD_DIAG fit\\n array([-0.00650758, 0.57761793, 0.35369061, 1.87834152])\\n\\n Params for ORTHOG fit\\n array([-0.02014989, 5.7007518 , -0.83345416, 0.97711175])\\n\\n Params for BCK_DIAG fit\\n array([-0.01608705, 9.44079769, -0.92071169, 0.89094967])\\n\\n Params for BCK fit\\n array([ -0.01451187, 10.92674105, -0.93514904, 0.87868538])\\n \\\"\\\"\\\"\\n\\n #fitting function\\n def f(x,params):\\n return params[0] + (1.0 / (params[1]*(x+params[2])**params[3]))\\n\\n #force float math, in case theta is an integer\\n theta = float(theta)\\n\\n #into an angle index form:\\n t = abs(int(4.0*theta/np.pi))\\n\\n if (t == 0) or (t == 8):\\n return 1.0\\n elif (t == 1) or (t == 7):\\n #forward diagonal\\n return f(lwr, [-0.00650758, 0.57761793, 0.35369061, 1.87834152])\\n elif (t == 2) or (t == 6):\\n #orthogonal\\n return f(lwr, [-0.02014989, 5.7007518 , -0.83345416, 0.97711175])\\n elif (t == 3) or (t == 5):\\n #backward diagonal\\n return f(lwr, [-0.01608705, 9.44079769, -0.92071169, 0.89094967])\\n elif t == 4:\\n #backward\\n return f(lwr, [ -0.01451187, 10.92674105, -0.93514904, 0.87868538])\\n else:\\n #hmmm... TODO\\n return 0.0\",\n \"def merge_lightcurve_fits(options):\\n import numpy\\n import astropy\\n import os\\n import JLA_library as JLA\\n from astropy.table import Table, MaskedColumn, vstack\\n from scipy.optimize import leastsq\\n\\n params = JLA.build_dictionary(options.config)\\n\\n # ---------------- JLA ------------------------\\n lightCurveFits = JLA.get_full_path(params['JLAlightCurveFits'])\\n f=open(lightCurveFits)\\n header=f.readlines()\\n f.close()\\n names=header[0].strip('#').split()\\n\\n # I imagine that the tables package in astropy could also be used to read the ascii input file\\n SNeSpec = Table(numpy.genfromtxt(lightCurveFits,\\n skip_header=1,\\n dtype='S12,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8',\\n names=names))\\n\\n nSNeSpec=len(SNeSpec)\\n print 'There are %d SNe from the spectrscopically confirmed sample' % (nSNeSpec)\\n\\n # Add an extra column to the table\\n SNeSpec['source']=['JLA']*nSNeSpec\\n\\n # -------------- Malmquist bias fits\\n malmBias={}\\n\\n if options.bias:\\n # Compute the bias correction\\n bias = numpy.genfromtxt(JLA.get_full_path(params['biasPolynomial']),\\n skip_header=3,\\n usecols=(0, 1, 2, 3),\\n dtype='S10,f8,f8,f8',\\n names=['sample', 'redshift', 'bias', 'e_bias'])\\n\\n for sample in numpy.unique(bias['sample']):\\n selection=(bias['sample']==sample)\\n guess=[0,0,0]\\n \\n plsq=leastsq(residuals, guess, args=(bias[selection]['bias'],\\n bias[selection]['redshift'],\\n bias[selection]['e_bias'],\\n 'poly'), full_output=1)\\n\\n if plsq[4] in [1,2,3,4]:\\n print 'Solution for %s found' % (sample)\\n malmBias[sample]=plsq[0]\\n\\n\\n # ---------------- Shuvo's sample aka JLA++ ------------------------\\n # Photometrically identified SNe in Shuvo's sample, if the parameter exists\\n if params['photLightCurveFits']!='None':\\n lightCurveFits = JLA.get_full_path(params['photLightCurveFits'])\\n SNePhot=Table.read(lightCurveFits, format='fits')\\n nSNePhot=len(SNePhot)\\n\\n print 'There are %d SNe from the photometric sample' % (nSNePhot)\\n\\n # Converting from Shuvo's names to thosed used by JLA\\n conversion={'name':'name_adj', 'zcmb':None, 'zhel':'z', 'dz':None, 'mb':'mb', 'dmb':'emb', 'x1':'x1', 'dx1':'ex1', 'color':'c', 'dcolor':'ec', '3rdvar':'col27', 'd3rdvar':'d3rdvar', 'tmax':None, 'dtmax':None, 'cov_m_s':'cov_m_x1', 'cov_m_c':'cov_m_c', 'cov_s_c':'cov_x1_c', 'set':None, 'ra':'col4', 'dec':'col5', 'biascor':None}\\n\\n # Add the uncertainty in the mass column\\n SNePhot['d3rdvar']=(SNePhot['col29']+SNePhot['col28'])/2. - SNePhot['col27']\\n\\n # Remove columns that are not listed in conversion\\n \\n for colname in SNePhot.colnames:\\n if colname not in conversion.values():\\n SNePhot.remove_column(colname)\\n \\n for key in conversion.keys():\\n # Rename the column if it does not already exist\\n if conversion[key]!=None and conversion[key]!=key:\\n SNePhot.rename_column(conversion[key], key)\\n elif conversion[key]==None:\\n # Create it, mask it, and fill all values\\n SNePhot[key]=MaskedColumn(numpy.zeros(nSNePhot), numpy.ones(nSNePhot,bool))\\n SNePhot[key].fill_value=-99 # does not work as expected, so we set it explicitly in the next line\\n SNePhot[key]=-99.9\\n else:\\n # Do nothing if the column already exists\\n pass\\n\\n # Compute the bias correction\\n for i,SN in enumerate(SNePhot):\\n if 'SDSS' in SN['name']:\\n SNePhot['biascor'][i]=poly(SN['zhel'],malmBias['SDSS'])\\n else:\\n SNePhot['biascor'][i]=poly(SN['zhel'],malmBias['SNLS'])\\n\\n # Add the source column\\n SNePhot['source']=\\\"Phot_Uddin\\\" \\n\\n # ---------------------- CfA4 ----------------------------------\\n if params['CfA4LightCurveFits']!='None':\\n lightCurveFits = JLA.get_full_path(params['CfA4LightCurveFits'])\\n f=open(lightCurveFits)\\n header=f.readlines()\\n f.close()\\n names=header[0].strip('#').split(',') \\n\\n SNeCfA4=Table(numpy.genfromtxt(lightCurveFits,\\n skip_header=1,\\n dtype='S12,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8',\\n names=names,delimiter=','))\\n\\n nSNeCfA4=len(SNeCfA4) \\n \\n conversion={'name':'name', 'zcmb':None, 'zhel':'z', 'dz':None, 'mb':'mb', 'dmb':'emb', 'x1':'x1', 'dx1':'ex1', 'color':'c', 'dcolor':'ec', '3rdvar':None, 'd3rdvar':None, 'tmax':None, 'dtmax':None, 'cov_m_s':'cov_m_x1', 'cov_m_c':'cov_m_c', 'cov_s_c':'cov_x1_c', 'set':None, 'ra':None, 'dec':None, 'biascor':None}\\n\\n # Remove columns that are not listed in conversion\\n \\n for colname in SNeCfA4.colnames:\\n if colname not in conversion.values():\\n SNeCfA4.remove_column(colname)\\n \\n for key in conversion.keys():\\n # Rename the column if it does not already exist\\n if conversion[key]!=None and conversion[key]!=key:\\n SNeCfA4.rename_column(conversion[key], key)\\n elif conversion[key]==None:\\n # Create it, mask it, and fill all values\\n SNeCfA4[key]=MaskedColumn(numpy.zeros(nSNeCfA4), numpy.ones(nSNeCfA4,bool))\\n SNeCfA4[key].fill_value=-99 # does not work as expected, so we set it explicitly in the next line\\n SNeCfA4[key]=-99.9\\n else:\\n # Do nothing if the column already exists\\n pass\\n\\n # Add the source column\\n SNeCfA4['source']=\\\"CfA4\\\" \\n\\n # We also need to gather information on the host mass, the host mass uncertainty, CMB redshift and Malmquist bias\\n CfA4lightcurves=[]\\n CfA4_lcDirectories=params['CfA4MassesAndCMBz'].split(',')\\n for lcDir in CfA4_lcDirectories:\\n listing=os.listdir(JLA.get_full_path(lcDir))\\n for lc in listing:\\n CfA4lightcurves.append(JLA.get_full_path(lcDir)+lc)\\n\\n for i,SN in enumerate(SNeCfA4):\\n for lc in CfA4lightcurves:\\n if SN['name'][2:] in lc:\\n keywords=getKeywords(lc)\\n SNeCfA4[i]['zcmb']=keywords['REDSHIFT_CMB']\\n SNeCfA4[i]['3rdvar']=keywords['HOSTGAL_LOGMASS']\\n SNeCfA4[i]['d3rdvar']=keywords['e_HOSTGAL_LOGMASS']\\n SNeCfA4[i]['ra']=keywords['RA']\\n SNeCfA4[i]['dec']=keywords['DECL']\\n if SNeCfA4[i]['3rdvar'] < 0:\\n SNeCfA4[i]['3rdvar']=-99.9\\n SNeCfA4[i]['d3rdvar']=-99.9\\n\\n # Compute the bias correction\\n SNeCfA4['biascor']=poly(SNeCfA4['zcmb'],malmBias['nearby'])\\n\\n try:\\n SNe=vstack([SNeSpec,SNePhot,SNeCfA4])\\n except:\\n SNe=SNeSpec\\n\\n# print len(SNe),len(numpy.unique(SNe['name']))\\n\\n # Write out the result as a FITS table\\n date = JLA.get_date()\\n SNe.write('%s_%s.fits' % (options.output, date), format='fits', overwrite=True)\\n\\n return\",\n \"def fit_langevin(self, h, m):\\n # get guess for magnitude and frequency\\n msatguess = max(m)\\n bguess = 4.0 * (ma.pi * 1439.5315)**2.0 * 151 / ( 1.9872e-3 *298 )\\n Bopt, Bcov = curve_fit(self.langevin, h, m, p0 = [ msatguess, bguess, 0] )\\n A = Bopt[0]\\n B = Bopt[1]\\n C = Bopt[2]\\n A_std = np.sqrt(np.diag(Bcov))[0]\\n B_std = np.sqrt(np.diag(Bcov))[1]\\n C_std = np.sqrt(np.diag(Bcov))[2]\\n AB_std = Bcov[0,1]\\n m_fit = self.langevin(h, A, B, C )\\n susceptibility = self.langevin_derivative( 0, A, B, C )\\n return A, B, C, susceptibility\",\n \"def fit(init_params, data):\\n snrs, ras, decs = data.transpose()\\n errorfunction = lambda p: np.ravel(observed_snr(*p)(ras, decs) - snrs)\\n if debug:\\n output = opt.leastsq(errorfunction, init_params, maxfev=10000, full_output=1)\\n print output[-1], output[-2]\\n p = output[0]\\n else:\\n p, success = opt.leastsq(errorfunction, init_params, maxfev=10000)\\n return p\",\n \"def get_resolution(testdata):\\n diffs = np.transpose([testdata[1:, 0], np.diff(testdata[:, 0])])\\n resolutions = ud.safedivide(diffs[:, 0], diffs[:, 1])\\n # popt, pcov = scipy.optimize.curve_fit(fit_line, diffs[:, 0], resolutions, maxfev=1000000)\\n # fitLine = fit_line(diffs[:, 0], *popt)\\n # fitMax = np.max(fitLine)\\n # fitMin = np.min(fitLine)\\n # diffs_new = diffs[(1.2 * fitMin < resolutions) & (resolutions < 1.2 * fitMax)]\\n # resolutions_new = resolutions[(1.2 * fitMin < resolutions) & (resolutions < 1.2 * fitMax)]\\n # popt2, pcov2 = scipy.optimize.curve_fit(fit_line, diffs_new[:, 0], resolutions_new, maxfev=1000000)\\n # plt.figure()\\n # plt.plot(diffs[:,0], resolutions)\\n # plt.plot(diffs[:, 0], fit_line(diffs[:, 0], *popt2), 'r-')\\n # plt.show()\\n # Currently use A * m ^1.5 (0.5?)\\n # Maybe use a*M^b\\n # return popt2\\n return np.median(resolutions)\",\n \"def get_thresh(amp,c): \\n #Helper functions for fitting the psychometric curve, need to be\\n #defined within the local scope, so that they can grok the data:\\n \\n def weib_fit(pars):\\n thresh,slope = pars\\n return weibull(x,thresh,slope,guess,flake)\\n\\n def err_func(pars):\\n return y-weib_fit(pars)\\n\\n #Throw away the None's:\\n hit_amps = amp[c==1]\\n miss_amps = amp[c==0]\\n\\n # Get rid of floating point error:\\n hit_amps = defloaterrorize(hit_amps)\\n miss_amps = defloaterrorize(miss_amps)\\n\\n all_amps = np.hstack([hit_amps,miss_amps])\\n stim_intensities = np.unique(all_amps)\\n\\n n_correct = [len(np.where(hit_amps==i)[0]) for i in stim_intensities]\\n n_trials = [len(np.where(all_amps==i)[0]) for i in stim_intensities]\\n Data = zip(stim_intensities,n_correct,n_trials)\\n x = []\\n y = []\\n n = []\\n for idx,this in enumerate(Data):\\n #Take only cases where there were at least n_up observations:\\n if n_trials[idx]>=self.n_up:\\n #Contrast values: \\n x = np.hstack([x,this[2] * [this[0]]])\\n #% correct:\\n y = np.hstack([y,this[2] * [this[1]/float(this[2])]])\\n\\n initial = np.mean(x),slope\\n this_fit , msg = leastsq(err_func,initial)\\n return this_fit,x,y\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def get_keff(self, take_final=False):\\n \\n # find max in rec (or final value, don't force as default)\\n if take_final:\\n _rec_max = self.rec_curve[-1, 1]\\n else:\\n _rec_max = numpy.max(self.rec_curve[:, 1])\\n \\n _rec_min = self.rec_curve[0, 1] \\n #Bit of a cheat - take the first point. Will be wrong in the case of \\n #very fast recovery compared to 1st interval. But in this case, _rec_min and _rec_max \\n #should be similar and caught below\\n \\n if _rec_min > 0.95 * _rec_max:\\n print (\\\"No recovery because too little desensitization (fast limit)\\\")\\n print (\\\"Setting k_eff = 1000\\\")\\n self.k_eff = 1000 #We could certainly not measure a rate this fast\\n \\n else:\\n _half_rec_amp = _rec_max - 0.5 * (_rec_max - _rec_min)\\n _near_idx = (numpy.abs(self.rec_curve[:, 1] - _half_rec_amp)).argmin()\\n _near_value = self.rec_curve [_near_idx, 1]\\n\\n #interpolate\\n #must be a smarter way to combine the two possibilities?\\n if _near_value > _half_rec_amp:\\n #true half time was before our nearest neighbor\\n _left = self.rec_curve[_near_idx - 1, 1]\\n _right = self.rec_curve[_near_idx, 1]\\n _tl = self.rec_curve[_near_idx - 1, 0]\\n _tr = self.rec_curve[_near_idx, 0]\\n #inverse of time difference scaled by normalized (point-threshold distance)\\n self.k_eff = 1 / (_tr - (_tr - _tl) * float(_right - _half_rec_amp)/(_right - _left))\\n\\n elif _near_value < _half_rec_amp:\\n #true half time was after our nearest neighbor\\n _left = self.rec_curve[_near_idx, 1]\\n _right = self.rec_curve[_near_idx + 1, 1]\\n _tl = self.rec_curve[_near_idx, 0]\\n _tr = self.rec_curve[_near_idx + 1, 0]\\n #as above rearranged to approach from below.\\n self.k_eff = 1 / (_tl + (_tr - _tl) * float(_half_rec_amp - _left)/(_right - _left))\\n\\n elif _near_value == _half_rec_amp:\\n\\n self.k_eff = 1 / self.rec_curve[near_hi_idx, 0]\",\n \"def calibration(self) -> int:\",\n \"def _curvature(self):\\n y_eval = self.left_fitx.shape[0] - 10\\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.left_fit[0]))\\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.right_fit[0]))\\n return left_curverad, right_curverad\",\n \"def get_tol_2d():\\r\\n return geometry.gmGetXyTol()\",\n \"def best_fit(self, **kwargs):\\n n_fit_p = len(self.fit_parameters)\\n n_wc = len(self.fit_wc_names)\\n if n_fit_p + n_wc == 1:\\n def f(x):\\n return -self.log_likelihood([x])\\n opt = scipy.optimize.minimize_scalar(f, **kwargs)\\n else:\\n def f(x):\\n return -self.log_likelihood(x)\\n if 'x0' not in kwargs:\\n x0 = np.zeros(n_fit_p + n_wc)\\n if n_fit_p > 1:\\n x0[:n_fit_p] = self.get_central_fit_parameters\\n opt = minimize_robust(f, x0, **kwargs)\\n else:\\n opt = minimize_robust(f, **kwargs)\\n if not opt.success:\\n raise ValueError(\\\"Optimization failed.\\\")\\n else:\\n return {'x': opt.x, 'log_likelihood': -opt.fun}\",\n \"def STRidge(X0, y, lam, maxit, tol, normalize=2):\\n\\n n, d = X0.shape\\n X = np.zeros((n, d), dtype=np.float64)\\n # First normalize data\\n if normalize != 0:\\n Mreg = np.zeros((d, 1))\\n for i in range(0, d):\\n Mreg[i] = 1.0 / (np.linalg.norm(X0[:, i], normalize))\\n X[:, i] = Mreg[i] * X0[:, i]\\n else:\\n X = X0\\n\\n # Get the standard ridge esitmate\\n if lam != 0:\\n w = np.linalg.lstsq(X.T.dot(X) + lam * np.eye(d), X.T.dot(y), rcond=None)[0]\\n else:\\n w = np.linalg.lstsq(X, y)[0]\\n num_relevant = d\\n biginds = np.where(abs(w) > tol)[0]\\n\\n # Threshold and continue\\n for j in range(maxit):\\n if j == maxit - 1:\\n warnings.warn('Maxit in STRidge is not large enough and has stopped Regression at this point')\\n\\n # Figure out which items to cut out\\n smallinds = np.where(abs(w) < tol)[0]\\n new_biginds = [i for i in range(d) if i not in smallinds]\\n\\n # If nothing changes then stop\\n if num_relevant == len(new_biginds):\\n break\\n else:\\n num_relevant = len(new_biginds)\\n\\n # Also make sure we didn't just lose all the coefficients\\n if len(new_biginds) == 0:\\n if j == 0:\\n # if print_results: print \\\"Tolerance too high - all coefficients set below tolerance\\\"\\n return w\\n else:\\n break\\n biginds = new_biginds\\n\\n # Otherwise get a new guess\\n w[smallinds] = 0\\n if lam != 0:\\n w[biginds] = \\\\\\n np.linalg.lstsq(X[:, biginds].T.dot(X[:, biginds]) + lam * np.eye(len(biginds)), X[:, biginds].T.dot(y), rcond=None)[0]\\n else:\\n w[biginds] = np.linalg.lstsq(X[:, biginds], y)[0]\\n\\n # Now that we have the sparsity pattern, use standard least squares to get w\\n if biginds != []: w[biginds] = np.linalg.lstsq(X[:, biginds], y, rcond=None)[0]\\n\\n if normalize != 0:\\n return np.multiply(Mreg, w)\\n else:\\n return w\",\n \"def compute(self):\\n # update parameters with the values of widgets\\n initguess = str(self.ptext.toPlainText())\\n if not self.checkUserInput(initguess):\\n return\\n stguess = initguess.replace('\\\\n', ',')\\n # update self.parmVal\\n self.guessToParms(stguess)\\n try:\\n self.parent.app.setOverrideCursor(Qt.WaitCursor)\\n result = least_squares(self.residuals, self.parmVal, bounds=self.bounds,\\n args=(self.data[1], self.data[0]))\\n self.parent.app.restoreOverrideCursor()\\n except ValueError as err:\\n errmsg = \\\"Fitting process failure:\\\\n{0}\\\".format(err)\\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\\n return\\n RMSE = np.sqrt(np.sum(np.square(result.fun)) / len(self.data[1]))\\n msg = \\\"Initial guess : \\\\n{0}\\\\n\\\".format(initguess)\\n msg += \\\"Number of peaks = {0:d}\\\\n\\\".format(self.npeaks)\\n logmsg = msg + 'Fitting results:\\\\n'\\n res = np.reshape(result.x, (self.npeaks, self.maxparm))\\n strres = self.resToStr(res)\\n logmsg += '[xm, amp, fwhm, asym, m] = \\\\n{0}\\\\n'.format(strres)\\n rmsemsg = 'RMSE = {0:g}\\\\n\\\\n'.format(RMSE)\\n msg += rmsemsg\\n logmsg += rmsemsg\\n self.parmVal = result.x\\n\\n # Show results in log windows\\n self.log.setText(msg)\\n self.log.moveCursor(QtGui.QTextCursor.End)\\n self.saveToLogFile(logmsg)\\n self.data[2] = self.fitfunc(self.data[0], result.x)\\n self.data[3] = self.data[2] - self.data[1] - self.diffshift\\n\\n self.updatePlot()\\n self.updateParmsEdit()\",\n \"def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\\n\\n # useful display and computational data\\n y_fitted = poly_fit(x_data)\\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\\n x_fitted_display = np.linspace(min_x_display, max_x_display)\\n y_fitted_display = poly_fit(x_fitted_display)\\n\\n # goodness of fit indicators\\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\\n R2 = 1.0 - SSE/SST # R squared\\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 2, 1)\\n\\n # plot of the fitted polynomial itself\\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\\n ax.scatter(x_data, y_data, color='C7')\\n ax.set(title=\\\"Fitted polynomial (deg{}) for \\\\'{}\\\\'\\\".format(poly_fit.order, fit_name), xlabel=\\\"x\\\", ylabel=\\\"y\\\")\\n\\n # histogram of residuals\\n ax2 = fig.add_subplot(1, 2, 2)\\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\\n ax2.set(title=\\\"Histogram of residuals\\\", xlabel=\\\"Residual value $y_k - \\\\\\\\widehat{y_k}$\\\", ylabel=\\\"Count\\\")\\n\\n # display of fit indicators\\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\\n\\n fig.tight_layout()\\n fig.subplots_adjust(bottom=0.2)\\n\\n figurefiles.save_in_perfs_fits_folder(fig, \\\"Polyfit_{}_order_{}.pdf\\\".format(fit_name, poly_fit.order))\",\n \"def get_normfactor(self, full_well=FULL_WELL):\\n\\n max_value = np.amax(self.data)\\n normfactor = full_well/max_value\\n\\n return normfactor\",\n \"def _UpdateCriteria(self):\\n grad = self.traj.grad[-1]\\n disp = self.traj.coords[-1] - self.traj.coords[-2]\\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\\n self.grad_max = numpy.amax(grad)\\n self.disp_max = numpy.amax(disp)\\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\\n self.disp_rms = math.sqrt(numpy.mean(disp**2))\",\n \"def guess_fit_gaussian():\\n a = z.max()\\n\\n # Compute moments\\n total = z.sum()\\n x_0 = np.dot(x, z) / total\\n y_0 = np.dot(y, z) / total\\n\\n # Approximate sigmas\\n sigma_x = np.dot(x**2, z) / total\\n sigma_y = np.dot(y**2, z) / total\\n sigma = np.sqrt(sigma_x * sigma_y)\\n\\n # Return guess\\n return (a, x_0, y_0, sigma)\",\n \"def get_fit(self) -> np.poly1d:\\n if self.log_fits is not None:\\n return next(self.log_fits)\\n x = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\\n .to_list()\\n )\\n y = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\\n .to_list()\\n )\\n if self.orientation == Orientation.UP_DOWN:\\n fit = np.polyfit(x, y, 1)\\n else:\\n fit = np.polyfit(y, x, 1)\\n return np.poly1d(fit)\",\n \"def makeFit(self):\\n if not self.fitModel.params:\\n return\\n cs = self.spectrum\\n self.worker.make_model_curve(cs, allData=csi.allLoadedItems)\\n\\n dfparams = cs.fitParams\\n lcfRes = dfparams['lcf_result']\\n self.fitR.setText('R={0:.5g}'.format(lcfRes['R']))\\n self.updateFitResults()\\n self.fitReady.emit()\",\n \"def _lowess_robustify_fit(x_copy, y_copy, fitted, weights, k, n):\\n nn_indices = [0,k]\\n X = np.ones((k,2))\\n\\n residual_weights = np.copy(y_copy)\\n residual_weights.shape = (n,)\\n residual_weights -= fitted\\n residual_weights = np.absolute(residual_weights)#, out=residual_weights)\\n s = np.median(residual_weights)\\n residual_weights /= (6*s)\\n too_big = residual_weights>=1\\n _lowess_bisquare(residual_weights)\\n residual_weights[too_big] = 0\\n\\n\\n for i in range(n):\\n total_weights = weights[i,:] * np.sqrt(residual_weights[nn_indices[0]:\\n nn_indices[1]])\\n\\n X[:,1] = x_copy[nn_indices[0]:nn_indices[1]]\\n y_i = total_weights * y_copy[nn_indices[0]:nn_indices[1]]\\n total_weights.shape = (k,1)\\n\\n beta = lstsq(total_weights * X, y_i, rcond=-1)[0]\\n\\n fitted[i] = beta[0] + beta[1] * x_copy[i]\\n\\n _lowess_update_nn(x_copy, nn_indices, i+1)\",\n \"def fit(x_array, y_array, function, A_start):\\n param = (x_array, y_array, function)\\n\\n A_final, cov_x, infodict, mesg, ier = leastsq(minimize, A_start, args=param, full_output=True)#, warning=True)\\n \\n return A_final\",\n \"def _accept_fit(self, fit, curvature):\\n self.detected = True\\n self.current_fit.append(fit)\\n self.best_fit = np.average(self.current_fit, axis=0)\\n if 10000 > curvature > 100:\\n self.radius_of_curvature.append(curvature)\\n self.best_curvature = np.average(self.radius_of_curvature)\",\n \"def _find_best_threshold(self, num_of_steps=20, verbose=False):\\n xmin = self.x.min()\\n xmax = self.x.max()\\n step = (xmax - xmin)/num_of_steps\\n \\n lower_th = None\\n lower_IR = 1\\n\\n # for each potential threshold\\n for threshold in np.arange(xmin+step, xmax, step):\\n IR = self._compute_isometric_ratio(threshold)\\n \\n if IR < lower_IR:\\n lower_IR = IR\\n lower_th = threshold\\n \\n self.threshold = lower_th\\n if verbose:\\n print(f'\\\\tThreshold:\\\\t\\\\t{lower_th}\\\\n\\\\tIsometric Ratio:\\\\t{lower_IR}')\",\n \"def polyfit(x, y, yerror, pinit=[0,0,0,0]):\\n x = np.array(x)\\n y = np.array(y)\\n pinit[2] = np.mean(y)\\n pinit[3] = x[len(x)/2]\\n if (type(yerror) != list and type(yerror) != np.ndarray):\\n yerror = np.ones(len(x)) * yerror\\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\\n p = out[0]\\n covar = out[1]\\n return(p)\",\n \"def fit_focus(self) -> Tuple[float, float]:\\n\\n # get data\\n focus = [d[\\\"focus\\\"] for d in self._data]\\n xfwhm = [d[\\\"x\\\"] for d in self._data]\\n xsig = [d[\\\"xerr\\\"] for d in self._data]\\n yfwhm = [d[\\\"y\\\"] for d in self._data]\\n ysig = [d[\\\"yerr\\\"] for d in self._data]\\n\\n # fit focus\\n try:\\n xfoc, xerr = fit_hyperbola(focus, xfwhm, xsig)\\n yfoc, yerr = fit_hyperbola(focus, yfwhm, ysig)\\n\\n # weighted mean\\n xerr = np.sqrt(xerr)\\n yerr = np.sqrt(yerr)\\n foc = (xfoc / xerr + yfoc / yerr) / (1.0 / xerr + 1.0 / yerr)\\n err = 2.0 / (1.0 / xerr + 1.0 / yerr)\\n except (RuntimeError, RuntimeWarning):\\n raise ValueError(\\\"Could not find best focus.\\\")\\n\\n # get min and max foci\\n min_focus = np.min(focus)\\n max_focus = np.max(focus)\\n if foc < min_focus or foc > max_focus:\\n raise ValueError(\\\"New focus out of bounds: {0:.3f}+-{1:.3f}mm.\\\".format(foc, err))\\n\\n # return it\\n return float(foc), float(err)\",\n \"def fit(self):\\n\\n fitdata = np.polyfit(self.v**(-2./3.), self.e, 3, full=True)\\n ssr = fitdata[1]\\n sst = np.sum((self.e - np.average(self.e))**2.)\\n residuals0 = ssr/sst\\n deriv0 = np.poly1d(fitdata[0])\\n deriv1 = np.polyder(deriv0, 1)\\n deriv2 = np.polyder(deriv1, 1)\\n deriv3 = np.polyder(deriv2, 1)\\n\\n self.v0 = None\\n for x in np.roots(deriv1):\\n if x > 0 and deriv2(x) > 0:\\n self.v0 = x**(-3./2.)\\n break\\n\\n if self.v0 is None:\\n raise ValueError('No minimum!')\\n\\n derivV2 = 4./9. * x**5. * deriv2(x)\\n derivV3 = (-20./9. * x**(13./2.) * deriv2(x) -\\n 8./27. * x**(15./2.) * deriv3(x))\\n bulk_modulus0 = derivV2 / x**(3./2.)\\n bulk_deriv0 = -1 - x**(-3./2.) * derivV3 / derivV2\\n\\n self.e0 = deriv0(x)\\n self.B0 = bulk_modulus0\\n self.B1 = bulk_deriv0\\n\\n return self.v0, self.e0, self.B0, self.B1, residuals0\",\n \"def recovery(self):\\n\\n def exponential(time, tau):\\n\\n time = list(map(lambda x: float(x), time))\\n exponent = np.exp(-np.divide(time, tau))\\n return (1 - exponent)\\n \\n \\n initial_guess = [55]\\n \\n tau = []\\n for i in range(self.n_cols):\\n current = self.screened_data.iloc[:,i]\\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\\n tau.append(popt[0][0])\\n\\n print('Median: ', np.median(tau))\\n print('Min: ', np.min(tau))\\n print('Max: ', np.max(tau))\\n return 0\\n\\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\\n for i in range(len(popt)):\\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\\n plt.xlabel('Time (ms)')\\n plt.ylabel('Normalized Current')\\n plt.title('Recovery from Inactivation')\\n plt.legend()\\n plt.savefig('recovery_exponential_fit.png')\\n return popt\",\n \"def find_k(model, data, tol = 1e-3):\\n\\n # Store the quantities that never change\\n pow_mod = 10 ** model\\n\\n # Make the array x_k 10 times finer than the tolerance\\n step = tol * 0.1\\n k_arr = np.arange(0, 1 + step, step)\\n\\n # Get the x_k array\\n x_k = np.array([(1 - k_arr) + k_arr * p for p in pow_mod]).T\\n\\n # And now the really useful arrays\\n coef = (pow_mod - 1)/x_k * 2/np.log(10)\\n log_x_k = np.log10(x_k)\\n\\n # Start with the extremes\\n k0 = k_arr[0:1]\\n k1 = k_arr[-1:]\\n km = (k0 + k1) * 0.5\\n\\n first = True\\n while True:\\n\\n # Each of the gradients\\n gradm = get_one_gradient(k_arr, coef, log_x_k, data, km)\\n if first:\\n # If first time, we have to calculate everything\\n grad0 = get_one_gradient(k_arr, coef, log_x_k, data, k0)\\n grad1 = get_one_gradient(k_arr, coef, log_x_k, data, k1)\\n\\n first = False\\n else:\\n # Otherwise we can use the previous calculation\\n grad0 = (sum0 * gradm + dif0 * grad0) * 0.5\\n grad1 = (sum1 * gradm + dif1 * grad1) * 0.5\\n\\n # Get signs\\n sign0 = np.sign(grad0)\\n signm = np.sign(gradm)\\n sign1 = np.sign(grad1)\\n\\n # Get differences\\n sum0 = np.abs(signm + sign0)\\n dif0 = np.abs(signm - sign0)\\n sum1 = np.abs(signm + sign1)\\n dif1 = np.abs(signm - sign1)\\n\\n # Vectorized change\\n k0 = (sum0 * km + dif0 * k0) * 0.5\\n k1 = (sum1 * km + dif1 * k1) * 0.5\\n\\n # Get the middle point\\n new_km = (k0 + k1) * 0.5\\n\\n # Check if converged\\n dif = np.abs(new_km[0] - km[0])\\n if dif < tol:\\n return new_km\\n\\n # Update\\n km = new_km\",\n \"def overall_sensitivity(self):\\n if self.mod1:\\n s = torch.max(torch.max(self.weight, -1)[0], -1)[0].item()\\n else:\\n s = torch.max(torch.sqrt(torch.sum(self.weight * self.weight, -1)))[0].item()\\n s *= np.sqrt(2. / np.e)\\n return s\",\n \"def find_best_fit_gaussian(self, also_use_scipy=True, save=True, fix_mean=False, x_y=None):\\n if x_y is None:\\n x, y = self.get_local_maxes()\\n else:\\n x, y = x_y\\n y_max = np.max(y)\\n amplitude = np.max(y)\\n mean = np.sum(x * y) / np.sum(y)\\n sigma = np.sqrt(np.abs(np.sum(y * (x - mean) ** 2) / np.sum(y)))\\n\\n if also_use_scipy:\\n if fix_mean is not False:\\n # TODO: Allow fixed mean optimisation\\n pass\\n else:\\n # fit_params is (amplitude, mean, sigma)\\n gaussian_fit = lambda fit_params, x: fit_params[0] * np.exp(\\n -(x - fit_params[1]) ** 2 / (2 * fit_params[2] ** 2))\\n err_func = lambda fit_params, x, y: gaussian_fit(fit_params, x) - y # Distance to the target function\\n initial_parameters = [y_max, mean, sigma] # Initial guess for the parameters\\n fitted_params, success = optimize.leastsq(err_func, initial_parameters[:], args=(x, y))\\n # print(fitted_params, success)\\n\\n if save:\\n self.config['gaussian_fit_amplitude'] = str(fitted_params[0])\\n self.config['gaussian_fit_mean'] = str(fitted_params[1])\\n self.config['gaussian_fit_sigma'] = str(fitted_params[2])\\n\\n return fitted_params, (amplitude, mean, sigma)\\n\\n else:\\n # calculate gaussian fit from points\\n return amplitude, mean, sigma\",\n \"def correct(self) -> float:\\n return self._coreEstimation[DetailedMaskType.CorrectMask]\",\n \"def fitTranslation(data, target, xtol=1e-5, maxfev=0, verbose=0):\\n\\n def obj(x):\\n dataT = data + x\\n d = ( ( dataT - target ) ** 2.0 ).sum(1)\\n return d\\n\\n x0 = scipy.array([0.0, 0.0, 0.0])\\n\\n if verbose:\\n rms0 = scipy.sqrt(obj(x0).mean())\\n print 'initial RMS:', rms0\\n\\n xOpt = leastsq(obj, x0, xtol=xtol, maxfev=maxfev)[0]\\n\\n if verbose:\\n rmsOpt = scipy.sqrt(obj(xOpt).mean())\\n print 'final RMS:', rmsOpt\\n\\n dataFitted = data + xOpt\\n return xOpt, dataFitted\",\n \"def fit(self,\\n x: np.ndarray,\\n y: np.ndarray,\\n init_guess: np.ndarray = None) -> np.ndarray:\\n\\n self.x = x\\n self.y = y\\n if init_guess is not None:\\n self.init_guess = init_guess\\n\\n if init_guess is None:\\n raise Exception(\\\"Initial guess needs to be provided\\\")\\n\\n self.coefficients = self.init_guess\\n rmse_prev = np.inf\\n for k in range(self.max_iter):\\n residual = self.get_residual()\\n jacobian = self._calculate_jacobian(self.coefficients, step=10 ** (-6))\\n self.coefficients = self.coefficients - self._calculate_pseudoinverse(jacobian) @ residual\\n rmse = np.sqrt(np.sum(residual ** 2))\\n logger.info(f\\\"Round {k}: RMSE {rmse}\\\")\\n if self.tolerance_difference is not None:\\n diff = np.abs(rmse_prev - rmse)\\n if diff < self.tolerance_difference:\\n logger.info(\\\"RMSE difference between iterations smaller than tolerance. Fit terminated.\\\")\\n return self.coefficients\\n if rmse < self.tolerance:\\n logger.info(\\\"RMSE error smaller than tolerance. Fit terminated.\\\")\\n return self.coefficients\\n rmse_prev = rmse\\n logger.info(\\\"Max number of iterations reached. Fit didn't converge.\\\")\\n\\n return self.coefficients\",\n \"def solve(self):\\n max_iter = 1000\\n iter_count = 0\\n yhat = self.predict()\\n loss = self.cross_entropy(yhat)\\n gradloss = self.cross_entropy_gradient(yhat)\\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\\n alpha = 1.0\\n slope = la.norm(gradloss)**2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n while loss_new < loss + 1e-4 * alpha * slope:\\n alpha = alpha / 2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n self.beta = beta_new\\n loss = loss_new\\n gradloss = self.cross_entropy_gradient(yhat)\\n iter_count += 1\",\n \"def brute_leastsquare_fit(fun, x_data, y_data,weight_data=None,p_names=None,p_min_max_steps_dict=None,\\r\\n const_params=[], visualize=False):\\r\\n \\r\\n if p_names == None or p_min_max_steps_dict==None:\\r\\n raise Exception ('p_names and p_min_max_steps must be given!'+ \\r\\n 'structure of p_min_max_steps_dict: {\\\"pname0\\\":[min0,max0,brute_steps0]}')\\r\\n \\r\\n params = Parameters() ### initialize LMfit parameters\\r\\n for p_name in p_names:\\r\\n min_val=p_min_max_steps_dict[p_name][0]\\r\\n max_val=p_min_max_steps_dict[p_name][1]\\r\\n steps=p_min_max_steps_dict[p_name][2]\\r\\n params.add(p_name,value=min_val,\\r\\n min=min_val,\\r\\n max=max_val,\\r\\n brute_step=(max_val-min_val)/(steps-1))\\r\\n \\r\\n ### define function to be minimized for fit \\r\\n \\r\\n def cost_function_fit(p=params):\\r\\n def minimize_fun(pars):\\r\\n \\r\\n v=pars.valuesdict()\\r\\n arglist=[]\\r\\n for p_name in p_names:\\r\\n arglist.append(v[p_name])\\r\\n \\r\\n for const_param in const_params:\\r\\n arglist.append(const_param)\\r\\n \\r\\n ret=np.array((fun(x_data,*arglist)-y_data),dtype=float)\\r\\n if weight_data is not None:\\r\\n ret=ret*np.sqrt(weight_data)\\r\\n return(ret)\\r\\n brute_result=lmfit.minimize(minimize_fun,params,method='brute',nan_policy='omit')\\r\\n best_result=copy.deepcopy(brute_result)\\r\\n for candidate in brute_result.candidates[0:5]:\\r\\n trial = lmfit.minimize(minimize_fun, params=candidate.params,method='leastsq',nan_policy='omit')\\r\\n if trial.chisqr < best_result.chisqr:\\r\\n best_result = trial\\r\\n \\r\\n return((best_result,brute_result))\\r\\n \\r\\n best_result,brute_result = cost_function_fit()\\r\\n arg_list=[]\\r\\n for p_name in p_names:\\r\\n arg_list.append(best_result.params.valuesdict()[p_name])\\r\\n for const_param in const_params:\\r\\n arg_list.append(const_param)\\r\\n \\r\\n \\r\\n if visualize == True:\\r\\n plot_brute_leastsquares_results(brute_result,leastsq_fit_result=best_result)\\r\\n plt.figure()\\r\\n plt.plot(x_data,y_data,label='data',color='blue')\\r\\n plt.plot(x_data,fun(x_data,*arg_list),label='Fit',color='red')\\r\\n plt.title(best_result.params.valuesdict())\\r\\n plt.show()\\r\\n return (arg_list[0:len(p_names)])\",\n \"def get_last_fit(flag='L'):\\n if flag == 'L':\\n return l_coeff_queue[-1]\\n else:\\n return r_coeff_queue[-1]\",\n \"def abs_robust_loss(diff, eps=0.01, q=0.4):\\n return torch.pow((torch.abs(diff) + eps), q)\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def get_Curvature(self):\\n #return str(np.mean([self.line_l.get_CurveRad(), self.line_r.get_CurveRad()]))\\n y = np.linspace(0,719, 10)\\n x = self.center_poly(y)\\n fit_scaled = np.polyfit(y*self.line_l.y_pxm,x*self.line_l.x_pxm, deg=2)\\n curverad = ((1 + (2 * fit_scaled[0] * 600 + fit_scaled[1]) ** 2) ** 1.5) / np.absolute(2 * fit_scaled[0])\\n\\n if len(self.curve_buffer) > 15:\\n self.curve_buffer.pop(0)\\n\\n self.curve_buffer.append(curverad)\\n _, self.curve_buffer = self.line_l.remove_outliers(self.curve_buffer,[None]*len(self.curve_buffer), m=3)\\n buff_mean= np.mean(self.curve_buffer)\\n #print(\\\"Buf Mean: \\\" +str(buff_mean))\\n #outlier = np.abs(buff_mean - curverad) > np.std(self.curve_buffer)*2\\n if curverad > 4000.0:\\n buff_mean = \\\"Straight Lane\\\"\\n else:\\n buff_mean = str(int(buff_mean)) + \\\" m\\\"\\n\\n return buff_mean\",\n \"def get_gev_fit(data):\\n md = mode(data)[0][0]\\n std = np.std(data)\\n # first try with loc=mode\\n shape, loc, scale = gev.fit(data, loc=md)\\n # if bad try again with mean\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\\n else:\\n print('GEV fit with mode')\\n # if still bad (ugh), try again with mode - std\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=md-std)\\n else:\\n print('GEV fit with mean')\\n if loc > md+std:\\n print('GEV fit with c=0')\\n shape, loc, scale = gev.fit(data, 0)\\n else:\\n print('GEV fit with mode minus std deviation')\\n return shape, loc, scale\",\n \"def get_gev_fit(data):\\n md = mode(data)[0][0]\\n std = np.std(data)\\n # first try with loc=mode\\n shape, loc, scale = gev.fit(data, loc=md)\\n # if bad try again with mean\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\\n else:\\n print('GEV fit with mode')\\n # if still bad (ugh), try again with mode - std\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=md-std)\\n else:\\n print('GEV fit with mean')\\n if loc > md+std:\\n print('GEV fit with c=0')\\n shape, loc, scale = gev.fit(data, 0)\\n else:\\n print('GEV fit with mode minus std deviation')\\n return shape, loc, scale\",\n \"def get_gev_fit(data):\\n md = mode(data)[0][0]\\n std = np.std(data)\\n # first try with loc=mode\\n shape, loc, scale = gev.fit(data, loc=md)\\n # if bad try again with mean\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=np.mean(data))\\n else:\\n print('GEV fit with mode')\\n # if still bad (ugh), try again with mode - std\\n if loc > md+std:\\n shape, loc, scale = gev.fit(data, loc=md-std)\\n else:\\n print('GEV fit with mean')\\n if loc > md+std:\\n print('GEV fit with c=0')\\n shape, loc, scale = gev.fit(data, 0)\\n else:\\n print('GEV fit with mode minus std deviation')\\n return shape, loc, scale\",\n \"def _compute_distance_residual(undist_x, undist_y, fit_poly_x, fit_poly_y):\\n dist = np.sqrt((undist_x - fit_poly_x)**2 + (undist_y - fit_poly_y)**2)\\n max_resid = dist.max()\\n return max_resid\",\n \"def fit_polynomial(self, ym_per_pix, xm_per_pix):\\r\\n\\r\\n # Fit a second order polynomial\\r\\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\\r\\n\\r\\n # Fit a second order polynomial (in meters)\\r\\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\\r\\n\\r\\n # calculate the curvature (in meters)\\r\\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\\r\\n\\r\\n # flag that a polynomial is found\\r\\n self.detected = True\",\n \"def best_params(self):\\n return self.X[np.argmax(self.y.numpy())]\",\n \"def get_autofocus_ratio(self, x):\\n\\n # sample designs from the prior\\n z = tf.random.normal([tf.shape(x)[0], self.latent_size])\\n q_dx = self.q_vae.decoder.get_distribution(z, training=False)\\n p_dx = self.p_vae.decoder.get_distribution(z, training=False)\\n\\n # evaluate the score and importance weights\\n log_w = q_dx.log_prob(x)[..., tf.newaxis] - \\\\\\n p_dx.log_prob(x)[..., tf.newaxis]\\n while len(log_w.shape) > 2:\\n log_w = tf.reduce_sum(log_w, axis=1)\\n return tf.math.exp(log_w)\",\n \"def test_extended_truncated_power_law_fit(self):\\n\\t\\t\\n\\t\\t#TODO: fix this; low priority\\n\\t\\tdetails= self.watcher.analyze(layers=[self.fc1_layer], pl_package=POWERLAW_PACKAGE, fit=E_TPL)\\n\\t\\tactual_alpha = details.alpha[0]\\n\\t\\tactual_Lambda = details.Lambda[0]\\n\\n\\t\\tself.assertTrue(actual_Lambda > -1) #Lambda must be set for TPL\\n\\t\\t\\n\\t\\t# these numbers have not been independently verified yet\\n\\t\\texpected_alpha = 2.3\\n\\t\\texpected_Lambda = 0.006069\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=2)\\n\\t\\tself.assertAlmostEqual(actual_Lambda,expected_Lambda, places=2)\",\n \"def Solve(self):\\n if self.verbose:\\n print(\\\"{0:>6s}{1:>16s}{2:>16s}{3:>16s}\\\".format(\\\"iter\\\", \\\"energy\\\", \\\"rms error\\\", \\\"max error\\\"))\\n guess = self.polarization_matrix.dot(self.F)\\n\\n for k in range(1, self.max_iterations):\\n F = self.F + self.interaction_matrix.dot(guess)\\n\\n (guess, difference) = self.Step(guess, F, k)\\n\\n # error is RMS in the difference\\n rms_err = numpy.std(difference)\\n max_err = numpy.max(difference)\\n\\n energy = -0.5 * self.F.dot(guess)\\n if self.verbose:\\n print(\\\"{0:6d}{1:16.8f}{2:16.8f}{3:16.8f}\\\".format(k, energy, rms_err, max_err))\\n\\n # according to:\\n # Scalmani G et al. Theo. Chem. Account. 2004, (111), 90 - 100, DOI: 10.1007/s00214-003-0527-2\\n #\\n # we use a convergence threshold on both the RMS and MAX of the residual\\n if rms_err < self.threshold and max_err < self.threshold:\\n break\\n\\n # destroy matrices to conserve memory\\n self.polarization_matrix = None\\n self.interaction_matrix = None\\n return guess\",\n \"def _fit_point_lens(self):\\n\\n def chi2_fun(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n for a given event set attributes from parameters_to_fit\\n (list of str) to values from theta list\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n chi2 = event.get_chi2()\\n if chi2 < chi2_fun.best_chi2:\\n chi2_fun.best_chi2 = chi2\\n return chi2\\n chi2_fun.best_chi2 = 1.e10\\n\\n def jacobian(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n Calculate chi^2 gradient (also called Jacobian).\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n return event.chi2_gradient(parameters_to_fit)\\n\\n if self._event_PSPL is None:\\n self._set_event_PSPL()\\n\\n parameters_to_fit = [\\\"t_0\\\", \\\"u_0\\\", \\\"t_E\\\"]\\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\\n\\n failed = False\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n failed = True\\n\\n if failed:\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n pass\\n# XXX what if fit failed (i.e., .success is False)?\\n\\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2\",\n \"def fit(self, x):\\n pass\",\n \"def get_heuristic_corrections(self, tile_key):\\n\\n if (len(self.foc_est[tile_key]) > 1\\n and len(self.astgx_est[tile_key]) > 1\\n and len(self.astgy_est[tile_key]) > 1):\\n\\n wd_corr = (self.heuristic_calibration[0]\\n * (self.foc_est[tile_key][0] - self.foc_est[tile_key][1]))\\n a1 = (self.heuristic_calibration[1]\\n * (self.astgx_est[tile_key][0] - self.astgx_est[tile_key][1]))\\n a2 = (self.heuristic_calibration[2]\\n * (self.astgy_est[tile_key][0] - self.astgy_est[tile_key][1]))\\n\\n ax_corr = a1 * cos(self.rot_angle) - a2 * sin(self.rot_angle)\\n ay_corr = a1 * sin(self.rot_angle) + a2 * cos(self.rot_angle)\\n ax_corr *= self.scale_factor\\n ay_corr *= self.scale_factor\\n # Are results within permissible range?\\n within_range = (abs(wd_corr/1000) <= self.max_wd_diff\\n and abs(ax_corr) <= self.max_sx_diff\\n and abs(ay_corr) <= self.max_sy_diff)\\n if within_range:\\n # Store corrections for this tile:\\n self.wd_stig_corr[tile_key] = [wd_corr/1000, ax_corr, ay_corr]\\n else:\\n self.wd_stig_corr[tile_key] = [0, 0, 0]\\n\\n return wd_corr, ax_corr, ay_corr, within_range\\n else:\\n return None, None, None, False\",\n \"def Train(R, Ut, lam, d_tol, maxit=10, STR_iters=10, l0_penalty=1, normalize=2, split=0.8,\\n print_best_tol=False, sparse='STR'):\\n\\n # Split data into 80% training and 20% test, then search for the best tolderance.\\n # np.random.seed(0) # for consistancy\\n n, _ = R.shape\\n #train = np.random.choice(n, int(n * split), replace=False)\\n #test = [i for i in np.arange(n) if i not in train]\\n TrainR = R#[train, :]\\n TestR = R#[test, :]\\n TrainY = Ut#[train, :]\\n TestY = Ut#[test, :]\\n D = TrainR.shape[1]\\n\\n # Set up the initial tolerance and l0 penalty\\n d_tol = float(d_tol)\\n tol = d_tol\\n if l0_penalty == None: l0_penalty = 0.001 * np.linalg.cond(R)\\n\\n # Get the standard least squares estimator\\n w = np.zeros((D, 1))\\n\\n # check\\n # print(np.nan in TrainR)\\n # print(np.inf in TrainR)\\n\\n def AIC(w, err):\\n k = 0\\n for item in w:\\n if item != 0:\\n k += 1\\n\\n return 2*k+2*np.log(err)\\n\\n w_best = np.linalg.lstsq(TrainR, TrainY)[0]\\n data_err_best = np.linalg.norm(TestY - TestR.dot(w_best), 2)\\n err_best = np.linalg.norm(TestY - TestR.dot(w_best), 2) + l0_penalty * np.count_nonzero(w_best)\\n aic_best = AIC(w_best[:, 0], data_err_best)\\n tol_best = 0\\n\\n if sparse == 'STR':\\n # Now increase tolerance until test performance decreases\\n for iter in range(maxit):\\n\\n # Get a set of coefficients and error\\n w = STRidge(R, Ut, lam, STR_iters, tol, normalize=normalize)\\n err = np.linalg.norm(TestY - TestR.dot(w), 2) + l0_penalty * np.count_nonzero(w)\\n data_err = np.linalg.norm(TestY - TestR.dot(w), 2)\\n\\n # Has the accuracy improved?\\n aic = AIC(w[:, 0], data_err)\\n if aic <= aic_best:\\n aic_best = aic\\n err_best = err\\n w_best = w\\n data_err_best = data_err\\n tol_best = tol\\n tol = tol + d_tol\\n else:\\n tol = max([0, tol - 2 * d_tol])\\n d_tol = 2 * d_tol / (maxit - iter)\\n tol = tol + d_tol\\n\\n if print_best_tol: print(\\\"Optimal tolerance:\\\", tol_best)\\n\\n elif sparse == 'Lasso':\\n w = Lasso(R, Ut, lam, w=np.array([0]), maxit=maxit*10, normalize=normalize)\\n err = np.linalg.norm(Ut - R.dot(w), 2) + l0_penalty * np.count_nonzero(w)\\n data_err = np.linalg.norm(Ut - R.dot(w), 2)\\n\\n if err <= err_best:\\n err_best = err\\n w_best = w\\n data_err_best = data_err\\n\\n return w_best, err_best, data_err_best, aic_best\",\n \"def get_correction(d, a, hfov, img_x):\\n\\n width = 2 * d*math.tan((hfov/2)*math.pi/180) # in meters\\n one_meter = img_x / width\\n return int(a*one_meter)\",\n \"def curve_fit():\\n x_west, z_west, x_east, z_east = roof_measurements()\\n \\n # find best curve fit for west roof section\\n param_west, param_cov_west = optimize.curve_fit(test_func, x_west, z_west)\\n print(param_west)\\n \\n # z = 7.29944696 + (1.27415518*x) + (-0.0680139854*x**2) + (0.00152035861*x**3)\\n \\n z_west_fitted = test_func(x_west,*param_west)\\n \\n # mirror curve for east roof section\\n z_east_fitted = np.flip(z_west_fitted,axis=0)\\n \\n # create array for both west and east roof sections\\n x_whole_roof = np.concatenate((x_west, x_east), axis=0)\\n z_whole_roof = np.concatenate((z_west_fitted, z_east_fitted), axis=0)\\n\\n # plot roof\\n plt.plot(x_whole_roof, z_whole_roof, '-', color ='blue', label=\\\"roof curve\\\") \\n plt.axis('equal') # make axes square\\n plt.show() \\n\\n return param_west\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit_function_to_data(distance, light):\\n params, _ = curve_fit(objective_func, distance, light)\\n a, b, c = params\\n print(\\\"y = (\\\",a,\\\"(^x-\\\",b,\\\")) +\\\",c)\\n x_line = np.arange(min(distance), max(distance))\\n y_line = objective_func(x_line, a, b, c)\\n return a, b, c\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n #least square fitting(minimizes raw data and fit)\\n return p\",\n \"def _predict_adaptive_lasso(self, X, predictors, target, gamma=1.0):\\r\\n\\t\\tlr = LinearRegression()\\r\\n\\t\\tlr.fit(X[:, predictors], X[:, target])\\r\\n\\t\\tweight = np.power(np.abs(lr.coef_), gamma)\\r\\n\\t\\treg = LassoLarsIC(criterion='bic')\\r\\n\\t\\treg.fit(X[:, predictors] * weight, X[:, target])\\r\\n\\t\\treturn reg.coef_ * weight\",\n \"def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\\n #epsx = (1/2)*(eps1+eps2)\\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def initial_guess(self):\\n\\n x0 = [self.material_model.isotropic_matrix.c1, self.material_model.isotropic_matrix.c2]\\n\\n if not self.material_model.is_isotropic:\\n # c5 is scaled in the optimisation function\\n x0.append(self.material_model.fibres.c5 / c5_factor)\\n\\n if self.include_lm:\\n x0.append(self.material_model.fibres.lm)\\n\\n return np.asarray(x0)\",\n \"def _partial_min_solution(self, j):\\n beta_without_j = np.delete(self.betas, j, axis=0)\\n X_without_j = np.delete(self.X, j, axis=0)\\n X_j = self.X[j] # these are the X values for the jth feature in the model\\n # Make predictions and obtain residuals on the full set of Ys, without the effect of the jth predictor included\\n R_without_j = (self.Y - (beta_without_j.T @ X_without_j))\\n c_j = 2/self.n * (X_j @ R_without_j) # This quantity is described in the notes\\n # The following if statements are due to the subgradient of the L1 penality\\n if abs(c_j) <= self.lam: # this step is what causes the lasso to shrink coefficients to 0 based on lambda\\n return 0\\n a_j = 2 * sum(X_j**2) # also described in notes\\n if c_j < -self.lam:\\n return (c_j + self.lam) / (a_j / self.n)\\n elif c_j > self.lam:\\n return (c_j - self.lam) / (a_j / self.n)\",\n \"def calc_error(self):\\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit\",\n \"def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\\n \\n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\\n# epsx = (1/2)*(eps1+eps2)\\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6179351","0.5929913","0.58914375","0.587837","0.58164775","0.57964665","0.5769313","0.575269","0.57327217","0.5724726","0.5707219","0.56688213","0.5661554","0.56298316","0.5593415","0.558705","0.5580057","0.55682325","0.55587983","0.5546923","0.5546372","0.5520702","0.5511536","0.5502812","0.5501396","0.54886615","0.54735446","0.5468514","0.54656124","0.54384696","0.54207516","0.541964","0.54164344","0.5412308","0.54095054","0.5396614","0.53961223","0.5394179","0.5386922","0.53859985","0.5381801","0.536743","0.5360844","0.53523535","0.53427017","0.53407204","0.53400505","0.53339356","0.53262514","0.5323289","0.5313688","0.53006417","0.5292286","0.528897","0.5272635","0.5262471","0.5259987","0.5259541","0.52481884","0.5247875","0.52474076","0.52471805","0.5241391","0.52376455","0.5236992","0.5230543","0.5229558","0.5229085","0.521954","0.52151155","0.5210083","0.5201552","0.51984215","0.5198037","0.51956284","0.51955205","0.51955205","0.51955205","0.51896244","0.5186932","0.51715887","0.5169975","0.51694256","0.5166965","0.51609886","0.5158311","0.51542497","0.5147783","0.5146475","0.5144076","0.51434857","0.51434857","0.51434857","0.51404214","0.51374775","0.51368576","0.51352376","0.51332736","0.51330155","0.5132901","0.5132359"],"string":"[\n \"0.6179351\",\n \"0.5929913\",\n \"0.58914375\",\n \"0.587837\",\n \"0.58164775\",\n \"0.57964665\",\n \"0.5769313\",\n \"0.575269\",\n \"0.57327217\",\n \"0.5724726\",\n \"0.5707219\",\n \"0.56688213\",\n \"0.5661554\",\n \"0.56298316\",\n \"0.5593415\",\n \"0.558705\",\n \"0.5580057\",\n \"0.55682325\",\n \"0.55587983\",\n \"0.5546923\",\n \"0.5546372\",\n \"0.5520702\",\n \"0.5511536\",\n \"0.5502812\",\n \"0.5501396\",\n \"0.54886615\",\n \"0.54735446\",\n \"0.5468514\",\n \"0.54656124\",\n \"0.54384696\",\n \"0.54207516\",\n \"0.541964\",\n \"0.54164344\",\n \"0.5412308\",\n \"0.54095054\",\n \"0.5396614\",\n \"0.53961223\",\n \"0.5394179\",\n \"0.5386922\",\n \"0.53859985\",\n \"0.5381801\",\n \"0.536743\",\n \"0.5360844\",\n \"0.53523535\",\n \"0.53427017\",\n \"0.53407204\",\n \"0.53400505\",\n \"0.53339356\",\n \"0.53262514\",\n \"0.5323289\",\n \"0.5313688\",\n \"0.53006417\",\n \"0.5292286\",\n \"0.528897\",\n \"0.5272635\",\n \"0.5262471\",\n \"0.5259987\",\n \"0.5259541\",\n \"0.52481884\",\n \"0.5247875\",\n \"0.52474076\",\n \"0.52471805\",\n \"0.5241391\",\n \"0.52376455\",\n \"0.5236992\",\n \"0.5230543\",\n \"0.5229558\",\n \"0.5229085\",\n \"0.521954\",\n \"0.52151155\",\n \"0.5210083\",\n \"0.5201552\",\n \"0.51984215\",\n \"0.5198037\",\n \"0.51956284\",\n \"0.51955205\",\n \"0.51955205\",\n \"0.51955205\",\n \"0.51896244\",\n \"0.5186932\",\n \"0.51715887\",\n \"0.5169975\",\n \"0.51694256\",\n \"0.5166965\",\n \"0.51609886\",\n \"0.5158311\",\n \"0.51542497\",\n \"0.5147783\",\n \"0.5146475\",\n \"0.5144076\",\n \"0.51434857\",\n \"0.51434857\",\n \"0.51434857\",\n \"0.51404214\",\n \"0.51374775\",\n \"0.51368576\",\n \"0.51352376\",\n \"0.51332736\",\n \"0.51330155\",\n \"0.5132901\",\n \"0.5132359\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20278,"cells":{"query":{"kind":"string","value":"Returns a dictionary containing all diagnostic light curves. The dictionary will provide a light curve for each matrix in the design matrix collection."},"document":{"kind":"string","value":"def _create_diagnostic_lightcurves(self):\n if self.coefficients is None:\n raise ValueError(\"you need to call `correct()` first\")\n\n lcs = {}\n for idx, submatrix in enumerate(self.dmc.matrices):\n # What is the index of the first column for the submatrix?\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\n submatrix_coefficients = self.coefficients[\n firstcol_idx : firstcol_idx + submatrix.shape[1]\n ]\n # submatrix_coefficients_err = self.coefficients_err[firstcol_idx:firstcol_idx+submatrix.shape[1], firstcol_idx:firstcol_idx+submatrix.shape[1]]\n # samples = np.asarray([np.dot(submatrix.values, np.random.multivariate_normal(submatrix_coefficients, submatrix_coefficients_err)) for idx in range(100)]).T\n # model_err = np.abs(np.percentile(samples, [16, 84], axis=1) - np.median(samples, axis=1)[:, None].T).mean(axis=0)\n model_flux = u.Quantity(\n submatrix.X.dot(submatrix_coefficients), unit=self.lc.flux.unit\n )\n model_flux_err = u.Quantity(\n np.zeros(len(model_flux)), unit=self.lc.flux.unit\n )\n lcs[submatrix.name] = LightCurve(\n time=self.lc.time,\n flux=model_flux,\n flux_err=model_flux_err,\n label=submatrix.name,\n )\n return lcs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def generate_materials_dict(self):\n c = 299792458.0\n w_mat = 2 * np.pi * c / self.l_mat - self.w0\n l2_mat = (self.l_mat * 1e6) ** 2\n\n n_air = 1 + 0.05792105 * l2_mat / (238.0185 * l2_mat - 1) + 0.00167917 * l2_mat / (57.362 * l2_mat - 1)\n air_ip = interp1d(w_mat, n_air, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['air'] = air_ip\n\n n_fs = np.sqrt(1 + 0.6961663 * l2_mat / (l2_mat - 0.0684043 ** 2) +\n 0.4079426 * l2_mat / (l2_mat - 0.1162414 ** 2) +\n 0.8974794 * l2_mat / (l2_mat - 9.896161 ** 2))\n fs_ip = interp1d(w_mat, n_fs, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['fs'] = fs_ip\n\n n_mgf2 = np.sqrt(1 + 0.48755108 * l2_mat / (l2_mat - 0.04338408 ** 2) +\n 0.39875031 * l2_mat / (l2_mat - 0.09461442 ** 2) +\n 2.3120353 * l2_mat / (l2_mat - 23.793604 ** 2))\n mgf2_ip = interp1d(w_mat, n_mgf2, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['mgf2'] = mgf2_ip\n\n n_sapphire_o = np.sqrt(1 + 1.4313493 * l2_mat / (l2_mat - 0.0726631 ** 2) +\n 0.65054713 * l2_mat / (l2_mat - 0.1193242 ** 2) +\n 5.3414021 * l2_mat / (l2_mat - 18.028251 ** 2))\n sapphire_o_ip = interp1d(w_mat, n_sapphire_o, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['sapphire_o'] = sapphire_o_ip\n\n n_sapphire_e = np.sqrt(1 + 1.5039759 * l2_mat / (l2_mat - 0.0740288 ** 2) +\n 0.55069141 * l2_mat / (l2_mat - 0.1216529 ** 2) +\n 6.5927379 * l2_mat / (l2_mat - 20.072248 ** 2))\n sapphire_e_ip = interp1d(w_mat, n_sapphire_e, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['sapphire_e'] = sapphire_e_ip\n\n n_bbo_o = np.sqrt(2.7405 + 0.0184 / (l2_mat - 0.0179) - 0.0155 * l2_mat)\n bbo_o_ip = interp1d(w_mat, n_bbo_o, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['bbo_o'] = bbo_o_ip\n\n n_bbo_e = np.sqrt(2.3730 + 0.0128 / (l2_mat - 0.0156) - 0.0044 * l2_mat)\n bbo_e_ip = interp1d(w_mat, n_bbo_e, bounds_error=False, fill_value=np.nan, kind=\"quadratic\")\n self.materials['bbo_e'] = bbo_e_ip\n\n materials_files = os.listdir(self.materials_path)\n logger.info(\"Found {0:d}\".format(materials_files.__len__()))\n for mat_file in materials_files:\n logger.debug(mat_file)\n self.read_material(''.join((self.materials_path, '/', mat_file)))","def light_curve(num_energies, num_samples):\n fixed_header = (\n 1*8 # SSID\n + 4*8 # SCET Coarse time\n + 2*8 # SCET Fine time\n + 2*8 # Integration time\n + 4*8 # Detector mask\n + 4 # spare\n + 12 # Pixel mask\n + 1 # spare\n + 1 # Comp Schema light curve S\n + 3 # Comp Schema light curve K\n + 3 # Comp Schema light curve M\n + 1 # Comp Schema trigger S\n + 3 # Comp Schema trigger K\n + 3 # Comp Schema trigger M\n + 1 # Energy bin mask upper boundary\n + 4*8 # Energy bin mask lower boundray\n + 1*8 # Number of energies\n + num_energies*2*8 # Number data points\n + 2*8 # Number of data points\n + 2*8 # Number of data point\n )\n\n variable = (\n + num_energies*num_samples*8 # Compressed light curves\n + num_samples*8 # Compressed triggers\n + num_samples*8 # RCR\n )\n\n return fixed_header, variable","def lights(self) -> List[dict]:\n return self.items_by_domain(\"light\")","def read_lightcurves(params,log):\n\n lightcurves = { 'g':None, 'r':None , 'i': None}\n\n for f in lightcurves.keys():\n\n lc_file = params['target_lc_file_'+f]\n\n if path.isfile(lc_file):\n\n lightcurves[f] = read_rbn_lightcurve(lc_file,log)\n\n return lightcurves","def gradients(self):\n return {}","async def Lights_Description() -> List[Dict[str, Any]]:\n result = []\n for index, light in enumerate(busylightapi.manager.lights):\n result.append(\n {\n \"light_id\": index,\n \"name\": light.name,\n \"info\": light.info,\n \"is_on\": light.is_on,\n \"color\": rgb_to_hex(*light.color),\n }\n )\n return result","def show_materials(self):\n print('\\nThe materials with known dielectric properties are:\\n')\n pprint.pprint(mats.Electrical.props)\n# pprint.pprint(mats.Electrical.DIELECTRIC)\n print('\\nThe materials with known loss tangents are:\\n')\n pprint.pprint(mats.Electrical.props)\n# pprint.pprint(mats.Electrical.LOSS_TAN)\n return","def curves(self):\n return self._curve_reg","def show_lightcurve(self):\n\n time_array = self.exp_start_times\n\n fig = plt.figure()\n\n if self.transmission_spectroscopy:\n lc_model = self.generate_lightcurves(time_array,\n self.planet.calcTransitDepth())\n plt.ylabel(\"Transit Depth\")\n else:\n lc_model = np.ones_like(time_array)\n plt.ylabel(\"Unit Flux\")\n\n if self._visit_trend:\n trend_model = self._visit_trend.scale_factors\n # have to convert weird model format to flat array\n lc_model = trend_model * lc_model.T[0]\n\n plt.scatter(time_array, lc_model)\n plt.xlabel(\"Time (JD)\")\n plt.title(\"Normalised White Time Series of observation\")\n\n return time_array, lc_model","def compute_diagnostics(self) -> Dict[str, Any]:\n return {}","def get_sigma_dict(self):\n sigma = {}\n for c in self.cellLines:\n sigma[c] = {}\n for l in self.ligands:\n sigma[c][l] = self.aucs[c][l]['sigma']\n return sigma","def contrast_matrices(self):\n \n p = len(self.formula.terms)\n matrices = {}\n for crep in self._contrast_reps:\n s = self.slices[crep]\n l = s.stop - s.start\n array = np.zeros((l,p), np.float)\n for i, j in enumerate(range(l)):\n array[i,j+s.start] = 1.\n matrices[crep] = array\n return matrices","def realizations(self):\n return [ self.km(), self.kHLP(), self.affineSchur(), self.dual_k_Schur()]","def get_light_list(self):\n return self.light_array","def Thresholds(self) :\n \n # keep pass through thresholds\n d = { }\n\n\n from Hlt2Lines.SingleMuon.Lines import SingleMuonLines\n d.update({SingleMuonLines : \n {'Prescale' : {\"Hlt2SingleMuon\" : 0.5, \n \"Hlt2SingleMuonLowPT\" : 0.1},\n 'HltReq' : {\"SingleMuon\" : \"HLT_PASS_RE('Hlt1TrackMuonDecision')\"},\n 'Common' : {'TrChi2' : 3, # Adimensional\n 'Pt' : 1300 * MeV },\n 'SingleMuon' : {'IP' : 0.0 * mm,\n 'IPChi2' : 16 }, # Adimensional\n 'HighPT' : {'HighPt' : 10000 *MeV },\n 'LowPT' : { 'HighPt' : 4800 * MeV }\n }\n })\n \n return d","def get_mof_descriptors(self) -> dict:\n result_dict = OrderedDict(\n (\n (\"name\", self.name),\n (\"graph_hash\", self.graph_hash),\n (\"path\", self._filename),\n (\"density\", self.density),\n (\"has_oms\", self.has_oms),\n (\"has_carbon\", self.has_carbon),\n (\"has_hydrogen\", self.has_hydrogen),\n (\"has_atomic_overlaps\", self.has_atomic_overlaps),\n (\"has_overcoordinated_c\", self.has_overvalent_c),\n (\"has_overcoordinated_n\", self.has_overvalent_n),\n (\"has_overcoordinated_h\", self.has_overvalent_h),\n (\"has_undercoordinated_c\", self.has_undercoordinated_c),\n (\"has_undercoordinated_n\", self.has_undercoordinated_n),\n (\"has_metal\", self.has_metal),\n (\"has_lone_atom\", self.has_lone_atom),\n (\"has_lone_molecule\", self.has_lone_molecule),\n (\"has_high_charges\", self.has_high_charges),\n (\"has_undercoordinated_metal\", self.has_undercoordinated_metal),\n )\n )\n return result_dict","def Thresholds(self) :\n \n # keep pass through thresholds\n d = { }\n\n from Hlt2Lines.Commissioning.Lines import CommissioningLines \n d.update({CommissioningLines :\n {'Prescale' : {'Hlt2PassThrough' : 0.0001,\n 'Hlt2Forward' : 0.00001,\n 'Hlt2DebugEvent' : 0.000001},\n 'Postscale' : {'Hlt2ErrorEvent' : 'RATE(0.01)'},\n # do not want debug events on lumi-exclusive Hlt1 events...\n 'DebugEvent' : {'HLT1' : \"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\"},\n 'ErrorEvent' : {'Priority' : 254,\n 'VoidFilter' : '',\n 'HLT2' : \"HLT_COUNT_ERRORBITS_RE('^Hlt2.*',0xffff) > 0\"},\n 'PassThrough' : {'HLT1' : \"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\",\n 'VoidFilter' : ''},\n 'NoBiasPassThrough' : {'HLT1' : \"HLT_PASS('Hlt1NoBiasPrescaledDecision')\",\n 'VoidFilter' : ''},\n 'Transparent' : {'HLT1' : \"HLT_PASS_RE('^Hlt1(ODIN.*|L0.*|MB.*|BeamGas.*|Velo.*|NZS.*|Incident|Tell1Error|ErrorEvent)Decision$')\",\n 'VoidFilter' : ''},\n 'Lumi' : {'HLT1' : \"HLT_PASS_SUBSTR('Hlt1Lumi')\",\n 'VoidFilter' : ''},\n 'KS0_DD' : {'HLT1' : \"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\",\n 'VoidFilter' : ''},\n 'KS0_LL' : {'HLT1' : \"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\",\n 'VoidFilter' : ''},\n 'Turbo' : ['KS0_DD', 'KS0_LL']\n }}\n )\n return d","def lightcurve(self):\n return NGCLightCurve(self['corotid'])","def generate_lightcurves(self, time_array, depth=False):\n\n # TODO (ryan) quick check if out of transit, in that case ones!\n\n # TODO (ryan) should this be in generate exposure?\n\n planet = self.planet\n star = self.planet.star\n\n P = float(planet.P.rescale(pq.day))\n a = float((planet.a / star.R).simplified)\n rp = float((planet.R / star.R).simplified)\n i = float(planet.i.rescale(pq.deg))\n e = planet.e\n W = float(planet.periastron)\n transittime = float(planet.transittime)\n\n if np.isnan(W):\n W = 0\n\n time_array = time_array.to(u.day).value\n # model for each resolution element.\n\n if depth:\n planet_spectrum = np.array(\n [depth]) # an array as we want to perform ndim later.\n else:\n planet_spectrum = self.planet_spectrum\n\n models = np.zeros((len(time_array), len(planet_spectrum)))\n\n planet_spectrum = np.sqrt(\n planet_spectrum) # pylc wants Rp/Rs not transit depth\n\n time_array = tools.jd_to_hjd(time_array,\n planet) # pylc wants hjd not jd\n\n logger.debug(\n \"Generating lightcurves with P={}, a={}, i={}, e={}, W={}, T14={},\"\n \" mean_depth={}\".format(\n P, a, i, e, W, transittime, np.mean(planet_spectrum)\n ))\n\n for j, spec_elem in enumerate(planet_spectrum):\n models[:, j] = pylc.transit('claret', self.ldcoeffs, spec_elem, P, a, e, i,\n W, transittime, time_array) - \\\n (\n 1. - pylc.eclipse(spec_elem ** 2, rp, P, a, e,\n i, W,\n transittime, time_array))\n\n return models","def generate_visualization_dict(self):\n self._data = {}\n self._data['name'] = self.name\n self._data['type'] = self.__repr__()\n self._data['color'] = self._color_rgb\n\n try:\n self._data['simulation_matrix'] = \\\n self._visualization_matrix.tolist()\n\n except:\n #Not sure which error to call here.\n raise RuntimeError('''Please call the numerical\n transformation methods,\n before generating simulation dict ''')\n\n\n return self._data","def get_lightcurves(product_type):\n\n # Build lists of paths to lightcurves\n results = session.query(Outputs).all()\n individual_lightcurves = set([os.path.join(result.individual_path, result.individual_filename) for result in results])\n composite_lightcurves = set([os.path.join(result.composite_path, result.composite_filename) for result in results if result.composite_filename != None])\n\n # Return appropriate list based on product_type\n if product_type == 'individual':\n lightcurves = individual_lightcurves\n elif product_type == 'composite':\n lightcurves = composite_lightcurves\n elif product_type == 'both':\n lightcurves = individual_lightcurves | composite_lightcurves\n\n return lightcurves","def _supported_convergence_norms() -> Dict[Text, _NormType]:\n return {\n _monitor_key('convergence', 'l-1'): _NormType.L1,\n _monitor_key('convergence', 'l-2'): _NormType.L2,\n _monitor_key('convergence', 'l-inf'): _NormType.L_INF,\n _monitor_key('subiter-scalar', 'convergence_l-1'): _NormType.L1,\n _monitor_key('subiter-scalar', 'convergence_l-2'): _NormType.L2,\n _monitor_key('subiter-scalar', 'convergence_l-inf'): _NormType.L_INF,\n }","def all_lightcurves():\n for fname in listdir(join(DATA_PATH, 'lightcurves')):\n try:\n locus_id, fmt = fname.split('.')\n assert fmt == 'lc'\n yield fetch_lightcurve(locus_id)\n except Exception as e:\n print(f'{repr(e)} fetching {fname}')","def get_metal_descriptors(self) -> dict:\n if not self.has_metal:\n raise NoMetal\n return self._get_metal_descriptors()","def sans_monitor() -> dict:\n return {**beamline.beamline(scatter=False), **tof.elastic_wavelength('tof')}","def contrasts(self):\n if not hasattr(self, \"_contrasts\"):\n self._contrasts = {}\n self._contrast_reps = []\n self._formulae = []\n for expr in sorted(self.graded_dict.keys()):\n formulae = get_contributions(self.codings[expr],\n self.sorted_factors)\n for formula, srep in formulae:\n v = formula * Formula([expr])\n sexpr = \"I(%s)\" % str(expr)\n if srep:\n crep = ':'.join([sexpr,srep])\n else:\n crep = sexpr\n self._contrasts[crep] = v\n self._contrast_reps.append(crep)\n self._formulae.append(v)\n return self._contrasts","def get_gradients(self):\n\n result_gradients = {}\n for signal in self.signals_list:\n net = self.networks[signal]\n\n list_gradients = []\n for w in net.parameters():\n list_gradients.append(w.grad.view(-1).clone())\n\n grad_vector = torch.cat(list_gradients, dim=0)\n result_gradients[signal] = grad_vector\n\n return result_gradients","def loss_functions(self) -> dict:\n tmp_dict = dict()\n tmp_dict['From_Root'] = (('Cov', self.log_post_cov, self.constraint_cov),\n ('Beta', self.log_post_beta, self.constraint_sigma),\n ('Lambda', self.log_post_lambda, self.constraint_sigma),\n ('Psi', self.log_post_psi, self.constraint_psi),\n ('Theta', self.log_post_theta, self.constraint_theta),\n ('Tree', self.log_post_tree, self.constraint_tree))\n\n tmp_dict['Likelihood'] = (self.log_likelihood, ('Psi',\n 'Beta',\n 'Theta',\n 'Lambda'))\n return tmp_dict","def lCurve(self): \n\n # --------------------------------------------------------------------------------------------- #\n # Read data\n fitsNnam = os.path.join(self.workpath, 'LCresults.fits')\n lcTab = Table.read(fitsNnam)\n if (self.tstart is not None) and (self.tstop is not None):\n lcTab = lcTab[ (self.tstart <= lcTab['mjd']) & (lcTab['mjd'] <= self.tstop)]\n lcTab = lcTab[lcTab['flux'] != -1.] # avoid undone analyses\n\n timeMJD = lcTab['mjd']\n tref = int(np.floor( timeMJD[0] / 100.0)) * 100 # round to lowest hundred\n timeMJD -= tref\n ts = lcTab['ts']\n detect = lcTab['ts'] >= self.tsmin\n undet = lcTab['ts'] < self.tsmin\n flux = lcTab['flux'][detect]\n fluxerr = lcTab['fluxerr'][detect]\n upperl = lcTab['upperlim'][undet]\n upperl[upperl == -1.] = 0. # for when it failed\n scale = 10**int(np.floor(np.log10( np.mean( np.concatenate( (flux, upperl), axis=0) ) ))) \n\n # --------------------------------------------------------------------------------------------- #\n # Plot\n lcplt = FermiPlot(savepath='', xsize=8.5, ysize=6)\n lcplt.figname = os.path.join(self.workpath, 'LightCurve.pdf')\n lcplt.xlabel = r'Time (MJD $-$ {})'.format(tref)\n lcplt.ylabel = [r'Flux ($10^{%d}$ ph\\,cm$^{-2}$\\,s$^{-1}$)'%(int(np.log10(scale))), r'TS']\n lcplt.hline = [None, self.tsmin]\n deltaY = max(np.concatenate((flux+fluxerr, upperl), axis=0)) - min(np.concatenate((flux-fluxerr, upperl), axis=0))\n lcplt.ymin = [(min(np.concatenate((flux-fluxerr, upperl-upperl*0.1), axis=0)) - 0.05*deltaY) / scale, min(ts) - 0.05*(max(ts)-min(ts))]\n lcplt.ymax = [(max(np.concatenate((flux+fluxerr, upperl), axis=0)) + 0.05*deltaY) / scale, max(ts) + 0.05*(max(ts)-min(ts))]\n deltaX = (timeMJD[-1] + lcTab['mjderr'][-1]) - (timeMJD[0] - lcTab['mjderr'][0]) \n lcplt.xmin = timeMJD[0] - lcTab['mjderr'][0] - 0.05*deltaX\n lcplt.xmax = timeMJD[-1] + lcTab['mjderr'][-1] + 0.05*deltaX\n lcplt.fill = [item for sublist in zip( timeMJD[detect]-lcTab['mjderr'][detect], timeMJD[detect]+lcTab['mjderr'][detect] ) for item in sublist]\n lcplt.shadecol= self.loran \n if len(flux) == 0:\n lcplt.mksize = [2, 2]\n lcplt.ymode = ['linear', 'linear']\n lcplt.color = ['gray', 'black']\n lcplt.prop = [3, 1]\n lcplt.limit = [True, False]\n lcplt.multiplot(x = [ timeMJD[undet], timeMJD ],\n y = [ upperl/scale, ts ],\n xerr = [ lcTab['mjderr'][undet], lcTab['mjderr']],\n yerr = [ upperl/scale*0.1, None])\n else:\n lcplt.mksize = [2, 2, 2]\n lcplt.ymode = ['linear', 'linear', 'linear']\n lcplt.color = ['gray', 'black', 'black']\n lcplt.prop = [3, 1]\n lcplt.limit = [[True, False], False]\n lcplt.multiplot(x = [ [timeMJD[undet], timeMJD[detect]], timeMJD ],\n y = [ [upperl/scale, flux/scale], ts ],\n xerr = [ [lcTab['mjderr'][undet], lcTab['mjderr'][detect]], lcTab['mjderr']],\n yerr = [ [upperl/scale*0.1, fluxerr/scale], None])\n lcplt.save()\n\n print(\"\\t=== Figure '{}' created ===\".format(lcplt.figname)) \n return","def _collect_legend(self) -> Dict[str, Any]:\n legend_labels = dict()\n for ax in self.axes_active:\n for handle, label in zip(*ax.get_legend_handles_labels()): # type: ignore\n if label in legend_labels:\n # TODO: Add warning/exception if color conflict is found\n pass\n else:\n legend_labels[label] = handle\n return legend_labels","def extract_matrix_list(self, an_dep='', fg_dep='', datums = '', hours=[0,1]):\n\n matrices = {}\n\n for h in hours:\n lista = [] \n for date in range(len(datums)):\n an = an_dep[h,:,date]\n fg = fg_dep[h,:,date]\n corrMatrix = self.calc_cov(an,fg)\n lista.append(corrMatrix)\n matrices[str(h)] = lista\n return matrices","def dic_info(self):\n\n info = {}\n try:\n info[\"DIC\"] = self.mc.DIC\n info[\"deviance\"] = np.mean(self.mc.db.trace(\"deviance\")(), axis=0)\n info[\"pD\"] = info[\"DIC\"] - info[\"deviance\"]\n except pm.ZeroProbability:\n info[\"DIC\"] = np.nan\n info[\"deviance\"] = np.nan\n info[\"pD\"] = np.nan\n\n return info","def get_linear_discrete_matrices(self):\n\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\n if self.model_type == ModelType.EASY:\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\n elif self.model_type == ModelType.GYROMOMENT:\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\n if self.model_type == ModelType.EASY:\n Ct = np.array([[1, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0]])\n elif self.model_type == ModelType.GYROMOMENT:\n if self.nOutputs == 3:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n elif self.nOutputs == 5:\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 1]])\n Dt = np.array([[0, 0],\n [0, 0],\n [0, 0],\n [0, 0],\n [0, 0]])\n\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\n return Ak, Bk, Ck, Dk","def matrixGroup(self):\n\n group = MatrixGroup(label=self.name)\n\n wavelength = self.designWavelength\n previousSurface = Surface(mat=Air())\n for surface in self.lensSurfaces():\n mat1 = previousSurface.mat\n mat2 = surface.mat\n interface = DielectricInterface(R=surface.R, \n n1=mat1.n(wavelength),\n n2=mat2.n(wavelength),\n diameter=surface.diameter)\n group.append(interface)\n\n if not isinstance(mat2, Air):\n spacing = Space(d=surface.spacing, n=mat2.n(wavelength))\n group.append(spacing)\n\n previousSurface = surface\n\n return group","def get_colors():\n colors = {}\n for h in wn.synset('chromatic_color.n.01').hyponyms():\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \n for h in wn.synset('achromatic_color.n.01').hyponyms():\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \n return colors","def get_metrics(self):\n f = Figure(title='DRM_Gradient Train Loss', x_axis_label='Epoch', y_axis_label='Value')\n f.line(color='blue',\n x=range(len(self.train_stats['loss_lst'])),\n y=self.train_stats['loss_lst'],\n legend='Loss')\n f.line(color='green',\n x=range(len(self.train_stats['objective_lst'])),\n y=self.train_stats['objective_lst'],\n legend='CPIT')\n return [f.draw()]","def load_mat_dict():\n param_df = pd.DataFrame(loadmat(\n 'X:/YuxiangWang/DataAnalysis/skinMechanicsAll/analysis/' +\n 'ViscoAnalysis052013/strain_level_2py.mat')['qlv2tFixPara'])\n param_df.columns = ['tau1', 'tau2', 'g1', 'g2', 'ginf', 'mu', 'alpha',\n 'r2', 'stretch', 'thickness', 'skin_id', 'ramp_time']\n param_df['skin_id'] = param_df['skin_id'].astype('i')\n param_df['thickness'] *= 1e3 # Change unit to microns\n return param_df","def get_demographic_dictionary(cause_id, hybridizer=False):\n keys = {}\n call = \"\"\"\n SELECT model_version_type_id, age_start, age_end FROM cod.model_version\n WHERE cause_id = {c} AND gbd_round_id > 5 AND status = 1\n AND model_version_type_id IN ({mvt})\n \"\"\".format(c=cause_id,\n mvt=model_version_type_ids(hybridizer))\n df = query(call, conn_def='codem').drop_duplicates()\n if df.empty:\n raise RuntimeError(\"There are no previous model versions for cause {}.\".format(cause_id))\n for m in df.model_version_type_id.unique().tolist():\n keys[m] = {}\n for a_start in df.query('model_version_type_id == {}'.format(m))['age_start'].unique().tolist():\n keys[m][a_start] = {}\n for a_end in df.query('model_version_type_id == {} & '\n 'age_start == {}'.format(m, a_start))['age_end'].unique().tolist():\n keys[m][a_start][a_end] = {}\n return keys","def pgradient(self):\n d = {}\n\n # Det coeff\n det_coeff_grad = (\n self._dets[0][0, :, self._det_map[0]]\n * self._dets[1][0, :, self._det_map[1]]\n * np.exp(\n self._dets[0][1, :, self._det_map[0]]\n + self._dets[1][1, :, self._det_map[1]]\n )\n )\n\n curr_val = self.value()\n d[\"det_coeff\"] = (\n det_coeff_grad.T / (curr_val[0] * np.exp(curr_val[1]))[:, np.newaxis]\n )\n\n # Mo_coeff, adapted from SlaterUHF\n for parm in [\"mo_coeff_alpha\", \"mo_coeff_beta\"]:\n s = 0\n if \"beta\" in parm:\n s = 1\n\n ao = self._aovals[\n :, s * self._nelec[0] : self._nelec[s] + s * self._nelec[0], :\n ]\n pgrad_shape = (ao.shape[0],) + self.parameters[parm].shape\n pgrad = np.zeros(pgrad_shape)\n\n largest_mo = np.max(np.ravel(self._det_occup[s]))\n for i in range(largest_mo + 1): # MO loop\n if i not in self.freeze_orb[s]:\n for det in range(self.parameters[\"det_coeff\"].shape[0]): # Det loop\n if (\n i in self._det_occup[s][self._det_map[s][det]]\n ): # Check if MO in det\n col = self._det_occup[s][self._det_map[s][det]].index(i)\n pgrad[:, :, i] += (\n self.parameters[\"det_coeff\"][det]\n * d[\"det_coeff\"][:, det, np.newaxis]\n * self._testcol(self._det_map[s][det], col, s, ao)\n )\n d[parm] = np.array(pgrad)\n return d","def get_material_mapping(self):\n return {name: self.get_material(name) for name in self.parts.keys()}","def get_stats(dataset):\n\n # Initialize dictionary\n stats_dict = {}\n\n # Add path information\n stats_dict['lightcurve_path'] = os.path.dirname(dataset)\n stats_dict['lightcurve_filename'] = os.path.basename(dataset)\n\n # Open lightcurve and extract information\n hdulist = fits.open(dataset, mode='readonly')\n counts = hdulist[1].data.counts\n mjd = hdulist[1].data.mjd\n\n # Populate stats_dict with counts information\n stats_dict['total'] = int(np.sum(counts))\n\n # If total counts is zero, there is nothing else to compute\n # If there are counts, then populate the rest of stats_dict\n if stats_dict['total'] > 0:\n\n # Populate stats dict with count stats\n stats_dict['mean'] = float(np.mean(counts))\n stats_dict['mu'] = float(np.sqrt(stats_dict['mean']))\n stats_dict['stdev'] = float(np.std(counts))\n\n # Populate stats_dict with poisson information\n try:\n stats_dict['poisson_factor'] = float(stats_dict['stdev'] / stats_dict['mu'])\n except ZeroDivisionError:\n stats_dict['poisson_factor'] = 9999999.\n\n # Populate stats_dict with pearson information\n pearson_results = pearsonr(mjd, counts)\n stats_dict['pearson_r'] = float(pearson_results[0])\n stats_dict['pearson_p'] = float(pearson_results[1])\n\n # Set 'interesting periodogram' flag\n interesting_periodogram = False\n significant_threshold = 0.30\n for freq_space in ['short', 'med', 'long']:\n periods, power, mean, three_sigma, significant_periods, significant_powers = get_periodogram_stats(dataset, freq_space)\n if len(significant_powers) > 0:\n if max(significant_powers) >= significant_threshold:\n interesting_periodogram = True\n stats_dict['periodogram'] = interesting_periodogram\n\n return stats_dict","def lineBuilders() :\n return dict(_lineBuilders)","def Thresholds(self) :\n\n from Hlt1Lines.Hlt1TrackLines import Hlt1TrackLinesConf\n from Hlt1Lines.Hlt1MuonLines import Hlt1MuonLinesConf\n from Hlt1Lines.Hlt1ElectronLines import Hlt1ElectronLinesConf\n from Hlt1Lines.Hlt1L0Lines import Hlt1L0LinesConf\n from Hlt1Lines.Hlt1MBLines import Hlt1MBLinesConf\n from Hlt1Lines.Hlt1CommissioningLines import Hlt1CommissioningLinesConf\n from Hlt1Lines.Hlt1DisplVertexLines import Hlt1DisplVertexLinesConf\n from Hlt2Lines.Hlt2CommissioningLines import Hlt2CommissioningLinesConf\n from Hlt1Lines.Hlt1BeamGasLines import Hlt1BeamGasLinesConf\n from Hlt2Lines.Hlt2diphotonDiMuonLines import Hlt2diphotonDiMuonLinesConf\n from Hlt2Lines.Hlt2InclusiveDiProtonLines import Hlt2InclusiveDiProtonLinesConf\n from Hlt2Lines.Hlt2DisplVerticesLines import Hlt2DisplVerticesLinesConf\n\n thresholds = { Hlt1TrackLinesConf : { 'AllL0Tight_PT' : 1700\n , 'AllL0Tight_P' : 3000\n , 'AllL0Tight_IP' : 0.100\n , 'AllL0Tight_IPChi2' : 16 \n , 'AllL0Tight_TrChi2' : 1.5 \n , 'AllL0Tight_GEC' : 'Loose'\n , 'AllL0Tight_Velo_NHits' : 9 \n , 'AllL0Tight_Velo_Qcut' : 3 \n , 'AllL0Tight_ValidateTT' : True \n , 'AllL0_PT' : 1600\n , 'AllL0_P' : 3000\n , 'AllL0_IP' : 0.100\n , 'AllL0_IPChi2' : 16\n , 'AllL0_TrChi2' : 2.0\n , 'AllL0_GEC' : 'Loose'\n , 'AllL0_Velo_NHits' : 9 \n , 'AllL0_Velo_Qcut' : 3 \n , 'AllL0_ValidateTT' : True \n , 'Muon_PT' : 1000 \n , 'Muon_P' : 3000 \n , 'Muon_IP' : 0.100\n , 'Muon_IPChi2' : 16\n , 'Muon_TrChi2' : 2.5 \n , 'Muon_GEC' : 'Loose'\n , 'Muon_ValidateTT' : False\n , 'Muon_L0Channels' : 'Muon,DiMuon,MuonNoSPD,DiMuonNoSPD' \n , 'Photon_PT' : 1200\n , 'Photon_P' : 3000\n , 'Photon_IP' : 0.100\n , 'Photon_IPChi2' : 16\n , 'Photon_TrChi2' : 2.0\n , 'Photon_L0Channels' : 'PhotonHi,ElectronHi' \n , 'Photon_GEC' : 'Loose'\n , 'Photon_ValidateTT' : True\n , 'Prescale' : {'Hlt1TrackAllL0' : 1.0, \n 'Hlt1TrackAllL0Tight' : 1.0,\n 'Hlt1TrackForwardPassThrough' : 0,\n 'Hlt1TrackForwardPassThroughLoose' : 0}\n \n }\n , Hlt1ElectronLinesConf : { 'SingleElectronNoIP_P' : 20000\n , 'SingleElectronNoIP_PT' : 10000\n , 'SingleElectronNoIP_TrChi2' : 3\n , 'SingleElectronNoIP_TrNTHits' : 0 #OFF\n , 'SingleElectronNoIP_Velo_NHits' : 0 #OFF\n , 'SingleElectronNoIP_Velo_Qcut' : 999 #OFF\n , 'SingleElectronNoIP_GEC' : 'Loose'\n , 'L0Channels': { 'SingleElectronNoIP' : ( 'Electron', ) }\n }\n , Hlt1MuonLinesConf : { 'SingleMuonHighPT_P' : 3000\n , 'SingleMuonHighPT_PT' : 4800\n , 'SingleMuonHighPT_TrChi2' : 3.\n , 'SingleMuonHighPT_GEC' : 'Loose'\n , 'SingleMuonNoIP_P' : 3000\n , 'SingleMuonNoIP_PT' : 1300\n , 'SingleMuonNoIP_TrChi2' : 3.\n , 'SingleMuonNoIP_GEC' : 'Loose'\n , 'DiMuonLowMass_VxDOCA' : 0.2\n , 'DiMuonLowMass_VxChi2' : 25\n , 'DiMuonLowMass_P' : 0\n , 'DiMuonLowMass_PT' : 0\n , 'DiMuonLowMass_TrChi2' : 3\n , 'DiMuonLowMass_M' : 0.\n , 'DiMuonLowMass_IPChi2' : 6.\n , 'DiMuonLowMass_GEC' : 'Loose'\n , 'DiMuonHighMass_VxDOCA' : 0.2\n , 'DiMuonHighMass_VxChi2' : 25\n , 'DiMuonHighMass_P' : 3000\n , 'DiMuonHighMass_PT' : 500\n , 'DiMuonHighMass_TrChi2' : 3\n , 'DiMuonHighMass_M' : 2700\n , 'DiMuonHighMass_GEC' : 'Loose'\n , 'MultiMuonNoIP_P' : 3000\n , 'MultiMuonNoIP_PT' : 500\n , 'MultiMuonNoIP_TrChi2' : 3.\n , 'MultiMuonNoIP_GT' : 2.5\n , 'MultiMuonNoIP_GEC' : 'Loose'\n ,'L0Channels' : {\n 'SingleMuonHighPT' : ( 'Muon', 'MuonNoSPD'),\n 'SingleMuonNoIP' : ( 'Muon', 'MuonNoSPD'),\n 'DiMuonLowMass' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ),\n 'DiMuonHighMass' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ),\n 'MultiMuonNoIP' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ) }\n\n , 'Prescale' : { 'Hlt1SingleMuonNoIP' : 0.01,\n 'Hlt1MultiMuonNoIP' : 0.0 }\n }\n , Hlt1L0LinesConf : { 'Postscale' : { 'Hlt1L0AnyRateLimited' : 'RATE(1)'\n , 'Hlt1L0AnyNoSPDRateLimited' : 'RATE(1)'\n }\n , 'Prescale' : { 'Hlt1L0HighSumETJet' : 1 \n , 'Hlt1L0AnyNoSPD' : 0.01\n }\n }\n , Hlt1BeamGasLinesConf : {\n 'Prescale' : { 'Hlt1BeamGasCrossingForcedRecoFullZ': 0.001 }\n , 'Postscale' : { 'Hlt1BeamGasNoBeamBeam1' : 'RATE(0.5)'\n , 'Hlt1BeamGasNoBeamBeam2' : 'RATE(0.5)'\n , 'Hlt1BeamGasBeam1' : 'RATE(2)'\n , 'Hlt1BeamGasBeam2' : 'RATE(2)'\n , 'Hlt1BeamGasCrossingEnhancedBeam1' : 'RATE(0)'\n , 'Hlt1BeamGasCrossingEnhancedBeam2' : 'RATE(0)'\n , 'Hlt1BeamGasCrossingForcedReco' : 'RATE(0.5)'\n , 'Hlt1BeamGasCrossingForcedRecoFullZ': 'RATE(0.5)'\n , 'Hlt1BeamGasCrossingParasitic' : 'RATE(1)'\n , 'Hlt1BeamGasHighRhoVertices' : 'RATE(4)'\n }\n }\n , Hlt1DisplVertexLinesConf: { \"VertexDisplVertex_DOCABL\" : \"2.0*mm\"\n , \"VertexDisplVertex_VELO_NSP\" : \"3\"\n , \"VertexDisplVertex_VELO_NCSP\" : \"2\"\n , \"VertexDisplVertex_VELOTrChi2\": \"2.5\"\n , \"VertexDisplVertex_VX_DOCA\" : \"0.3*mm\"\n , \"VertexDisplVertex_VX_CHI2\" : \"1000000000.0\"\n , \"VertexDisplVertex_VX_RHO\" : \"12.0*mm\"\n , \"VertexDisplVertex_Tr_P\" : \"10.0*GeV\"\n , \"VertexDisplVertex_Tr_PT\" : \"1.7*GeV\"\n , \"VertexDisplVertex_Tr_CHI2\" : \"2.5\"\n , \"VertexDisplVertex_GEC\" : \"Loose\"\n , \"Prescale\" : {'Hlt1VertexDisplVertex':1.0 }\n }\n #, Hlt1ProtonLinesConf : { 'Prescale' : { 'Hlt1DiProtonLowMult' : 0.01, \n # 'Hlt1DiProton' : 0.01\n # } } \n , Hlt1CommissioningLinesConf : { 'Postscale' : { 'Hlt1ErrorEvent' : 'RATE(0.01)'\n\n } }\n , Hlt2CommissioningLinesConf : { 'Prescale' : { 'Hlt2PassThrough' : 0.0001 \n , 'Hlt2Forward' : 0.00001\n , 'Hlt2DebugEvent' : 0.000001 }\n , 'Postscale' : { 'Hlt2ErrorEvent' : 'RATE(0.01)' } }\n # micro bias lines switched off for high mu physics running \n , Hlt1MBLinesConf : { 'Prescale' : { 'Hlt1MBMicroBiasVelo' : 0\n , 'Hlt1MBMicroBiasTStation' : 0\n , 'Hlt1MBMicroBiasVeloRateLimited' : 0\n , 'Hlt1MBMicroBiasTStationRateLimited' : 0 }\n , 'MaxNoBiasRate' : 1000000.\n }\n , Hlt2diphotonDiMuonLinesConf : { 'Prescale' : { 'Hlt2LowMultHadron' : 1.0 # for 0x0035, this is already done in L0\n , 'Hlt2LowMultPhoton' : 0.01\n } } \n\n #, Hlt2InclusiveDiProtonLinesConf: { 'Prescale' : { 'Hlt2DiProton' : 0.001\n # , 'Hlt2DiProtonLowMult' : 0.001\n # } } \n\n , Hlt2DisplVerticesLinesConf : { 'Prescale' : \n { 'Hlt2DisplVerticesHighMassSingle' : 1\n , 'Hlt2DisplVerticesSingle' : 1\n , 'Hlt2DisplVerticesDouble' : 1\n , 'Hlt2DisplVerticesHighMassSingle' : 1 \n , 'Hlt2DisplVerticesHighFDSingle' : 1\n , 'Hlt2DisplVerticesSinglePostScaled' : 1\n , 'Hlt2DisplVerticesSingleDown' : 1\n , 'Hlt2DisplVerticesDoublePostScaled' : 1\n , 'Hlt2DisplVerticesSingleHighMassPostScaled' : 1\n , 'Hlt2DisplVerticesSingleHighFDPostScaled' : 1\n , 'Hlt2DisplVerticesSingleMVPostScaled' : 1 } \n }\n\n }\n\n\n from Muons_April2012 import Muons_April2012\n __update_conf__(thresholds, Muons_April2012().Thresholds() )\n\n from Electrons_July2011 import Electrons_July2011\n __update_conf__(thresholds, Electrons_July2011().Thresholds() )\n\n from Hadrons_September2012 import Hadrons_September2012\n __update_conf__(thresholds, Hadrons_September2012().Thresholds() )\n\n from DV_draft2012 import DV_draft2012\n __update_conf__(thresholds, DV_draft2012().Thresholds() )\n\n from CharmLeptonic_draft2012 import CharmLeptonic_draft2012\n __update_conf__(thresholds, CharmLeptonic_draft2012().Thresholds() )\n\n return thresholds","def get_disp_lims():\n\n return [[0., 10.], [0., 20.], [0., 1./3.]]","def read_light_bumps(self):\n rtn = {}\n\n for light_bump in Bump.light_bumps():\n rtn[light_bump] = self.read_light_bump(light_bump)\n\n return rtn","def curvature_matrix(self) -> np.ndarray:\r\n return self.curvature_matrix_diag","def lights(self):\n return list(self.GetLights())","def fCZ_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\n return {tuple(es.targets): es.fCZ_std_err for es in self.edges_specs}","def efficiency_curves(self):\n for key in self._efficiency_curves:\n yield key, self._data[key]","def get_lightcones(self, regex=''):\n\n self.lightcones = []\n\n suffix = f'HIIDIM={self.HII_DIM}_BOXLEN={self.BOX_LEN}_fisher_*{regex}*{self.param}*'\n lightcone_filename = f'{self.output_dir}LightCone_z{self.min_redshift:.1f}_*{suffix}.h5'\n\n if self.vb: print(f' Searching for lightcones with name {lightcone_filename}')\n lc_files = glob.glob(lightcone_filename)\n fid_filename = lightcone_filename.replace(self.param,'fid')\n fid_files = glob.glob(fid_filename)\n lc_files.extend(fid_files)\n\n # Don't get minihalo param lightcones if it's not the minihalo param!\n if 'MINI' not in self.param:\n lc_files = [f for f in lc_files if 'MINI' not in f]\n\n if self.vb: print(f' Found {len(lc_files)} lightcones to load')\n\n for f in lc_files:\n self.lightcones.append(p21c.LightCone.read(f))\n print(' Loaded lightcones',f)\n\n self.k_fundamental, self.k_max, self.Nk = get_k_min_max(lightcone=self.lightcones[0], n_chunks=self.n_chunks)\n self.lc_redshifts = self.lightcones[0].lightcone_redshifts\n np.save(self.lc_redshifts_file, self.lc_redshifts, allow_pickle=True)\n\n return","def colors(self) -> dict:\n raise NotImplementedError","def exportLightLinking(self):\n\t\tlights = [a for a in mc.ls( typ = ['light','aiAreaLight'] ) if not 'eye' in a]\n\t\tallShapes = [s for s in mc.ls( type = 'geometryShape', ni = 1) if not (mc.objectType( s ) in ( 'aiAreaLight','aiSkyDomeLight' ))]\n\t\tlitLinks = {}\n\t\tfor l in lights:\n\t\t\tlightLinkShapes = mc.lightlink( query=True, light=l ,shp=1,t=0,set=0,h=0)\n\t\t\tlitLinks[l]\t = list( set( allShapes ) - set( lightLinkShapes ) )#SHAPES WITH NO LINK TO THIS LIGHT\n\t\tpickle.dump( litLinks, open( self.lightLinkPath.path, \"wb\" ) )","def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['a'] = mean - np.sqrt(3) * stdv\n internals['b'] = mean + np.sqrt(3) * stdv\n\n return internals","def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['a'] = mean - np.sqrt(3) * stdv\n internals['b'] = mean + np.sqrt(3) * stdv\n\n return internals","def AssembleStructuralMaterialsJson(KratosWindowManager):\n for key in KratosWindowManager.MatSave.keys():\n if(DEBUG):\n print(key)\n print(type(KratosWindowManager.MatSave[key]))\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"Variables\"][key]=KratosWindowManager.MatSave[key]\n for bclistobject in KratosWindowManager.boundaryConditionEditor:\n if(DEBUG):\n print(bclistobject.name)\n if bclistobject.entityType=='Element':\n sm.structuralmaterials_dict[\"properties\"][0][\"model_part_name\"]=bclistobject.name\n\n\n if KratosWindowManager.is2D:\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"constitutive_law\"][\"name\"]=\"KratosMultiphysics.StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw\"\n else:\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"constitutive_law\"][\"name\"]=\"KratosMultiphysics.StructuralMechanicsApplication.LinearElastic3DLaw\"\n \n\n if(DEBUG):\n print(sm.structuralmaterials_dict)\n return sm.WriteMaterialToJson(sm.structuralmaterials_dict)","def get_semiMajorAxes_dict():\n de431 = {\n # \"BODY1_semiMajorAxis\" : 2.2031780000000021E+04 ,\n # \"BODY2_semiMajorAxis\" : 3.2485859200000006E+05 ,\n # \"BODY3_semiMajorAxis\" : 4.0350323550225981E+05 ,\n # \"BODY4_semiMajorAxis\" : 4.2828375214000022E+04 ,\n # \"BODY5_semiMajorAxis\" : 1.2671276480000021E+08 ,\n # \"BODY6_semiMajorAxis\" : 3.7940585200000003E+07 ,\n # \"BODY7_semiMajorAxis\" : 5.7945486000000080E+06 ,\n # \"BODY8_semiMajorAxis\" : 6.8365271005800236E+06 ,\n # \"BODY9_semiMajorAxis\" : 9.7700000000000068E+02 ,\n # \"BODY10_semiMajorAxis\" : 1.3271244004193938E+11 ,\n\n \"BODY199_semiMajorAxis\" : 57.91e6 ,\n \"BODY299_semiMajorAxis\" : 108.21e6 ,\n \"BODY399_semiMajorAxis\" : 149.60e6 ,\n \"BODY499_semiMajorAxis\" : 227.92e6 ,\n \"BODY599_semiMajorAxis\" : 778.57e6 ,\n \"BODY699_semiMajorAxis\" : 1433.53e6 ,\n \"BODY799_semiMajorAxis\" : 2872.46e6 ,\n \"BODY899_semiMajorAxis\" : 4495.06e6 ,\n \"BODY999_semiMajorAxis\" : 5906.38e6 ,\n\n \"BODY301_semiMajorAxis\" : 0.3844e6 ,\n\n \"BODY401_semiMajorAxis\" : 9378.0 ,\n \"BODY402_semiMajorAxis\" : 23459.0 ,\n\n \"BODY501_semiMajorAxis\" : 431.8e3 ,\n \"BODY502_semiMajorAxis\" : 671.1e3 ,\n \"BODY503_semiMajorAxis\" : 1070.4e3 ,\n \"BODY504_semiMajorAxis\" : 1882.7e3 ,\n \"BODY505_semiMajorAxis\" : 181.4e3 ,\n\n \"BODY601_semiMajorAxis\" : 185.52e3 ,\n \"BODY602_semiMajorAxis\" : 238.02e3 ,\n \"BODY603_semiMajorAxis\" : 294.64e3 ,\n \"BODY604_semiMajorAxis\" : 377.60e3 ,\n \"BODY605_semiMajorAxis\" : 527.04e3 ,\n \"BODY606_semiMajorAxis\" : 1221.83e3 ,\n \"BODY607_semiMajorAxis\" : 1481.1e3 ,\n \"BODY608_semiMajorAxis\" : 3561.3e3 ,\n # \"BODY609_semiMajorAxis\" : 5.531110414633374E-01 ,\n # \"BODY610_semiMajorAxis\" : 1.266231296945636E-01 ,\n # \"BODY611_semiMajorAxis\" : 3.513977490568457E-02 ,\n # \"BODY615_semiMajorAxis\" : 3.759718886965353E-04 ,\n # \"BODY616_semiMajorAxis\" : 1.066368426666134E-02 ,\n # \"BODY617_semiMajorAxis\" : 9.103768311054300E-03 ,\n\n \"BODY701_semiMajorAxis\" : 190.90e3 ,\n \"BODY702_semiMajorAxis\" : 266.00e3 ,\n \"BODY703_semiMajorAxis\" : 436.39e3 ,\n \"BODY704_semiMajorAxis\" : 583.50e3 ,\n \"BODY705_semiMajorAxis\" : 129.90e3 ,\n\n \"BODY801_semiMajorAxis\" : 354.76e3,\n\n \"BODY901_semiMajorAxis\" : 19596 ,\n \"BODY902_semiMajorAxis\" : 48690 ,\n \"BODY903_semiMajorAxis\" : 64740 ,\n \"BODY904_semiMajorAxis\" : 57780,\n\n # \"BODY2000001_semiMajorAxis\" : 6.3130000000000003E+01 ,\n # \"BODY2000002_semiMajorAxis\" : 1.3730000000000000E+01 ,\n # \"BODY2000003_semiMajorAxis\" : 1.8200000000000001E+00 ,\n # \"BODY2000004_semiMajorAxis\" : 1.7289999999999999E+01 ,\n # \"BODY2000006_semiMajorAxis\" : 9.3000000000000005E-01 ,\n # \"BODY2000007_semiMajorAxis\" : 8.5999999999999999E-01 ,\n # \"BODY2000010_semiMajorAxis\" : 5.7800000000000002E+00 ,\n # \"BODY2000015_semiMajorAxis\" : 2.1000000000000001E+00 ,\n # \"BODY2000016_semiMajorAxis\" : 1.8100000000000001E+00 ,\n # \"BODY2000029_semiMajorAxis\" : 8.5999999999999999E-01 ,\n # \"BODY2000052_semiMajorAxis\" : 1.5900000000000001E+00 ,\n # \"BODY2000065_semiMajorAxis\" : 9.1000000000000003E-01 ,\n # \"BODY2000087_semiMajorAxis\" : 9.8999999999999999E-01 ,\n # \"BODY2000088_semiMajorAxis\" : 1.0200000000000000E+00 ,\n # \"BODY2000433_semiMajorAxis\" : 4.463E-4 ,\n # \"BODY2000511_semiMajorAxis\" : 2.2599999999999998E+00 ,\n # \"BODY2000704_semiMajorAxis\" : 2.1899999999999999E+00 \n }\n return de431","def diagnostics(self):\r\n # NB: should be not None for multiprocessing works\r\n return {}","def get_transit_light_curves(self, params, plots=False):\n time_diffs = np.diff(sorted(self.times.jd))\n diff_between_transits = params.per/2.\n split_inds = np.argwhere(time_diffs > diff_between_transits) + 1\n\n if len(split_inds) > 1:\n\n split_ind_pairs = [[0, split_inds[0][0]]]\n split_ind_pairs.extend([[split_inds[i][0], split_inds[i+1][0]]\n for i in range(len(split_inds)-1)])\n split_ind_pairs.extend([[split_inds[-1], len(self.times)]])\n\n transit_light_curves = []\n counter = -1\n for start_ind, end_ind in split_ind_pairs:\n counter += 1\n if plots:\n plt.plot(self.times.jd[start_ind:end_ind],\n self.fluxes[start_ind:end_ind], '.-')\n\n parameters = dict(times=self.times[start_ind:end_ind],\n fluxes=self.fluxes[start_ind:end_ind],\n errors=self.errors[start_ind:end_ind],\n quarters=self.quarters[start_ind:end_ind],\n name=counter)\n transit_light_curves.append(TransitLightCurve(**parameters))\n if plots:\n plt.show()\n else:\n transit_light_curves = []\n\n return transit_light_curves","def __get_color_table(self):\n #Color: Green Yellow Orange Red Distance:\n return [[0.70, 0.15, 0.1, 0.05], # 0\n [0.17, 0.6, 0.17, 0.06], # 1\n [0.06, 0.17, 0.6, 0.17], # 2\n [0.05, 0.12, 0.23, 0.6], # 3\n [0.05, 0.1, 0.15, 0.8]] # >= 4 ","def _compute_kratios_multilayers(self):\n for i, layer in enumerate(self._layers.keys()):\n if not layer.is_thickness_known():\n raise ValueError(\"Thickness of layer %i is unknown\" % i)\n\n # Compute\n layer = list(self._layers.keys())[0]\n thickness_low_m = layer.thickness_m\n thickness_high_m = layer.thickness_m * 10\n step = 1\n\n _thicknesses, kratios = \\\n self.compute_kratio_vs_thickness(layer, thickness_low_m,\n thickness_high_m, step)\n\n # Reorganize results\n output = {}\n for experiment, kratio in kratios.items():\n output.setdefault(experiment, kratio[0])\n\n return output","def get_material_features(self):\n return self.material_features","def Thresholds(self) :\n\n from Hlt1Lines.Hlt1PhiLines import Hlt1PhiLinesConf\n from Hlt1Lines.Hlt1CalibTrackingLines import Hlt1CalibTrackingLinesConf\n\n thresholds = { Hlt1PhiLinesConf : { 'TrackPT' : 800 # MeV\n ,'TrackP' : 4000 # MeV\n ,'TrackChi2DOF' : 5 # dimensionless\n ,'PhiMassWin' : 30 # MeV\n ,'PhiDOCA' : 0.2 # mm\n ,'PhiVCHI2' : 20 # dimensionless\n ,'Velo_Qcut' : 3 # dimensionless\n ,'TrNTHits' : 16.\n ,'ValidateTT' : False\n }\n , Hlt1CalibTrackingLinesConf : { 'TrackPT' : 500 # MeV\n ,'TrackP' : 2000 # MeV\n ,'TrackChi2DOF' : 5 # dimensionless\n ,'D0MassWin' : 100 # MeV\n ,'D0DOCA' : 0.2 # mm\n ,'D0VCHI2' : 20 # dimensionless\n ,'D0PT' : 2000 # MeV\n ,'Velo_Qcut' : 3 # dimensionless\n ,'TrNTHits' : 16\n ,'ValidateTT' : False\n }\n }\n\n return thresholds","def _detectors2(self, hdr):\n # Called AnalysisParam in OpenMIMS, first part only\n # presets separate, last part in _detectors3\n d = {}\n d['Detector 6'] = self._exit_slits(hdr)\n d['Detector 6'].update(self._electron_multiplier(hdr))\n d['Detector 7'] = self._exit_slits(hdr)\n d['Detector 7'].update(self._electron_multiplier(hdr))\n d['exit slit xl'] = unpack(self._bo + '70i', hdr.read(280))\n return d","def fillDetInfo():\n print('here i am')\n # 1. maps of analysis channel to cpd, and pulser monitor channels\n detCH, pMons = {}, {}\n for ds in [0,1,2,3,4,5,6]:\n f = np.load(\"%s/data/ds%d_detChans.npz\" % (os.environ['LATDIR'], ds))\n detCH[ds] = f['arr_0'].item()\n pMons[ds] = f['arr_1'].item()\n\n # 2. maps of HV and TRAP threshold settings are stored in the DB.\n # make them global, and move them to the runSettings file.\n # FORMAT: {ds : {'det' : [(run1,val1),(run2,val2)...]} }\n detHV, detTH = {}, {}\n\n # load all possible values, as in settingsMgr\n detDB = db.TinyDB(\"%s/calDB-v2.json\" % dsi.latSWDir)\n detPars = db.Query()\n cal = dsi.CalInfo()\n for ds in [0,1,2,3,4,5,6]:\n # for ds in [0]:\n print(\"scanning ds\",ds)\n detTH[ds] = {}\n detHV[ds] = {}\n for key in cal.GetKeys(ds):\n mod = -1\n if \"m1\" in key: mod = 1\n if \"m2\" in key: mod = 2\n for cIdx in range(cal.GetIdxs(key)):\n\n # load the DB records\n dbKeyTH = \"trapThr_%s_c%d\" % (key, cIdx)\n dbValTH = dsi.getDBRecord(dbKeyTH,calDB=detDB,pars=detPars)\n\n dbKeyHV = \"hvBias_%s_c%d\" % (key, cIdx)\n dbValHV = dsi.getDBRecord(dbKeyHV,calDB=detDB,pars=detPars)\n\n # debug: print the record\n # for val in sorted(dbValTH):\n # if len(dbValTH[val])>0:\n # print(val, dbValTH[val])\n # return\n\n # fill the first value\n if len(detTH[ds])==0:\n detTH[ds] = dbValTH\n detHV[ds] = dbValHV\n continue\n\n # check for new threshold values.\n for cpd in detTH[ds]:\n nOld, nNew = len(detTH[ds][cpd]), len(dbValTH[cpd])\n\n # detector just came online\n if nOld==0 and nNew>0:\n detTH[ds][cpd] = dbValTH[cpd]\n continue\n # detector still offline\n if nOld==0 and nNew==0:\n continue\n # detector just went offline\n if nOld>0 and nNew==0:\n continue\n\n # check last run/trap pair against each new one\n prevRun, prevTH = detTH[ds][cpd][-1][0], detTH[ds][cpd][-1][1]\n for val in dbValTH[cpd]:\n thisRun, thisTH = val[0], val[1]\n if thisTH != prevTH:\n detTH[ds][cpd].append([thisRun,thisTH])\n prevTH = thisTH\n\n # check for new HV values.\n for cpd in detHV[ds]:\n\n nOld, nNew = len(detHV[ds][cpd]), len(dbValHV[cpd])\n\n # detector just came online\n if nOld==0 and nNew>0:\n detHV[ds][cpd] = dbValHV[cpd]\n continue\n # detector still offline\n if nOld==0 and nNew==0:\n continue\n # detector just went offline\n if nOld>0 and nNew==0:\n continue\n\n # check last run/trap pair against each new one\n prevRun, prevHV = detHV[ds][cpd][-1][0], detHV[ds][cpd][-1][1]\n for val in dbValHV[cpd]:\n thisRun, thisHV = val[0], val[1]\n if thisHV != prevHV:\n print(\"found HV diff. cpd %d prev %dV (run %d) new %dV (run %d)\" % (cpd, prevHV, prevRun, thisHV, thisRun))\n detHV[ds][cpd].append([thisRun,thisHV])\n prevHV = thisHV\n\n # return\n\n # # load the old file and compare\n # # GOAL: improve on this file.\n # # f = np.load(\"%s/data/runSettings.npz\" % dsi.latSWDir)\n # # detHVOld = f['arr_0'].item()\n # # detTHOld = f['arr_1'].item()\n # # detCHOld = f['arr_2'].item()\n # # pMonsOld = f['arr_3'].item()\n #\n # ds = 3\n # print(\"old results, ds\",ds)\n # for cpd in sorted(detTHOld[ds]):\n # if cpd!=\"122\":continue\n # if len(detTHOld[ds][cpd]) > 0:\n # print(cpd, detTHOld[ds][cpd])\n #\n # # for ds in [0,1,2,3,4,5,6]:\n # print(\"thresh results, ds:\",ds)\n # for cpd in sorted(detTH[ds]):\n # # if cpd!=122:continue\n # if len(detTH[ds][cpd]) > 0:\n # print(cpd, detTH[ds][cpd])\n\n\n np.savez(\"%s/data/runSettings-v2.npz\" % dsi.latSWDir,detHV,detTH,detCH,pMons)","def describe(self) -> Dict:\n\n desc = {\n \"Win\": {\n \"max\": np.max(self.Win),\n \"min\": np.min(self.Win),\n \"mean\": np.mean(self.Win),\n \"median\": np.median(self.Win),\n \"std\": np.std(self.Win)\n },\n \"W\": {\n \"max\": np.max(self.W),\n \"min\": np.min(self.W),\n \"mean\": np.mean(self.W),\n \"median\": np.median(self.W),\n \"std\": np.std(self.W),\n \"sr\": max(abs(linalg.eig(self.W)[0]))\n }\n }\n if self.Wfb is not None:\n desc[\"Wfb\"] = {\n \"max\": np.max(self.Wfb),\n \"min\": np.min(self.Wfb),\n \"mean\": np.mean(self.Wfb),\n \"median\": np.median(self.Wfb),\n \"std\": np.std(self.Wfb)\n }\n if self.Wout is not None:\n desc[\"Wout\"] = {\n \"max\": np.max(self.Wout),\n \"min\": np.min(self.Wout),\n \"mean\": np.mean(self.Wout),\n \"median\": np.median(self.Wout),\n \"std\": np.std(self.Wout)\n }\n return desc","def read_rbn_lightcurve(lc_file,log):\n\n if path.isfile(lc_file):\n\n lines = open(lc_file, 'r').readlines()\n\n imnames = []\n hjd = []\n cal_mag = []\n cal_mag_err = []\n\n for l in lines:\n\n if l[0:1] != '#':\n\n entries = l.replace('\\n','').split()\n\n imnames.append( str(entries[0]).replace('.fits','').replace('_crop','') )\n hjd.append( float(entries[1]) )\n cal_mag.append( float(entries[8]) )\n cal_mag_err.append( float(entries[9]) )\n\n lc = Table()\n lc['images'] = imnames\n lc['hjd'] = hjd\n lc['mag'] = cal_mag\n lc['mag_err'] = cal_mag_err\n\n log.info('Read data for lightcurve '+lc_file)\n\n else:\n log.info('ERROR: Cannot access lightcurve file '+lc_file)\n\n lc = Table()\n\n return lc","def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['k'] = mean ** 2. / stdv ** 2.\n internals['LAMBDA'] = mean / stdv ** 2.\n\n return internals","def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['mu'] = mean\n internals['sigma'] = stdv\n\n return internals","def _generateLSSData():\n d65data=matFromVec([d65Illum(x) for x in brange(10,380,730)])\n a=matNew([cie1931cmf(x) for x in brange(10,380,730)])\n aprime=matT(a)\n width=matShape(a)[0]\n wdiag=matDiag(d65data[0])\n mat=matNew([ \\\n [3.240970, -1.537383, -0.4986108],\\\n [-0.9692436, 1.875968, 0.04155506],\\\n [0.05563008, -0.2039770, 1.056972]])\n wnorm=vecDot(d65data[0],aprime[1])\n t=matScale(matMul(matMul(mat,aprime),wdiag),1.0/wnorm)\n # Compute Least Slope Squared matrix\n d=matScale(matEye(width),4)\n dSize=matShape(d)[0]\n matSet(d,0,0,2)\n matSet(d,dSize-1,dSize-1,2)\n for i in range(1,dSize):\n matSet(d,i,i-1,-2)\n matSet(d,i-1,i,-2)\n dt=matT(d)\n vt=matT(t)\n tshape=matShape(t)\n bm=matBlock(d,vt,t,matZeros((tshape[0],tshape[0])))\n bm=matI(bm)\n b11=matPart(bm,0,width,0,width)\n b12=matPart(bm,0,matShape(vt)[0],width,matShape(bm)[1])\n return [b11, b12]","def fISWAP_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\n return {tuple(es.targets): es.fISWAP_std_err for es in self.edges_specs}","def draggableCircuitResults(self):\n returnedDictionary={}\n self.blochSpheres=self.separatedBlochSpheres()\n returnedDictionary[\"probabilities\"] = self.separatedProbabilities()\n #returnedDictionary[\"blochSpheres\"] = self.separatedBlochSpheres()\n returnedDictionary[\"diracNotation\"] = self.diracNotation()\n returnedDictionary[\"link\"] = \"\"\n returnedDictionary['chart'] = self.graph()\n try:\n returnedDictionary[\"qasm\"] = self.circuit.qasm()\n except Exception:\n #str(Exception)\n returnedDictionary[\"qasm\"] = \"//You are using custom gate\\n//with size more than 2 qubits\\n//sorry, this version doesn't support that\\n//qiskit version 0.19.1\"\n \n if self.API_TOKEN != \"\":\n returnedDictionary[\"link\"] = self.runOnIBMQ()\n \n return returnedDictionary","def _retrieve_solution(self, m):\n result = {} # {component: {resource: production}}\n for comp in m.Components:\n prod = getattr(m, '{n}_production'.format(n=comp.name))\n result[comp.name] = {}\n for res, comp_r in m.resource_index_map[comp].items():\n result[comp.name][res] = np.fromiter((prod[comp_r, t].value for t in m.T), dtype=float, count=len(m.T))\n return result","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['alpha'] = self.alpha\n retDict['beta'] = self.beta\n retDict['scale'] = self.high-self.low\n retDict['low'] = self.low\n return retDict","def get_maturities(self):\r\n return sorted(self.instruments.keys())","def qasmCircuitResults(self):\n returnedDictionary={}\n self.circutDrawing = self.draw()\n self.blochSpheres=self.separatedBlochSpheres()\n returnedDictionary[\"wires\"]=self.num_qubits\n returnedDictionary[\"probabilities\"] = self.separatedProbabilities()\n #returnedDictionary[\"blochSpheres\"] = self.separatedBlochSpheres()\n returnedDictionary[\"diracNotation\"] = self.diracNotation()\n returnedDictionary['chart'] = self.graph()\n returnedDictionary[\"link\"] = \"\"\n #returnedDictionary[\"qasmRows\"] = np.transpose(cols).tolist()\n \n if self.API_TOKEN != \"\":\n returnedDictionary[\"link\"] = self.runOnIBMQ()\n \n return returnedDictionary","def get_spectral_features(image, img_type: str): # Apply on the whole image\r\n spectrum = spectral_power(image, log=False)\r\n bins_energy, _ = get_energy_bins(spectrum, num_bins=3) # Use images with outside val: NaN\r\n spectral_features = {img_type + \"low_freq_energy\": bins_energy[0],\r\n img_type + \"mid_freq_energy\": bins_energy[1], \r\n img_type + \"high_freq_energy\": bins_energy[2]}\r\n return spectral_features","def obtain_meta_data_frame_for_available_lightcurves(self):\n # noinspection SpellCheckingInspection\n columns_to_use = ['tic_id', 'Disposition', 'Epoc', 'Period', 'Duration', 'Sectors']\n liang_yu_dispositions = pd.read_csv(self.liang_yu_dispositions_path, usecols=columns_to_use)\n # noinspection SpellCheckingInspection\n liang_yu_dispositions.rename(columns={'tic_id': 'TIC ID', 'Disposition': 'disposition', 'Epoc': 'transit_epoch',\n 'Period': 'transit_period', 'Duration': 'transit_duration',\n 'Sectors': 'Sector'}, inplace=True)\n liang_yu_dispositions = liang_yu_dispositions[(liang_yu_dispositions['disposition'] != 'PC') |\n (liang_yu_dispositions['transit_epoch'].notna() &\n liang_yu_dispositions['transit_period'].notna() &\n liang_yu_dispositions['transit_duration'].notna())]\n lightcurve_paths = list(self.lightcurve_directory.glob('*lc.fits'))\n tess_data_interface = TessDataInterface()\n tic_ids = [tess_data_interface.get_tic_id_from_single_sector_obs_id(path.name) for path in lightcurve_paths]\n sectors = [tess_data_interface.get_sector_from_single_sector_obs_id(path.name) for path in lightcurve_paths]\n lightcurve_meta_data = pd.DataFrame({'lightcurve_path': list(map(str, lightcurve_paths)), 'TIC ID': tic_ids,\n 'Sector': sectors})\n meta_data_frame_with_candidate_nans = pd.merge(liang_yu_dispositions, lightcurve_meta_data,\n how='inner', on=['TIC ID', 'Sector'])\n self.meta_data_frame = meta_data_frame_with_candidate_nans.dropna()","def getldcoeffs(Teff, logg, z, Tefferr, loggerr, zerr, law, channel, quiet = False):\n\n if not quiet: print \"\\nInterpolating {} limb darkening coefficients for {}...\".format(law,channel)\n # Paths where the tables are stored\n ch1path = \"{}/PhD/code/LD3.6Spitzer.txt\".format(os.getenv('HOME'))\n ch2path = \"{}/PhD/code/LD4.5Spitzer.txt\".format(os.getenv('HOME'))\n\n # Read in the required table\n if channel == 'ch1':\n table = np.genfromtxt(ch1path, skip_header=13, dtype=float, encoding = None)\n elif channel == 'ch2':\n table = np.genfromtxt(ch2path, skip_header=13, dtype=float, encoding = None)\n\n # 3D array of discrete values of teff, logg and z\n points = np.array([table.T[0], table.T[1], table.T[2]]).T\n\n if law == \"linear\": index = [0]\n elif law == \"quadratic\": index = [1,2]\n elif law == \"nonlinear\": index = [6,7,8,9]\n else: pass\n\n coeffs = np.zeros(len(index))\n coeffs_err = np.zeros(len(index))\n\n for i in range(len(index)):\n # All possible values of desired limb darkening coefficient (indexed)\n values = table.T[3+index[i]]\n # 3D Interpolates\n interp = LinearNDInterpolator(points,values)\n coeffs[i] = interp.__call__([Teff,logg,z])\n\n # Estimate the error on the interpolated result based on errors Teff,logg,z\n coeffsTU = interp.__call__(np.array([Teff+Tefferr,logg,z]))\n coeffsTL = interp.__call__(np.array([Teff-Tefferr,logg,z]))\n coeffsgU = interp.__call__(np.array([Teff,logg+loggerr,z]))\n coeffsgL = interp.__call__(np.array([Teff,logg-loggerr,z]))\n coeffszU = interp.__call__(np.array([Teff,logg,z+zerr]))\n coeffszL = interp.__call__(np.array([Teff,logg,z-zerr]))\n\n coeffs_err[i] = np.sqrt( ((coeffsTU - coeffsTL)/2.)**2 + ((coeffsgU - coeffsgL)/2.)**2 + ((coeffszU - coeffszL)/2.)**2 )\n\n if not quiet: print \"\\t Coeff(s): {}\".format(coeffs)\n if not quiet: print \"\\t Coeff Err(s): {}\".format(coeffs_err)\n\n return coeffs.tolist(), coeffs_err.tolist()","def createSurfaceGeo(self):\n self.surfGeo = dict()\n r = self.geoParam['CylinderLightGuideRadius']\n self.surfGeo[r] = 'LightGuide'\n #self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\n while(r + self.geoParam['DetectorThickness'] < self.geoParam['CylinderRadius']):\n r += self.geoParam['DetectorThickness']\n self.surfGeo[r] = 'Detector'\n r += self.geoParam['DetectorSpacing']\n if (r < self.geoParam['CylinderRadius']):\n self.surfGeo[r] = 'LightGuide'\n return self.surfGeo","def get_materials_properties(dbpath): #<un-named>nook\n odb = openOdb(path=dbpath)\n data = []\n for _name,_mat in odb.materials.items():\n _elastic_mod = _mat.elastic.table[0][0]\n _poisson = _mat.elastic.table[0][1]\n if hasattr(_mat,\"plastic\"):\n _plastic = _mat.plastic.table\n else:\n _plastic = []\n data.append((_name,_elastic_mod,_poisson,_plastic))\n odb.close()\n return data","def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n cov = stdv / mean\n zeta = np.sqrt(np.log(1. + cov ** 2.))\n LAMBDA = np.log(mean) - 0.5 * zeta ** 2.\n internals = {}\n internals['LAMBDA'] = LAMBDA\n internals['zeta'] = zeta\n\n return internals","def test_light_dict(self):\n light = self._create_example_light()\n\n dictionary = light.as_dict()\n assert isinstance(dictionary, dict)\n assert dictionary == {\"warning\": False, \"off\": True}","def legend_entries(self):\n return self._legend_entries.setdefault(self._plotid, [])","def lfric_sst():\n mesh = sample_lfric_sst()\n name = mesh.active_scalars_name\n mesh[\"cids\"] = np.arange(mesh.n_cells)\n mesh[\"pids\"] = np.arange(mesh.n_points)\n mesh.set_active_scalars(name)\n return mesh","def gather_krec(self):\n \n #getting Qlo and Qhi the wrong way round here gives perfect flat s.s. recovery\n rec1 = Recovery_Qmade(self.m1.param, self.m1.N_states, \n self.m1.open_states, self.m1.Qlo, self.m1.Qhi, self.m1.P_init_hi, t_range=1e4)\n\n rec1.build_curve()\n rec1.get_keff()\n \n rec2 = Recovery_Qmade(self.m2.param, self.m2.N_states, \n self.m2.open_states, self.m2.Qlo, self.m2.Qhi, self.m2.P_init_hi, t_range=1e4)\n\n rec2.build_curve()\n rec2.get_keff()\n \n self.k_eff1 = rec1.k_eff\n self.k_eff2 = rec2.k_eff\n \n self.mean_keff = (rec1.k_eff + rec2.k_eff ) / 2","def get_density_cmap():\n # Add completely white color to Reds colormap in Matplotlib\n list_colors = plt.cm.datad['Reds']\n list_colors = list(list_colors)\n list_colors.insert(0, (1, 1, 1))\n list_colors.insert(0, (1, 1, 1))\n lscm = matplotlib.colors.LinearSegmentedColormap.from_list(\"my_Reds\", list_colors)\n return lscm","def info_materials_polymer_get():\n materials = _material_by_group(974) # 974 == intermediate group\n return materials, 200","def get_function_gradients(self):\n funcs = self.get_functions()\n gradients = []\n\n for n,func in enumerate(funcs):\n func_list = []\n for scenario in self.scenarios:\n if scenario.group_master:\n func_list.extend(scenario.active_derivatives(n))\n else:\n func_list.extend(scenario.uncoupled_derivatives(n))\n\n for body in self.bodies:\n if body.group_master:\n func_list.extend(body.active_derivatives(n))\n else:\n func_list.extend(body.uncoupled_derivatives(n))\n gradients.append(func_list)\n\n return gradients","def get_spectra_pixell(alm1, alm2=None, spectra=None):\n \n if spectra is None:\n if alm2 is None:\n cls = curvedsky.alm2cl(alm1)\n else:\n cls = curvedsky.alm2cl(alm1, alm2)\n l = np.arange(len(cls))\n return l, cls\n \n \n cls = curvedsky.alm2cl(alm1[:,None], alm2[None,:])\n l = np.arange(len(cls[0,0]))\n cl_dict = {}\n for i, l1 in enumerate([\"T\",\"E\",\"B\"]):\n for j, l2 in enumerate([\"T\",\"E\",\"B\"]):\n cl_dict[l1+l2] = cls[i,j]\n \n return(l, cl_dict)","def test_lightcurve_seismology_plot():\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()","def fXY_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\n return {tuple(es.targets): es.fXY_std_err for es in self.edges_specs}","def GetLMCoverageOfMultipleRoutes(RouteInfoList, ReqLineMeasureTime, FirstDayOfPeriod, LastDayOfPeriod, LMRequirements=None):\r\n\tLMCoverageOfRoutesPerLineKey = {}\r\n\r\n\tfor RouteInfo in RouteInfoList:\r\n\t\t(LMCoverageOfRoutePerSegment, LMCoverageOfRoutePerLineKey) = \\\r\n\t\t\tGetLMCoverageOfRoute(RouteInfo, ReqLineMeasureTime, FirstDayOfPeriod, LastDayOfPeriod, LMRequirements)\r\n\r\n\t\t# add dictionaries\r\n\t\tLMCoverageOfRoutesPerLineKey = AddDicValues(LMCoverageOfRoutesPerLineKey, LMCoverageOfRoutePerLineKey, DefaultEmptyVal = 0)\r\n\r\n\treturn LMCoverageOfRoutesPerLineKey","def IR():\n s = np.array(\n [2.40774137,2.287696084,2.203613927,2.048710132,1.899829585,1.591776247,\n 2.021218754,2.572949552,3.298381484,3.635993426,3.788266224,3.8307278,3.834208811]\n )\n\n TI = np.array([50, 75, 100, 150, 200, 300, 400, 500, 750, 1000, 1500, 2000, 3000])\n\n comp1 = s * np.array([-159.1,-134.2,-109.1,-64.7,25.0,40.1,88.6,126.8,187.6,219.4,245.4,253.6,256.1])\n comp2 = s * np.array([-368.3,-356.9,-343.8,-318.1,-292.0,-242.5,-199.3,-158.4,-68.8,14.2,131.9,219.5,333.5])\n comp3 = s * np.array([-77.5,-51.9,-29.8,9.9,40.2,85.7,115.4,135.1,160.1,167.6,172.3,171.7,171.8])\n comp4 = s * np.array([-265.0,-240.6,-216.7,-170.5,-128.2,-53.5,9.6,62.3,159.7,223.8,296.5,328.3,346.7])\n comp5 = s * np.array([-346.5,-328.9,-312.1,-278.5,-244.4,-182.3,-128.0,-80.0,30.8,109.3,225.1,299.5,372.2])\n\n comp = [comp1, comp2, comp3, comp4, comp5]\n MSE = []\n colors = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\"]\n x_new = np.linspace(0, 3000, 10000)\n for i, j, k in zip(comp, colors, np.arange(1, 6)):\n plt.scatter(TI, i, c=j)\n # popt, _ = curve_fit(MZ, TI, i, p0=np.array([200, 220, 300]))\n popt, _ = curve_fit(MZ, TI, i, p0=np.array([300, 220]))\n # M_z0, T1, M0 = popt\n M0, T1 = popt\n y_new = MZ(x_new, *popt)\n plt.plot(x_new, y_new, \"--\", c=j, label=f\"Fit Comp. {k:d} : $T_1$={T1:3.2f}\")\n MSE.append(mean_squared_error(i,y_new[TI]))\n print(MSE)\n print(np.mean(MSE))\n plt.grid()\n plt.legend(loc=\"best\")\n plt.xlabel(\"TI\")\n plt.ylabel(r\"Singal Intensity $M_z$\")\n plt.show()","def generate_lut(self):\n colormap = self.get_colormap()\n\n if self.block_type == \"equidistant\":\n ev_colormap = colors.colormap_to_ev_blocks_equidistant(colormap, self.exposure_values)\n if self.test:\n self.print_colormap(self.name, ev_colormap)\n return self.generate_spi3d_from_evs(ev_colormap)\n elif self.block_type == \"centered\":\n ev_colormap = colors.colormap_to_ev_blocks_centered(colormap, self.exposure_values)\n if self.test:\n self.print_colormap(self.name, ev_colormap)\n return self.generate_spi3d_from_evs(ev_colormap)\n elif self.block_type == \"stretched\":\n ev_colormap = colors.colormap_to_ev_blocks_stretched(colormap, self.exposure_values)\n if self.test:\n self.print_colormap(self.name, ev_colormap)\n return self.generate_spi3d_from_evs(ev_colormap)","def createDict( self ):\n self.d = {}\n self.d['comp1'] = compensation_channel('comp1', 0, (-479.0, -10.0))\n self.d['comp2'] = compensation_channel('comp2', 1, (-479.0, -10.0))\n self.addCalibration()","def _get_all_residuals(self) -> Dict[int, np.ndarray]:\n residuals = self.residuals\n # if residuals have not been calculated yet\n if residuals is None:\n levels = self.levels\n models = self.models\n residuals = {}\n for k in levels:\n # assert models is not None\n # pyre-fixme[16]: `Optional` has no attribute `__getitem__`.\n if models[k] is not None:\n try:\n vals = self._get_residuals(models[k])\n except Exception as e:\n msg = (\n f\"Failed to get residuals for level {k} with error \"\n f\"message {e}.\"\n )\n raise _log_error(msg)\n\n residuals[k] = vals\n else:\n residuals[k] = self.info_residuals[k]\n self.residuals = residuals\n return residuals","def _extract_data(self) -> np.ndarray:\n \n mats = Material.objects.all()\n \n mat_arrays = []\n for mat in mats: # django queryset -> python list\n mat_features = []\n \n # Add data\n # Some data are missing here.\n #TODO: Delete those if sentences after cleaning the data.\n mat_features.append(mat.model_surface_temperature if mat.model_surface_temperature!=None else 0)\n mat_features.append(mat.melt_temperature if mat.melt_temperature!=None else 0)\n mat_features.append(mat.mold_temperature_range_min if mat.mold_temperature_range_min!=None else 0)\n mat_features.append(mat.mold_temperature_range_max if mat.mold_temperature_range_max!=None else 0)\n mat_features.append(mat.melt_temperature_range_min if mat.melt_temperature_range_min!=None else 0)\n mat_features.append(mat.melt_temperature_range_max if mat.melt_temperature_range_max!=None else 0)\n mat_features.append(mat.absolute_maximum_melt_temperature if mat.absolute_maximum_melt_temperature!=None else 0)\n mat_features.append(mat.ejection_temperature if mat.ejection_temperature!=None else 0)\n mat_features.append(mat.maximum_shear_stress if mat.maximum_shear_stress!=None else 0)\n mat_features.append(mat.maximum_shear_rate if mat.maximum_shear_rate!=None else 0)\n mat_features.append(mat.melt_density if mat.melt_density!=None else 0)\n mat_features.append(mat.solid_density if mat.solid_density!=None else 0)\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\n mat_features.append(mat.elastic_modulus_e1 if mat.elastic_modulus_e1!=None else 0)\n mat_features.append(mat.elastic_modulus_e2 if mat.elastic_modulus_e2!=None else 0)\n mat_features.append(mat.poisson_ratio_v12 if mat.poisson_ratio_v12!=None else 0)\n mat_features.append(mat.poisson_ratio_v23 if mat.poisson_ratio_v23!=None else 0)\n mat_features.append(mat.shear_modulus_g12 if mat.shear_modulus_g12!=None else 0.)\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1!=None else 0.)\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2!=None else 0.)\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\n mat_features.append(mat.c1 if mat.c1!=None else 0.)\n mat_features.append(mat.c2 if mat.c2!=None else 0.)\n mat_features.append(mat.conversion_temperature if mat.conversion_temperature!=None else 0.)\n mat_features.append(mat.MFR_temperature if mat.MFR_temperature!=None else 0.)\n mat_features.append(mat.MFR_loading if mat.MFR_loading!=None else 0.)\n mat_features.append(mat.measured_MFR if mat.measured_MFR!=None else 0.)\n \n mat_arrays.append(mat_features)\n \n # Get numpy arrays.\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\n \n return mat_arrays","def calc_saturation_curves(self):\n HEOS = CP.AbstractState(self.additional_backend, self.fluid)\n PCSAFT = CP.AbstractState(self.backend, self.fluid)\n self.dictL, self.dictV = {}, {}\n for Q, dic in zip([0, 1], [self.dictL, self.dictV]):\n # rhomolar, smolar, hmolar, T, p, umolar = [], [], [], [], [], []\n rhomolar, T, p = [], [], []\n for _T in np.logspace(np.log10(HEOS.keyed_output(CP.iT_triple)), np.log10(HEOS.keyed_output(CP.iT_critical)), 500):\n try:\n PCSAFT.update(CP.QT_INPUTS, Q, _T)\n # print('T', PCSAFT.T())\n # print('p', PCSAFT.p())\n # print('rhomolar', PCSAFT.rhomolar())\n if (PCSAFT.p() < 0): raise ValueError('P is negative:' + str(PCSAFT.p()))\n PCSAFT.T(), PCSAFT.p(), PCSAFT.rhomolar()\n # PCSAFT.hmolar(), PCSAFT.smolar(), PCSAFT.umolar()\n\n T.append(PCSAFT.T())\n p.append(PCSAFT.p())\n rhomolar.append(PCSAFT.rhomolar())\n # hmolar.append(PCSAFT.hmolar())\n # smolar.append(PCSAFT.smolar())\n # umolar.append(PCSAFT.umolar())\n except ValueError as VE:\n myprint(1, 'satT error:', VE, '; T:', '{T:0.16g}'.format(T=_T), 'T/Tc:', _T / HEOS.keyed_output(CP.iT_critical))\n\n dic.update(dict(T=np.array(T),\n P=np.array(p),\n Dmolar=np.array(rhomolar)))\n # Hmolar=np.array(hmolar),\n # Smolar=np.array(smolar)))\n # Umolar=np.array(umolar)))","def logs(self):\n dataTuples = list()\n try:\n with sqlite3.connect(self.db_file) as conn:\n cur = conn.cursor()\n cur.execute(\"SELECT * FROM curves\")\n dataTuples = cur.fetchall()\n return [{\"id\": a[0], \"name\": a[1], \"units\": a[2],\n \"descr\": a[3]} for a in dataTuples]\n except:\n return dataTuples","def mapped_reconstructed_data_dict(\r\n self,\r\n ) -> Dict[LinearObj, Visibilities]:\r\n mapped_reconstructed_data_dict = {}\r\n\r\n image_dict = self.mapped_reconstructed_image_dict\r\n\r\n for linear_obj in self.linear_obj_list:\r\n visibilities = self.transformer.visibilities_from(\r\n image=image_dict[linear_obj]\r\n )\r\n\r\n visibilities = Visibilities(visibilities=visibilities)\r\n\r\n mapped_reconstructed_data_dict[linear_obj] = visibilities\r\n\r\n return mapped_reconstructed_data_dict"],"string":"[\n \"def generate_materials_dict(self):\\n c = 299792458.0\\n w_mat = 2 * np.pi * c / self.l_mat - self.w0\\n l2_mat = (self.l_mat * 1e6) ** 2\\n\\n n_air = 1 + 0.05792105 * l2_mat / (238.0185 * l2_mat - 1) + 0.00167917 * l2_mat / (57.362 * l2_mat - 1)\\n air_ip = interp1d(w_mat, n_air, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['air'] = air_ip\\n\\n n_fs = np.sqrt(1 + 0.6961663 * l2_mat / (l2_mat - 0.0684043 ** 2) +\\n 0.4079426 * l2_mat / (l2_mat - 0.1162414 ** 2) +\\n 0.8974794 * l2_mat / (l2_mat - 9.896161 ** 2))\\n fs_ip = interp1d(w_mat, n_fs, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['fs'] = fs_ip\\n\\n n_mgf2 = np.sqrt(1 + 0.48755108 * l2_mat / (l2_mat - 0.04338408 ** 2) +\\n 0.39875031 * l2_mat / (l2_mat - 0.09461442 ** 2) +\\n 2.3120353 * l2_mat / (l2_mat - 23.793604 ** 2))\\n mgf2_ip = interp1d(w_mat, n_mgf2, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['mgf2'] = mgf2_ip\\n\\n n_sapphire_o = np.sqrt(1 + 1.4313493 * l2_mat / (l2_mat - 0.0726631 ** 2) +\\n 0.65054713 * l2_mat / (l2_mat - 0.1193242 ** 2) +\\n 5.3414021 * l2_mat / (l2_mat - 18.028251 ** 2))\\n sapphire_o_ip = interp1d(w_mat, n_sapphire_o, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['sapphire_o'] = sapphire_o_ip\\n\\n n_sapphire_e = np.sqrt(1 + 1.5039759 * l2_mat / (l2_mat - 0.0740288 ** 2) +\\n 0.55069141 * l2_mat / (l2_mat - 0.1216529 ** 2) +\\n 6.5927379 * l2_mat / (l2_mat - 20.072248 ** 2))\\n sapphire_e_ip = interp1d(w_mat, n_sapphire_e, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['sapphire_e'] = sapphire_e_ip\\n\\n n_bbo_o = np.sqrt(2.7405 + 0.0184 / (l2_mat - 0.0179) - 0.0155 * l2_mat)\\n bbo_o_ip = interp1d(w_mat, n_bbo_o, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['bbo_o'] = bbo_o_ip\\n\\n n_bbo_e = np.sqrt(2.3730 + 0.0128 / (l2_mat - 0.0156) - 0.0044 * l2_mat)\\n bbo_e_ip = interp1d(w_mat, n_bbo_e, bounds_error=False, fill_value=np.nan, kind=\\\"quadratic\\\")\\n self.materials['bbo_e'] = bbo_e_ip\\n\\n materials_files = os.listdir(self.materials_path)\\n logger.info(\\\"Found {0:d}\\\".format(materials_files.__len__()))\\n for mat_file in materials_files:\\n logger.debug(mat_file)\\n self.read_material(''.join((self.materials_path, '/', mat_file)))\",\n \"def light_curve(num_energies, num_samples):\\n fixed_header = (\\n 1*8 # SSID\\n + 4*8 # SCET Coarse time\\n + 2*8 # SCET Fine time\\n + 2*8 # Integration time\\n + 4*8 # Detector mask\\n + 4 # spare\\n + 12 # Pixel mask\\n + 1 # spare\\n + 1 # Comp Schema light curve S\\n + 3 # Comp Schema light curve K\\n + 3 # Comp Schema light curve M\\n + 1 # Comp Schema trigger S\\n + 3 # Comp Schema trigger K\\n + 3 # Comp Schema trigger M\\n + 1 # Energy bin mask upper boundary\\n + 4*8 # Energy bin mask lower boundray\\n + 1*8 # Number of energies\\n + num_energies*2*8 # Number data points\\n + 2*8 # Number of data points\\n + 2*8 # Number of data point\\n )\\n\\n variable = (\\n + num_energies*num_samples*8 # Compressed light curves\\n + num_samples*8 # Compressed triggers\\n + num_samples*8 # RCR\\n )\\n\\n return fixed_header, variable\",\n \"def lights(self) -> List[dict]:\\n return self.items_by_domain(\\\"light\\\")\",\n \"def read_lightcurves(params,log):\\n\\n lightcurves = { 'g':None, 'r':None , 'i': None}\\n\\n for f in lightcurves.keys():\\n\\n lc_file = params['target_lc_file_'+f]\\n\\n if path.isfile(lc_file):\\n\\n lightcurves[f] = read_rbn_lightcurve(lc_file,log)\\n\\n return lightcurves\",\n \"def gradients(self):\\n return {}\",\n \"async def Lights_Description() -> List[Dict[str, Any]]:\\n result = []\\n for index, light in enumerate(busylightapi.manager.lights):\\n result.append(\\n {\\n \\\"light_id\\\": index,\\n \\\"name\\\": light.name,\\n \\\"info\\\": light.info,\\n \\\"is_on\\\": light.is_on,\\n \\\"color\\\": rgb_to_hex(*light.color),\\n }\\n )\\n return result\",\n \"def show_materials(self):\\n print('\\\\nThe materials with known dielectric properties are:\\\\n')\\n pprint.pprint(mats.Electrical.props)\\n# pprint.pprint(mats.Electrical.DIELECTRIC)\\n print('\\\\nThe materials with known loss tangents are:\\\\n')\\n pprint.pprint(mats.Electrical.props)\\n# pprint.pprint(mats.Electrical.LOSS_TAN)\\n return\",\n \"def curves(self):\\n return self._curve_reg\",\n \"def show_lightcurve(self):\\n\\n time_array = self.exp_start_times\\n\\n fig = plt.figure()\\n\\n if self.transmission_spectroscopy:\\n lc_model = self.generate_lightcurves(time_array,\\n self.planet.calcTransitDepth())\\n plt.ylabel(\\\"Transit Depth\\\")\\n else:\\n lc_model = np.ones_like(time_array)\\n plt.ylabel(\\\"Unit Flux\\\")\\n\\n if self._visit_trend:\\n trend_model = self._visit_trend.scale_factors\\n # have to convert weird model format to flat array\\n lc_model = trend_model * lc_model.T[0]\\n\\n plt.scatter(time_array, lc_model)\\n plt.xlabel(\\\"Time (JD)\\\")\\n plt.title(\\\"Normalised White Time Series of observation\\\")\\n\\n return time_array, lc_model\",\n \"def compute_diagnostics(self) -> Dict[str, Any]:\\n return {}\",\n \"def get_sigma_dict(self):\\n sigma = {}\\n for c in self.cellLines:\\n sigma[c] = {}\\n for l in self.ligands:\\n sigma[c][l] = self.aucs[c][l]['sigma']\\n return sigma\",\n \"def contrast_matrices(self):\\n \\n p = len(self.formula.terms)\\n matrices = {}\\n for crep in self._contrast_reps:\\n s = self.slices[crep]\\n l = s.stop - s.start\\n array = np.zeros((l,p), np.float)\\n for i, j in enumerate(range(l)):\\n array[i,j+s.start] = 1.\\n matrices[crep] = array\\n return matrices\",\n \"def realizations(self):\\n return [ self.km(), self.kHLP(), self.affineSchur(), self.dual_k_Schur()]\",\n \"def get_light_list(self):\\n return self.light_array\",\n \"def Thresholds(self) :\\n \\n # keep pass through thresholds\\n d = { }\\n\\n\\n from Hlt2Lines.SingleMuon.Lines import SingleMuonLines\\n d.update({SingleMuonLines : \\n {'Prescale' : {\\\"Hlt2SingleMuon\\\" : 0.5, \\n \\\"Hlt2SingleMuonLowPT\\\" : 0.1},\\n 'HltReq' : {\\\"SingleMuon\\\" : \\\"HLT_PASS_RE('Hlt1TrackMuonDecision')\\\"},\\n 'Common' : {'TrChi2' : 3, # Adimensional\\n 'Pt' : 1300 * MeV },\\n 'SingleMuon' : {'IP' : 0.0 * mm,\\n 'IPChi2' : 16 }, # Adimensional\\n 'HighPT' : {'HighPt' : 10000 *MeV },\\n 'LowPT' : { 'HighPt' : 4800 * MeV }\\n }\\n })\\n \\n return d\",\n \"def get_mof_descriptors(self) -> dict:\\n result_dict = OrderedDict(\\n (\\n (\\\"name\\\", self.name),\\n (\\\"graph_hash\\\", self.graph_hash),\\n (\\\"path\\\", self._filename),\\n (\\\"density\\\", self.density),\\n (\\\"has_oms\\\", self.has_oms),\\n (\\\"has_carbon\\\", self.has_carbon),\\n (\\\"has_hydrogen\\\", self.has_hydrogen),\\n (\\\"has_atomic_overlaps\\\", self.has_atomic_overlaps),\\n (\\\"has_overcoordinated_c\\\", self.has_overvalent_c),\\n (\\\"has_overcoordinated_n\\\", self.has_overvalent_n),\\n (\\\"has_overcoordinated_h\\\", self.has_overvalent_h),\\n (\\\"has_undercoordinated_c\\\", self.has_undercoordinated_c),\\n (\\\"has_undercoordinated_n\\\", self.has_undercoordinated_n),\\n (\\\"has_metal\\\", self.has_metal),\\n (\\\"has_lone_atom\\\", self.has_lone_atom),\\n (\\\"has_lone_molecule\\\", self.has_lone_molecule),\\n (\\\"has_high_charges\\\", self.has_high_charges),\\n (\\\"has_undercoordinated_metal\\\", self.has_undercoordinated_metal),\\n )\\n )\\n return result_dict\",\n \"def Thresholds(self) :\\n \\n # keep pass through thresholds\\n d = { }\\n\\n from Hlt2Lines.Commissioning.Lines import CommissioningLines \\n d.update({CommissioningLines :\\n {'Prescale' : {'Hlt2PassThrough' : 0.0001,\\n 'Hlt2Forward' : 0.00001,\\n 'Hlt2DebugEvent' : 0.000001},\\n 'Postscale' : {'Hlt2ErrorEvent' : 'RATE(0.01)'},\\n # do not want debug events on lumi-exclusive Hlt1 events...\\n 'DebugEvent' : {'HLT1' : \\\"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\\\"},\\n 'ErrorEvent' : {'Priority' : 254,\\n 'VoidFilter' : '',\\n 'HLT2' : \\\"HLT_COUNT_ERRORBITS_RE('^Hlt2.*',0xffff) > 0\\\"},\\n 'PassThrough' : {'HLT1' : \\\"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\\\",\\n 'VoidFilter' : ''},\\n 'NoBiasPassThrough' : {'HLT1' : \\\"HLT_PASS('Hlt1NoBiasPrescaledDecision')\\\",\\n 'VoidFilter' : ''},\\n 'Transparent' : {'HLT1' : \\\"HLT_PASS_RE('^Hlt1(ODIN.*|L0.*|MB.*|BeamGas.*|Velo.*|NZS.*|Incident|Tell1Error|ErrorEvent)Decision$')\\\",\\n 'VoidFilter' : ''},\\n 'Lumi' : {'HLT1' : \\\"HLT_PASS_SUBSTR('Hlt1Lumi')\\\",\\n 'VoidFilter' : ''},\\n 'KS0_DD' : {'HLT1' : \\\"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\\\",\\n 'VoidFilter' : ''},\\n 'KS0_LL' : {'HLT1' : \\\"HLT_PASS_RE('^Hlt1(?!Lumi).*Decision$')\\\",\\n 'VoidFilter' : ''},\\n 'Turbo' : ['KS0_DD', 'KS0_LL']\\n }}\\n )\\n return d\",\n \"def lightcurve(self):\\n return NGCLightCurve(self['corotid'])\",\n \"def generate_lightcurves(self, time_array, depth=False):\\n\\n # TODO (ryan) quick check if out of transit, in that case ones!\\n\\n # TODO (ryan) should this be in generate exposure?\\n\\n planet = self.planet\\n star = self.planet.star\\n\\n P = float(planet.P.rescale(pq.day))\\n a = float((planet.a / star.R).simplified)\\n rp = float((planet.R / star.R).simplified)\\n i = float(planet.i.rescale(pq.deg))\\n e = planet.e\\n W = float(planet.periastron)\\n transittime = float(planet.transittime)\\n\\n if np.isnan(W):\\n W = 0\\n\\n time_array = time_array.to(u.day).value\\n # model for each resolution element.\\n\\n if depth:\\n planet_spectrum = np.array(\\n [depth]) # an array as we want to perform ndim later.\\n else:\\n planet_spectrum = self.planet_spectrum\\n\\n models = np.zeros((len(time_array), len(planet_spectrum)))\\n\\n planet_spectrum = np.sqrt(\\n planet_spectrum) # pylc wants Rp/Rs not transit depth\\n\\n time_array = tools.jd_to_hjd(time_array,\\n planet) # pylc wants hjd not jd\\n\\n logger.debug(\\n \\\"Generating lightcurves with P={}, a={}, i={}, e={}, W={}, T14={},\\\"\\n \\\" mean_depth={}\\\".format(\\n P, a, i, e, W, transittime, np.mean(planet_spectrum)\\n ))\\n\\n for j, spec_elem in enumerate(planet_spectrum):\\n models[:, j] = pylc.transit('claret', self.ldcoeffs, spec_elem, P, a, e, i,\\n W, transittime, time_array) - \\\\\\n (\\n 1. - pylc.eclipse(spec_elem ** 2, rp, P, a, e,\\n i, W,\\n transittime, time_array))\\n\\n return models\",\n \"def generate_visualization_dict(self):\\n self._data = {}\\n self._data['name'] = self.name\\n self._data['type'] = self.__repr__()\\n self._data['color'] = self._color_rgb\\n\\n try:\\n self._data['simulation_matrix'] = \\\\\\n self._visualization_matrix.tolist()\\n\\n except:\\n #Not sure which error to call here.\\n raise RuntimeError('''Please call the numerical\\n transformation methods,\\n before generating simulation dict ''')\\n\\n\\n return self._data\",\n \"def get_lightcurves(product_type):\\n\\n # Build lists of paths to lightcurves\\n results = session.query(Outputs).all()\\n individual_lightcurves = set([os.path.join(result.individual_path, result.individual_filename) for result in results])\\n composite_lightcurves = set([os.path.join(result.composite_path, result.composite_filename) for result in results if result.composite_filename != None])\\n\\n # Return appropriate list based on product_type\\n if product_type == 'individual':\\n lightcurves = individual_lightcurves\\n elif product_type == 'composite':\\n lightcurves = composite_lightcurves\\n elif product_type == 'both':\\n lightcurves = individual_lightcurves | composite_lightcurves\\n\\n return lightcurves\",\n \"def _supported_convergence_norms() -> Dict[Text, _NormType]:\\n return {\\n _monitor_key('convergence', 'l-1'): _NormType.L1,\\n _monitor_key('convergence', 'l-2'): _NormType.L2,\\n _monitor_key('convergence', 'l-inf'): _NormType.L_INF,\\n _monitor_key('subiter-scalar', 'convergence_l-1'): _NormType.L1,\\n _monitor_key('subiter-scalar', 'convergence_l-2'): _NormType.L2,\\n _monitor_key('subiter-scalar', 'convergence_l-inf'): _NormType.L_INF,\\n }\",\n \"def all_lightcurves():\\n for fname in listdir(join(DATA_PATH, 'lightcurves')):\\n try:\\n locus_id, fmt = fname.split('.')\\n assert fmt == 'lc'\\n yield fetch_lightcurve(locus_id)\\n except Exception as e:\\n print(f'{repr(e)} fetching {fname}')\",\n \"def get_metal_descriptors(self) -> dict:\\n if not self.has_metal:\\n raise NoMetal\\n return self._get_metal_descriptors()\",\n \"def sans_monitor() -> dict:\\n return {**beamline.beamline(scatter=False), **tof.elastic_wavelength('tof')}\",\n \"def contrasts(self):\\n if not hasattr(self, \\\"_contrasts\\\"):\\n self._contrasts = {}\\n self._contrast_reps = []\\n self._formulae = []\\n for expr in sorted(self.graded_dict.keys()):\\n formulae = get_contributions(self.codings[expr],\\n self.sorted_factors)\\n for formula, srep in formulae:\\n v = formula * Formula([expr])\\n sexpr = \\\"I(%s)\\\" % str(expr)\\n if srep:\\n crep = ':'.join([sexpr,srep])\\n else:\\n crep = sexpr\\n self._contrasts[crep] = v\\n self._contrast_reps.append(crep)\\n self._formulae.append(v)\\n return self._contrasts\",\n \"def get_gradients(self):\\n\\n result_gradients = {}\\n for signal in self.signals_list:\\n net = self.networks[signal]\\n\\n list_gradients = []\\n for w in net.parameters():\\n list_gradients.append(w.grad.view(-1).clone())\\n\\n grad_vector = torch.cat(list_gradients, dim=0)\\n result_gradients[signal] = grad_vector\\n\\n return result_gradients\",\n \"def loss_functions(self) -> dict:\\n tmp_dict = dict()\\n tmp_dict['From_Root'] = (('Cov', self.log_post_cov, self.constraint_cov),\\n ('Beta', self.log_post_beta, self.constraint_sigma),\\n ('Lambda', self.log_post_lambda, self.constraint_sigma),\\n ('Psi', self.log_post_psi, self.constraint_psi),\\n ('Theta', self.log_post_theta, self.constraint_theta),\\n ('Tree', self.log_post_tree, self.constraint_tree))\\n\\n tmp_dict['Likelihood'] = (self.log_likelihood, ('Psi',\\n 'Beta',\\n 'Theta',\\n 'Lambda'))\\n return tmp_dict\",\n \"def lCurve(self): \\n\\n # --------------------------------------------------------------------------------------------- #\\n # Read data\\n fitsNnam = os.path.join(self.workpath, 'LCresults.fits')\\n lcTab = Table.read(fitsNnam)\\n if (self.tstart is not None) and (self.tstop is not None):\\n lcTab = lcTab[ (self.tstart <= lcTab['mjd']) & (lcTab['mjd'] <= self.tstop)]\\n lcTab = lcTab[lcTab['flux'] != -1.] # avoid undone analyses\\n\\n timeMJD = lcTab['mjd']\\n tref = int(np.floor( timeMJD[0] / 100.0)) * 100 # round to lowest hundred\\n timeMJD -= tref\\n ts = lcTab['ts']\\n detect = lcTab['ts'] >= self.tsmin\\n undet = lcTab['ts'] < self.tsmin\\n flux = lcTab['flux'][detect]\\n fluxerr = lcTab['fluxerr'][detect]\\n upperl = lcTab['upperlim'][undet]\\n upperl[upperl == -1.] = 0. # for when it failed\\n scale = 10**int(np.floor(np.log10( np.mean( np.concatenate( (flux, upperl), axis=0) ) ))) \\n\\n # --------------------------------------------------------------------------------------------- #\\n # Plot\\n lcplt = FermiPlot(savepath='', xsize=8.5, ysize=6)\\n lcplt.figname = os.path.join(self.workpath, 'LightCurve.pdf')\\n lcplt.xlabel = r'Time (MJD $-$ {})'.format(tref)\\n lcplt.ylabel = [r'Flux ($10^{%d}$ ph\\\\,cm$^{-2}$\\\\,s$^{-1}$)'%(int(np.log10(scale))), r'TS']\\n lcplt.hline = [None, self.tsmin]\\n deltaY = max(np.concatenate((flux+fluxerr, upperl), axis=0)) - min(np.concatenate((flux-fluxerr, upperl), axis=0))\\n lcplt.ymin = [(min(np.concatenate((flux-fluxerr, upperl-upperl*0.1), axis=0)) - 0.05*deltaY) / scale, min(ts) - 0.05*(max(ts)-min(ts))]\\n lcplt.ymax = [(max(np.concatenate((flux+fluxerr, upperl), axis=0)) + 0.05*deltaY) / scale, max(ts) + 0.05*(max(ts)-min(ts))]\\n deltaX = (timeMJD[-1] + lcTab['mjderr'][-1]) - (timeMJD[0] - lcTab['mjderr'][0]) \\n lcplt.xmin = timeMJD[0] - lcTab['mjderr'][0] - 0.05*deltaX\\n lcplt.xmax = timeMJD[-1] + lcTab['mjderr'][-1] + 0.05*deltaX\\n lcplt.fill = [item for sublist in zip( timeMJD[detect]-lcTab['mjderr'][detect], timeMJD[detect]+lcTab['mjderr'][detect] ) for item in sublist]\\n lcplt.shadecol= self.loran \\n if len(flux) == 0:\\n lcplt.mksize = [2, 2]\\n lcplt.ymode = ['linear', 'linear']\\n lcplt.color = ['gray', 'black']\\n lcplt.prop = [3, 1]\\n lcplt.limit = [True, False]\\n lcplt.multiplot(x = [ timeMJD[undet], timeMJD ],\\n y = [ upperl/scale, ts ],\\n xerr = [ lcTab['mjderr'][undet], lcTab['mjderr']],\\n yerr = [ upperl/scale*0.1, None])\\n else:\\n lcplt.mksize = [2, 2, 2]\\n lcplt.ymode = ['linear', 'linear', 'linear']\\n lcplt.color = ['gray', 'black', 'black']\\n lcplt.prop = [3, 1]\\n lcplt.limit = [[True, False], False]\\n lcplt.multiplot(x = [ [timeMJD[undet], timeMJD[detect]], timeMJD ],\\n y = [ [upperl/scale, flux/scale], ts ],\\n xerr = [ [lcTab['mjderr'][undet], lcTab['mjderr'][detect]], lcTab['mjderr']],\\n yerr = [ [upperl/scale*0.1, fluxerr/scale], None])\\n lcplt.save()\\n\\n print(\\\"\\\\t=== Figure '{}' created ===\\\".format(lcplt.figname)) \\n return\",\n \"def _collect_legend(self) -> Dict[str, Any]:\\n legend_labels = dict()\\n for ax in self.axes_active:\\n for handle, label in zip(*ax.get_legend_handles_labels()): # type: ignore\\n if label in legend_labels:\\n # TODO: Add warning/exception if color conflict is found\\n pass\\n else:\\n legend_labels[label] = handle\\n return legend_labels\",\n \"def extract_matrix_list(self, an_dep='', fg_dep='', datums = '', hours=[0,1]):\\n\\n matrices = {}\\n\\n for h in hours:\\n lista = [] \\n for date in range(len(datums)):\\n an = an_dep[h,:,date]\\n fg = fg_dep[h,:,date]\\n corrMatrix = self.calc_cov(an,fg)\\n lista.append(corrMatrix)\\n matrices[str(h)] = lista\\n return matrices\",\n \"def dic_info(self):\\n\\n info = {}\\n try:\\n info[\\\"DIC\\\"] = self.mc.DIC\\n info[\\\"deviance\\\"] = np.mean(self.mc.db.trace(\\\"deviance\\\")(), axis=0)\\n info[\\\"pD\\\"] = info[\\\"DIC\\\"] - info[\\\"deviance\\\"]\\n except pm.ZeroProbability:\\n info[\\\"DIC\\\"] = np.nan\\n info[\\\"deviance\\\"] = np.nan\\n info[\\\"pD\\\"] = np.nan\\n\\n return info\",\n \"def get_linear_discrete_matrices(self):\\n\\n vf_op, vb_op = get_operating_point_inputs(self.operating_point[1], self.model_type)\\n if self.model_type == ModelType.EASY:\\n At, Bt, Vf_op, Vd_op = getLinearizedMatrices(self.model_type, self.operating_point[0:6], vf_op, vb_op)\\n elif self.model_type == ModelType.GYROMOMENT:\\n At, Bt = get_gyro_matrices(self.operating_point, self.operating_point[6] / mc.K_f, vf_op, vb_op)\\n if self.model_type == ModelType.EASY:\\n Ct = np.array([[1, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.model_type == ModelType.GYROMOMENT:\\n if self.nOutputs == 3:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n elif self.nOutputs == 5:\\n Ct = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 1, 0],\\n [0, 0, 0, 0, 0, 0, 0, 1]])\\n Dt = np.array([[0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0],\\n [0, 0]])\\n\\n Ak, Bk, Ck, Dk = discretize_linear_state_space(At, Bt, Ct, Dt, self.timeStep)\\n return Ak, Bk, Ck, Dk\",\n \"def matrixGroup(self):\\n\\n group = MatrixGroup(label=self.name)\\n\\n wavelength = self.designWavelength\\n previousSurface = Surface(mat=Air())\\n for surface in self.lensSurfaces():\\n mat1 = previousSurface.mat\\n mat2 = surface.mat\\n interface = DielectricInterface(R=surface.R, \\n n1=mat1.n(wavelength),\\n n2=mat2.n(wavelength),\\n diameter=surface.diameter)\\n group.append(interface)\\n\\n if not isinstance(mat2, Air):\\n spacing = Space(d=surface.spacing, n=mat2.n(wavelength))\\n group.append(spacing)\\n\\n previousSurface = surface\\n\\n return group\",\n \"def get_colors():\\n colors = {}\\n for h in wn.synset('chromatic_color.n.01').hyponyms():\\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \\n for h in wn.synset('achromatic_color.n.01').hyponyms():\\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \\n return colors\",\n \"def get_metrics(self):\\n f = Figure(title='DRM_Gradient Train Loss', x_axis_label='Epoch', y_axis_label='Value')\\n f.line(color='blue',\\n x=range(len(self.train_stats['loss_lst'])),\\n y=self.train_stats['loss_lst'],\\n legend='Loss')\\n f.line(color='green',\\n x=range(len(self.train_stats['objective_lst'])),\\n y=self.train_stats['objective_lst'],\\n legend='CPIT')\\n return [f.draw()]\",\n \"def load_mat_dict():\\n param_df = pd.DataFrame(loadmat(\\n 'X:/YuxiangWang/DataAnalysis/skinMechanicsAll/analysis/' +\\n 'ViscoAnalysis052013/strain_level_2py.mat')['qlv2tFixPara'])\\n param_df.columns = ['tau1', 'tau2', 'g1', 'g2', 'ginf', 'mu', 'alpha',\\n 'r2', 'stretch', 'thickness', 'skin_id', 'ramp_time']\\n param_df['skin_id'] = param_df['skin_id'].astype('i')\\n param_df['thickness'] *= 1e3 # Change unit to microns\\n return param_df\",\n \"def get_demographic_dictionary(cause_id, hybridizer=False):\\n keys = {}\\n call = \\\"\\\"\\\"\\n SELECT model_version_type_id, age_start, age_end FROM cod.model_version\\n WHERE cause_id = {c} AND gbd_round_id > 5 AND status = 1\\n AND model_version_type_id IN ({mvt})\\n \\\"\\\"\\\".format(c=cause_id,\\n mvt=model_version_type_ids(hybridizer))\\n df = query(call, conn_def='codem').drop_duplicates()\\n if df.empty:\\n raise RuntimeError(\\\"There are no previous model versions for cause {}.\\\".format(cause_id))\\n for m in df.model_version_type_id.unique().tolist():\\n keys[m] = {}\\n for a_start in df.query('model_version_type_id == {}'.format(m))['age_start'].unique().tolist():\\n keys[m][a_start] = {}\\n for a_end in df.query('model_version_type_id == {} & '\\n 'age_start == {}'.format(m, a_start))['age_end'].unique().tolist():\\n keys[m][a_start][a_end] = {}\\n return keys\",\n \"def pgradient(self):\\n d = {}\\n\\n # Det coeff\\n det_coeff_grad = (\\n self._dets[0][0, :, self._det_map[0]]\\n * self._dets[1][0, :, self._det_map[1]]\\n * np.exp(\\n self._dets[0][1, :, self._det_map[0]]\\n + self._dets[1][1, :, self._det_map[1]]\\n )\\n )\\n\\n curr_val = self.value()\\n d[\\\"det_coeff\\\"] = (\\n det_coeff_grad.T / (curr_val[0] * np.exp(curr_val[1]))[:, np.newaxis]\\n )\\n\\n # Mo_coeff, adapted from SlaterUHF\\n for parm in [\\\"mo_coeff_alpha\\\", \\\"mo_coeff_beta\\\"]:\\n s = 0\\n if \\\"beta\\\" in parm:\\n s = 1\\n\\n ao = self._aovals[\\n :, s * self._nelec[0] : self._nelec[s] + s * self._nelec[0], :\\n ]\\n pgrad_shape = (ao.shape[0],) + self.parameters[parm].shape\\n pgrad = np.zeros(pgrad_shape)\\n\\n largest_mo = np.max(np.ravel(self._det_occup[s]))\\n for i in range(largest_mo + 1): # MO loop\\n if i not in self.freeze_orb[s]:\\n for det in range(self.parameters[\\\"det_coeff\\\"].shape[0]): # Det loop\\n if (\\n i in self._det_occup[s][self._det_map[s][det]]\\n ): # Check if MO in det\\n col = self._det_occup[s][self._det_map[s][det]].index(i)\\n pgrad[:, :, i] += (\\n self.parameters[\\\"det_coeff\\\"][det]\\n * d[\\\"det_coeff\\\"][:, det, np.newaxis]\\n * self._testcol(self._det_map[s][det], col, s, ao)\\n )\\n d[parm] = np.array(pgrad)\\n return d\",\n \"def get_material_mapping(self):\\n return {name: self.get_material(name) for name in self.parts.keys()}\",\n \"def get_stats(dataset):\\n\\n # Initialize dictionary\\n stats_dict = {}\\n\\n # Add path information\\n stats_dict['lightcurve_path'] = os.path.dirname(dataset)\\n stats_dict['lightcurve_filename'] = os.path.basename(dataset)\\n\\n # Open lightcurve and extract information\\n hdulist = fits.open(dataset, mode='readonly')\\n counts = hdulist[1].data.counts\\n mjd = hdulist[1].data.mjd\\n\\n # Populate stats_dict with counts information\\n stats_dict['total'] = int(np.sum(counts))\\n\\n # If total counts is zero, there is nothing else to compute\\n # If there are counts, then populate the rest of stats_dict\\n if stats_dict['total'] > 0:\\n\\n # Populate stats dict with count stats\\n stats_dict['mean'] = float(np.mean(counts))\\n stats_dict['mu'] = float(np.sqrt(stats_dict['mean']))\\n stats_dict['stdev'] = float(np.std(counts))\\n\\n # Populate stats_dict with poisson information\\n try:\\n stats_dict['poisson_factor'] = float(stats_dict['stdev'] / stats_dict['mu'])\\n except ZeroDivisionError:\\n stats_dict['poisson_factor'] = 9999999.\\n\\n # Populate stats_dict with pearson information\\n pearson_results = pearsonr(mjd, counts)\\n stats_dict['pearson_r'] = float(pearson_results[0])\\n stats_dict['pearson_p'] = float(pearson_results[1])\\n\\n # Set 'interesting periodogram' flag\\n interesting_periodogram = False\\n significant_threshold = 0.30\\n for freq_space in ['short', 'med', 'long']:\\n periods, power, mean, three_sigma, significant_periods, significant_powers = get_periodogram_stats(dataset, freq_space)\\n if len(significant_powers) > 0:\\n if max(significant_powers) >= significant_threshold:\\n interesting_periodogram = True\\n stats_dict['periodogram'] = interesting_periodogram\\n\\n return stats_dict\",\n \"def lineBuilders() :\\n return dict(_lineBuilders)\",\n \"def Thresholds(self) :\\n\\n from Hlt1Lines.Hlt1TrackLines import Hlt1TrackLinesConf\\n from Hlt1Lines.Hlt1MuonLines import Hlt1MuonLinesConf\\n from Hlt1Lines.Hlt1ElectronLines import Hlt1ElectronLinesConf\\n from Hlt1Lines.Hlt1L0Lines import Hlt1L0LinesConf\\n from Hlt1Lines.Hlt1MBLines import Hlt1MBLinesConf\\n from Hlt1Lines.Hlt1CommissioningLines import Hlt1CommissioningLinesConf\\n from Hlt1Lines.Hlt1DisplVertexLines import Hlt1DisplVertexLinesConf\\n from Hlt2Lines.Hlt2CommissioningLines import Hlt2CommissioningLinesConf\\n from Hlt1Lines.Hlt1BeamGasLines import Hlt1BeamGasLinesConf\\n from Hlt2Lines.Hlt2diphotonDiMuonLines import Hlt2diphotonDiMuonLinesConf\\n from Hlt2Lines.Hlt2InclusiveDiProtonLines import Hlt2InclusiveDiProtonLinesConf\\n from Hlt2Lines.Hlt2DisplVerticesLines import Hlt2DisplVerticesLinesConf\\n\\n thresholds = { Hlt1TrackLinesConf : { 'AllL0Tight_PT' : 1700\\n , 'AllL0Tight_P' : 3000\\n , 'AllL0Tight_IP' : 0.100\\n , 'AllL0Tight_IPChi2' : 16 \\n , 'AllL0Tight_TrChi2' : 1.5 \\n , 'AllL0Tight_GEC' : 'Loose'\\n , 'AllL0Tight_Velo_NHits' : 9 \\n , 'AllL0Tight_Velo_Qcut' : 3 \\n , 'AllL0Tight_ValidateTT' : True \\n , 'AllL0_PT' : 1600\\n , 'AllL0_P' : 3000\\n , 'AllL0_IP' : 0.100\\n , 'AllL0_IPChi2' : 16\\n , 'AllL0_TrChi2' : 2.0\\n , 'AllL0_GEC' : 'Loose'\\n , 'AllL0_Velo_NHits' : 9 \\n , 'AllL0_Velo_Qcut' : 3 \\n , 'AllL0_ValidateTT' : True \\n , 'Muon_PT' : 1000 \\n , 'Muon_P' : 3000 \\n , 'Muon_IP' : 0.100\\n , 'Muon_IPChi2' : 16\\n , 'Muon_TrChi2' : 2.5 \\n , 'Muon_GEC' : 'Loose'\\n , 'Muon_ValidateTT' : False\\n , 'Muon_L0Channels' : 'Muon,DiMuon,MuonNoSPD,DiMuonNoSPD' \\n , 'Photon_PT' : 1200\\n , 'Photon_P' : 3000\\n , 'Photon_IP' : 0.100\\n , 'Photon_IPChi2' : 16\\n , 'Photon_TrChi2' : 2.0\\n , 'Photon_L0Channels' : 'PhotonHi,ElectronHi' \\n , 'Photon_GEC' : 'Loose'\\n , 'Photon_ValidateTT' : True\\n , 'Prescale' : {'Hlt1TrackAllL0' : 1.0, \\n 'Hlt1TrackAllL0Tight' : 1.0,\\n 'Hlt1TrackForwardPassThrough' : 0,\\n 'Hlt1TrackForwardPassThroughLoose' : 0}\\n \\n }\\n , Hlt1ElectronLinesConf : { 'SingleElectronNoIP_P' : 20000\\n , 'SingleElectronNoIP_PT' : 10000\\n , 'SingleElectronNoIP_TrChi2' : 3\\n , 'SingleElectronNoIP_TrNTHits' : 0 #OFF\\n , 'SingleElectronNoIP_Velo_NHits' : 0 #OFF\\n , 'SingleElectronNoIP_Velo_Qcut' : 999 #OFF\\n , 'SingleElectronNoIP_GEC' : 'Loose'\\n , 'L0Channels': { 'SingleElectronNoIP' : ( 'Electron', ) }\\n }\\n , Hlt1MuonLinesConf : { 'SingleMuonHighPT_P' : 3000\\n , 'SingleMuonHighPT_PT' : 4800\\n , 'SingleMuonHighPT_TrChi2' : 3.\\n , 'SingleMuonHighPT_GEC' : 'Loose'\\n , 'SingleMuonNoIP_P' : 3000\\n , 'SingleMuonNoIP_PT' : 1300\\n , 'SingleMuonNoIP_TrChi2' : 3.\\n , 'SingleMuonNoIP_GEC' : 'Loose'\\n , 'DiMuonLowMass_VxDOCA' : 0.2\\n , 'DiMuonLowMass_VxChi2' : 25\\n , 'DiMuonLowMass_P' : 0\\n , 'DiMuonLowMass_PT' : 0\\n , 'DiMuonLowMass_TrChi2' : 3\\n , 'DiMuonLowMass_M' : 0.\\n , 'DiMuonLowMass_IPChi2' : 6.\\n , 'DiMuonLowMass_GEC' : 'Loose'\\n , 'DiMuonHighMass_VxDOCA' : 0.2\\n , 'DiMuonHighMass_VxChi2' : 25\\n , 'DiMuonHighMass_P' : 3000\\n , 'DiMuonHighMass_PT' : 500\\n , 'DiMuonHighMass_TrChi2' : 3\\n , 'DiMuonHighMass_M' : 2700\\n , 'DiMuonHighMass_GEC' : 'Loose'\\n , 'MultiMuonNoIP_P' : 3000\\n , 'MultiMuonNoIP_PT' : 500\\n , 'MultiMuonNoIP_TrChi2' : 3.\\n , 'MultiMuonNoIP_GT' : 2.5\\n , 'MultiMuonNoIP_GEC' : 'Loose'\\n ,'L0Channels' : {\\n 'SingleMuonHighPT' : ( 'Muon', 'MuonNoSPD'),\\n 'SingleMuonNoIP' : ( 'Muon', 'MuonNoSPD'),\\n 'DiMuonLowMass' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ),\\n 'DiMuonHighMass' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ),\\n 'MultiMuonNoIP' : ( 'Muon', 'MuonNoSPD', 'DiMuon', 'DiMuonNoSPD' ) }\\n\\n , 'Prescale' : { 'Hlt1SingleMuonNoIP' : 0.01,\\n 'Hlt1MultiMuonNoIP' : 0.0 }\\n }\\n , Hlt1L0LinesConf : { 'Postscale' : { 'Hlt1L0AnyRateLimited' : 'RATE(1)'\\n , 'Hlt1L0AnyNoSPDRateLimited' : 'RATE(1)'\\n }\\n , 'Prescale' : { 'Hlt1L0HighSumETJet' : 1 \\n , 'Hlt1L0AnyNoSPD' : 0.01\\n }\\n }\\n , Hlt1BeamGasLinesConf : {\\n 'Prescale' : { 'Hlt1BeamGasCrossingForcedRecoFullZ': 0.001 }\\n , 'Postscale' : { 'Hlt1BeamGasNoBeamBeam1' : 'RATE(0.5)'\\n , 'Hlt1BeamGasNoBeamBeam2' : 'RATE(0.5)'\\n , 'Hlt1BeamGasBeam1' : 'RATE(2)'\\n , 'Hlt1BeamGasBeam2' : 'RATE(2)'\\n , 'Hlt1BeamGasCrossingEnhancedBeam1' : 'RATE(0)'\\n , 'Hlt1BeamGasCrossingEnhancedBeam2' : 'RATE(0)'\\n , 'Hlt1BeamGasCrossingForcedReco' : 'RATE(0.5)'\\n , 'Hlt1BeamGasCrossingForcedRecoFullZ': 'RATE(0.5)'\\n , 'Hlt1BeamGasCrossingParasitic' : 'RATE(1)'\\n , 'Hlt1BeamGasHighRhoVertices' : 'RATE(4)'\\n }\\n }\\n , Hlt1DisplVertexLinesConf: { \\\"VertexDisplVertex_DOCABL\\\" : \\\"2.0*mm\\\"\\n , \\\"VertexDisplVertex_VELO_NSP\\\" : \\\"3\\\"\\n , \\\"VertexDisplVertex_VELO_NCSP\\\" : \\\"2\\\"\\n , \\\"VertexDisplVertex_VELOTrChi2\\\": \\\"2.5\\\"\\n , \\\"VertexDisplVertex_VX_DOCA\\\" : \\\"0.3*mm\\\"\\n , \\\"VertexDisplVertex_VX_CHI2\\\" : \\\"1000000000.0\\\"\\n , \\\"VertexDisplVertex_VX_RHO\\\" : \\\"12.0*mm\\\"\\n , \\\"VertexDisplVertex_Tr_P\\\" : \\\"10.0*GeV\\\"\\n , \\\"VertexDisplVertex_Tr_PT\\\" : \\\"1.7*GeV\\\"\\n , \\\"VertexDisplVertex_Tr_CHI2\\\" : \\\"2.5\\\"\\n , \\\"VertexDisplVertex_GEC\\\" : \\\"Loose\\\"\\n , \\\"Prescale\\\" : {'Hlt1VertexDisplVertex':1.0 }\\n }\\n #, Hlt1ProtonLinesConf : { 'Prescale' : { 'Hlt1DiProtonLowMult' : 0.01, \\n # 'Hlt1DiProton' : 0.01\\n # } } \\n , Hlt1CommissioningLinesConf : { 'Postscale' : { 'Hlt1ErrorEvent' : 'RATE(0.01)'\\n\\n } }\\n , Hlt2CommissioningLinesConf : { 'Prescale' : { 'Hlt2PassThrough' : 0.0001 \\n , 'Hlt2Forward' : 0.00001\\n , 'Hlt2DebugEvent' : 0.000001 }\\n , 'Postscale' : { 'Hlt2ErrorEvent' : 'RATE(0.01)' } }\\n # micro bias lines switched off for high mu physics running \\n , Hlt1MBLinesConf : { 'Prescale' : { 'Hlt1MBMicroBiasVelo' : 0\\n , 'Hlt1MBMicroBiasTStation' : 0\\n , 'Hlt1MBMicroBiasVeloRateLimited' : 0\\n , 'Hlt1MBMicroBiasTStationRateLimited' : 0 }\\n , 'MaxNoBiasRate' : 1000000.\\n }\\n , Hlt2diphotonDiMuonLinesConf : { 'Prescale' : { 'Hlt2LowMultHadron' : 1.0 # for 0x0035, this is already done in L0\\n , 'Hlt2LowMultPhoton' : 0.01\\n } } \\n\\n #, Hlt2InclusiveDiProtonLinesConf: { 'Prescale' : { 'Hlt2DiProton' : 0.001\\n # , 'Hlt2DiProtonLowMult' : 0.001\\n # } } \\n\\n , Hlt2DisplVerticesLinesConf : { 'Prescale' : \\n { 'Hlt2DisplVerticesHighMassSingle' : 1\\n , 'Hlt2DisplVerticesSingle' : 1\\n , 'Hlt2DisplVerticesDouble' : 1\\n , 'Hlt2DisplVerticesHighMassSingle' : 1 \\n , 'Hlt2DisplVerticesHighFDSingle' : 1\\n , 'Hlt2DisplVerticesSinglePostScaled' : 1\\n , 'Hlt2DisplVerticesSingleDown' : 1\\n , 'Hlt2DisplVerticesDoublePostScaled' : 1\\n , 'Hlt2DisplVerticesSingleHighMassPostScaled' : 1\\n , 'Hlt2DisplVerticesSingleHighFDPostScaled' : 1\\n , 'Hlt2DisplVerticesSingleMVPostScaled' : 1 } \\n }\\n\\n }\\n\\n\\n from Muons_April2012 import Muons_April2012\\n __update_conf__(thresholds, Muons_April2012().Thresholds() )\\n\\n from Electrons_July2011 import Electrons_July2011\\n __update_conf__(thresholds, Electrons_July2011().Thresholds() )\\n\\n from Hadrons_September2012 import Hadrons_September2012\\n __update_conf__(thresholds, Hadrons_September2012().Thresholds() )\\n\\n from DV_draft2012 import DV_draft2012\\n __update_conf__(thresholds, DV_draft2012().Thresholds() )\\n\\n from CharmLeptonic_draft2012 import CharmLeptonic_draft2012\\n __update_conf__(thresholds, CharmLeptonic_draft2012().Thresholds() )\\n\\n return thresholds\",\n \"def get_disp_lims():\\n\\n return [[0., 10.], [0., 20.], [0., 1./3.]]\",\n \"def read_light_bumps(self):\\n rtn = {}\\n\\n for light_bump in Bump.light_bumps():\\n rtn[light_bump] = self.read_light_bump(light_bump)\\n\\n return rtn\",\n \"def curvature_matrix(self) -> np.ndarray:\\r\\n return self.curvature_matrix_diag\",\n \"def lights(self):\\n return list(self.GetLights())\",\n \"def fCZ_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\\n return {tuple(es.targets): es.fCZ_std_err for es in self.edges_specs}\",\n \"def efficiency_curves(self):\\n for key in self._efficiency_curves:\\n yield key, self._data[key]\",\n \"def get_lightcones(self, regex=''):\\n\\n self.lightcones = []\\n\\n suffix = f'HIIDIM={self.HII_DIM}_BOXLEN={self.BOX_LEN}_fisher_*{regex}*{self.param}*'\\n lightcone_filename = f'{self.output_dir}LightCone_z{self.min_redshift:.1f}_*{suffix}.h5'\\n\\n if self.vb: print(f' Searching for lightcones with name {lightcone_filename}')\\n lc_files = glob.glob(lightcone_filename)\\n fid_filename = lightcone_filename.replace(self.param,'fid')\\n fid_files = glob.glob(fid_filename)\\n lc_files.extend(fid_files)\\n\\n # Don't get minihalo param lightcones if it's not the minihalo param!\\n if 'MINI' not in self.param:\\n lc_files = [f for f in lc_files if 'MINI' not in f]\\n\\n if self.vb: print(f' Found {len(lc_files)} lightcones to load')\\n\\n for f in lc_files:\\n self.lightcones.append(p21c.LightCone.read(f))\\n print(' Loaded lightcones',f)\\n\\n self.k_fundamental, self.k_max, self.Nk = get_k_min_max(lightcone=self.lightcones[0], n_chunks=self.n_chunks)\\n self.lc_redshifts = self.lightcones[0].lightcone_redshifts\\n np.save(self.lc_redshifts_file, self.lc_redshifts, allow_pickle=True)\\n\\n return\",\n \"def colors(self) -> dict:\\n raise NotImplementedError\",\n \"def exportLightLinking(self):\\n\\t\\tlights = [a for a in mc.ls( typ = ['light','aiAreaLight'] ) if not 'eye' in a]\\n\\t\\tallShapes = [s for s in mc.ls( type = 'geometryShape', ni = 1) if not (mc.objectType( s ) in ( 'aiAreaLight','aiSkyDomeLight' ))]\\n\\t\\tlitLinks = {}\\n\\t\\tfor l in lights:\\n\\t\\t\\tlightLinkShapes = mc.lightlink( query=True, light=l ,shp=1,t=0,set=0,h=0)\\n\\t\\t\\tlitLinks[l]\\t = list( set( allShapes ) - set( lightLinkShapes ) )#SHAPES WITH NO LINK TO THIS LIGHT\\n\\t\\tpickle.dump( litLinks, open( self.lightLinkPath.path, \\\"wb\\\" ) )\",\n \"def _compute_internals(self, moments):\\n\\n [mean, stdv] = moments\\n internals = {}\\n internals['a'] = mean - np.sqrt(3) * stdv\\n internals['b'] = mean + np.sqrt(3) * stdv\\n\\n return internals\",\n \"def _compute_internals(self, moments):\\n\\n [mean, stdv] = moments\\n internals = {}\\n internals['a'] = mean - np.sqrt(3) * stdv\\n internals['b'] = mean + np.sqrt(3) * stdv\\n\\n return internals\",\n \"def AssembleStructuralMaterialsJson(KratosWindowManager):\\n for key in KratosWindowManager.MatSave.keys():\\n if(DEBUG):\\n print(key)\\n print(type(KratosWindowManager.MatSave[key]))\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"Variables\\\"][key]=KratosWindowManager.MatSave[key]\\n for bclistobject in KratosWindowManager.boundaryConditionEditor:\\n if(DEBUG):\\n print(bclistobject.name)\\n if bclistobject.entityType=='Element':\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"model_part_name\\\"]=bclistobject.name\\n\\n\\n if KratosWindowManager.is2D:\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"constitutive_law\\\"][\\\"name\\\"]=\\\"KratosMultiphysics.StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw\\\"\\n else:\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"constitutive_law\\\"][\\\"name\\\"]=\\\"KratosMultiphysics.StructuralMechanicsApplication.LinearElastic3DLaw\\\"\\n \\n\\n if(DEBUG):\\n print(sm.structuralmaterials_dict)\\n return sm.WriteMaterialToJson(sm.structuralmaterials_dict)\",\n \"def get_semiMajorAxes_dict():\\n de431 = {\\n # \\\"BODY1_semiMajorAxis\\\" : 2.2031780000000021E+04 ,\\n # \\\"BODY2_semiMajorAxis\\\" : 3.2485859200000006E+05 ,\\n # \\\"BODY3_semiMajorAxis\\\" : 4.0350323550225981E+05 ,\\n # \\\"BODY4_semiMajorAxis\\\" : 4.2828375214000022E+04 ,\\n # \\\"BODY5_semiMajorAxis\\\" : 1.2671276480000021E+08 ,\\n # \\\"BODY6_semiMajorAxis\\\" : 3.7940585200000003E+07 ,\\n # \\\"BODY7_semiMajorAxis\\\" : 5.7945486000000080E+06 ,\\n # \\\"BODY8_semiMajorAxis\\\" : 6.8365271005800236E+06 ,\\n # \\\"BODY9_semiMajorAxis\\\" : 9.7700000000000068E+02 ,\\n # \\\"BODY10_semiMajorAxis\\\" : 1.3271244004193938E+11 ,\\n\\n \\\"BODY199_semiMajorAxis\\\" : 57.91e6 ,\\n \\\"BODY299_semiMajorAxis\\\" : 108.21e6 ,\\n \\\"BODY399_semiMajorAxis\\\" : 149.60e6 ,\\n \\\"BODY499_semiMajorAxis\\\" : 227.92e6 ,\\n \\\"BODY599_semiMajorAxis\\\" : 778.57e6 ,\\n \\\"BODY699_semiMajorAxis\\\" : 1433.53e6 ,\\n \\\"BODY799_semiMajorAxis\\\" : 2872.46e6 ,\\n \\\"BODY899_semiMajorAxis\\\" : 4495.06e6 ,\\n \\\"BODY999_semiMajorAxis\\\" : 5906.38e6 ,\\n\\n \\\"BODY301_semiMajorAxis\\\" : 0.3844e6 ,\\n\\n \\\"BODY401_semiMajorAxis\\\" : 9378.0 ,\\n \\\"BODY402_semiMajorAxis\\\" : 23459.0 ,\\n\\n \\\"BODY501_semiMajorAxis\\\" : 431.8e3 ,\\n \\\"BODY502_semiMajorAxis\\\" : 671.1e3 ,\\n \\\"BODY503_semiMajorAxis\\\" : 1070.4e3 ,\\n \\\"BODY504_semiMajorAxis\\\" : 1882.7e3 ,\\n \\\"BODY505_semiMajorAxis\\\" : 181.4e3 ,\\n\\n \\\"BODY601_semiMajorAxis\\\" : 185.52e3 ,\\n \\\"BODY602_semiMajorAxis\\\" : 238.02e3 ,\\n \\\"BODY603_semiMajorAxis\\\" : 294.64e3 ,\\n \\\"BODY604_semiMajorAxis\\\" : 377.60e3 ,\\n \\\"BODY605_semiMajorAxis\\\" : 527.04e3 ,\\n \\\"BODY606_semiMajorAxis\\\" : 1221.83e3 ,\\n \\\"BODY607_semiMajorAxis\\\" : 1481.1e3 ,\\n \\\"BODY608_semiMajorAxis\\\" : 3561.3e3 ,\\n # \\\"BODY609_semiMajorAxis\\\" : 5.531110414633374E-01 ,\\n # \\\"BODY610_semiMajorAxis\\\" : 1.266231296945636E-01 ,\\n # \\\"BODY611_semiMajorAxis\\\" : 3.513977490568457E-02 ,\\n # \\\"BODY615_semiMajorAxis\\\" : 3.759718886965353E-04 ,\\n # \\\"BODY616_semiMajorAxis\\\" : 1.066368426666134E-02 ,\\n # \\\"BODY617_semiMajorAxis\\\" : 9.103768311054300E-03 ,\\n\\n \\\"BODY701_semiMajorAxis\\\" : 190.90e3 ,\\n \\\"BODY702_semiMajorAxis\\\" : 266.00e3 ,\\n \\\"BODY703_semiMajorAxis\\\" : 436.39e3 ,\\n \\\"BODY704_semiMajorAxis\\\" : 583.50e3 ,\\n \\\"BODY705_semiMajorAxis\\\" : 129.90e3 ,\\n\\n \\\"BODY801_semiMajorAxis\\\" : 354.76e3,\\n\\n \\\"BODY901_semiMajorAxis\\\" : 19596 ,\\n \\\"BODY902_semiMajorAxis\\\" : 48690 ,\\n \\\"BODY903_semiMajorAxis\\\" : 64740 ,\\n \\\"BODY904_semiMajorAxis\\\" : 57780,\\n\\n # \\\"BODY2000001_semiMajorAxis\\\" : 6.3130000000000003E+01 ,\\n # \\\"BODY2000002_semiMajorAxis\\\" : 1.3730000000000000E+01 ,\\n # \\\"BODY2000003_semiMajorAxis\\\" : 1.8200000000000001E+00 ,\\n # \\\"BODY2000004_semiMajorAxis\\\" : 1.7289999999999999E+01 ,\\n # \\\"BODY2000006_semiMajorAxis\\\" : 9.3000000000000005E-01 ,\\n # \\\"BODY2000007_semiMajorAxis\\\" : 8.5999999999999999E-01 ,\\n # \\\"BODY2000010_semiMajorAxis\\\" : 5.7800000000000002E+00 ,\\n # \\\"BODY2000015_semiMajorAxis\\\" : 2.1000000000000001E+00 ,\\n # \\\"BODY2000016_semiMajorAxis\\\" : 1.8100000000000001E+00 ,\\n # \\\"BODY2000029_semiMajorAxis\\\" : 8.5999999999999999E-01 ,\\n # \\\"BODY2000052_semiMajorAxis\\\" : 1.5900000000000001E+00 ,\\n # \\\"BODY2000065_semiMajorAxis\\\" : 9.1000000000000003E-01 ,\\n # \\\"BODY2000087_semiMajorAxis\\\" : 9.8999999999999999E-01 ,\\n # \\\"BODY2000088_semiMajorAxis\\\" : 1.0200000000000000E+00 ,\\n # \\\"BODY2000433_semiMajorAxis\\\" : 4.463E-4 ,\\n # \\\"BODY2000511_semiMajorAxis\\\" : 2.2599999999999998E+00 ,\\n # \\\"BODY2000704_semiMajorAxis\\\" : 2.1899999999999999E+00 \\n }\\n return de431\",\n \"def diagnostics(self):\\r\\n # NB: should be not None for multiprocessing works\\r\\n return {}\",\n \"def get_transit_light_curves(self, params, plots=False):\\n time_diffs = np.diff(sorted(self.times.jd))\\n diff_between_transits = params.per/2.\\n split_inds = np.argwhere(time_diffs > diff_between_transits) + 1\\n\\n if len(split_inds) > 1:\\n\\n split_ind_pairs = [[0, split_inds[0][0]]]\\n split_ind_pairs.extend([[split_inds[i][0], split_inds[i+1][0]]\\n for i in range(len(split_inds)-1)])\\n split_ind_pairs.extend([[split_inds[-1], len(self.times)]])\\n\\n transit_light_curves = []\\n counter = -1\\n for start_ind, end_ind in split_ind_pairs:\\n counter += 1\\n if plots:\\n plt.plot(self.times.jd[start_ind:end_ind],\\n self.fluxes[start_ind:end_ind], '.-')\\n\\n parameters = dict(times=self.times[start_ind:end_ind],\\n fluxes=self.fluxes[start_ind:end_ind],\\n errors=self.errors[start_ind:end_ind],\\n quarters=self.quarters[start_ind:end_ind],\\n name=counter)\\n transit_light_curves.append(TransitLightCurve(**parameters))\\n if plots:\\n plt.show()\\n else:\\n transit_light_curves = []\\n\\n return transit_light_curves\",\n \"def __get_color_table(self):\\n #Color: Green Yellow Orange Red Distance:\\n return [[0.70, 0.15, 0.1, 0.05], # 0\\n [0.17, 0.6, 0.17, 0.06], # 1\\n [0.06, 0.17, 0.6, 0.17], # 2\\n [0.05, 0.12, 0.23, 0.6], # 3\\n [0.05, 0.1, 0.15, 0.8]] # >= 4 \",\n \"def _compute_kratios_multilayers(self):\\n for i, layer in enumerate(self._layers.keys()):\\n if not layer.is_thickness_known():\\n raise ValueError(\\\"Thickness of layer %i is unknown\\\" % i)\\n\\n # Compute\\n layer = list(self._layers.keys())[0]\\n thickness_low_m = layer.thickness_m\\n thickness_high_m = layer.thickness_m * 10\\n step = 1\\n\\n _thicknesses, kratios = \\\\\\n self.compute_kratio_vs_thickness(layer, thickness_low_m,\\n thickness_high_m, step)\\n\\n # Reorganize results\\n output = {}\\n for experiment, kratio in kratios.items():\\n output.setdefault(experiment, kratio[0])\\n\\n return output\",\n \"def get_material_features(self):\\n return self.material_features\",\n \"def Thresholds(self) :\\n\\n from Hlt1Lines.Hlt1PhiLines import Hlt1PhiLinesConf\\n from Hlt1Lines.Hlt1CalibTrackingLines import Hlt1CalibTrackingLinesConf\\n\\n thresholds = { Hlt1PhiLinesConf : { 'TrackPT' : 800 # MeV\\n ,'TrackP' : 4000 # MeV\\n ,'TrackChi2DOF' : 5 # dimensionless\\n ,'PhiMassWin' : 30 # MeV\\n ,'PhiDOCA' : 0.2 # mm\\n ,'PhiVCHI2' : 20 # dimensionless\\n ,'Velo_Qcut' : 3 # dimensionless\\n ,'TrNTHits' : 16.\\n ,'ValidateTT' : False\\n }\\n , Hlt1CalibTrackingLinesConf : { 'TrackPT' : 500 # MeV\\n ,'TrackP' : 2000 # MeV\\n ,'TrackChi2DOF' : 5 # dimensionless\\n ,'D0MassWin' : 100 # MeV\\n ,'D0DOCA' : 0.2 # mm\\n ,'D0VCHI2' : 20 # dimensionless\\n ,'D0PT' : 2000 # MeV\\n ,'Velo_Qcut' : 3 # dimensionless\\n ,'TrNTHits' : 16\\n ,'ValidateTT' : False\\n }\\n }\\n\\n return thresholds\",\n \"def _detectors2(self, hdr):\\n # Called AnalysisParam in OpenMIMS, first part only\\n # presets separate, last part in _detectors3\\n d = {}\\n d['Detector 6'] = self._exit_slits(hdr)\\n d['Detector 6'].update(self._electron_multiplier(hdr))\\n d['Detector 7'] = self._exit_slits(hdr)\\n d['Detector 7'].update(self._electron_multiplier(hdr))\\n d['exit slit xl'] = unpack(self._bo + '70i', hdr.read(280))\\n return d\",\n \"def fillDetInfo():\\n print('here i am')\\n # 1. maps of analysis channel to cpd, and pulser monitor channels\\n detCH, pMons = {}, {}\\n for ds in [0,1,2,3,4,5,6]:\\n f = np.load(\\\"%s/data/ds%d_detChans.npz\\\" % (os.environ['LATDIR'], ds))\\n detCH[ds] = f['arr_0'].item()\\n pMons[ds] = f['arr_1'].item()\\n\\n # 2. maps of HV and TRAP threshold settings are stored in the DB.\\n # make them global, and move them to the runSettings file.\\n # FORMAT: {ds : {'det' : [(run1,val1),(run2,val2)...]} }\\n detHV, detTH = {}, {}\\n\\n # load all possible values, as in settingsMgr\\n detDB = db.TinyDB(\\\"%s/calDB-v2.json\\\" % dsi.latSWDir)\\n detPars = db.Query()\\n cal = dsi.CalInfo()\\n for ds in [0,1,2,3,4,5,6]:\\n # for ds in [0]:\\n print(\\\"scanning ds\\\",ds)\\n detTH[ds] = {}\\n detHV[ds] = {}\\n for key in cal.GetKeys(ds):\\n mod = -1\\n if \\\"m1\\\" in key: mod = 1\\n if \\\"m2\\\" in key: mod = 2\\n for cIdx in range(cal.GetIdxs(key)):\\n\\n # load the DB records\\n dbKeyTH = \\\"trapThr_%s_c%d\\\" % (key, cIdx)\\n dbValTH = dsi.getDBRecord(dbKeyTH,calDB=detDB,pars=detPars)\\n\\n dbKeyHV = \\\"hvBias_%s_c%d\\\" % (key, cIdx)\\n dbValHV = dsi.getDBRecord(dbKeyHV,calDB=detDB,pars=detPars)\\n\\n # debug: print the record\\n # for val in sorted(dbValTH):\\n # if len(dbValTH[val])>0:\\n # print(val, dbValTH[val])\\n # return\\n\\n # fill the first value\\n if len(detTH[ds])==0:\\n detTH[ds] = dbValTH\\n detHV[ds] = dbValHV\\n continue\\n\\n # check for new threshold values.\\n for cpd in detTH[ds]:\\n nOld, nNew = len(detTH[ds][cpd]), len(dbValTH[cpd])\\n\\n # detector just came online\\n if nOld==0 and nNew>0:\\n detTH[ds][cpd] = dbValTH[cpd]\\n continue\\n # detector still offline\\n if nOld==0 and nNew==0:\\n continue\\n # detector just went offline\\n if nOld>0 and nNew==0:\\n continue\\n\\n # check last run/trap pair against each new one\\n prevRun, prevTH = detTH[ds][cpd][-1][0], detTH[ds][cpd][-1][1]\\n for val in dbValTH[cpd]:\\n thisRun, thisTH = val[0], val[1]\\n if thisTH != prevTH:\\n detTH[ds][cpd].append([thisRun,thisTH])\\n prevTH = thisTH\\n\\n # check for new HV values.\\n for cpd in detHV[ds]:\\n\\n nOld, nNew = len(detHV[ds][cpd]), len(dbValHV[cpd])\\n\\n # detector just came online\\n if nOld==0 and nNew>0:\\n detHV[ds][cpd] = dbValHV[cpd]\\n continue\\n # detector still offline\\n if nOld==0 and nNew==0:\\n continue\\n # detector just went offline\\n if nOld>0 and nNew==0:\\n continue\\n\\n # check last run/trap pair against each new one\\n prevRun, prevHV = detHV[ds][cpd][-1][0], detHV[ds][cpd][-1][1]\\n for val in dbValHV[cpd]:\\n thisRun, thisHV = val[0], val[1]\\n if thisHV != prevHV:\\n print(\\\"found HV diff. cpd %d prev %dV (run %d) new %dV (run %d)\\\" % (cpd, prevHV, prevRun, thisHV, thisRun))\\n detHV[ds][cpd].append([thisRun,thisHV])\\n prevHV = thisHV\\n\\n # return\\n\\n # # load the old file and compare\\n # # GOAL: improve on this file.\\n # # f = np.load(\\\"%s/data/runSettings.npz\\\" % dsi.latSWDir)\\n # # detHVOld = f['arr_0'].item()\\n # # detTHOld = f['arr_1'].item()\\n # # detCHOld = f['arr_2'].item()\\n # # pMonsOld = f['arr_3'].item()\\n #\\n # ds = 3\\n # print(\\\"old results, ds\\\",ds)\\n # for cpd in sorted(detTHOld[ds]):\\n # if cpd!=\\\"122\\\":continue\\n # if len(detTHOld[ds][cpd]) > 0:\\n # print(cpd, detTHOld[ds][cpd])\\n #\\n # # for ds in [0,1,2,3,4,5,6]:\\n # print(\\\"thresh results, ds:\\\",ds)\\n # for cpd in sorted(detTH[ds]):\\n # # if cpd!=122:continue\\n # if len(detTH[ds][cpd]) > 0:\\n # print(cpd, detTH[ds][cpd])\\n\\n\\n np.savez(\\\"%s/data/runSettings-v2.npz\\\" % dsi.latSWDir,detHV,detTH,detCH,pMons)\",\n \"def describe(self) -> Dict:\\n\\n desc = {\\n \\\"Win\\\": {\\n \\\"max\\\": np.max(self.Win),\\n \\\"min\\\": np.min(self.Win),\\n \\\"mean\\\": np.mean(self.Win),\\n \\\"median\\\": np.median(self.Win),\\n \\\"std\\\": np.std(self.Win)\\n },\\n \\\"W\\\": {\\n \\\"max\\\": np.max(self.W),\\n \\\"min\\\": np.min(self.W),\\n \\\"mean\\\": np.mean(self.W),\\n \\\"median\\\": np.median(self.W),\\n \\\"std\\\": np.std(self.W),\\n \\\"sr\\\": max(abs(linalg.eig(self.W)[0]))\\n }\\n }\\n if self.Wfb is not None:\\n desc[\\\"Wfb\\\"] = {\\n \\\"max\\\": np.max(self.Wfb),\\n \\\"min\\\": np.min(self.Wfb),\\n \\\"mean\\\": np.mean(self.Wfb),\\n \\\"median\\\": np.median(self.Wfb),\\n \\\"std\\\": np.std(self.Wfb)\\n }\\n if self.Wout is not None:\\n desc[\\\"Wout\\\"] = {\\n \\\"max\\\": np.max(self.Wout),\\n \\\"min\\\": np.min(self.Wout),\\n \\\"mean\\\": np.mean(self.Wout),\\n \\\"median\\\": np.median(self.Wout),\\n \\\"std\\\": np.std(self.Wout)\\n }\\n return desc\",\n \"def read_rbn_lightcurve(lc_file,log):\\n\\n if path.isfile(lc_file):\\n\\n lines = open(lc_file, 'r').readlines()\\n\\n imnames = []\\n hjd = []\\n cal_mag = []\\n cal_mag_err = []\\n\\n for l in lines:\\n\\n if l[0:1] != '#':\\n\\n entries = l.replace('\\\\n','').split()\\n\\n imnames.append( str(entries[0]).replace('.fits','').replace('_crop','') )\\n hjd.append( float(entries[1]) )\\n cal_mag.append( float(entries[8]) )\\n cal_mag_err.append( float(entries[9]) )\\n\\n lc = Table()\\n lc['images'] = imnames\\n lc['hjd'] = hjd\\n lc['mag'] = cal_mag\\n lc['mag_err'] = cal_mag_err\\n\\n log.info('Read data for lightcurve '+lc_file)\\n\\n else:\\n log.info('ERROR: Cannot access lightcurve file '+lc_file)\\n\\n lc = Table()\\n\\n return lc\",\n \"def _compute_internals(self, moments):\\n\\n [mean, stdv] = moments\\n internals = {}\\n internals['k'] = mean ** 2. / stdv ** 2.\\n internals['LAMBDA'] = mean / stdv ** 2.\\n\\n return internals\",\n \"def _compute_internals(self, moments):\\n\\n [mean, stdv] = moments\\n internals = {}\\n internals['mu'] = mean\\n internals['sigma'] = stdv\\n\\n return internals\",\n \"def _generateLSSData():\\n d65data=matFromVec([d65Illum(x) for x in brange(10,380,730)])\\n a=matNew([cie1931cmf(x) for x in brange(10,380,730)])\\n aprime=matT(a)\\n width=matShape(a)[0]\\n wdiag=matDiag(d65data[0])\\n mat=matNew([ \\\\\\n [3.240970, -1.537383, -0.4986108],\\\\\\n [-0.9692436, 1.875968, 0.04155506],\\\\\\n [0.05563008, -0.2039770, 1.056972]])\\n wnorm=vecDot(d65data[0],aprime[1])\\n t=matScale(matMul(matMul(mat,aprime),wdiag),1.0/wnorm)\\n # Compute Least Slope Squared matrix\\n d=matScale(matEye(width),4)\\n dSize=matShape(d)[0]\\n matSet(d,0,0,2)\\n matSet(d,dSize-1,dSize-1,2)\\n for i in range(1,dSize):\\n matSet(d,i,i-1,-2)\\n matSet(d,i-1,i,-2)\\n dt=matT(d)\\n vt=matT(t)\\n tshape=matShape(t)\\n bm=matBlock(d,vt,t,matZeros((tshape[0],tshape[0])))\\n bm=matI(bm)\\n b11=matPart(bm,0,width,0,width)\\n b12=matPart(bm,0,matShape(vt)[0],width,matShape(bm)[1])\\n return [b11, b12]\",\n \"def fISWAP_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\\n return {tuple(es.targets): es.fISWAP_std_err for es in self.edges_specs}\",\n \"def draggableCircuitResults(self):\\n returnedDictionary={}\\n self.blochSpheres=self.separatedBlochSpheres()\\n returnedDictionary[\\\"probabilities\\\"] = self.separatedProbabilities()\\n #returnedDictionary[\\\"blochSpheres\\\"] = self.separatedBlochSpheres()\\n returnedDictionary[\\\"diracNotation\\\"] = self.diracNotation()\\n returnedDictionary[\\\"link\\\"] = \\\"\\\"\\n returnedDictionary['chart'] = self.graph()\\n try:\\n returnedDictionary[\\\"qasm\\\"] = self.circuit.qasm()\\n except Exception:\\n #str(Exception)\\n returnedDictionary[\\\"qasm\\\"] = \\\"//You are using custom gate\\\\n//with size more than 2 qubits\\\\n//sorry, this version doesn't support that\\\\n//qiskit version 0.19.1\\\"\\n \\n if self.API_TOKEN != \\\"\\\":\\n returnedDictionary[\\\"link\\\"] = self.runOnIBMQ()\\n \\n return returnedDictionary\",\n \"def _retrieve_solution(self, m):\\n result = {} # {component: {resource: production}}\\n for comp in m.Components:\\n prod = getattr(m, '{n}_production'.format(n=comp.name))\\n result[comp.name] = {}\\n for res, comp_r in m.resource_index_map[comp].items():\\n result[comp.name][res] = np.fromiter((prod[comp_r, t].value for t in m.T), dtype=float, count=len(m.T))\\n return result\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['alpha'] = self.alpha\\n retDict['beta'] = self.beta\\n retDict['scale'] = self.high-self.low\\n retDict['low'] = self.low\\n return retDict\",\n \"def get_maturities(self):\\r\\n return sorted(self.instruments.keys())\",\n \"def qasmCircuitResults(self):\\n returnedDictionary={}\\n self.circutDrawing = self.draw()\\n self.blochSpheres=self.separatedBlochSpheres()\\n returnedDictionary[\\\"wires\\\"]=self.num_qubits\\n returnedDictionary[\\\"probabilities\\\"] = self.separatedProbabilities()\\n #returnedDictionary[\\\"blochSpheres\\\"] = self.separatedBlochSpheres()\\n returnedDictionary[\\\"diracNotation\\\"] = self.diracNotation()\\n returnedDictionary['chart'] = self.graph()\\n returnedDictionary[\\\"link\\\"] = \\\"\\\"\\n #returnedDictionary[\\\"qasmRows\\\"] = np.transpose(cols).tolist()\\n \\n if self.API_TOKEN != \\\"\\\":\\n returnedDictionary[\\\"link\\\"] = self.runOnIBMQ()\\n \\n return returnedDictionary\",\n \"def get_spectral_features(image, img_type: str): # Apply on the whole image\\r\\n spectrum = spectral_power(image, log=False)\\r\\n bins_energy, _ = get_energy_bins(spectrum, num_bins=3) # Use images with outside val: NaN\\r\\n spectral_features = {img_type + \\\"low_freq_energy\\\": bins_energy[0],\\r\\n img_type + \\\"mid_freq_energy\\\": bins_energy[1], \\r\\n img_type + \\\"high_freq_energy\\\": bins_energy[2]}\\r\\n return spectral_features\",\n \"def obtain_meta_data_frame_for_available_lightcurves(self):\\n # noinspection SpellCheckingInspection\\n columns_to_use = ['tic_id', 'Disposition', 'Epoc', 'Period', 'Duration', 'Sectors']\\n liang_yu_dispositions = pd.read_csv(self.liang_yu_dispositions_path, usecols=columns_to_use)\\n # noinspection SpellCheckingInspection\\n liang_yu_dispositions.rename(columns={'tic_id': 'TIC ID', 'Disposition': 'disposition', 'Epoc': 'transit_epoch',\\n 'Period': 'transit_period', 'Duration': 'transit_duration',\\n 'Sectors': 'Sector'}, inplace=True)\\n liang_yu_dispositions = liang_yu_dispositions[(liang_yu_dispositions['disposition'] != 'PC') |\\n (liang_yu_dispositions['transit_epoch'].notna() &\\n liang_yu_dispositions['transit_period'].notna() &\\n liang_yu_dispositions['transit_duration'].notna())]\\n lightcurve_paths = list(self.lightcurve_directory.glob('*lc.fits'))\\n tess_data_interface = TessDataInterface()\\n tic_ids = [tess_data_interface.get_tic_id_from_single_sector_obs_id(path.name) for path in lightcurve_paths]\\n sectors = [tess_data_interface.get_sector_from_single_sector_obs_id(path.name) for path in lightcurve_paths]\\n lightcurve_meta_data = pd.DataFrame({'lightcurve_path': list(map(str, lightcurve_paths)), 'TIC ID': tic_ids,\\n 'Sector': sectors})\\n meta_data_frame_with_candidate_nans = pd.merge(liang_yu_dispositions, lightcurve_meta_data,\\n how='inner', on=['TIC ID', 'Sector'])\\n self.meta_data_frame = meta_data_frame_with_candidate_nans.dropna()\",\n \"def getldcoeffs(Teff, logg, z, Tefferr, loggerr, zerr, law, channel, quiet = False):\\n\\n if not quiet: print \\\"\\\\nInterpolating {} limb darkening coefficients for {}...\\\".format(law,channel)\\n # Paths where the tables are stored\\n ch1path = \\\"{}/PhD/code/LD3.6Spitzer.txt\\\".format(os.getenv('HOME'))\\n ch2path = \\\"{}/PhD/code/LD4.5Spitzer.txt\\\".format(os.getenv('HOME'))\\n\\n # Read in the required table\\n if channel == 'ch1':\\n table = np.genfromtxt(ch1path, skip_header=13, dtype=float, encoding = None)\\n elif channel == 'ch2':\\n table = np.genfromtxt(ch2path, skip_header=13, dtype=float, encoding = None)\\n\\n # 3D array of discrete values of teff, logg and z\\n points = np.array([table.T[0], table.T[1], table.T[2]]).T\\n\\n if law == \\\"linear\\\": index = [0]\\n elif law == \\\"quadratic\\\": index = [1,2]\\n elif law == \\\"nonlinear\\\": index = [6,7,8,9]\\n else: pass\\n\\n coeffs = np.zeros(len(index))\\n coeffs_err = np.zeros(len(index))\\n\\n for i in range(len(index)):\\n # All possible values of desired limb darkening coefficient (indexed)\\n values = table.T[3+index[i]]\\n # 3D Interpolates\\n interp = LinearNDInterpolator(points,values)\\n coeffs[i] = interp.__call__([Teff,logg,z])\\n\\n # Estimate the error on the interpolated result based on errors Teff,logg,z\\n coeffsTU = interp.__call__(np.array([Teff+Tefferr,logg,z]))\\n coeffsTL = interp.__call__(np.array([Teff-Tefferr,logg,z]))\\n coeffsgU = interp.__call__(np.array([Teff,logg+loggerr,z]))\\n coeffsgL = interp.__call__(np.array([Teff,logg-loggerr,z]))\\n coeffszU = interp.__call__(np.array([Teff,logg,z+zerr]))\\n coeffszL = interp.__call__(np.array([Teff,logg,z-zerr]))\\n\\n coeffs_err[i] = np.sqrt( ((coeffsTU - coeffsTL)/2.)**2 + ((coeffsgU - coeffsgL)/2.)**2 + ((coeffszU - coeffszL)/2.)**2 )\\n\\n if not quiet: print \\\"\\\\t Coeff(s): {}\\\".format(coeffs)\\n if not quiet: print \\\"\\\\t Coeff Err(s): {}\\\".format(coeffs_err)\\n\\n return coeffs.tolist(), coeffs_err.tolist()\",\n \"def createSurfaceGeo(self):\\n self.surfGeo = dict()\\n r = self.geoParam['CylinderLightGuideRadius']\\n self.surfGeo[r] = 'LightGuide'\\n #self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\\n while(r + self.geoParam['DetectorThickness'] < self.geoParam['CylinderRadius']):\\n r += self.geoParam['DetectorThickness']\\n self.surfGeo[r] = 'Detector'\\n r += self.geoParam['DetectorSpacing']\\n if (r < self.geoParam['CylinderRadius']):\\n self.surfGeo[r] = 'LightGuide'\\n return self.surfGeo\",\n \"def get_materials_properties(dbpath): #<un-named>nook\\n odb = openOdb(path=dbpath)\\n data = []\\n for _name,_mat in odb.materials.items():\\n _elastic_mod = _mat.elastic.table[0][0]\\n _poisson = _mat.elastic.table[0][1]\\n if hasattr(_mat,\\\"plastic\\\"):\\n _plastic = _mat.plastic.table\\n else:\\n _plastic = []\\n data.append((_name,_elastic_mod,_poisson,_plastic))\\n odb.close()\\n return data\",\n \"def _compute_internals(self, moments):\\n\\n [mean, stdv] = moments\\n cov = stdv / mean\\n zeta = np.sqrt(np.log(1. + cov ** 2.))\\n LAMBDA = np.log(mean) - 0.5 * zeta ** 2.\\n internals = {}\\n internals['LAMBDA'] = LAMBDA\\n internals['zeta'] = zeta\\n\\n return internals\",\n \"def test_light_dict(self):\\n light = self._create_example_light()\\n\\n dictionary = light.as_dict()\\n assert isinstance(dictionary, dict)\\n assert dictionary == {\\\"warning\\\": False, \\\"off\\\": True}\",\n \"def legend_entries(self):\\n return self._legend_entries.setdefault(self._plotid, [])\",\n \"def lfric_sst():\\n mesh = sample_lfric_sst()\\n name = mesh.active_scalars_name\\n mesh[\\\"cids\\\"] = np.arange(mesh.n_cells)\\n mesh[\\\"pids\\\"] = np.arange(mesh.n_points)\\n mesh.set_active_scalars(name)\\n return mesh\",\n \"def gather_krec(self):\\n \\n #getting Qlo and Qhi the wrong way round here gives perfect flat s.s. recovery\\n rec1 = Recovery_Qmade(self.m1.param, self.m1.N_states, \\n self.m1.open_states, self.m1.Qlo, self.m1.Qhi, self.m1.P_init_hi, t_range=1e4)\\n\\n rec1.build_curve()\\n rec1.get_keff()\\n \\n rec2 = Recovery_Qmade(self.m2.param, self.m2.N_states, \\n self.m2.open_states, self.m2.Qlo, self.m2.Qhi, self.m2.P_init_hi, t_range=1e4)\\n\\n rec2.build_curve()\\n rec2.get_keff()\\n \\n self.k_eff1 = rec1.k_eff\\n self.k_eff2 = rec2.k_eff\\n \\n self.mean_keff = (rec1.k_eff + rec2.k_eff ) / 2\",\n \"def get_density_cmap():\\n # Add completely white color to Reds colormap in Matplotlib\\n list_colors = plt.cm.datad['Reds']\\n list_colors = list(list_colors)\\n list_colors.insert(0, (1, 1, 1))\\n list_colors.insert(0, (1, 1, 1))\\n lscm = matplotlib.colors.LinearSegmentedColormap.from_list(\\\"my_Reds\\\", list_colors)\\n return lscm\",\n \"def info_materials_polymer_get():\\n materials = _material_by_group(974) # 974 == intermediate group\\n return materials, 200\",\n \"def get_function_gradients(self):\\n funcs = self.get_functions()\\n gradients = []\\n\\n for n,func in enumerate(funcs):\\n func_list = []\\n for scenario in self.scenarios:\\n if scenario.group_master:\\n func_list.extend(scenario.active_derivatives(n))\\n else:\\n func_list.extend(scenario.uncoupled_derivatives(n))\\n\\n for body in self.bodies:\\n if body.group_master:\\n func_list.extend(body.active_derivatives(n))\\n else:\\n func_list.extend(body.uncoupled_derivatives(n))\\n gradients.append(func_list)\\n\\n return gradients\",\n \"def get_spectra_pixell(alm1, alm2=None, spectra=None):\\n \\n if spectra is None:\\n if alm2 is None:\\n cls = curvedsky.alm2cl(alm1)\\n else:\\n cls = curvedsky.alm2cl(alm1, alm2)\\n l = np.arange(len(cls))\\n return l, cls\\n \\n \\n cls = curvedsky.alm2cl(alm1[:,None], alm2[None,:])\\n l = np.arange(len(cls[0,0]))\\n cl_dict = {}\\n for i, l1 in enumerate([\\\"T\\\",\\\"E\\\",\\\"B\\\"]):\\n for j, l2 in enumerate([\\\"T\\\",\\\"E\\\",\\\"B\\\"]):\\n cl_dict[l1+l2] = cls[i,j]\\n \\n return(l, cl_dict)\",\n \"def test_lightcurve_seismology_plot():\\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()\",\n \"def fXY_std_errs(self) -> Dict[Tuple[int, ...], Optional[float]]:\\n return {tuple(es.targets): es.fXY_std_err for es in self.edges_specs}\",\n \"def GetLMCoverageOfMultipleRoutes(RouteInfoList, ReqLineMeasureTime, FirstDayOfPeriod, LastDayOfPeriod, LMRequirements=None):\\r\\n\\tLMCoverageOfRoutesPerLineKey = {}\\r\\n\\r\\n\\tfor RouteInfo in RouteInfoList:\\r\\n\\t\\t(LMCoverageOfRoutePerSegment, LMCoverageOfRoutePerLineKey) = \\\\\\r\\n\\t\\t\\tGetLMCoverageOfRoute(RouteInfo, ReqLineMeasureTime, FirstDayOfPeriod, LastDayOfPeriod, LMRequirements)\\r\\n\\r\\n\\t\\t# add dictionaries\\r\\n\\t\\tLMCoverageOfRoutesPerLineKey = AddDicValues(LMCoverageOfRoutesPerLineKey, LMCoverageOfRoutePerLineKey, DefaultEmptyVal = 0)\\r\\n\\r\\n\\treturn LMCoverageOfRoutesPerLineKey\",\n \"def IR():\\n s = np.array(\\n [2.40774137,2.287696084,2.203613927,2.048710132,1.899829585,1.591776247,\\n 2.021218754,2.572949552,3.298381484,3.635993426,3.788266224,3.8307278,3.834208811]\\n )\\n\\n TI = np.array([50, 75, 100, 150, 200, 300, 400, 500, 750, 1000, 1500, 2000, 3000])\\n\\n comp1 = s * np.array([-159.1,-134.2,-109.1,-64.7,25.0,40.1,88.6,126.8,187.6,219.4,245.4,253.6,256.1])\\n comp2 = s * np.array([-368.3,-356.9,-343.8,-318.1,-292.0,-242.5,-199.3,-158.4,-68.8,14.2,131.9,219.5,333.5])\\n comp3 = s * np.array([-77.5,-51.9,-29.8,9.9,40.2,85.7,115.4,135.1,160.1,167.6,172.3,171.7,171.8])\\n comp4 = s * np.array([-265.0,-240.6,-216.7,-170.5,-128.2,-53.5,9.6,62.3,159.7,223.8,296.5,328.3,346.7])\\n comp5 = s * np.array([-346.5,-328.9,-312.1,-278.5,-244.4,-182.3,-128.0,-80.0,30.8,109.3,225.1,299.5,372.2])\\n\\n comp = [comp1, comp2, comp3, comp4, comp5]\\n MSE = []\\n colors = [\\\"#1f77b4\\\", \\\"#ff7f0e\\\", \\\"#2ca02c\\\", \\\"#d62728\\\", \\\"#9467bd\\\"]\\n x_new = np.linspace(0, 3000, 10000)\\n for i, j, k in zip(comp, colors, np.arange(1, 6)):\\n plt.scatter(TI, i, c=j)\\n # popt, _ = curve_fit(MZ, TI, i, p0=np.array([200, 220, 300]))\\n popt, _ = curve_fit(MZ, TI, i, p0=np.array([300, 220]))\\n # M_z0, T1, M0 = popt\\n M0, T1 = popt\\n y_new = MZ(x_new, *popt)\\n plt.plot(x_new, y_new, \\\"--\\\", c=j, label=f\\\"Fit Comp. {k:d} : $T_1$={T1:3.2f}\\\")\\n MSE.append(mean_squared_error(i,y_new[TI]))\\n print(MSE)\\n print(np.mean(MSE))\\n plt.grid()\\n plt.legend(loc=\\\"best\\\")\\n plt.xlabel(\\\"TI\\\")\\n plt.ylabel(r\\\"Singal Intensity $M_z$\\\")\\n plt.show()\",\n \"def generate_lut(self):\\n colormap = self.get_colormap()\\n\\n if self.block_type == \\\"equidistant\\\":\\n ev_colormap = colors.colormap_to_ev_blocks_equidistant(colormap, self.exposure_values)\\n if self.test:\\n self.print_colormap(self.name, ev_colormap)\\n return self.generate_spi3d_from_evs(ev_colormap)\\n elif self.block_type == \\\"centered\\\":\\n ev_colormap = colors.colormap_to_ev_blocks_centered(colormap, self.exposure_values)\\n if self.test:\\n self.print_colormap(self.name, ev_colormap)\\n return self.generate_spi3d_from_evs(ev_colormap)\\n elif self.block_type == \\\"stretched\\\":\\n ev_colormap = colors.colormap_to_ev_blocks_stretched(colormap, self.exposure_values)\\n if self.test:\\n self.print_colormap(self.name, ev_colormap)\\n return self.generate_spi3d_from_evs(ev_colormap)\",\n \"def createDict( self ):\\n self.d = {}\\n self.d['comp1'] = compensation_channel('comp1', 0, (-479.0, -10.0))\\n self.d['comp2'] = compensation_channel('comp2', 1, (-479.0, -10.0))\\n self.addCalibration()\",\n \"def _get_all_residuals(self) -> Dict[int, np.ndarray]:\\n residuals = self.residuals\\n # if residuals have not been calculated yet\\n if residuals is None:\\n levels = self.levels\\n models = self.models\\n residuals = {}\\n for k in levels:\\n # assert models is not None\\n # pyre-fixme[16]: `Optional` has no attribute `__getitem__`.\\n if models[k] is not None:\\n try:\\n vals = self._get_residuals(models[k])\\n except Exception as e:\\n msg = (\\n f\\\"Failed to get residuals for level {k} with error \\\"\\n f\\\"message {e}.\\\"\\n )\\n raise _log_error(msg)\\n\\n residuals[k] = vals\\n else:\\n residuals[k] = self.info_residuals[k]\\n self.residuals = residuals\\n return residuals\",\n \"def _extract_data(self) -> np.ndarray:\\n \\n mats = Material.objects.all()\\n \\n mat_arrays = []\\n for mat in mats: # django queryset -> python list\\n mat_features = []\\n \\n # Add data\\n # Some data are missing here.\\n #TODO: Delete those if sentences after cleaning the data.\\n mat_features.append(mat.model_surface_temperature if mat.model_surface_temperature!=None else 0)\\n mat_features.append(mat.melt_temperature if mat.melt_temperature!=None else 0)\\n mat_features.append(mat.mold_temperature_range_min if mat.mold_temperature_range_min!=None else 0)\\n mat_features.append(mat.mold_temperature_range_max if mat.mold_temperature_range_max!=None else 0)\\n mat_features.append(mat.melt_temperature_range_min if mat.melt_temperature_range_min!=None else 0)\\n mat_features.append(mat.melt_temperature_range_max if mat.melt_temperature_range_max!=None else 0)\\n mat_features.append(mat.absolute_maximum_melt_temperature if mat.absolute_maximum_melt_temperature!=None else 0)\\n mat_features.append(mat.ejection_temperature if mat.ejection_temperature!=None else 0)\\n mat_features.append(mat.maximum_shear_stress if mat.maximum_shear_stress!=None else 0)\\n mat_features.append(mat.maximum_shear_rate if mat.maximum_shear_rate!=None else 0)\\n mat_features.append(mat.melt_density if mat.melt_density!=None else 0)\\n mat_features.append(mat.solid_density if mat.solid_density!=None else 0)\\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\\n mat_features.append(mat.elastic_modulus_e1 if mat.elastic_modulus_e1!=None else 0)\\n mat_features.append(mat.elastic_modulus_e2 if mat.elastic_modulus_e2!=None else 0)\\n mat_features.append(mat.poisson_ratio_v12 if mat.poisson_ratio_v12!=None else 0)\\n mat_features.append(mat.poisson_ratio_v23 if mat.poisson_ratio_v23!=None else 0)\\n mat_features.append(mat.shear_modulus_g12 if mat.shear_modulus_g12!=None else 0.)\\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1!=None else 0.)\\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2!=None else 0.)\\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\\n mat_features.append(mat.c1 if mat.c1!=None else 0.)\\n mat_features.append(mat.c2 if mat.c2!=None else 0.)\\n mat_features.append(mat.conversion_temperature if mat.conversion_temperature!=None else 0.)\\n mat_features.append(mat.MFR_temperature if mat.MFR_temperature!=None else 0.)\\n mat_features.append(mat.MFR_loading if mat.MFR_loading!=None else 0.)\\n mat_features.append(mat.measured_MFR if mat.measured_MFR!=None else 0.)\\n \\n mat_arrays.append(mat_features)\\n \\n # Get numpy arrays.\\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\\n \\n return mat_arrays\",\n \"def calc_saturation_curves(self):\\n HEOS = CP.AbstractState(self.additional_backend, self.fluid)\\n PCSAFT = CP.AbstractState(self.backend, self.fluid)\\n self.dictL, self.dictV = {}, {}\\n for Q, dic in zip([0, 1], [self.dictL, self.dictV]):\\n # rhomolar, smolar, hmolar, T, p, umolar = [], [], [], [], [], []\\n rhomolar, T, p = [], [], []\\n for _T in np.logspace(np.log10(HEOS.keyed_output(CP.iT_triple)), np.log10(HEOS.keyed_output(CP.iT_critical)), 500):\\n try:\\n PCSAFT.update(CP.QT_INPUTS, Q, _T)\\n # print('T', PCSAFT.T())\\n # print('p', PCSAFT.p())\\n # print('rhomolar', PCSAFT.rhomolar())\\n if (PCSAFT.p() < 0): raise ValueError('P is negative:' + str(PCSAFT.p()))\\n PCSAFT.T(), PCSAFT.p(), PCSAFT.rhomolar()\\n # PCSAFT.hmolar(), PCSAFT.smolar(), PCSAFT.umolar()\\n\\n T.append(PCSAFT.T())\\n p.append(PCSAFT.p())\\n rhomolar.append(PCSAFT.rhomolar())\\n # hmolar.append(PCSAFT.hmolar())\\n # smolar.append(PCSAFT.smolar())\\n # umolar.append(PCSAFT.umolar())\\n except ValueError as VE:\\n myprint(1, 'satT error:', VE, '; T:', '{T:0.16g}'.format(T=_T), 'T/Tc:', _T / HEOS.keyed_output(CP.iT_critical))\\n\\n dic.update(dict(T=np.array(T),\\n P=np.array(p),\\n Dmolar=np.array(rhomolar)))\\n # Hmolar=np.array(hmolar),\\n # Smolar=np.array(smolar)))\\n # Umolar=np.array(umolar)))\",\n \"def logs(self):\\n dataTuples = list()\\n try:\\n with sqlite3.connect(self.db_file) as conn:\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * FROM curves\\\")\\n dataTuples = cur.fetchall()\\n return [{\\\"id\\\": a[0], \\\"name\\\": a[1], \\\"units\\\": a[2],\\n \\\"descr\\\": a[3]} for a in dataTuples]\\n except:\\n return dataTuples\",\n \"def mapped_reconstructed_data_dict(\\r\\n self,\\r\\n ) -> Dict[LinearObj, Visibilities]:\\r\\n mapped_reconstructed_data_dict = {}\\r\\n\\r\\n image_dict = self.mapped_reconstructed_image_dict\\r\\n\\r\\n for linear_obj in self.linear_obj_list:\\r\\n visibilities = self.transformer.visibilities_from(\\r\\n image=image_dict[linear_obj]\\r\\n )\\r\\n\\r\\n visibilities = Visibilities(visibilities=visibilities)\\r\\n\\r\\n mapped_reconstructed_data_dict[linear_obj] = visibilities\\r\\n\\r\\n return mapped_reconstructed_data_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60194796","0.59146357","0.5619035","0.55798995","0.55360436","0.54979974","0.54268354","0.5380969","0.53533584","0.53345037","0.5332291","0.52693045","0.52423155","0.5225769","0.52155113","0.5174672","0.51708114","0.51582485","0.51488817","0.51368886","0.51165","0.5111178","0.5093713","0.50933754","0.50664324","0.5058357","0.5046492","0.5044474","0.5043926","0.5040329","0.5037271","0.5032845","0.5027544","0.50221604","0.5014884","0.5001354","0.49968988","0.4992462","0.498691","0.49692926","0.49546313","0.4948662","0.49470717","0.49395478","0.49344057","0.4929027","0.49079084","0.49057043","0.4900124","0.48969746","0.4895901","0.48766458","0.48501307","0.48501307","0.4848168","0.4843955","0.4843152","0.48296964","0.4826359","0.48261327","0.4823839","0.48227677","0.4801273","0.47978523","0.47955775","0.4780388","0.47801477","0.47790807","0.47781873","0.4771561","0.4763709","0.47583312","0.4755895","0.4755695","0.47541124","0.4751423","0.47513962","0.4743105","0.47319856","0.47222406","0.47094506","0.4707524","0.47048432","0.47031057","0.4700041","0.46978757","0.46954724","0.4695282","0.4693548","0.46697676","0.46672547","0.4665902","0.4663704","0.46617094","0.4657355","0.4656544","0.46533668","0.46529168","0.4645248","0.4643819"],"string":"[\n \"0.60194796\",\n \"0.59146357\",\n \"0.5619035\",\n \"0.55798995\",\n \"0.55360436\",\n \"0.54979974\",\n \"0.54268354\",\n \"0.5380969\",\n \"0.53533584\",\n \"0.53345037\",\n \"0.5332291\",\n \"0.52693045\",\n \"0.52423155\",\n \"0.5225769\",\n \"0.52155113\",\n \"0.5174672\",\n \"0.51708114\",\n \"0.51582485\",\n \"0.51488817\",\n \"0.51368886\",\n \"0.51165\",\n \"0.5111178\",\n \"0.5093713\",\n \"0.50933754\",\n \"0.50664324\",\n \"0.5058357\",\n \"0.5046492\",\n \"0.5044474\",\n \"0.5043926\",\n \"0.5040329\",\n \"0.5037271\",\n \"0.5032845\",\n \"0.5027544\",\n \"0.50221604\",\n \"0.5014884\",\n \"0.5001354\",\n \"0.49968988\",\n \"0.4992462\",\n \"0.498691\",\n \"0.49692926\",\n \"0.49546313\",\n \"0.4948662\",\n \"0.49470717\",\n \"0.49395478\",\n \"0.49344057\",\n \"0.4929027\",\n \"0.49079084\",\n \"0.49057043\",\n \"0.4900124\",\n \"0.48969746\",\n \"0.4895901\",\n \"0.48766458\",\n \"0.48501307\",\n \"0.48501307\",\n \"0.4848168\",\n \"0.4843955\",\n \"0.4843152\",\n \"0.48296964\",\n \"0.4826359\",\n \"0.48261327\",\n \"0.4823839\",\n \"0.48227677\",\n \"0.4801273\",\n \"0.47978523\",\n \"0.47955775\",\n \"0.4780388\",\n \"0.47801477\",\n \"0.47790807\",\n \"0.47781873\",\n \"0.4771561\",\n \"0.4763709\",\n \"0.47583312\",\n \"0.4755895\",\n \"0.4755695\",\n \"0.47541124\",\n \"0.4751423\",\n \"0.47513962\",\n \"0.4743105\",\n \"0.47319856\",\n \"0.47222406\",\n \"0.47094506\",\n \"0.4707524\",\n \"0.47048432\",\n \"0.47031057\",\n \"0.4700041\",\n \"0.46978757\",\n \"0.46954724\",\n \"0.4695282\",\n \"0.4693548\",\n \"0.46697676\",\n \"0.46672547\",\n \"0.4665902\",\n \"0.4663704\",\n \"0.46617094\",\n \"0.4657355\",\n \"0.4656544\",\n \"0.46533668\",\n \"0.46529168\",\n \"0.4645248\",\n \"0.4643819\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75933963"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20279,"cells":{"query":{"kind":"string","value":"Produce diagnostic plots to assess the effectiveness of the correction."},"document":{"kind":"string","value":"def _diagnostic_plot(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=True)\n ax = axs[0]\n self.lc.plot(ax=ax, normalize=False, label=\"original\", alpha=0.4)\n for key in self.diagnostic_lightcurves.keys():\n (\n self.diagnostic_lightcurves[key]\n - np.median(self.diagnostic_lightcurves[key].flux)\n + np.median(self.lc.flux)\n ).plot(ax=ax)\n ax.set_xlabel(\"\")\n ax = axs[1]\n self.lc.plot(ax=ax, normalize=False, alpha=0.2, label=\"original\")\n self.corrected_lc[self.outlier_mask].scatter(\n normalize=False, c=\"r\", marker=\"x\", s=10, label=\"outlier_mask\", ax=ax\n )\n self.corrected_lc[~self.cadence_mask].scatter(\n normalize=False,\n c=\"dodgerblue\",\n marker=\"x\",\n s=10,\n label=\"~cadence_mask\",\n ax=ax,\n )\n self.corrected_lc.plot(normalize=False, label=\"corrected\", ax=ax, c=\"k\")\n return axs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def Diagnostic_plot2(self):\n\n probs = pd.read_csv(self.probfile)\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'SNR')\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n #plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')","def diagnose(self):\n return self._diagnostic_plot()","def galactic_correction_summary(self):\n t = self.GalacticCorrection(self).x\n dd = dict()\n for i,c in enumerate(t.T):\n dd[i] = dict(offset=c.mean()-1,std=c.std())\n df = pd.DataFrame(dd).T\n fig, ax = plt.subplots()\n ax.errorbar(x=range(8), y=df.offset.values, yerr=df['std'].values, fmt='o')\n ax.axhline(0, color='grey')\n ax.set(xlabel='energy band', ylabel='offset', title='galactic correction offsets')\n return fig","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n for ncl in self._ncl:\n diagUtilsLib.generate_ncl_plots(env, ncl)","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n for ncl in self._ncl:\n diagUtilsLib.generate_ncl_plots(env, ncl)","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n for ncl in self._ncl:\n diagUtilsLib.generate_ncl_plots(env, ncl)","def summarize_diagnostics(self):\n # plot loss\n pyplot.subplot(211)\n pyplot.title('Cross Entropy Loss')\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\n # plot accuracy\n pyplot.subplot(212)\n pyplot.title('Classification Accuracy')\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\n # save plot to file\n pyplot.savefig(f'{self.project_home / \"o\"}/{self.model.name}_plot.png')\n pyplot.close()","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train reconstruction errors\")\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\n axarr[1].set_title('vali reconstruction errors')\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\n axarr[2].set_title('generated reconstruction errors')\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\n axarr[3].set_title('random reconstruction errors')\n for ax in axarr:\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"bottom\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"left\"].set_visible(False)\n ax.tick_params(bottom='off', left='off')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n axarr[3].set_xlim(0, 0.05)\n plt.tight_layout()\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\n return True","def test_plotting():\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\n specs['interpolxydecs'][:, 1], specs['xopt'])\n\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\n potdata = np.vstack((xint, yint)).T\n\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\n\n expvaldata = np.vstack((expval, uncval)).T\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\n\n # qm_plottings('tests/test_data', scale=0.5)\n # assert True","def plot_proof_functions():\n\n def thm1_D(x):\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\n\n def thm2_D(x):\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 2, 1000)\n\n plt.plot(x, thm1_D(x))\n plt.xlim(0, 2)\n plt.ylim(0.15, 0.22)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\n plt.xticks(range(3), range(3))\n plt.close()\n\n print(f'Saved plot to: plots/thm1_D.pdf')\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 5, 1000)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\n plt.plot(x, thm2_D(x))\n plt.xlim(0, 5)\n plt.ylim(0, 0.4)\n plt.xticks(range(6), range(6))\n\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\n plt.close()\n\n print(f'Saved plot to: plots/thm2_D.pdf')","def visualize(self):\n\t\tplt.figure(1)\n\t\tax1 = plt.add_suplot(1,2,1)\n\t\t# Plot free energy error\n\t\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\n\t\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\n\t\tplt.legend()\n\n\t\t# Plot density error\n\n\t\t# Plot log-likelihood of test set\n\n\t\t# Plot clustering score\n\n\t\tplt.show()\n\n\t\treturn","def plot_spectrumxichange(self):\n countgood = 0 ; countbad = 0\n for idata in self.datarg:\n if idata[-1, 0] == 1.: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \n countgood += 1\n print countgood , 'good solution'\n else: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \n print countbad, 'bad solution'\n countbad += 1\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\'s what you expected' %(countgood,countbad)\n #Create custom artistsr[goodline,badline],['solution','breakdown']\n goodline = pl.Line2D((0,1),(0,0), color='b') \n badline = pl.Line2D((0,1),(0,0), color='r')\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\n self.savefig('xispec')","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def plot_field_uncertainties():\n\n resize_size = (1000, 1000)\n\n\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\n if drug_name == 'DMSO':\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/30_hours/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\n\n def transform(x):\n if type(x) is np.ndarray:\n x = change_array_lims(x)\n x = np.log(x)\n return x\n\n F_unc_vmin = -7\n F_unc_vmax = -4\n sigma_vmin = -5\n sigma_vmax = 0 #0.4\n sigma_unc_vmin = -6\n sigma_unc_vmax = -2\n\n fig_Fs = [plt.figure() for _ in range(3)]\n fig_uncertainty = plt.figure()\n sigma_lists, F_arrays = [], []\n for idx_fig, dir in enumerate(dirs):\n\n p_list = _load_and_resize_list(dir+'p_list_0.pickle')\n D_list = _load_and_resize_list(dir+'D_list_0.pickle')\n U_array = pickle.load(open(dir+'U.pickle', 'rb'))\n U_array = cv2.resize(U_array, resize_size, interpolation = cv2.INTER_LINEAR)\n Gx, Gy = np.gradient(U_array, 26./resize_size[0], 26./resize_size[0]) # gradients with respect to x and y\n F_array = (Gx**2+Gy**2)**.5 # gradient magnitude\n F_array[np.isinf(F_array)] = np.nan\n F_array[p_list[-1]<1e-3]=np.nan # final PDF\n sigma_list = []\n for j in range(9):\n arr = D_list[2*j] # current PDF\n arr[p_list[j]<1e-3]=np.nan\n sigma_list.append(np.sqrt(2*arr))\n\n\n sigma_lists.append(sigma_list)\n F_arrays.append(F_array)\n\n ax = fig_Fs[idx_fig].add_subplot(111)\n ax.imshow(transform(F_array)[::-1, :], cmap = cmap, vmin = -4.6, vmax = -2)\n ax.set_title(dir)\n\n all_axes = [i for j in fig_Fs for i in j.axes]\n for ax in all_axes:\n ax.axis('off')\n\n # uncertainties\n\n std = np.std(F_arrays, axis = 0)\n ax = fig_uncertainty.add_subplot(121)\n ax.imshow(transform(std)[::-1, :], cmap = cmap, vmin = F_unc_vmin, vmax = F_unc_vmax)\n ax.set_title('F_uncertainty')\n\n fig_sigma = plt.figure()\n ax = fig_sigma.add_subplot(111)\n ax.imshow(transform(np.nanmean(sigma_lists[0], axis = 0))[::-1, :], cmap = cmap, vmin = sigma_vmin, vmax = sigma_vmax) # index 0 (i.3 'original' is corresponds to the landscapes in other figures)\n ax.set_title('sigma_mean')\n\n sigma_means = [np.nanmean(sigma_list, axis = 0) for sigma_list in sigma_lists]\n std_array = np.nanstd(sigma_means, axis = 0)\n ax = fig_uncertainty.add_subplot(122)\n ax.imshow(transform(std_array)[::-1, :], cmap = cmap, vmin = sigma_unc_vmin, vmax = sigma_unc_vmax)\n ax.set_title('sigma_uncertainty')\n\n fig_sigma.savefig(path_to_here+'/../outputs/{}_mean_sigma.png'.format(drug_name), dpi = 1200)\n fig_uncertainty.savefig(path_to_here+'/../outputs/{}_uncertainties.png'.format(drug_name), dpi = 1200)","def quick_plot(solution):\n plt.suptitle('GNLSE solution')\n\n plt.subplot(1, 2, 1)\n plot_wavelength_vs_distance(solution)\n\n plt.subplot(1, 2, 2)\n plot_delay_vs_distance(solution)\n\n plt.show()","def interactions_plot():\n data = load_data('ints_CC'),load_data('ints_CD')\n fig,ax = plt.subplots()\n plot_mean_std(data_CC,ax,'C-C interactions')\n plot_mean_std(data_CD,ax,'C-D interactions')\n plt.xlabel('cluster size, n')\n plt.legend(loc='best')\n plt.savefig('interactions.pdf')","def robustnessPlot(ax):\n # Setup the range of avidity and ligand concentration we'll look at\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\n\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\n columns=['gnus', 'Los'])\n\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\n\n # Change avidities to strings\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\nu=' + str(int(gnu)) + '$')\n\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\n\n # Plot the calculated crossvalidation performance\n sns.FacetGrid(pp,\n hue='gnus',\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\n\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\n\n ax.set_xlabel('Assumed IC Conc. (M)')\n ax.set_ylabel('LOO Prediction R-Squared')\n ax.set_ylim(0.0, 1.0)","def plot_metric_results():\n from run_metric_comparison_experiments import (\n PIVECTOR_TEMPLATE,\n PIVECTOR_DISTANCE_MATRIX_TEMPLATE,\n DISCRIMINATOR_DISTANCE_MATRIX_TEMPLATE,\n GAUSSIAN_DISTANCE_MATRIX_TEMPLATE,\n ENCODER_DISTANCE_MATRIX_TEMPLATE,\n DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE,\n NUM_TRAJECTORIES,\n NUM_COMPONENTS,\n NUM_REPETITIONS,\n REWARD_SCALES,\n ENVS\n )\n\n # Path-templates to each distance matrix to compare\n # BC = Behavioural Characteristication\n BC_DISTANCE_MATRIX_TEMPLATES = [\n PIVECTOR_DISTANCE_MATRIX_TEMPLATE,\n GAUSSIAN_DISTANCE_MATRIX_TEMPLATE,\n DISCRIMINATOR_DISTANCE_MATRIX_TEMPLATE,\n ENCODER_DISTANCE_MATRIX_TEMPLATE,\n DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE\n ]\n\n BC_LEGEND_NAMES = [\n \"Supervector\",\n \"Gaussian\",\n \"Discriminator\",\n \"Encoder\",\n \"Discretization\"\n ]\n\n BC_PLOT_COLORS = [\n \"C0\",\n \"C1\",\n \"C2\",\n \"C3\",\n \"C4\"\n ]\n\n fig, axs = pyplot.subplots(\n figsize=[4.8 * 3 * 0.75, 4.8 * 0.75],\n nrows=1,\n ncols=3,\n )\n\n def get_policy_names(env):\n policy_names = glob(PIVECTOR_TEMPLATE.format(env=env, num_traj=\"*\", num_components=\"*\", policy_name=\"*\", repetition_num=\"*\"))\n policy_names = [\"_\".join(os.path.basename(x).split(\"_\")[-4:-2]) for x in policy_names]\n policy_names = sorted(list(set(policy_names)))\n return policy_names\n\n # For each different distance measurement\n for distance_matrix_template, plot_legend_name, plot_color in zip(BC_DISTANCE_MATRIX_TEMPLATES, BC_LEGEND_NAMES, BC_PLOT_COLORS):\n # These will be NUM_TRAJECTORY length lists\n average_scores = np.ones((len(NUM_TRAJECTORIES),))\n std_scores = np.ones((len(NUM_TRAJECTORIES),))\n for num_traj_idx, num_traj in enumerate(NUM_TRAJECTORIES):\n # Average over environments, policies and repetitions\n scores = []\n for env_i, env in enumerate(ENVS):\n if \"Bipedal\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\n print(\"[Note] Skipping env {} for discretization distances (OOM)\".format(env))\n continue\n min_reward, max_reward = REWARD_SCALES[env]\n policy_names = get_policy_names(env)\n\n for policy_name in policy_names:\n for repetition in range(1, NUM_REPETITIONS + 1):\n # Ugh bit of messing around because I did not think this through...\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\n else:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\n\n data = np.load(file_path)\n distance_matrix = data[\"distance_matrix\"]\n rewards = data[\"average_episodic_rewards\"]\n\n raveled_reward_distances = np.abs(rewards - rewards[:, None])\n # Take upper diagonal, skip diagonal\n raveled_reward_distances = raveled_reward_distances[np.triu_indices(raveled_reward_distances.shape[0], 1)]\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\n\n # Score is correlation between the two\n correlation = np.corrcoef(raveled_distances, raveled_reward_distances)[0, 1]\n scores.append(correlation)\n\n scores = np.array(scores)\n average_score = np.mean(scores)\n std_score = np.std(scores)\n average_scores[num_traj_idx] = average_score\n std_scores[num_traj_idx] = std_score\n ax = axs[0]\n ax.plot(NUM_TRAJECTORIES, average_scores, c=plot_color, label=plot_legend_name)\n ax.scatter(NUM_TRAJECTORIES, average_scores, c=plot_color)\n #ax.fill_between(\n # NUM_TRAJECTORIES,\n # average_scores - std_scores,\n # average_scores + std_scores,\n # alpha=0.2,\n # color=plot_color,\n # edgecolor=\"none\",\n # linewidth=0.0\n #)\n ax.set_xticks(NUM_TRAJECTORIES)\n ax.tick_params(axis='both', which='both', labelsize=\"x-large\")\n ax.set_ylabel(\"Correlation with return-distances\", fontsize=\"x-large\")\n ax.set_xlabel(\"Number of trajectories\", fontsize=\"x-large\")\n ax.grid(alpha=0.2)\n\n # Amount of error to \"ground truth\" result,\n # where \"ground truth\" is one of the results with 100 trajectories of data.\n # Because of wonkyness of this, store list [#num-traj] of lists,\n # each storing results for that num-traj run\n per_trajectory_relative_errors = [[] for i in NUM_TRAJECTORIES]\n for env in ENVS:\n if \"Bipedal\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\n print(\"[Note] Skipping env {} for discretization distances (OOM)\".format(env))\n continue\n policy_names = get_policy_names(env)\n for policy_name in policy_names:\n # The \"ground truth\" distances, will be filled with first\n # result with 100 trajectories.\n anchor_distance = None\n for traj_i, num_traj in enumerate(NUM_TRAJECTORIES):\n for repetition in range(1, NUM_REPETITIONS + 1):\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\n else:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\n distance_matrix = np.load(file_path)[\"distance_matrix\"]\n # Normalize to [0, 1]\n distance_matrix = (distance_matrix - distance_matrix.min()) / (distance_matrix.max() - distance_matrix.min())\n # Get only upper triangle as distance matrix is symmetric. Exlude diagonal\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\n # Check if we use this as the zero-point or compute relative error to\n if anchor_distance is None:\n assert num_traj == 100\n anchor_distance = raveled_distances\n else:\n per_trajectory_relative_errors[traj_i].append(\n np.mean(np.abs(raveled_distances - anchor_distance) / np.abs(anchor_distance))\n )\n # Lists are not of equal length, so can not just change into an array\n mean_average_errors = np.array([np.mean(np.array(results) * 100) for results in per_trajectory_relative_errors])\n std_average_errors = np.array([np.std(np.array(results) * 100) for results in per_trajectory_relative_errors])\n ax = axs[1]\n ax.plot(NUM_TRAJECTORIES, mean_average_errors, c=plot_color, label=plot_legend_name)\n ax.scatter(NUM_TRAJECTORIES, mean_average_errors, c=plot_color)\n #ax.fill_between(\n # NUM_TRAJECTORIES,\n # mean_average_errors - std_average_errors,\n # mean_average_errors + std_average_errors,\n # alpha=0.2,\n # color=plot_color,\n # edgecolor=\"none\",\n # linewidth=0.0\n #)\n ax.set_xticks(NUM_TRAJECTORIES)\n ax.tick_params(axis='both', which='both', labelsize=\"x-large\")\n ax.set_ylabel(\"Relative error to ground truth (%)\", fontsize=\"x-large\")\n ax.set_xlabel(\"Number of trajectories\", fontsize=\"x-large\")\n ax.grid(alpha=0.2)\n\n # Variation between results\n cv_means = np.ones((len(NUM_TRAJECTORIES,)))\n cv_stds = np.ones((len(NUM_TRAJECTORIES,)))\n for traj_i, num_traj in enumerate(NUM_TRAJECTORIES):\n traj_averaged_cvs = []\n for env in ENVS:\n if \"Bipedal\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\n print(\"[Note] Skipping env {} for discretization distances (OOM)\".format(env))\n continue\n policy_names = get_policy_names(env)\n for policy_name in policy_names:\n # Compute std over repetitions\n distances = []\n for repetition in range(1, NUM_REPETITIONS + 1):\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\n else:\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\n\n distance_matrix = np.load(file_path)[\"distance_matrix\"]\n # Normalize to [0, 1]\n distance_matrix = (distance_matrix - distance_matrix.min()) / (distance_matrix.max() - distance_matrix.min())\n # Get only upper triangle as distance matrix is symmetric. Exlude diagonal\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\n distances.append(raveled_distances)\n distances = np.stack(distances)\n # Coefficient of variance (std / mean)\n average_cv = np.mean(np.std(distances, axis=0) / np.mean(distances, axis=0))\n traj_averaged_cvs.append(average_cv)\n traj_averaged_cvs = np.array(traj_averaged_cvs)\n cv_means[traj_i] = np.mean(traj_averaged_cvs)\n cv_stds[traj_i] = np.std(traj_averaged_cvs)\n\n ax = axs[2]\n ax.plot(NUM_TRAJECTORIES, cv_means, c=plot_color, label=plot_legend_name)\n ax.scatter(NUM_TRAJECTORIES, cv_means, c=plot_color)\n #ax.fill_between(\n # NUM_TRAJECTORIES,\n # cv_means - cv_stds,\n # cv_means + cv_stds,\n # alpha=0.2,\n # color=plot_color,\n # edgecolor=\"none\",\n # linewidth=0.0\n #)\n ax.set_xticks(NUM_TRAJECTORIES)\n ax.tick_params(axis='both', which='both', labelsize=\"x-large\")\n ax.set_ylabel(\"Coefficient of variance $\\\\sigma/\\\\mu$\", fontsize=\"x-large\")\n ax.set_xlabel(\"Number of trajectories\", fontsize=\"x-large\")\n ax.grid(alpha=0.2)\n\n axs[1].legend(prop={\"size\": \"large\"})\n pyplot.tight_layout()\n pyplot.savefig(\"figures/metric_comparison.pdf\", bbox_inches=\"tight\", pad_inches=0.0)","def analysis_plot(predictions, ys):\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\n\n residuals = ys - predictions\n\n # Plot 1 - Predicted vs Actual\n sns.scatterplot(predictions, ys, ax=ax1)\n ax1.set_title('Predicted vs Actual', fontsize=20)\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\n\n # Plot 2 - Residuals PLot (predicted vs residuals)\n sns.scatterplot(predictions, residuals, ax=ax2)\n ax2.set_title('Residuals Plot', fontsize=20)\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\n\n # Plot 3 - QQ Plot\n sm.qqplot(residuals, ax=ax3, line='s')\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\n\n plt.show();","def compareRepeatability():\n fc,pc = refCylNoise()\n fp,pp = flatNoisePellicle()\n fcgh,pcgh = flatNoiseCGH()\n fpco,ppco = PCO1S12Noise()\n\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([fp,fc,fcgh,fpco],[pp,pc,pcgh,ppco])]\n plt.clf()\n \n plt.loglog(fp,pp/fp[0],label='Flat+Pellicle: %.2f' % midfreq[0])\n plt.loglog(fc,pc/fc[0],label='Cylinder+CGH: % .2f' % midfreq[1])\n plt.loglog(fcgh,pcgh/fcgh[0],label='Flat+CGH: %.2f' % midfreq[2])\n plt.loglog(fpco,ppco/fpco[0],label='PCO1S12: %.2f' % midfreq[3])\n plt.title('Repeatability Comparison')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n plt.legend(loc='lower left')","def small_signal_mobility_paperplot(fieldVector, freqVector, df):\n vcm = np.array(fieldVector)*1e-2\n n = utilities.calculate_density(df)\n lw = 1.5\n fig, ax = plt.subplots()\n for freq in freqVector:\n cond = []\n mu_3 = []\n for ee in fieldVector:\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\n cond.append(np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n ax.plot(vcm, np.array(np.real(cond))/c.e/n*100**2, '-', label='{:.1f} GHz'.format(freq),linewidth=lw)\n ax.plot(vcm,mu_3,'-',label = 'Ohmic Mobility',linewidth=lw)\n plt.xlabel(r'Field ($\\rm V \\, cm^{-1}$)')\n plt.ylabel(r'AC Mobility ($\\rm cm^2 \\, V^{-1} \\, s^{-1}$)')\n plt.ylim([-0.05*np.max(mu_3),np.max(mu_3)*1.2])\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\n plt.legend(ncol=3,loc='lower center')\n plt.savefig(pp.figureLoc+'ac_mobility.png', bbox_inches='tight',dpi=600)\n\n\n plt.figure(figsize=(2.05, 2.5))\n ax = plt.axes([0.21, 0.19, 0.75, 0.75])\n i = 0\n for ee in fieldVector:\n colorList = [eq_color, med_color, high_color]\n cond = []\n cond_linear = []\n mu_3 = []\n for freq in freqVector:\n mu_3 = []\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\n cond.append(np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n cond_linear.append(np.load(pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n ax.plot(freqVector, np.array(np.real(cond))/c.e/n*100**2/1000, '-',\n label='{:.0f} '.format(ee/100)+r'$\\rm V \\, cm^{-1}$', linewidth=lw, color=colorList[i])\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\, cm^{-1}$',linewidth=lw,color = colorList[i])\n i = i + 1\n\n plt.xlabel(r'Frequency (GHz)')\n plt.ylabel(r'$\\Re(\\rm AC\\ mobility$) (1000 $\\rm cm^2 \\, V^{-1}\\, s^{-1}$)')\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\n plt.xscale('log')\n plt.legend(frameon=False)\n plt.ylim([0, 20])\n plt.xlim([freqs[0], freqs[-1]])\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\n ax.yaxis.set_major_formatter(FormatStrFormatter('%.0f'))\n plt.xlim([freqVector[0],freqVector[-1]])\n locmaj = matplotlib.ticker.LogLocator(base=10, numticks=6)\n ax.xaxis.set_major_locator(locmaj)\n locmin = matplotlib.ticker.LogLocator(base=10.0, subs=np.arange(2, 10) * .1,\n numticks=100)\n ax.xaxis.set_minor_locator(locmin)\n plt.savefig(pp.figureLoc+'Real_ac_mobility.png',dpi=600)\n\n fig, ax = plt.subplots()\n i = 0\n for ee in fieldVector:\n colorList = ['black', 'dodgerblue', 'tomato']\n cond = []\n cond_linear = []\n mu_3 = []\n\n for freq in freqVector:\n mu_3 = []\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\n cond.append(\n np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n cond_linear.append(np.load(\n pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n\n ax.plot(freqVector, np.array(np.imag(cond)) / c.e / n * 100 ** 2, '-',\n label='{:.0f} '.format(ee / 100) + r'$\\rm V \\, cm^{-1}$', linewidth=lw, color=colorList[i])\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\, cm^{-1}$',linewidth=lw,color = colorList[i])\n\n i = i + 1\n plt.xlabel(r'Frequency ($\\rm GHz$)')\n plt.ylabel(r'$\\Im \\, [\\mu_{\\omega}]$ ($\\rm cm^2 \\, V^{-1}\\, s^{-1}$)')\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\n plt.xscale('log')\n plt.legend(frameon=False)\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\n plt.savefig(pp.figureLoc + 'Imag_ac_mobility.png', bbox_inches='tight', dpi=600)\n\n\n fig, ax = plt.subplots()\n i = 0\n for ee in fieldVector:\n colorList = ['black', 'dodgerblue', 'tomato']\n cond = []\n cond_linear = []\n mu_3 = []\n\n for freq in freqVector:\n mu_3 = []\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\n cond.append(\n np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n cond_linear.append(np.load(\n pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \"f_{:.1e}_E_{:.1e}.npy\".format(freq, ee)))\n\n ax.plot(freqVector, np.array(np.arctan(np.imag(cond)/np.real(cond)))/np.pi, '-',\n label='{:.0f} '.format(ee / 100) + r'$\\rm V \\, cm^{-1}$', linewidth=lw, color=colorList[i])\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\, cm^{-1}$',linewidth=lw,color = colorList[i])\n i = i + 1\n ax.yaxis.set_major_formatter(tck.FormatStrFormatter('%g $\\pi$'))\n ax.yaxis.set_major_locator(tck.MultipleLocator(base=1.0))\n plt.xlabel(r'Frequency ($\\rm GHz$)')\n plt.ylabel(r'AC Mobility Phase Angle (Radians)')\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\n plt.xscale('log')\n plt.legend()\n yloc = plt.MaxNLocator(6)\n ax.yaxis.set_major_locator(yloc)\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\n plt.savefig(pp.figureLoc + 'Phase_ac_mobility.png', bbox_inches='tight', dpi=600)","def plot_diagnostics(foldspec, flag, mask):\n \n plt.figure(figsize=(15,10))\n \n plt.subplot(231)\n plt.plot(foldspec.mean(0).mean(0), color='k')\n plt.xlabel('phase (bins)')\n plt.ylabel('I (arb.)')\n plt.title('Pulse Profile')\n plt.xlim(0, foldspec.shape[-1])\n \n plt.subplot(232)\n plt.title('RFI flagging parameter (log10)')\n plt.xlabel('time (bins)')\n plt.ylabel('freq (bins)')\n plt.imshow(np.log10(flag).T, aspect='auto')\n\n plt.subplot(233)\n plt.title('Manual off-gate scaling')\n plt.imshow(mask.T, aspect='auto', cmap='Greys')\n plt.xlabel('time (bins)')\n \n plt.subplot(234)\n plt.imshow(foldspec.mean(0), aspect='auto')\n plt.xlabel('phase')\n plt.ylabel('freq')\n\n plt.subplot(235)\n plt.imshow(foldspec.mean(1), aspect='auto')\n plt.xlabel('phase')\n plt.ylabel('time')\n\n plt.subplot(236)\n plt.imshow(foldspec.mean(2).T, aspect='auto')\n plt.xlabel('time')\n plt.ylabel('freq')","def save_figs(self):\n if not self._fitted:\n self.fit()\n #self._message(\"Saving plots...\")\n # 1. Generate the required PNG plots\n # 1.1 Truncation plots\n for i,s in enumerate(self.samples):\n fig,ax=plt.subplots(1,2,figsize=(8,4))\n cyct=np.arange(self.nvalues)\n cycf=np.arange(self._cutoffidx[i])\n cycd=0.5*(cyct[1:]+cyct[:-1])\n ax[0].plot(cyct,self.samplesdata[:,i],'k.-',linewidth=0.5,label=\"Full series\")\n ax[0].plot(cycf,self.samplesdata[:self._cutoffidx[i],i],'r-',linewidth=1,label=\"Truncated\")\n ax[0].set_xlim([0,self.nvalues-1])\n ax[0].set_ylim([0,self.samplesdata.max()*1.1])\n ax[0].set_xlabel(\"Cycle\")\n ax[0].set_ylabel(\"Fluorescence (a.u.)\")\n ax[0].set_title(\"Detected fluorescence\")\n plt.legend(loc='upper left',frameon=False)\n # First derivative\n ax[1].plot(cycd,self.samplesdatadiff[:,i],'k.-',linewidth=0.5)\n ax[1].axvline(self._cutoffidx[i],color='r')\n ax[1].set_xlim([0,self.nvalues-1])\n ax[1].set_ylim([self.samplesdatadiff.min()*1.1,self.samplesdatadiff.max()*1.1])\n ax[1].set_xlabel(\"Cycle\")\n ax[1].set_ylabel(\"dF/dCycle (a.u.)\")\n ax[1].set_title(\"Fluorescence rate\")\n plt.tight_layout()\n fn=get_valid_fname(self.samples[i])\n figname=\"%s_%s_%s.svg\"%(self.ID,\"01truncation\",fn)\n self.info['samples'][s]['Data truncation for fitting']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n plt.close() \n # 1.2 Fitting plots\n for i,s in enumerate(self.samples):\n fig,ax=plt.subplots(1,3,figsize=(12,4))\n cyct=np.arange(self.nvalues)\n cycf=np.arange(self._cutoffidx[i])\n ax[0].plot(cyct,self.samplesdata[:,i],'k:',linewidth=0.5,label=\"Full series\")\n ax[0].plot(cycf,self.samplesdata[:self._cutoffidx[i],i],'r.-',linewidth=0.5,label=\"Truncated\")\n #ax[0].plot(cycf,self.mak3fpre[s],'y-',linewidth=1,label=\"prefit\")\n ax[0].plot(cycf,self.mak3fluorescence[s],'g-',linewidth=1,label=\"MAK3 fit\")\n ax[0].axvline(self._cutoffidx[i],color='k')\n ax[0].set_xlim([0,self.nvalues-1])\n ax[0].set_ylim([0,self.samplesdata.max()*1.1])\n ax[0].set_xlabel(\"Cycle\")\n ax[0].set_ylabel(\"Fluorescence (a.u.)\")\n ax[0].set_title(\"Detected fluorescence\")\n ax[0].legend(loc='upper left',frameon=False)\n # DNA levels\n ax[1].plot(cycf,self.mak3concentration[s],'g-',linewidth=1,label=\"MAK3\")\n ax[1].axvline(self._cutoffidx[i],color='k')\n ax[1].set_xlim([0,self.nvalues-1])\n ax[1].set_ylim([0,self.mak3concentration[s].max()*1.1])\n ax[1].set_xlabel(\"Cycle\")\n ax[1].set_ylabel(\"concentration (a.u.)\")\n ax[1].set_title(\"estimated cDNA levels\")\n # Efficiency\n ax[2].plot(cycf,self.mak3efficiency[s],'b-',linewidth=1,label=\"MAK3\")\n ax[2].axvline(self._cutoffidx[i],color='k')\n ax[2].set_xlim([0,self.nvalues-1])\n ax[2].set_ylim([0,1.1])\n ax[2].set_xlabel(\"Cycle\")\n ax[2].set_ylabel(\"Efficiency\")\n ax[2].set_title(\"Amplification efficiency\") \n plt.tight_layout()\n fn=get_valid_fname(self.samples[i])\n figname=\"%s_%s_%s.svg\"%(self.ID,\"02mak3\",fn)\n self.info['samples'][s]['MAK3 Fitting']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n plt.close()\n # 2 Initial concentrations\n figwdth=np.maximum(5,0.4*self.nsamples+1)\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\n v=list(self.initialConcentration.values())\n k=list(self.initialConcentration.keys())\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\n ax.set_xticks(1+np.arange(self.nsamples))\n ax.set_xticklabels(k,rotation=90)\n ax.set_xlim([0,self.nsamples+1])\n plt.tight_layout()\n figname=\"%s_%s_.svg\"%(self.ID,\"00initialConcentration\")\n self.info['figname_initialConcentration']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n plt.close()\n # 3 Fitting Error\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\n v=list(self.fitting_error.values())\n k=list(self.fitting_error.keys())\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\n ax.set_xticks(1+np.arange(self.nsamples))\n ax.set_xticklabels(k,rotation=90)\n ax.set_xlim([0,self.nsamples+1])\n ax.set_ylim([0,1e-2])\n plt.tight_layout()\n figname=\"%s_%s_.svg\"%(self.ID,\"00fittingError\")\n self.info['figname_fittingError']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n # 4 kinetic constant\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\n v=list(self.k.values())\n k=list(self.k.keys())\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\n ax.set_xticks(1+np.arange(self.nsamples))\n ax.set_xticklabels(k,rotation=90)\n ax.set_xlim([0,self.nsamples+1])\n plt.tight_layout()\n figname=\"%s_%s_.svg\"%(self.ID,\"00kineticConstant\")\n self.info['figname_k']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n # 5 background fluorescence\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\n v=list(self.Fb.values())\n k=list(self.Fb.keys())\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\n ax.set_xticks(1+np.arange(self.nsamples))\n ax.set_xticklabels(k,rotation=90)\n ax.set_xlim([0,self.nsamples+1])\n plt.tight_layout()\n figname=\"%s_%s_.svg\"%(self.ID,\"00bkgFluorescence\")\n self.info['figname_Fb']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\n # 6 slope\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\n v=list(self.slope.values())\n k=list(self.slope.keys())\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\n ax.set_xticks(1+np.arange(self.nsamples))\n ax.set_xticklabels(k,rotation=90)\n ax.set_xlim([0,self.nsamples+1])\n ax.set_ylim([0,0.025])\n plt.tight_layout()\n figname=\"%s_%s_.svg\"%(self.ID,\"00fluorescenceSlope\")\n self.info['figname_slope']=figname\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def create_plots(initial_condition, flux):\n \n# Path to the hdf5 file containing results of computations\n computations_database = h5py.File(database_path, \"r\")\n \n# Path to the data group containing the computational data\n group_path = initial_condition + \"/\" + flux\n \n# Path to the highest grid resolution data (k = 16)\n dataset_path = group_path + \"/k = \" + str(16)\n# Adjust the plot window to the maximum and minimum values the computed solution attains \n ymax = asarray(computations_database[dataset_path]).max()\n ymin = asarray(computations_database[dataset_path]).min()\n pyplot.ylim(ymax = ymax*1.2)\n pyplot.ylim(ymin = ymin*1.2)\n \n# Path to the initial condition dataset \n dataset_initial_path = initial_condition + \"/k = \" + str(16) + \" initial_data\"\n \n# The title of the plot, containing relevant information about the computation \n title = \"{group_path}: CFL = {CFL}, a = {a}\".format(\n group_path = group_path.replace(\"/\", \", \"), \n CFL = computations_database[group_path].attrs[\"CFL\"], \n a = computations_database[group_path].attrs[\"a\"]\n )\n \n# Define the title and axes' labels; enable grid in the plot's background\n pyplot.title(title)\n pyplot.xlabel(\"x\")\n pyplot.ylabel(\"u(x, t = 9)\")\n pyplot.grid(True)\n\n# Define the grid against which data should be ploted, i.e. uniform grid with stepsize 2^(-16)\n x = numpy.linspace(0, 1, 2**16)\n# Plot the initial data \n pyplot.plot(x, computations_database[dataset_initial_path])\n\n# Include the initial data legend in the array of all legends which will be displayed in the plot\n legend_labels = [\"Initial Data\"]\n# Plot the legend for the initial data \n pyplot.legend(legend_labels)\n\n# Plot solutions corresponding to grid stepsizes 2^(-10), 2^(-12), 2^(-14), and 2^(-16),\n for k in range(10, 17, 2):\n x = numpy.linspace(0, 1, 2**k) \n \n dataset_path = group_path + \"/k = \" + str(k)\n \n pyplot.plot(x, computations_database[dataset_path])\n \n# Append the legend text corresponding to the current computation to the array of legends\n legend_labels.append(\"k = \" + str(k))\n# Plot the newly appended legend; ncol - number of columns, fancybox - rounded corners of the box enclosing the legend text\n pyplot.legend(legend_labels, ncol = 3, fancybox = True, fontsize = \"small\")\n\n# Output plots in two formats to be used in the website \n pyplot.savefig(html_path + \"images/\" + group_path.replace(\"/\",\"_\") + \".png\")\n pyplot.savefig(html_path + \"pdf/plots/\" + group_path.replace(\"/\",\"_\") + \".pdf\")\n pyplot.close()\n \n computations_database.close()","def residual_plots(test_data, mods, station=None, squared=False):\r\n import config\r\n learning_var = config.learning_var\r\n data = test_data.get_miniOD()\r\n mods.models[0].mod.load()\r\n pred = mods.models[0].mod.predict(test_data)\r\n test_data.miniOD = None\r\n if squared:\r\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\r\n else:\r\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\r\n ind = data[data['Annee'] == 0].index\r\n data.drop(ind, inplace=True)\r\n print(data.columns.values)\r\n i = 0\r\n if station is None:\r\n ch_an = test_data.get_stations_col(2015)\r\n else:\r\n ch_an = 'End date ' + str(station)\r\n for ch in learning_var:\r\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\r\n # data.boxplot(ch_an, by=ch)\r\n # if ch != 'Heure':\r\n plt.figure(i // 9)\r\n # plt.title('squared error / expectation')\r\n fig = plt.subplot(3, 3, (i % 9) + 1)\r\n i += 1\r\n # fig = plt.figure().add_subplot(111)\r\n fig.set_xlabel(ch)\r\n if squared:\r\n fig.set_ylabel('error²')\r\n else:\r\n fig.set_ylabel('error')\r\n l = []\r\n xaxis = np.unique(data[ch])\r\n print(ch, xaxis.shape)\r\n if xaxis.shape[0] < 20 or ch == 'Heure':\r\n for u in xaxis:\r\n l.append(data[ch_an][data[ch] == u])\r\n else:\r\n m = np.min(data[ch])\r\n M = np.max(data[ch])\r\n step = (M - m) / 20\r\n xaxis = np.arange(m, M, step)\r\n for u in xaxis:\r\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\r\n xaxis = xaxis.astype(int)\r\n # fig = plt.boxplot(ch_an, by=ch)\r\n # g = data.groupby(ch).mean()[ch_an]\r\n # v = data.groupby(ch).std()[ch_an]\r\n plt.boxplot(l, labels=xaxis)\r\n if squared:\r\n plt.ylim((0, 12))\r\n else:\r\n plt.ylim((-5, 5))\r\n # plt.plot(g, '-r')\r\n # plt.plot(g + v, ':r')\r\n # plt.plot(g - v, ':r')\r\n plt.show()","def plot_variables(self, n, show=False, diagnostics=False):\n\n if diagnostics:\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\n else:\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\n\n plt.subplots_adjust(hspace = 0)\n end = len(n.history[\"det F\"])\n epochs = np.arange(end)\n a, = ax[0].plot(epochs, n.history[\"det F\"], label = 'Training data')\n b, = ax[0].plot(epochs, n.history[\"det test F\"], label = 'Test data')\n # ax[0].axhline(y=5,ls='--',color='k')\n ax[0].legend(frameon = False)\n ax[0].set_ylabel(r'$|{\\bf F}_{\\alpha\\beta}|$')\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\"det test F\"][-1])\n ax[1].plot(epochs, n.history[\"loss\"])\n ax[1].plot(epochs, n.history[\"test loss\"])\n # ax[1].set_xlabel('Number of epochs')\n ax[1].set_ylabel(r'$\\Lambda$')\n ax[1].set_xlim([0, len(epochs)]);\n \n if diagnostics:\n ax[2].plot(epochs, n.history[\"det C\"])\n ax[2].plot(epochs, n.history[\"det test C\"])\n # ax[2].set_xlabel('Number of epochs')\n ax[2].set_ylabel(r'$|{\\bf C}|$')\n ax[2].set_xlim([0, len(epochs)]);\n \n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,0]\n , color = 'C0', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,1]\n , color = 'C0', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n \"\"\"\n\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,0]\n , color = 'C1', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,1]\n , color = 'C1', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n ax[3].legend(frameon=False)\n \"\"\"\n\n ax[3].set_ylabel(r'$\\partial\\mu/\\partial\\theta$')\n # ax[3].set_xlabel('Number of epochs')\n ax[3].set_xlim([0, len(epochs)])\n\n # Mean of network output summary 1\n ax[4].plot(epochs, np.array(n.history[\"μ\"])[:,0],alpha=0.5)\n # Mean of test output network summary 1\n ax[4].plot(epochs, np.array(n.history[\"test μ\"])[:,0],alpha=0.5)\n ax[4].set_ylabel('μ')\n ax[4].set_xlabel('Number of epochs')\n ax[4].set_xlim([0, len(epochs)])\n \n\n print ('Maximum Fisher info on train data:',np.max(n.history[\"det F\"]))\n print ('Final Fisher info on train data:',(n.history[\"det F\"][-1]))\n \n print ('Maximum Fisher info on test data:',np.max(n.history[\"det test F\"]))\n print ('Final Fisher info on test data:',(n.history[\"det test F\"][-1]))\n\n if np.max(n.history[\"det test F\"]) == n.history[\"det test F\"][-1]:\n print ('Promising network found, possibly more epochs needed')\n\n plt.tight_layout()\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def all_conditions_visualized(self):\n # group dataframe based on standard deviation and effect size\n grouped_df = self.df.groupby([\"es\", \"sd1\", \"samp2\"])\n results = self.helpers.get_mean_df(grouped_df, False)\n print(results.sample())\n\n # seperate groups based on typeI or typeII error\n dfs = {\"typeI_df\": results[:8*7],\n \"ef_0_2\": results[8*7:8*7*2],\n \"ef_0_5\": results[8*7*2:8*7*3],\n \"ef_0_8\": results[8*7*3:]}\n\n for i in dfs:\n sdI = self.get_sd_list(dfs[i], False)\n dictI = {\"xlabel\": 'Group sizes', \"ylabel\": \"TypeI error\",\n \"title\": \"Mean typeI error per group size\",\n \"xtickslabels\": sdI}\n self.multiple_bars(dfs[i], 2, 2, dictI)","def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\n\tcompObserved = []\n\tSStotalWarmth = 0\n\tSSresWarmth = 0\n\tSStotalComp = 0\n\tSSresComp = 0\n\tkeys = parser.getMappings(normalized)[0].keys()\n\tfor key in keys:\n\n\t\tif \"_\" in key:\n\t\t\twarmthAxis, compAxis = getPlotData(key)\n\t\t\twarmthPred.append(warmthAxis[3])\n\t\t\twarmthObserved.append(warmthAxis[2])\n\t\t\tcompPred.append(compAxis[3])\n\t\t\tcompObserved.append(compAxis[2])\n\n\tmeanObservedWarmth = np.mean(warmthObserved)\n\tmeanObservedComp = np.mean(compObserved)\n\tfor i in range(0, len(warmthObserved)):\n\t\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\n\t\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\n\t\tSStotalComp += (compObserved[i] - meanObservedComp)**2\n\t\tSSresComp += (compObserved[i] - compPred[i])**2\n\n\n\tplt.axis([0, 100, 0, 100])\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.title(\"Observed vs Predicted Warmth\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(warmthObserved, warmthPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.axis([0, 100, 0, 100])\n\tplt.title(\"Observed vs Predicted Competence\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(compObserved, compPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()","def plot(self, solution: Matrix) -> None:\n plots.plot_matrices(\"Total Variation Denoising\", self.M, solution)","def plotErr(self):\n if self.xp and self.wp:\n # plot the spectra\n w=self.ws.value(np.array(self.xp))\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\n if self.dxp and self.dwp:\n # plot the spectra\n dw=self.ws.value(np.array(self.dxp))\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')","def AGN_SB_diagnostic(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n\n fig,ax = plt.subplots()\n L_CII = getattr(GR,'L_[CII]158_sun')\n\n # x = getattr(GR,'L_[CII]158_sun')/getattr(GR,'L_[NII]122_sun')\n x = getattr(GR,'L_[OIV]25_sun')/getattr(GR,'L_[OIII]88_sun')\n y = getattr(GR,'L_[NeIII]15_sun')/getattr(GR,'L_[NeII]12_sun')\n sc = ax.scatter(x,y,marker='o',s=3,alpha=0.6,c=np.log10(getattr(GR,'SFR')))\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlim([8e-5,200])\n ax.set_ylim([0.02,150])\n # ax.set_xlabel('[CII]$_{158}$/[NII]$_{122}$')\n plt.colorbar(sc,label='log(SFR)')\n ax.set_xlabel('[OIV]$_{25.9}$/[OIII]$_{88}$')\n ax.set_ylabel('[NeIII]$_{15.6}$/[NeII]$_{12.8}$')\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/ratio_%s' % ratio_name,dpi=300)","def plot_hist_snfit_meta(self): \n \n self.read_meta()\n self.read_snfit_results()\n\n \n self.diff_x0 = []\n self.diff_x0_err = []\n self.diff_x1 = []\n self.diff_x1_err = [] \n self.diff_c = []\n self.diff_c_err = [] \n self.diff_mb = []\n self.diff_mb_err = [] \n self.diff_cov_x0_x1 = []\n self.diff_cov_x0_c = []\n self.diff_cov_x1_c = []\n self.diff_cov_mb_x1 = []\n self.diff_cov_mb_c = []\n\n for i in range (len(self.sn_name)):\n for j in range (len(self.meta_sn_name_list)):\n if self.sn_name[i] == self.meta_sn_name_list[j]:\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \n self.diff_c.append(self.c[i] - self.meta_c[j])\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\n# self.diff_cov_x0_x1.append()\n# self.diff_cov_x0_c.append()\n# self.diff_cov_x1_c.append()\n# self.diff_cov_mb_x1.append()\n# self.diff_cov_mb_c.append()\n else:\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\n\n\n fig = plt.figure(figsize=(8.,8.)) \n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x0,25,label='$\\Delta$ X0')\n ax0_2.hist(self.diff_x0_err,25,label='$\\Delta$ X0 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x1,25,label='$\\Delta$ X1')\n ax0_2.hist(self.diff_x1_err,25,label='$\\Delta$ X1 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_c,25,label='$\\Delta$ Color')\n ax0_2.hist(self.diff_c_err,25,label='$\\Delta$ Color error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n\n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_mb,50,label='$\\Delta$ mb')\n ax0_2.hist(self.diff_mb_err,50,label='$\\Delta$ mb error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def prob4():\n #get Omega, F, and initialize\n Omega = np.array([[-3/2,3/4],[0,1],[0,1/2],[0,1]])\n f = lambda x: np.exp(np.sum(-x**2/2,axis=0))/(2*np.pi)**(2)\n means, cov = np.zeros(4), np.eye(4)\n truth = scipy.stats.mvn.mvnun(list(Omega[:,0]),list(Omega[:,1]), means, cov)[0]\n domain = np.logspace(1,5,20)\n approxs = []\n error = []\n for N in domain:\n #calculate approx for various sizes of samples\n approx = mc_integrate(f,Omega[:,0],Omega[:,1],N)\n approxs.append(approx)\n #calculate relative err.\n error.append(np.abs((truth-approx)/truth))\n #PLOT it all\n plt.title(\"Error vs Sample Size\")\n plt.plot(domain,1/np.sqrt(domain),label = \"1/sqrt(N)\")\n plt.plot(domain,error,label = \"Error\")\n plt.loglog()\n plt.xlabel(\"N\")\n plt.ylabel(\"Relative Error\")\n plt.legend()\n plt.show()","def test_9(self):\n\n sq_qe = gen_step_qe(1.42, 0.9)\n test_ill = Illumination()\n # test_qef = qe_filter(sq_qe)\n\n filtered_ill = test_ill * sq_qe\n\n assert isinstance(filtered_ill, Illumination)\n\n #plt.plot(filtered_ill.get_spectrum('eV')[0, :], filtered_ill.get_spectrum('eV')[1, :], label=\"filtered\")\n #plt.plot(test_ill.get_spectrum('eV')[0, :], test_ill.get_spectrum('eV')[1, :], label=\"original\")\n\n #plt.xlabel('wavelength (eV)')\n #plt.ylabel('spectrum (W/eV/m^2)')\n\n #plt.legend()\n\n #plt.show()","def diagnosticos(): \r\n global rhoe,Ex,npuntos_malla,itiempo,longitud_malla,rho0,aP,v1,v2,F\r\n global EnergiaK, EnergiaP, EnergiaT, emax\r\n global iout,igrafica,ifase,ivdist, distribucion\r\n global Archivos_Densidades, Archivos_Campo, Archivos_Efase, Archivos_Fdistribucion\r\n \r\n # Se crea el eje para graficar las cantidades fisicas involucradas:\r\n xgrafica = dx * sp.arange(npuntos_malla+1)\r\n \r\n if (itiempo == 0): \r\n plt.figure('Cantidades')\r\n plt.clf()\r\n \r\n if (igrafica > 0):\r\n # Se grafica cada paso dado por el contador igrafica:\r\n if (sp.fmod(itiempo,igrafica) == 0): \r\n # Densidad total\r\n plt.figure(1)\r\n if (itiempo >0 ): plt.cla()\r\n plt.plot(xgrafica, -(rhoe+rho0), 'r', label='Densidad')\r\n plt.xlabel('x')\r\n plt.xlim(0,longitud_malla)\r\n plt.ylim(-1.5,1.5)\r\n plt.legend(loc=1)\r\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\r\n plt.pause(0.0001)\r\n plt.draw()\r\n filename = '%0*d_densidad'%(5, itiempo)\r\n Archivos_Densidades[itiempo] = filename\r\n if (iout > 0):\r\n if (sp.fmod(itiempo,iout) == 0): \r\n plt.savefig(filename+'.png',dpi=720)\r\n \r\n # Campo electrico\r\n plt.figure(2)\r\n if (itiempo >0 ): plt.cla()\r\n plt.plot(xgrafica, Ex, 'b' , label = 'Ex')\r\n plt.xlabel('x', fontsize = 18)\r\n plt.ylabel('Ex', fontsize = 18)\r\n plt.xticks(np.linspace(0,16,4), fontsize = 18)\r\n plt.yticks(np.linspace(-0.0010,0.0010,5), fontsize = 18)\r\n plt.xlim(0,longitud_malla)\r\n plt.ylim(-0.0015,0.0015)\r\n plt.legend(loc = 1)\r\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\r\n plt.pause(0.0001)\r\n plt.draw()\r\n filename = '%0*d_campoelectrico'%(5, itiempo)\r\n Archivos_Campo[itiempo] = filename\r\n if (iout > 0):\r\n if (sp.fmod(itiempo,iout) == 0): \r\n plt.savefig(filename+'.png',dpi=720)\r\n \r\n if (ifase > 0):\r\n if (sp.fmod(itiempo,ifase) == 0): \r\n # Se grafica el espacio de fase en el paso dado por el contador ifase:\r\n plt.figure(3)\r\n if (itiempo >0 ): plt.cla()\r\n v1 = sp.zeros(nparticulas)\r\n v2 = sp.zeros(nparticulas)\r\n x1 = sp.zeros(nparticulas)\r\n x2 = sp.zeros(nparticulas)\r\n for i in range(nparticulas):\r\n if (v[i-1]>v[i]):\r\n v1[i]=v[i]\r\n x1[i]=x[i]\r\n elif(v[i-1]<v[i]):\r\n v2[i]=v[i]\r\n x2[i]=x[i] \r\n if(distribucion == 0):\r\n plt.scatter(x,v,marker='.',s=0.1,color='black') \r\n elif(distribucion == 1 or distribucion == 2):\r\n plt.scatter(x1,v1,marker='.',s=0.1,color='red') \r\n plt.scatter(x2,v2,marker='.',s=0.1,color='blue')\r\n plt.xticks(np.linspace(0,100,6), fontsize = 18)\r\n plt.yticks(np.linspace(-8,8,5), fontsize = 18)\r\n plt.xlabel('x', fontsize = 18)\r\n plt.ylabel('v', fontsize = 18)\r\n plt.xlim(0,longitud_malla)\r\n plt.ylim(-4,8)\r\n\r\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\r\n plt.pause(0.0001)\r\n plt.draw()\r\n filename = '%0*d_espaciofase'%(5, itiempo)\r\n Archivos_Efase[itiempo] = filename\r\n if (iout > 0):\r\n if (sp.fmod(itiempo,iout) == 0): \r\n plt.savefig(filename+'.png',dpi=240)\r\n \r\n if (ivdist > 0):\r\n if (sp.fmod(itiempo,ivdist)==0):\r\n plt.figure(4)\r\n if (itiempo >0 ): plt.cla() \r\n plt.scatter(v,F,marker = '.' , s=0.1, color ='green')\r\n plt.xlim(-5*vh,5*vh)\r\n plt.ylim(0,1.0)\r\n plt.xlabel('v')\r\n plt.ylabel('f(v)')\r\n #fn_vdist = 'vdist_%0*d'%(5, itiempo)\r\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\r\n plt.pause(0.0001)\r\n plt.draw()\r\n filename = '%0*d_fdistribucion'%(5, itiempo)\r\n Archivos_Fdistribucion[itiempo] = filename\r\n if (iout > 0):\r\n if (sp.fmod(itiempo,iout) == 0): \r\n plt.savefig(filename+'.png',dpi=720)\r\n #Se escriben los datos de la distribucion en un archivo:\r\n# sp.savetxt(fn_vdist, sp.column_stack((v,F)),fmt=('%1.4e','%1.4e')) \r\n \r\n # Energia cinetica:\r\n v2 = v**2\r\n EnergiaK[itiempo] = 0.5*masa*sum(v2)\r\n \r\n # Energia potencial:\r\n e2 = Ex**2\r\n EnergiaP[itiempo] = 0.5*dx*sum(e2)\r\n emax = max(Ex) # Campo maximo para analisis de inestabilidad\r\n \r\n # Energia total: \r\n EnergiaT[itiempo] = EnergiaP[itiempo] + EnergiaK[itiempo]\r\n \r\n return True","def showPlot4():\n overall_data = []\n per_to_clean = [round(x * 0.1,1) for x in range(0,10)]\n number_of_robots = list(range(1,6))\n for per in per_to_clean:\n proc_sim_data = []\n for item in number_of_robots:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, per, 10, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n overall_data.append(proc_sim_data)\n plot(per_to_clean, overall_data)\n title('cleaning time vs. percentage cleaned')\n xlabel('percentage clean')\n ylabel('mean time (clocks)')\n show()","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n\n # chdir into the working directory\n os.chdir(env['WORKDIR'])\n\n for nclPlotFile in self._ncl:\n # copy the NCL command to the workdir\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\n\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\n if rc:\n try:\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\n except subprocess.CalledProcessError as e:\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\n print(' {0}'.format(e.cmd))\n print(' rc = {0}'.format(e.returncode))\n else:\n print('{0}... continuing with additional plots.'.format(err_msg))","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def spectral_check(self, ):\r\n a, b = self.dfa, self.dfm.copy()\r\n b['ts_a']=a.ts\r\n b['flux_a'] = a.flux\r\n b['dflux'] = (b.flux-b.flux_a)/b.flux_unc\r\n b['eflux100_a'] = a.eflux100\r\n b['deflux'] = (b.eflux100-b.eflux100_a)/b.eflux100_unc\r\n b['pindex_a'] = a.pindex\r\n b['gdelta'] = (b.pindex-b.pindex_a)/b.pindex_unc\r\n self.dfm = b # since copy\r\n\r\n fig,axx = plt.subplots(1,2, figsize=(10,5), sharey=True)\r\n hkw = dict(bins=np.linspace(-5,5,51), histtype='step', lw=2, density=True)\r\n\r\n cut = (b.ts>50) & ~pd.isnull(b.deflux) & ~pd.isnull(b.gdelta) &\\\r\n (b.modelname==\"LogParabola\") & (b.pindex<3) & (b.pindex>0.5) &\\\r\n (b.e0>500) &(b.eflux100_unc>0) &(b.pindex_unc>0)\r\n self.check_total = sum(cut)\r\n for ax, title, val in zip(axx.flatten(), ['Energy Flux', 'Spectral index'], [b.deflux, b.gdelta]): \r\n\r\n df=val[cut]\r\n ax.hist(df.clip(-5,5), label='mean {:5.2f}\\nstd {:5.2f}'.format(df.mean(),df.std()), **hkw);\r\n ax.grid(alpha=0.5); \r\n x=np.linspace(-4,4)\r\n ax.plot(x, stats.norm.pdf(x), '--g' );\r\n ax.set(xlabel='normalized fit deviation', title=title, )\r\n ax.legend(loc='upper left',prop=dict(family='monospace'))\r\n fig.suptitle('Normalized devations of fit from model', fontsize=16);\r\n\r\n return fig","def debug_plots(basename, rfile, state_prob, corr_w, mass):\n rfile.cd()\n prob_h = hist1d(state_prob, min=0, max=1, name=basename + '_state_prob')\n corr_h = hist1d(corr_w, log=True, name=basename + '_corr_w')\n w_h = hist1d(state_prob * corr_w, log=True, name=basename + '_final_weight')\n\n # Keep the 2d histograms consistent between different bins by setting ranges\n corr_v_prob = hist2d(state_prob, corr_w, minx=0, maxx=1,\n miny=1, maxy=1e5, logy=True, y_axis='corr_weight',\n name=basename + '_corr_w_v_state_prob')\n w_v_prob = hist2d(state_prob, corr_w * state_prob, minx=0, maxx=1,\n miny=0.01, maxy=1e4, logy=True, y_axis='final_weight',\n name=basename + '_final_weight_v_state_prob')\n\n mass_h = hist1d(mass, min=3.2, max=3.75, weights=state_prob,\n name=basename + '_mass_w_state_prob')\n\n mass_h_w = hist1d(mass, min=3.2, max=3.75, weights=state_prob * corr_w,\n name=basename + '_mass_w_final_weight')\n\n rej_sp_h = hist1d(state_prob[corr_w == 0], min=0, max=1,\n name=basename + '_state_prob_rej_ev')\n\n for h in [prob_h, corr_h, w_h, corr_v_prob, w_v_prob, mass_h, mass_h_w,\n rej_sp_h]:\n h.Write()","def plot_correction_diagram(fig_name):\n dir = \"log/circular antenna/around car\"\n files = utils.walk_files(dir)\n pattern_loc = r'.*\\\\(.*?) (.*?).csv$'\n radian_ref = 0.2\n for i in range(len(files)):\n file = files[i]\n match_obj = re.match(pattern_loc, file)\n if (match_obj.groups()[0] == 'left') & (match_obj.groups()[1] == '2m50'):\n df = pd.read_csv(file, sep=';', decimal=',')\n df1 = df[df['RSSI ANTENNA PCB'] != 0]\n rssi = pd.DataFrame(df1['RSSI ANTENNA PCB'])\n radian = pd.DataFrame(df1['ORIENTATION_X'])\n radian_mapped = radian.apply(utils.mapping_radian, args=(radian_ref, match_obj.groups()[0],))\n rssi_corrected = utils.correct_diagram(rssi, radian_mapped)\n rssi.columns = ['Original']\n rssi_corrected.columns = ['Corrected']\n rssi.index = np.arange(rssi.shape[0]) / utils.FREQ_LOG\n rssi_corrected.index = np.arange(rssi_corrected.shape[0]) / utils.FREQ_LOG\n\n plt.figure(figsize=(12, 8))\n ax1 = plt.subplot(2, 1, 1)\n rssi.plot(kind='line', ax=ax1)\n rssi_corrected.plot(kind='line', ax=ax1)\n plt.title(match_obj.groups()[0] + ' ' + match_obj.groups()[1])\n plt.title('RSSI Variation over time')\n plt.xlabel('Time: s')\n plt.ylabel('RSSI: dBm')\n\n ax3 = plt.subplot(2, 2, 3)\n rssi.plot(kind='density', ax=ax3)\n rssi_corrected.plot(kind='density', ax=ax3)\n plt.title('Distribution')\n plt.xlabel('RSSI: dBm')\n\n ax4 = plt.subplot(2, 2, 4)\n df = pd.DataFrame()\n df['Original'] = rssi\n df['Corrected'] = rssi_corrected\n df.plot(kind='box', ax=ax4)\n plt.title('Box')\n plt.ylabel('RSSI: dBm')\n if not os.path.exists(dir_fig):\n os.makedirs(dir_fig)\n plt.savefig(dir_fig + '/' + fig_name + '.png')","def simulationDelayedTreatment(numTrials):\n \n numViruses = 100\n maxPop = 1000\n maxBirthProb = 0.1\n clearProb = 0.05\n resistances = {'guttagonol': False}\n mutProb = 0.005\n delays = [300, 150, 75, 0]\n f, axarr = pylab.subplots(2, 2)\n x_plot = []\n\n for delay in delays:\n FinalPopSize = [0.0 for x in range(numTrials)]\n for trial in range(numTrials):\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\n patient = TreatedPatient(viruses, maxPop)\n for i in range(delay):\n patient.update()\n patient.addPrescription('guttagonol')\n for j in range(delay, delay+150):\n patient.update()\n FinalPopSize[trial] = patient.getTotalPop()\n x_plot.append(FinalPopSize)\n\n axarr[0, 0].hist(x_plot[0])\n axarr[0, 1].hist(x_plot[1])\n axarr[1, 0].hist(x_plot[2])\n axarr[1, 1].hist(x_plot[3])\n pylab.show()\n\n # pylab.plot(avgPopSize, label = 'avg pop size')\n # pylab.plot(avgGuttagonolResistantPop, label = 'avg pop size guttagonol-resistant')\n # pylab.xlabel(\"Time\")\n # pylab.ylabel(\"Average Population Size\")\n # pylab.title(\"Average Size of the Virus Populations\")\n # pylab.legend(loc = 'best')\n # pylab.show()","def showPlot1():\n\n interested_in = list(range(5,30,5))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on room size')\n xlabel('area of the room (tiles)')\n ylabel('mean time (clocks)')\n show()","def show_dcr_results(dg):\n cycle = dg.fileDB['cycle'].values[0]\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\n # print(df_dsp.describe()) \n\n # compare DCR and A/E distributions\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\n \n elo, ehi, epb = 0, 25000, 100\n \n # aoe distribution\n # ylo, yhi, ypb = -1, 2, 0.1\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\n p0.set_ylabel('A/E', ha='right', y=1)\n\n # dcr distribution\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\n # ylo, yhi, ypb = -3, 2, 0.1\n ylo, yhi, ypb = 0.9, 1.08, 0.001\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\n p1.set_ylabel('DCR', ha='right', y=1)\n \n # plt.show()\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\n plt.cla()","def showPlot3():\n interested_in = [(20,20),(25,16),(40,10),(50,8),(80,5),(100,4)]\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(2, 1.0, item[0], item[1], 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot([1,1.56,4,6.25,16,25], proc_sim_data)\n title('Dependence of cleaning time on room shape')\n xlabel('ratio of width to height')\n ylabel('mean time (clocks)')\n show()","def plot_correct_body_effect():\n file_with = 'log/influence/body/Left 2m with body.csv'\n file_without = 'log/influence/body/Left 2m without body.csv'\n rssi_with_subset = utils.read_file_rssi_37(file_with, correct_index=True)\n rssi_without_subset = utils.read_file_rssi_37(file_without, correct_index=True)\n plt.figure(figsize=(16, 6))\n ax1 = plt.subplot(1, 2, 1)\n rssi_with_subset.plot(kind='line', ax=ax1)\n plt.xlabel('Time: s')\n plt.ylabel('RSSI: dBm')\n plt.title('With Body Attenuation')\n ax2 = plt.subplot(1, 2, 2)\n rssi_without_subset.plot(kind='line', ax=ax2, sharey=ax1)\n plt.xlabel('Time: s')\n plt.title('Without Body Attenuation')\n plt.figure(figsize=(16, 6))\n rssi_with_subset = rssi_with_subset.apply(lambda x: x - rssi_with_subset[colums[1]])\n rssi_without_subset = rssi_without_subset.apply(lambda x: x - rssi_without_subset[colums[1]])\n ax3 = plt.subplot(1, 2, 1)\n rssi_with_subset.plot(kind='line', ax=ax3)\n plt.xlabel('Time: s')\n plt.ylabel('Difference: dB')\n plt.title('Difference With Body Attenuation')\n ax4 = plt.subplot(1, 2, 2)\n rssi_without_subset.plot(kind='line', ax=ax4, sharey=ax3)\n plt.xlabel('Time: s')\n plt.title('Difference Without Body Attenuation')","def _plot(self, rewards, losses, epsilons):\n plt.figure(figsize=(20,5))\n plt.subplot(131)\n plt.title('Episodic Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('TD Loss')\n plt.plot(losses)\n plt.subplot(133)\n plt.title('Epsilon')\n plt.plot(epsilons)\n plt.tight_layout()\n plt.show()","def diagnose_priors(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n names = [dm.name for dm in self.dmc]\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(\n 1, len(names), figsize=(len(names) * 4, 4), sharey=True\n )\n if not hasattr(axs, \"__iter__\"):\n axs = [axs]\n for idx, ax, X in zip(range(len(names)), axs, self.dmc):\n X.plot_priors(ax=ax)\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\n submatrix_coefficients = self.coefficients[\n firstcol_idx : firstcol_idx + X.shape[1]\n ]\n [ax.axvline(s, color=\"red\", zorder=-1) for s in submatrix_coefficients]\n return axs","def profil_consommation(params):\n N = 50; min_val = 120; max_val = 200;\n df = pd.DataFrame( data = np.random.rand(N, 3), columns = [\"a_i\",\"a_j\",\"a_k\"] );\n# df = pd.DataFrame( data = np.random.uniform(low=min_val, high=max_val, size=(N, 3)),\\\n# columns = [\"a_i\",\"a_j\",\"a_k\"] );\n df[\"a_j\"] = 0.3 + df[\"a_i\"] *( 1 + np.random.random(N,)*df[\"a_i\"]);\n df[\"a_k\"] = df[\"a_k\"] ; \n df[\"a_i\"] = df[\"a_i\"] + 0.6;\n df[\"a_j\"] = df[\"a_j\"] + 0.6;\n \n fig, ax = plt.subplots()\n df.plot( ax = ax);\n ax.set_yticklabels(['{:3.1f}'.format(x*100) \\\n for x in ax.get_yticks()]);\n ax.legend( df.columns, loc='upper center', bbox_to_anchor=(0.5, 1.00),\\\n ncol=3, fancybox=True, shadow=True); \n plt.savefig(params[\"path_save\"]+\\\n \"profilDeConsommationSeriesTemporelles.eps\",\\\n dpi= 190)","def linear_mobility_paperplot(fieldVector,df):\n vcm = np.array(fieldVector) * 1e-2\n lw = 1.5\n mu_1 = []\n mu_2 = []\n mu_3 = []\n meanE_1 = []\n meanE_2 = []\n meanE_3 = []\n for ee in fieldVector:\n chi_1_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '1_' + \"E_{:.1e}.npy\".format(ee))\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n mu_1.append(utilities.calc_linear_mobility(chi_1_i, df, ee) * 10 ** 4)\n mu_2.append(utilities.calc_linear_mobility(chi_2_i, df, ee) * 10 ** 4)\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\n meanE_1.append(utilities.mean_energy(chi_1_i,df))\n meanE_2.append(utilities.mean_energy(chi_2_i,df))\n meanE_3.append(utilities.mean_energy(chi_3_i,df))\n\n plt.figure(figsize=(2.05,2.5))\n # ax = plt.axes([0.2, 0.19, 0.75, 0.76])\n ax = plt.axes([0.21, 0.19, 0.75, 0.75])\n mufac = 1000\n # mufac = 1000\n ax.plot(vcm, np.array(mu_3)/mufac, '-', linewidth=lw, label='Warm', color=warm_color)\n ax.plot(vcm, np.array(mu_2)/mufac, '--', linewidth=lw, label='Cold', color=cold_color)\n ax.plot(vcm, np.array(mu_1)/mufac, '--', linewidth=lw, label='RTA', color=rta_color)\n\n plt.xlim([0,np.max(fieldVector)/100])\n plt.xlabel(r'Electric field ($\\rm V \\, cm^{-1}$)')\n # plt.ylabel(r'$\\sigma^{\\omega = 0}_{\\parallel}$ ($\\rm cm^2 \\, kV^{-1}\\, s^{-1}$)')\n plt.ylabel(r'DC mobility (1000 $\\rm cm^2 \\, V^{-1}\\, s^{-1}$)')\n plt.ylim([0.8e4/mufac, 2e4/mufac])\n ax.locator_params(axis='x', nbins=6)\n # plt.legend(ncol=3,loc='lower center',frameon=False)\n plt.legend(frameon=False)\n plt.savefig(pp.figureLoc +'linear_mobility2.png',dpi=600)\n\n plt.figure()\n lw = 2\n plt.plot(vcm,(np.array(meanE_1) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='RTA')\n plt.plot(vcm,(np.array(meanE_2) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='Cold '+r'$e^{-}$')\n plt.plot(vcm,(np.array(meanE_3) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='Warm '+r'$e^{-}$')\n plt.xlabel(r'Electric field [$kV/cm$]')\n plt.ylabel(r'Mean Energy [meV]')\n plt.title(pp.title_str)\n plt.savefig(pp.figureLoc +'meanEnergy_vField.png', bbox_inches='tight',dpi=600)\n plt.legend(frameon=False)","def compare(self, plot=False):\n oldConditionData, newConditionData = self.runSimulations()\n \n #For now make print statements about each none matching data\n conditionsBroken=[]\n variablesFailed=[]\n for i in range(len(oldConditionData)):\n timeOld, dataListOld = oldConditionData[i]\n timeNew, dataListNew = newConditionData[i]\n\n for variableOld, variableNew in zip(dataListOld, dataListNew):\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\n if i not in conditionsBroken: conditionsBroken.append(i)\n\n if variableOld.species:\n label = variableOld.species.molecule[0].toSMILES()\n print \"Species profile for {0} does not match between the old model ({1}) and \\\n the new model ({2}) in condition {3:d}.\".format(variableOld.species.molecule[0].toSMILES(),\n variableOld.label, \n variableNew.label,\n i+1)\n else:\n label = variableOld.label\n print \"{0} does not match between the old model and \\\n the new model in condition {1:d}.\".format(variableOld.label, i+1)\n\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\n print ''\n print 'The following reaction conditions were broken:'\n print ''\n for index in conditionsBroken:\n print \"Condition {0:d}:\"\n print str(self.conditions[index])\n print ''\n\n if plot:\n # Ignore Inerts\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\n for i in range(len(oldConditionData)):\n time, dataList = oldConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n time, dataList = newConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n # Name after the index of the condition\n # though it may be better to name it after the actual conditions in T, P, etc\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\n\n return variablesFailed","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def test4():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\t#Voigt\n\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def test3():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def checkCorr(originalDF):\n # BEGIN: from https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python\n # EXPLANATION: This code visualizes the correlation matrix of the data \n # using heatmap, representing different correlation coefficients by \n # different colors.\n corrmat = originalDF.corr()\n f, ax = plt.subplots(figsize=(12,9))\n sns.heatmap(corrmat, vmax=.8, square=True)\n \n #Zoom in the important variables\n #saleprice correlation matrix\n k = 10 #number of variables for heatmap\n cols = corrmat.nlargest(k, 'SalePrice')['SalePrice'].index\n cm = np.corrcoef(originalDF[cols].values.T)\n sns.set(font_scale=1.25)\n hm = sns.heatmap(cm, cbar=True, annot=True, square=True, fmt='.2f', annot_kws={'size': 10}, yticklabels=cols.values, xticklabels=cols.values)\n plt.show()\n # END: from https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python\n \n \"\"\"\n It seems like 1stFlrSF and TotalBsmtSF, \n TotRmsAbvGr and GrLivArea, YearBuilt and GarageYrBlt, \n GarageArea and GarageCars are highly correlated respectively.\n Let us check the specific correlations.\n \"\"\"\n cor1 = originalDF.loc[:, \"1stFlrSF\"].corr(originalDF.loc[:, \"TotalBsmtSF\"])\n cor2 = originalDF.loc[:, \"TotRmsAbvGrd\"].corr(originalDF.loc[:, \"GrLivArea\"])\n cor3 = originalDF.loc[:, \"YearBuilt\"].corr(originalDF.loc[:, \"GarageYrBlt\"])\n cor4 = originalDF.loc[:, \"GarageArea\"].corr(originalDF.loc[:, \"GarageCars\"])\n \n print(\"1st Floor SF and Total Basement SF\")\n print(cor1)\n print(\"Total Rooms Above Ground and Ground Living Area\")\n print(cor2)\n print(\"Year Built and Garage Year Built\")\n print(cor3)\n print(\"Garage Area and Garage Cars\")\n print(cor4)\n \n # Maybe try dropping those with abs(corr) > 0.9?","def make_summary_plot(run_lists, file_descriptor, attr='sipm1.threeSampleAmpl'):\n biases = []\n gains = []\n pes = []\n currs = []\n gainerrs = []\n quad_terms = []\n quad_errs = []\n for row in sorted(run_lists):\n biases.append(row[0])\n gain_out = fit_gain(row[1], attr=attr)\n out_tuple = gain_out[0]\n gains.append(out_tuple[0])\n gainerrs.append(out_tuple[3])\n smeans = sorted(gain_out[1])\n currs.append(0.5*(smeans[-1] + smeans[-2]))\n pes.append(currs[-1]/gains[-1])\n quad_terms.append(out_tuple[1])\n quad_errs.append(out_tuple[4])\n\n maxgain = max(gains)\n gains = np.array(gains)/maxgain\n gainerrs = np.array(gainerrs)/maxgain\n # gainerrs = 0.1*gains\n\n currs = np.array(currs)/max(currs)\n pes = np.array(pes)\n pe_errs = gainerrs/gains*pes\n maxpe = max(pes)\n fig, ax1 = plt.subplots()\n\n coeffs, V = np.polyfit(biases, gains, 1, w=1.0/gainerrs, cov=True)\n breakdown = -1*coeffs[1]/coeffs[0]\n\n breakdown_sigma = sigma_from_cov(coeffs, V)\n\n # calculate sigmas throughout range\n vals, vecs = np.linalg.eig(V)\n U = np.transpose(vecs)\n xs_for_error = np.arange(breakdown - 0.1, max(biases) + 0.1, 0.01)\n gain_sigmas = sig_from_diag(xs_for_error, U, vals)\n error_band_ys = np.array([i*coeffs[0] + coeffs[1] for i in xs_for_error])\n ax1.fill_between(xs_for_error, error_band_ys + gain_sigmas,\n error_band_ys - gain_sigmas, facecolor='red', alpha=0.5)\n\n fitline = [i*coeffs[0] + coeffs[1] for i in biases] + [0]\n fitbiases = biases + [breakdown]\n\n ax1.set_title('bias scan %s' % file_descriptor)\n fitplot = ax1.plot(fitbiases, fitline, 'r-')\n gainplot = ax1.errorbar(\n biases, gains, yerr=gainerrs, fmt='ro', markersize=10)\n currplot = ax1.plot(biases, currs, 'g*', markersize=15)\n ax1.set_ylim(0, 1.105)\n ax1.set_xlim([breakdown - 0.1, max(biases) + 0.1])\n ax1.set_xlabel('bias voltage [V]')\n ax1.set_ylabel('relative gain, charge [a.u.]')\n\n ticks = [breakdown]\n ticks.extend([bias for bias in biases[::2]])\n tick_labels = ['%.1f $\\pm$ %.1f' % (breakdown, breakdown_sigma)]\n tick_labels.extend([str(bias) for bias in biases[::2]])\n ax1.set_xticks(ticks)\n ax1.set_xticklabels(tick_labels)\n ax1.grid()\n ax1.get_xticklabels()[0].set_color('r')\n\n ax2 = ax1.twinx()\n peplot = ax2.errorbar(biases, pes, yerr=pe_errs, fmt='b^', markersize=10)\n ax2.set_ylabel('pe', color='b')\n ax2.set_ylim(0, maxpe*1.105)\n ax2.set_xlim([breakdown - 0.1, max(biases) + 0.1])\n for tick in ax2.get_yticklabels():\n tick.set_color('b')\n ax1.legend([gainplot[0]]+currplot+[peplot[0]]+fitplot,\n ['gain', 'charge', 'pes', 'gain fit'],\n loc='best', numpoints=1)\n\n plt.savefig('pdfs/breakdownPlot%s.pdf' % file_descriptor)\n plt.show()\n\n quadploterrs = 0.5/np.sqrt(quad_terms)*quad_errs\n plt.errorbar(biases, np.sqrt(quad_terms)*100, yerr=quadploterrs*100, fmt='ko')\n plt.xlim(min(biases) - 0.1, max(biases) + 0.1)\n plt.xlabel('bias [V]')\n plt.ylabel('sqrt(quadratic term) [%]')\n plt.title('quadratic terms %s' % file_descriptor)\n\n plt.savefig('pdfs/quadraticTerms%s.pdf' % file_descriptor)\n plt.show()","def figure_3(df):\n\n sns.set(style=\"white\", palette=sns.color_palette(\"cubehelix\", 6)) #still 6 if osa csa\n f, axes = plt.subplots(5, 1, figsize=(6, 9)) # 6, 2 if OSA CSA\n sns.despine(top=True, bottom=True)\n # f.suptitle(\"Outcome, Grouped by Contributing Etiology\")\n\n # contains used instead of equal to include patients with multiple etio (e.g. cardiac+medication count to both)\n neurologic_df = df.loc[df['PostDx'].str.contains(\"Neurologic\")].sort_values(by='Outcome')\n cardiac_df = df.loc[df['PostDx'].str.contains(\"Cardiac\")].sort_values(by='Outcome')\n medication_df = df.loc[df['PostDx'].str.contains(\"Medication\")].sort_values(by='Outcome')\n tecsa_df = df.loc[df['PostDx'].str.contains(\"TECSA\")].sort_values(by='Outcome')\n # osacsa_df = df.loc[df['PostDx'].str.contains(\"OSA-CSA\")].sort_values(by='Outcome')\n primary_df = df.loc[df['PostDx'].str.contains(\"Primary\")].sort_values(by='Outcome')\n\n # collapse possible outcomes\n neurologic_df['col_outcome'] = neurologic_df.apply(collapse_initial_outcome, axis=1)\n cardiac_df['col_outcome'] = cardiac_df.apply(collapse_initial_outcome, axis=1)\n medication_df['col_outcome'] = medication_df.apply(collapse_initial_outcome, axis=1)\n tecsa_df['col_outcome'] = tecsa_df.apply(collapse_initial_outcome, axis=1)\n # osacsa_df['col_outcome'] = osacsa_df.apply(collapse_initial_outcome, axis=1)\n primary_df['col_outcome'] = primary_df.apply(collapse_initial_outcome, axis=1)\n\n # Create count plot for each Etio on the left, then a Pie Chart with proportion on the right\n\n hatches = ['', '||||', '']\n face_color = ['white', 'white', 'dimgrey']\n\n # Neurologic\n bar = sns.countplot(y='col_outcome', data=neurologic_df, ax=axes[0])\n for i, this_bar in enumerate(bar.patches):\n # Set a different hatch for each bar\n this_bar.set_edgecolor('black')\n this_bar.set_facecolor(face_color[i])\n this_bar.set_hatch(hatches[i])\n axes[0].set(xlabel=\"\", ylabel=\"Neurologic\\nConditions\")\n\n\n # Cardiac\n bar = sns.countplot(y='col_outcome', data=cardiac_df, ax=axes[1])\n for i, this_bar in enumerate(bar.patches):\n # Set a different hatch for each bar\n this_bar.set_edgecolor('black')\n this_bar.set_facecolor(face_color[i])\n this_bar.set_hatch(hatches[i])\n axes[1].set(xlabel=\"\", ylabel=\"Cardiac\\nConditions\")\n\n # Medication\n bar = sns.countplot(y='col_outcome', data=medication_df, ax=axes[2])\n for i, this_bar in enumerate(bar.patches):\n # Set a different hatch for each bar\n this_bar.set_edgecolor('black')\n this_bar.set_facecolor(face_color[i])\n this_bar.set_hatch(hatches[i])\n axes[2].set(xlabel=\"\", ylabel=\"Opiate Use\")\n\n # OSA-CSA\n # bar = sns.countplot(y='col_outcome', data=osacsa_df, ax=axes[3,0])\n # for i, this_bar in enumerate(bar.patches):\n # # Set a different hatch for each bar\n # this_bar.set_hatch(hatches[i])\n # axes[3].set(xlabel=\"\", ylabel=\"OSA-CSA\")\n # If adding OSA-CSA back, would need to increase by 1 all of the axes indices\n\n # TE-CSA\n bar = sns.countplot(y='col_outcome', data=tecsa_df, ax=axes[3])\n for i, this_bar in enumerate(bar.patches):\n # Set a different hatch for each bar\n this_bar.set_edgecolor('black')\n this_bar.set_facecolor(face_color[i])\n this_bar.set_hatch(hatches[i])\n axes[3].set(xlabel=\"\", ylabel=\"TECSA\")\n\n #Primary\n bar = sns.countplot(y='col_outcome', data=primary_df, ax=axes[4])\n for i, this_bar in enumerate(bar.patches):\n # Set a different hatch for each bar\n this_bar.set_edgecolor('black')\n this_bar.set_facecolor(face_color[i])\n this_bar.set_hatch(hatches[i])\n axes[4].set(xlabel=\"Number of Patients\", ylabel=\"Primary CSA\")\n\n # Combined X axis for L side\n axes[4].get_shared_x_axes().join(axes[4], axes[3], axes[2], axes[1], axes[0]) # axes[5] would need to be added back\n axes[0].set_xticklabels(\"\")\n axes[1].set_xticklabels(\"\")\n axes[2].set_xticklabels(\"\")\n axes[3].set_xticklabels(\"\")\n # axes[4].set_xticklabels(\"\")\n # Leave bottom labels in\n\n # Resize all\n axes[0].autoscale()\n axes[1].autoscale()\n axes[2].autoscale()\n axes[3].autoscale()\n axes[4].autoscale()\n # axes[5].autoscale()\n\n f.tight_layout(rect=[0, 0, 1, 1])\n f.savefig('Figure 3 - outcome of cpap by etio.png', dpi=100)\n # plt.show()","def plot_anomalies(data, Species, family, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False):\n \n #result = test_stationarity(SpeciesName=Species, data = data)\n #result.plot()\n if Species == 'None':\n vo = data[(data.family == family) & (data.prediction_adjusted == syndrome)]\n else:\n vo = data[(data.ScientificName == Species) & (data.prediction_adjusted == syndrome)]\n \n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\n weekly_vo = pd.DataFrame(weekly_vo)\n weekly_vo.columns = ['ID']\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\n\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\n \n def identify_anomalies(c, sigma=sigma):\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\n return c.ID\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\n \n upper_bound = go.Scatter(\n name='upper Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\n mode='lines',\n marker=dict(color=\"#820101\"),\n line=dict(width=0),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n \n rolling_m = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['rolling mean'],\n name='rolling mean',\n mode='lines',\n line=dict(color='#1f77b4'),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n\n lower_bound = go.Scatter(\n name='lower Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\n marker=dict(color=\"#b7b7b7\"),\n line=dict(width=0),\n mode='lines',)\n\n addmissions = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['# admissions'],\n name='# admissions',)\n\n ano = go.Scatter(\n x = weekly_vo.index,\n y =weekly_vo['anomalies'] ,\n name='anomalies',\n mode='markers')\n\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\n if Species == 'None':\n T = \"Weekly admissions of \"+ str(family)+' ('+syndrome+')',\n else:\n T = \"Weekly admissions of \"+ str(Species)+' ('+syndrome+')',\n print (T)\n layout = go.Layout(\n title= 'Weekly admissions',\n yaxis=dict( title='number of admissions',), width=900, height=640\n )\n\n fig = go.Figure(data=plottingdata, layout=layout)\n plot_url = iplot(fig)\n if verbose:\n print('number of admissions triggering alert') \n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\n if save:\n name = family+Species+syndrome\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'.png')\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\n\n #from IPython.display import Image\n #Image('C:\\Users\\Falco\\Desktop\\directory\\WMRD\\data\\TimeSeries.png')\n \n return weekly_vo","def plot_various_confidences(self, graph_name, drop_rate, data_format,\n Y, directory='./attack_data/',\n confs=(0.0, 10.0, 20.0, 30.0, 40.0),\n get_attack_data_name=lambda c: \"example_carlini_\"+str(c)):\n import matplotlib.pyplot as plt\n import pylab\n\n pylab.rcParams['figure.figsize'] = 6, 4\n fig = plt.figure(1, (6, 4))\n ax = fig.add_subplot(1, 1, 1)\n\n det_only = []\n ref_only = []\n both = []\n none = []\n\n print(\"Drop Rate:\", drop_rate)\n thrs = self.operator.get_thrs(drop_rate)\n\n all_pass, _detector = self.operator.filter(self.operator.data.test_data, thrs)\n all_on_acc, _, _, _ = self.get_normal_acc(all_pass)\n\n print(_detector)\n print(\"Classification accuracy with all defense on:\", all_on_acc)\n\n for confidence in confs:\n f = get_attack_data_name(confidence)\n attack_data = AttackData(f, Y, \"Carlini L2 \" + str(confidence), directory=directory,\n input_data_format=CHANNELS_LAST, data_format=data_format)\n # compute number of all input data and filter out valid data\n total = len(attack_data.data)\n valid_adv_idx = np.argwhere(np.sum(attack_data.data, axis=(1, 2, 3)) > [0] * total).flatten()\n attack_data.data = attack_data.data[valid_adv_idx]\n attack_data.labels = attack_data.labels[valid_adv_idx]\n self.load_data(attack_data)\n\n print(\"Confidence:\", confidence)\n valid_adv_len = len(valid_adv_idx)\n print(\"valid attack %d/%d\" % (valid_adv_len, total))\n all_pass, detector_breakdown = self.operator.filter(self.untrusted_data.data, thrs)\n both_acc, det_only_acc, ref_only_acc, none_acc = self.get_attack_acc(all_pass)\n print(detector_breakdown)\n both.append(both_acc)\n det_only.append(det_only_acc)\n ref_only.append(ref_only_acc)\n none.append(none_acc)\n\n size = 2.5\n plt.plot(confs, none, c=\"green\", label=\"No fefense\", marker=\"x\", markersize=size)\n plt.plot(confs, det_only, c=\"orange\", label=\"With detector\", marker=\"o\", markersize=size)\n plt.plot(confs, ref_only, c=\"blue\", label=\"With reformer\", marker=\"^\", markersize=size)\n plt.plot(confs, both, c=\"red\", label=\"With detector & reformer\", marker=\"s\", markersize=size)\n\n pylab.legend(loc='lower left', bbox_to_anchor=(0.02, 0.1), prop={'size':8})\n plt.grid(linestyle='dotted')\n plt.xlabel(r\"Confidence in Carlini $L^2$ attack\")\n plt.ylabel(\"Classification accuracy\")\n plt.xlim(min(confs)-1.0, max(confs)+1.0)\n plt.ylim(-0.05, 1.05)\n ax.yaxis.set_major_formatter(FuncFormatter('{0:.0%}'.format))\n\n save_path = os.path.join(self.graph_dir, graph_name+\".pdf\")\n plt.savefig(save_path)\n plt.clf()","def plot_dereddening():\n extinction_coefficients = {'2365-2764-1': np.array([0.2622, 0.844]), '4109-638-1': np.array([0.0524, 0.1576]),\n '2058-56-1': np.array([0.0751, 0.248]), '3642-2459-1': np.array([0.1907, 0.608]),\n '3999-1391-1': np.array([0.3911, 1.2480]), '2607-1448-1': np.array([0.0430, 0.1310])}\n cepheids = {'2365-2764-1': np.array([0.959, 2.09]), '4109-638-1': np.array([0.705, 2.385]), '2058-56-1':\n np.array([1.222, 1.333]), '3642-2459-1': np.array([1.088, 2.0518]), '3999-1391-1':\n np.array([1.360, 1.2567]), '2607-1448-1': np.array([1.484, 0.6963])}\n periods = {'2365-2764-1': 1.61, '4109-638-1': 15.31, '2058-56-1': 63.08, '3642-2459-1': 1.86, '3999-1391-1': 24.98,\n '2607-1448-1': 8.54}\n max_periods = max(periods.values())\n\n new_positions_bv_mv = [] # in M_V vs B-V space\n colors = []\n theoretical_position = []\n for obj in extinction_coefficients.keys():\n # new_positions_bv_mv.append(cepheids[obj]-extinction_coefficients[obj])\n new_positions_bv_mv.append(cepheids[obj])\n colors.append(periods[obj]/max_periods)\n theoretical_position.append(-2.78*np.log10(periods[obj])-1.35)\n\n for pos in range(len(new_positions_bv_mv)):\n plt.scatter(new_positions_bv_mv[pos][0], new_positions_bv_mv[pos][1], marker='^', facecolor='w', s=40)\n plt.scatter(new_positions_bv_mv[pos][0], theoretical_position[pos], marker='o', facecolor='r', s=50)\n return new_positions_bv_mv, colors","def report(self, X, y):\n predict = self.model.predict(X)\n\n skplt.estimators.plot_feature_importances(\n self.model, x_tick_rotation=90)\n plt.show()\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=predict)\n lims = [\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\n ]\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\n ax.set_aspect('equal')\n ax.set_xlim(lims)\n ax.set_ylim(lims)\n ax.set_xlabel(\"Observed\")\n ax.set_ylabel(\"Predict\")\n ax.set_title(\"Predict vs. Observed\")\n plt.show()\n\n residuals = y - predict\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=residuals)\n plt.title(\"Residuals vs. Observed\")\n plt.xlabel(\"Obserbed\")\n plt.ylabel(\"Residuals\")\n plt.show()\n\n plt.hist(residuals)\n plt.title(\"Residuals distribution\")\n plt.xlabel(\"Residuals value\")\n plt.ylabel(\"Count\")\n plt.show()\n\n display(\n pd.DataFrame({\n \"explained_variance_score\":\n metrics.explained_variance_score(y, predict),\n \"mean_absolute_error\":\n metrics.mean_absolute_error(y, predict),\n \"mean_squared_log_error\":\n metrics.mean_squared_log_error(y, predict),\n \"median_absolute_error\":\n metrics.median_absolute_error(y, predict),\n \"r2_score\":\n metrics.r2_score(y, predict)\n },\n index=[0]))","def simplePlots() -> None:\r\n \r\n # Univariate data -------------------------\r\n \r\n # Make sure that always the same random numbers are generated\r\n np.random.seed(1234)\r\n \r\n # Generate data that are normally distributed\r\n x = np.random.randn(500)\r\n \r\n # Other graphics settings\r\n # Set \" context='poster' \" for printouts, and \"set_fonts(32)\"\r\n sns.set(context='notebook', style='ticks', palette='muted')\r\n \r\n # Set the fonts the way I like them\r\n set_fonts(16)\r\n \r\n # Scatter plot\r\n plt.plot(x, '.', markersize=7)\r\n plt.xlim([0, len(x)])\r\n \r\n # Save and show the data, in a systematic format\r\n printout('scatterPlot.jpg', xlabel='Datapoints', ylabel='Values', title='Scatter')\r\n \r\n # Histogram\r\n plt.hist(x)\r\n printout('histogram_plain.jpg', xlabel='Data Values',\r\n ylabel='Frequency', title='Histogram, default settings')\r\n \r\n plt.hist(x, 25, density=True)\r\n printout('density_histogram.jpg', xlabel='Data Values', ylabel='Probability',\r\n title='Density Histogram, 25 bins')\r\n \r\n # Boxplot\r\n # The ox consists of the first, second (middle) and third quartile\r\n set_fonts(18)\r\n plt.boxplot(x, sym='*')\r\n printout('boxplot.jpg', xlabel='Values', title='Boxplot')\r\n \r\n plt.boxplot(x, sym='*', vert=False)\r\n plt.title('Boxplot, horizontal')\r\n plt.xlabel('Values')\r\n plt.show()\r\n \r\n # Errorbars\r\n x = np.arange(5)\r\n y = x**2\r\n errorBar = x/2\r\n plt.errorbar(x,y, yerr=errorBar, fmt='o', capsize=5, capthick=3)\r\n plt.xlim([-0.2, 4.2])\r\n plt.ylim([-0.2, 19])\r\n printout('Errorbars.jpg', xlabel='Data Values', ylabel='Measurements', title='Errorbars')\r\n\r\n # SD for two groups\r\n weight = {'USA':89, 'Austria':74}\r\n weight_SD_male = 12\r\n plt.errorbar([1,2], weight.values(), yerr=weight_SD_male * np.r_[1,1],\r\n capsize=5, LineStyle='', marker='o')\r\n plt.xlim([0.5, 2.5])\r\n plt.xticks([1,2], weight.keys())\r\n plt.ylabel('Weight [kg]')\r\n plt.title('Adult male, mean +/- SD')\r\n\r\n show_data('SD_groups.jpg', out_dir='.')\r\n \r\n # Barplot\r\n # The font-size is set such that the legend does not overlap with the data\r\n np.random.seed(1234)\r\n set_fonts(16)\r\n \r\n df = pd.DataFrame(np.random.rand(7, 3), columns=['one', 'two', 'three'])\r\n df.plot(kind='bar', grid=False, color=sns.color_palette('muted'))\r\n \r\n show_data('barplot.jpg')\r\n\r\n # Bivariate Plots\r\n df2 = pd.DataFrame(np.random.rand(50, 3), columns=['a', 'b', 'c'])\r\n df2.plot(kind='scatter', x='a', y='b', s=df2['c']*500);\r\n plt.axhline(0, ls='--', color='#999999')\r\n plt.axvline(0, ls='--', color='#999999')\r\n printout('bivariate.jpg')\r\n \r\n sns.set_style('ticks')\r\n\r\n # Pieplot\r\n txtLabels = 'Cats', 'Dogs', 'Frogs', 'Others'\r\n fractions = [45, 30, 15, 10]\r\n offsets =(0, 0.05, 0, 0)\r\n \r\n plt.pie(fractions, explode=offsets, labels=txtLabels,\r\n autopct='%1.1f%%', shadow=True, startangle=90,\r\n colors=sns.color_palette('muted') )\r\n plt.axis('equal')\r\n printout('piePlot.jpg', title=' ')","def make_asimov_significance_plots(self):\n import matplotlib.pyplot as plt\n plt.rcParams['text.usetex'] = True\n outdir = os.path.join(self.outdir, 'Significances')\n mkdir(outdir)\n maintitle = self.make_main_title(\n end='Asimov Analysis Significances',\n end_center=True\n )\n\n # Want to ensure the resulting y range can show all of the plots\n # Therefore find the max and min sig of the whole set of data_sets\n maxsig = None\n minsig = None\n # xrange is easier\n hrange = self.inj_param_vals[-1]-self.inj_param_vals[0]\n xlims = [self.inj_param_vals[0]-0.1*hrange,\n self.inj_param_vals[-1]+0.1*hrange]\n\n for i in range(len(self.data_sets)):\n\n significances = self.deltachi2_significance(\n wh_to_th_metrics=self.wh_to_th[i]['metrics'],\n th_to_wh_metrics=self.th_to_wh[i]['metrics']\n )\n\n truth = self.labels[i][\n self.labels.keys()[0]].dict['data_name'].split('_')[0]\n plotlabel = 'True %s'%self.tex_axis_label(truth)\n \n self.make_1d_graph(\n xvals=self.inj_param_vals,\n yvals=significances,\n xlabel=self.inj_param_name,\n xunits=self.inj_param_units,\n ylabel=None,\n yunits=None,\n marker=self.marker_style(truth),\n color=self.plot_colour(truth),\n plotlabel=plotlabel,\n xlims=xlims\n )\n\n if maxsig is None:\n maxsig = max(significances)\n else:\n maxsig = max(maxsig, max(significances))\n if minsig is None:\n minsig = min(significances)\n else:\n minsig = min(minsig, min(significances))\n\n # Give a more descriptive y-axis label if only one thing being plotted\n if len(self.data_sets) == 1:\n alt = self.labels[\n self.labels.keys()[0]].dict['%s_name'%(\n self.wh_to_th[0]['params']['altfit'])].split('_')[0]\n plt.ylabel(r'%s from %s Significance $\\left(\\sigma\\right)$'%(\n self.tex_axis_label(truth),\n self.tex_axis_label(alt)\n ))\n else:\n plt.ylabel(r'Significance $\\left(\\sigma\\right)$', fontsize=24)\n\n vrange = maxsig - minsig\n plt.ylim(minsig-0.1*vrange, maxsig+0.2*vrange)\n plt.title(maintitle, fontsize=16)\n plt.legend(loc='best')\n plt.tight_layout()\n save_end = \"%s_asimov_significances\"%(self.inj_param_name)\n self.save_plot(outdir=outdir, end=save_end, truth=truth)\n if self.extra_points is not None:\n yminextra, ymaxextra = self.add_extra_points()\n yminall = min(yminextra, minsig)\n ymaxall = max(ymaxextra, maxsig)\n vrange = ymaxall - yminall\n if yminall == 0:\n plt.ylim(yminall, ymaxall+0.2*vrange)\n else:\n plt.ylim(yminall-0.1*vrange, ymaxall+0.3*vrange)\n plt.legend(loc='upper left')\n save_end = \"%s_asimov_significances_w_extra_points\"%(\n self.inj_param_name)\n self.save_plot(outdir=outdir, end=save_end, truth=truth)\n plt.close()","def distribution_horizontale_new(args):\n number_files = [2,5,10,20];\n rep = args[\"path_save\"]+args[\"correction\"]+\\\n \"/data_p_\"+str(args[\"p_value\"])+\"/distribution/\";\n fig = plt.figure(); default_size = fig.get_size_inches(); \n f, ax_arrs = plt.subplots(2, 4, figsize=(default_size[0]*2.2, \\\n default_size[1]*1.5), \\\n );\n cpt1 = 0; cpt2 = 1; tab_bins = [20, 40, 80,100, 100, 100]\n for ind, k in enumerate(number_files) :\n df = pd.read_csv(rep+args[\"fichier_prefix\"] +str(k)+args[\"ext\"], \\\n names=[\"cpt\",\"moy_dc\",\"moy_dh\", \"aretes_matE\", \"correl_dh_dl\"], \\\n sep=';')\n N_graphs = df[\"moy_dc\"].count();\n \n aretes = find_aretes(args, df)\n bins = range(0, (ind+1)*args[\"num_bins\"]);\n bins = range(0, tab_bins[ind]);\n max_count_dl, max_count_dh = count_max_df(df)\n \n # plot ax1\n (mu, sigma) = norm.fit(df[\"moy_dc\"]); # best fit of data\n sns.distplot(df[\"moy_dc\"], ax = ax_arrs[cpt1, ind], bins = bins, kde = False)\n ax_arrs[cpt1, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance de correction pour \\n \"+ str(k)+ \\\n \" cases modifiees\")\n ax_arrs[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs[cpt1, ind].get_yticks()])\n \n #plot ax2\n (mu, sigma) = norm.fit(df[\"moy_dh\"]); # best fit of data\n sns.distplot(df[\"moy_dh\"], ax = ax_arrs[cpt2, ind], bins = bins, kde = False)\n ax_arrs[cpt2, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance Hamming pour \\n \"+ str(k)+\\\n \" cases modifiees\")\n ax_arrs[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs[cpt2, ind].get_yticks()])\n \n# fig = ax_arrs[0,0].figure ;\n# fig.text(0.5,0.04, \"Some very long and even longer xlabel\", ha=\"center\", va=\"center\")\n# fig.text(0.05,0.5, \"Some quite extensive ylabel\", ha=\"center\", va=\"center\", rotation=90)\n\n \n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\n plt.grid(True)\n plt.savefig(args[\"path_save\"]+args[\"correction\"]+\"/courbes/\"+\\\n \"distributionMoyDCDHp05k1251020.jpeg\",\\\n dpi= 250) #190 ","def main_paper(mode = 'q-diff'):\n mode_name = 'Shared Autonomy'\n if mode== 'override':\n mode_name = 'Overrider'\n\n #trains rl again and fills a q-table\n _, rl_agent = rl_alone(1000, fill_table = True)\n\n #prints the q-table\n for y in range(7):\n for x in range(7):\n state_ind = y*(7)+x\n q = rl_agent.get_q_values(state_ind)\n print('Q-table')\n print(state_ind, [x,y], np.around(q, decimals=5))\n\n in_li = []\n r_li = []\n rp_li=[]\n\n print(\"Begin looping through constraint values\")\n for i in np.arange(0.0, 1.025, 0.025):\n #cooperates and gets results\n rewards, actionsct, rewardsP = grid_human_co(coagent=rl_agent, threshold=i, verbose=False, mode=mode)\n print(\"Threshold: \", i)\n avgInter = np.mean(actionsct, axis=0)\n avgR = np.mean(rewards, axis=0)\n avgRP = np.mean(rewardsP, axis=0)\n in_li.append(avgInter)\n r_li.append(avgR)\n rp_li.append(avgRP)\n print('Avg num of interventions: ', avgInter)\n print('Avg reward: ', avgR)\n print('Avg reward penalized: ', avgRP)\n print()\n\n plt.figure()\n plt.plot(np.arange(0.0, 1.025, 0.025), in_li)\n plt.title(mode_name + ' Interventions')\n plt.xlabel(r\"$\\alpha$\")\n plt.ylabel('Average intervention count')\n plt.show()\n\n plt.figure()\n plt.title(mode_name + ' Returns', fontsize=14)\n plt.xlabel(r\"$\\alpha$\", fontsize=13)\n plt.ylabel('Average return', fontsize=13)\n plt.plot(np.arange(0.0, 1.025, 0.025), r_li,label='Average environment return')\n plt.plot(np.arange(0.0, 1.025, 0.025), rp_li,label=\"Average intervention return\")\n plt.legend(fontsize=9)\n plt.show()","def hook_displaysuspicions(self):\n charMarginal = (np.array(self.hypCountByCharacter,dtype=np.float64)\n / np.sum(self.hypCountByCharacter))\n roomMarginal = (np.array(self.hypCountByRoom,dtype=np.float64)\n / np.sum(self.hypCountByRoom))\n weapMarginal = (np.array(self.hypCountByWeapon,dtype=np.float64)\n / np.sum(self.hypCountByWeapon))\n ui.plotscenariomarginals(charMarginal,roomMarginal,weapMarginal)\n ui.plotforbidden(self.forbidden)","def checkConservation2(nx, nt, c, display=False):\n \n # create array of space points\n x = np.linspace(0, 1, nx)\n \n # we use a smooth function\n phi_ic = ic.squareWave(x, 0, 0.5) \n\n\n if(display):\n plt.figure()\n \n # now we run and plot mass conservation\n # the name of the scheme is each time in the variable methodName\n \n methodName = \"FTBS\"\n # make a local copy every time because things get dirty after use\n # and we don't want to corrupt phi_ic because we'll use it again\n phi_ic_local = phi_ic.copy()\n \n _, phiMean, _ = ad.FTBS(phi_ic_local, c, nt, \\\n calculateConservation=True)\n \n if(display):\n plotConservation2(c, nt, phiMean, methodName)\n\n \n methodName = \"CTCS\"\n # make a local copy every time because things get dirty after use\n # and we don't want to corrupt phi_ic because we'll use it again\n phi_ic_local = phi_ic.copy()\n \n _, phiMean, _ = ad.CTCS(phi_ic_local, c, nt, \\\n calculateConservation=True)\n \n if(display):\n plotConservation2(c, nt, phiMean, methodName)\n\n \n methodName = \"CNCS\"\n # make a local copy every time because things get dirty after use\n # and we don't want to corrupt phi_ic because we'll use it again\n phi_ic_local = phi_ic.copy()\n \n _, phiMean, _ = ad.CNCS(phi_ic_local, c, nt, \\\n calculateConservation=True)\n \n if(display):\n plotConservation2(c, nt, phiMean, methodName)\n\n \n methodName = \"LaxWendroff\"\n # make a local copy every time because things get dirty after use\n # and we don't want to corrupt phi_ic because we'll use it again\n phi_ic_local = phi_ic.copy()\n \n _, phiMean, _ = ad.LaxWendroff(phi_ic_local, c, nt, \\\n calculateConservation=True)\n \n if(display):\n plotConservation2(c, nt, phiMean, methodName)\n\n\n if(display):\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n #plt.ylim([0.2, 0.3])\n plt.show()","def plotDispCoverage(dispData, dye_conc, caliConst, dispConst, outName):\n z = np.linspace(min(dispData[:,0]), max(dispData[:,0]), 1000)\n dispCoverage = DispDyeCoverage(z, dye_conc, caliConst[2], dispConst[2], caliConst[3])\n knownDyeCov = Frac_Cov(dye_conc, caliConst[2], caliConst[3])\n caliDyeCoverage = DispDyeCoverage(dye_conc, z, caliConst[2], caliConst[3], dispConst[2])\n #Covert the exp intensities to coverages\n expCoverages = IntToCoverage(dispData[:,1], dispConst);\n expCoverages = (expCoverages / expCoverages[0]) * knownDyeCov\n plt.figure()\n plt.rcParams.update({'font.size' : 16})\n plt.plot(z/1000, ((caliDyeCoverage) / caliDyeCoverage[0]) * knownDyeCov)\n plt.scatter(dispData[:,0]/1000, expCoverages);\n #plt.ylim([0,1])\n plt.savefig(outName + \"_disp_coverage_plot.png\")\n plt.show()\n #might as well get R^2 here\n ss_res = 0\n ss_total = 0\n residuals = np.zeros([len(dispData[:,0]), 1])\n for i in range(len(dispData[:,0])):\n predictedDyeCov = DispDyeCoverage(dye_conc, dispData[i,0], caliConst[2], caliConst[3], dispConst[2])\n scaledPredictedDyeCov = (predictedDyeCov / caliDyeCoverage[0]) * knownDyeCov\n residuals[i] = scaledPredictedDyeCov - expCoverages[i]\n ss_res += np.square(residuals[i])\n ss_total += np.square((expCoverages[i] - np.average(expCoverages[:])))\n print(ss_res)\n print(ss_total)\n r_sq = 1 - (ss_res/ss_total)\n print(r_sq)","def _create_plots(self):\n #########################\n # Histograms of original data\n # Generates composite plot of specific variables before correction\n # We fill these variables by sampling a normal distribution, so we use this plot mainly as evidence for that.\n if self.generate_bokeh:\n ws_hist = plotting_functions.histogram_plot(self.data_ws[~np.isnan(self.data_ws)],\n 'Windspeed', 'black', 'm/s')\n tmax_hist = plotting_functions.histogram_plot(self.data_tmax[~np.isnan(self.data_tmax)],\n 'TMax', 'red', 'degrees C')\n tmin_hist = plotting_functions.histogram_plot(self.data_tmin[~np.isnan(self.data_tmin)],\n 'TMin', 'blue', 'degrees C')\n tavg_hist = plotting_functions.histogram_plot(self.data_tmin[~np.isnan(self.data_tmin)],\n 'TAvg', 'black', 'degrees C')\n tdew_hist = plotting_functions.histogram_plot(self.data_tdew[~np.isnan(self.data_tdew)],\n 'TDew', 'black', 'degrees C')\n k_not_hist = plotting_functions.histogram_plot(self.k_not[~np.isnan(self.k_not)],\n 'Ko', 'black', 'degrees C')\n\n output_file(\"correction_files/\" + self.station_name + '_histograms.html',\n title=self.station_name + ' histograms')\n\n save(gridplot([ws_hist, tmax_hist, tmin_hist, tavg_hist, tdew_hist, k_not_hist], ncols=2,\n plot_width=400, plot_height=400, toolbar_location=None))\n\n #########################\n # Generate bokeh composite plot\n # Creates one large plot featuring all variables as subplots, used to get a concise overview of the full dataset\n # If user opts to not correct data (sets script_mode = 0), then this plots data before correction\n # If user does correct data, then this plots data after correction\n print(\"\\nSystem: Now creating composite bokeh graph.\")\n if self.generate_bokeh: # Flag to create graphs or not\n plot_list = []\n x_size = 500\n y_size = 350\n\n if self.script_mode == 0:\n output_file(\"correction_files/before_graphs/\" + self.station_name +\n \"_before_corrections_composite_graph.html\")\n elif self.script_mode == 1:\n output_file(\"correction_files/after_graphs/\" + self.station_name +\n \"_after_corrections_composite_graph.html\")\n else:\n # Incorrect setup of script mode variable, raise an error\n raise ValueError('Incorrect parameters: script mode is not set to a valid option.')\n\n # Temperature Maximum and Minimum Plot\n plot_tmax_tmin = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_tmax,\n self.data_tmin, 1, '')\n plot_list.append(plot_tmax_tmin)\n # Temperature Minimum and Dewpoint Plot\n plot_tmin_tdew = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_tmin,\n self.data_tdew, 2, '', plot_tmax_tmin)\n plot_list.append(plot_tmin_tdew)\n\n # Subplot 3 changes based on what variables are provided\n if self.column_df.ea != -1: # Vapor pressure was provided\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ea, self.data_null,\n 7, 'Provided ', plot_tmax_tmin)\n\n elif self.column_df.ea == -1 and self.column_df.tdew != -1: # Tdew was provided, show calculated ea\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ea, self.data_null,\n 7, 'Calculated ', plot_tmax_tmin)\n\n elif self.column_df.ea == -1 and self.column_df.tdew == -1 and \\\n self.column_df.rhmax != -1 and self.column_df.rhmin != -1: # RH max and RH min\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhmax,\n self.data_rhmin, 8, '', plot_tmax_tmin)\n\n elif self.column_df.ea == -1 and self.column_df.tdew == -1 and \\\n self.column_df.rhmax == -1 and self.column_df.rhavg != -1: # RH Avg\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhavg,\n self.data_null, 9, '', plot_tmax_tmin)\n else:\n # If an unsupported combination of humidity variables is present, raise a value error.\n raise ValueError('Bokeh figure generation encountered an unexpected combination of humidity inputs.')\n\n plot_list.append(plot_humid)\n\n # If both ea and rhmax/rhmin are provided, generate a supplementary rhmax/min graph\n if self.column_df.rhmax != -1 and self.column_df.rhmin != -1 and self.column_df.ea != -1:\n plot_supplemental_rh = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhmax,\n self.data_rhmin, 8, '', plot_tmax_tmin)\n plot_list.append(plot_supplemental_rh)\n\n # Mean Monthly Temperature Minimum and Dewpoint\n plot_mm_tmin_tdew = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_tmin,\n self.mm_tdew, 2, 'MM ')\n plot_list.append(plot_mm_tmin_tdew)\n\n # Mean Monthly k0 curve (Tmin-Tdew)\n plot_mm_k_not = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_k_not,\n self.data_null, 10, '', plot_mm_tmin_tdew)\n plot_list.append(plot_mm_k_not)\n\n # Solar radiation and clear sky solar radiation\n plot_rs_rso = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rs, self.rso,\n 5, '', plot_tmax_tmin)\n plot_list.append(plot_rs_rso)\n\n # Windspeed\n plot_ws = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ws, self.data_null,\n 3, '', plot_tmax_tmin)\n plot_list.append(plot_ws)\n\n # Precipitation\n plot_precip = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_precip, self.data_null,\n 4, '', plot_tmax_tmin)\n plot_list.append(plot_precip)\n\n # Optimized mean monthly Thornton-Running solar radiation and Mean Monthly solar radiation\n plot_mm_opt_rs_tr = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_rs,\n self.mm_opt_rs_tr, 6, 'MM Optimized ', plot_mm_tmin_tdew)\n plot_list.append(plot_mm_opt_rs_tr)\n\n # Optimized mean monthly Thornton-Running solar radiation and Mean Monthly solar radiation\n plot_mm_orig_rs_tr = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_rs,\n self.mm_orig_rs_tr, 6, 'MM Original ', plot_mm_tmin_tdew)\n plot_list.append(plot_mm_orig_rs_tr)\n\n # Now construct grid plot out of all of the subplots\n number_of_plots = len(plot_list)\n number_of_rows = ceil(number_of_plots / self.gridplot_columns)\n\n grid_of_plots = [([None] * 1) for i in range(number_of_rows)]\n\n for i in range(number_of_rows):\n for j in range(self.gridplot_columns):\n\n if len(plot_list) > 0:\n grid_of_plots[i][j] = plot_list.pop(0)\n else:\n pass\n\n fig = gridplot(grid_of_plots, toolbar_location='left')\n save(fig)\n\n print(\"\\nSystem: Composite bokeh graph has been generated.\")","def plot(self):\n\t\tself.plotOfSpect()","def display_results(experiment, norms, nus, filename):\n # plot the results of the experiment\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\n\n # plot large scale overview\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\n\n # plot more detailed errors exluding OLS estimate\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\n\n # add title and save\n plt.savefig(filename, dpi=300)","def plot_results(self):\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))","def testNonLinearity():\n vis = VISinformation()\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\n nonlin = CCDnonLinearityModel(data.copy())\n\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\n\n fig = plt.figure(frameon=False)\n\n left, width = 0.1, 0.8\n rect1 = [left, 0.3, width, 0.65]\n rect2 = [left, 0.1, width, 0.2]\n\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\n\n ax1.axhline(y=0, c='k', ls='--')\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\n\n ax2.axhline(y=0, c='k', ls='--')\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\n\n ax1.axvline(x=97, c='k', ls='--')\n ax2.axvline(x=97, c='k', ls='--')\n\n ax1.set_xticklabels([])\n ax2.set_xlabel('Real Charge [electrons]')\n ax1.set_ylabel('(Output / Real - 1)*100')\n ax2.set_ylabel('O - R [ADUs]')\n\n ax1.set_xlim(0, vis['fullwellcapacity'])\n ax2.set_xlim(0, vis['fullwellcapacity'])\n ax1.set_ylim(-.15, .2)\n\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\n plt.savefig('NonlinearityModel.pdf')\n\n ax1.set_ylim(-.1, 8)\n ax2.set_ylim(0, 2)\n ax1.set_xlim(50, 800)\n ax2.set_xlim(50, 800)\n plt.savefig('NonlinearityModel2.pdf')\n\n plt.close()","def allDirectionalityRatios(ratioFunction):\n if not os.path.exists(\"savedHeatmaps\"):\n os.mkdir(\"savedHeatmaps\")\n wildRatio = np.log(ratioFunction(\"Wildtype_0min_BglII_rep1\"))\n for j, dataset in enumerate(datasets):\n ax = plt.subplot(len(datasets), 1, j + 1)\n curRatio = (ratioFunction(dataset))\n plt.title(\"{1}, r = {0:.2f}, p={2:.2e}\".format(pearsonr(curRatio, wildRatio)[0], names[dataset],\n pearsonr(curRatio, wildRatio)[1]), fontsize=10)\n plt.tick_params(axis='both', which='major', labelsize=10)\n plt.tick_params(axis='both', which='minor', labelsize=8)\n plt.plot(curRatio)\n plt.ylim((0.25, 0.75))\n plt.xlim((0, len(curRatio)))\n #plt.ylim((0, 1))\n plt.yticks((0.25, 0.5, 0.75))\n geneCoor = [1162773, 3509071, 1180887, 543099, 1953250, 2522439, 3328524, 1503879, 900483, 242693, 3677144, 3931680, 3677704, 3762707, 3480870, 3829656, 1424678, 901855, 1439056, 3678537]\n genePos = [i / 10000. for i in geneCoor]\n #genePos = []\n for lpos in genePos:\n plt.vlines(lpos , -.8, .8, alpha=0.2, linewidth=1, color=\"black\")\n plt.xticks([0, 50, 100, 150, 200, 250, 300, 350, 400], [\"\" for i in xrange(9)], fontsize=98)\n removeAxes(ax=ax)\n plt.subplots_adjust(0.07, 0.05, 0.94, 0.95, 0.2, 0.5)\n\n\n\n plt.show()\n exit()","def PCO1S12Noise():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\n 'NoiseStudy/TestOptics_PCO1S12/'\n d1,dx1 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas2.fits')\n d3,dx3 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas3.fits')\n\n #Construct power spectra\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f13,pow13 = fourier.meanPSD((d1-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n\n #Mid frequency\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([f12,f23,f13],[pow12,pow23,pow13])]\n\n #Plot\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\n plt.loglog(f13,pow13/f13[0],label='1-3: %.2f' % midfreq[2])\n plt.legend(loc='lower left')\n plt.grid()\n plt.title('4D Repeatability: PCO1S12')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n\n print midfreq\n\n return f12,pow12","def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\n \n # Determine dimensions of plot grid\n nrows = len(perp_list) + 1\n ncols = len(data_list)\n \n # Configure axes\n axes = []\n fig = plt.figure(figsize = (16, 3 * nrows))\n \n # Generate plots of starting points (first two columns for high-dimensional)\n for index, dat in enumerate(data_list):\n X, labs = dat\n \n # Check whether original data should be plotted in 3D, and adjust axes accordingly\n if plot_3d:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_axis_off()\n else:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n axes[-1].set_title(\"\\n\".join(wrap(title_list[index], 35))) \n \n # Based on function input, generate either perplexity plots of interim iteration plots\n if perp_plot:\n # Generate plots of t-SNE output for different perplexities\n for perp in range(len(perp_list)):\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \"fastest\", df = df)\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(perp_list[perp]))\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n else:\n # Generate plots of t-SNE output for different iterations\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \"fastest\", \\\n df = df)\n for step in range(len(step_list)):\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(step_plot_perp) + \", Step = \" + str(step_list[step]))\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\n edgecolor = None, alpha = 0.8,\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')","def plot_anomalies_data_specific(df, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False, adjusted = True):\n \n #result = test_stationarity(SpeciesName=Species, data = data)\n #result.plot()\n if syndrome:\n if adjusted:\n vo = df[df.prediction_adjusted == syndrome]\n else:\n vo = df[df.prediction == syndrome]\n else:\n vo = df\n \n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\n weekly_vo = pd.DataFrame(weekly_vo)\n weekly_vo.columns = ['ID']\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\n\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\n \n def identify_anomalies(c, sigma=sigma):\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\n return c.ID\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\n \n upper_bound = go.Scatter(\n name='upper Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\n mode='lines',\n marker=dict(color=\"#820101\"),\n line=dict(width=0),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n \n rolling_m = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['rolling mean'],\n name='rolling mean',\n mode='lines',\n line=dict(color='#1f77b4'),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n\n lower_bound = go.Scatter(\n name='lower Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\n marker=dict(color=\"#b7b7b7\"),\n line=dict(width=0),\n mode='lines',)\n\n addmissions = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['# admissions'],\n name='# admissions',)\n\n ano = go.Scatter(\n x = weekly_vo.index,\n y =weekly_vo['anomalies'] ,\n name='anomalies',\n mode='markers')\n\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\n \n T = \"Weekly admissions\"\n print (T)\n layout = go.Layout(\n title= 'Weekly admissions',\n yaxis=dict( title='number of admissions',), width=900, height=640\n )\n\n fig = go.Figure(data=plottingdata, layout=layout)\n plot_url = iplot(fig)\n if verbose:\n print('number of admissions triggering alert') \n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\n if save:\n name = 'special_syndrome_study'\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WRMD_paper/outputs/'+name+'.png')\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\n\n #from IPython.display import Image\n #Image('C:\\Users\\Falco\\Desktop\\directory\\WMRD\\data\\TimeSeries.png')\n \n return weekly_vo","def dk_plotting():\n heatmap_mode1_error_x(make_heatmap=False, make_panel=True)\n\n #heatmap_mode1_error_x()\n figure_2_combined_cross_sections()\n\n #heatmap_combined_error_c()\n #heatmap_combined_error_koff()\n #heatmap_kpr_error_c()\n #heatmap_kpr_error_koff()\n\n #heatmap_kpr2_error_c()\n #heatmap_kpr2_error_koff()\n\n ctildePosterior = [truncate(f, 3) for f in list(np.arange(0.0 * KON / KP, 5.0 * KON / KP + 0.005, 0.005))[1:]]\n kofftildePosterior = [truncate(f, 2) for f in list(np.arange(0.0 / KP, 50.0 / KP + 0.05, 0.05))[1:]]\n\n #heatmap_figure_4()\n\n return 0","def create_val_plots(x_vals, vals_zeros,vals_ones):\n plt.plot(x_vals, vals_zeros,label=\"non-fraud\")\n plt.plot(x_vals, vals_ones,label=\"fraud\")\n plt.title('Accuracy per number of iterations')\n plt.xlabel('Number of Iterations')\n plt.ylabel('Accuracy')\n plt.xticks(np.arange(100, 210, 10))\n plt.legend() \n plt.show()\n # plt.savefig('./analysis_deliverable/visualizations/accuracy_plot.png')","def evidence_tuning_plots(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\",\n x_name=\"Mean Predicted\",\n y_name=\"Empirical Probability\"):\n\n def lineplot(x, y, trials, methods, **kwargs):\n \"\"\"method_lineplot.\n\n Args:\n y:\n methods:\n kwargs:\n \"\"\"\n uniq_methods = set(methods.values)\n method_order = sorted(uniq_methods)\n\n method_new_names = [f\"$\\lambda={i:0.4f}$\" for i in method_order]\n method_df = []\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\n method_new_names)):\n lines_y = y[methods == method]\n lines_x = x[methods == method]\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\n\n to_append = [{x_name : x,\n y_name: y,\n \"Method\": method_new_name,\n \"Trial\" : trial}\n for i, (x,y) in enumerate(zip(xx,yy))]\n method_df.extend(to_append)\n method_df = pd.DataFrame(method_df)\n x = np.linspace(0,1,100)\n plt.plot(x, x, linestyle='--', color=\"black\")\n sns.lineplot(x=x_name, y=y_name, hue=\"Method\",\n alpha=0.8,\n hue_order=method_new_names, data=method_df,)\n # estimator=None, units = \"Trial\")\n\n df = df.copy()\n # Query methods that have evidence_new_reg_2.0\n df = df[[\"evidence\" in i for i in\n df['method_name']]].reset_index()\n\n # Get the regularizer and reset coeff\n coeff = [float(i.split(\"evidence_new_reg_\")[1]) for i in df['method_name']]\n df[\"method_name\"] = coeff\n df[\"Data\"] = convert_dataset_names(df[\"dataset\"])\n df[\"Method\"] = df[\"method_name\"]\n\n g = sns.FacetGrid(df, col=\"Data\", height=6, sharex = False, sharey = False)\n g.map(lineplot, x_input, y_input, \"trial_number\",\n methods=df[\"Method\"]).add_legend()","def test_control_loop_example():\n example.control.print_error_measurement()\n matplotlib.use('agg')\n example.control.visualise_error_measurement(fig_file='cs_compare.pdf')\n assert path.isfile('cs_compare.pdf')\n example.control.sil_comparison()","def plot_pretty():\n\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\n plt.style.use('seaborn-deep')\n\n black = '#2B2B2D'\n red = '#E90039'\n orange = '#FF1800'\n white = '#FFFFFF'\n yellow = '#FF9900'\n\n plt.figure(figsize=(12.8, 9.6))\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\n\n plt.gcf().set_facecolor(black)\n\n plt.subplot(2, 3, 1)\n plt.plot(ts, ys[:, 2], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\n plt.title(r'$C_{FA}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 2)\n plt.plot(ts, ys[:, 0], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\n plt.title(r'$C_{G}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 3)\n plt.plot(ts, ys[:, 3], color=orange)\n plt.title(r'$C_{E}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 4)\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\n plt.title(r'$F_{m, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 5)\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\n plt.title(r'$F_{G, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 6)\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 1],\n color=red\n )\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 0],\n color=yellow\n )\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\n plt.title('bias')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n # plt.suptitle('Closedloop bioreactor without noise')\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n plt.savefig('no_noise_pretty.png', transparent=True)\n plt.show()","def plot_evaluation(parameters_dict, log_df, settings, evaluation_set_kde, plotname):\n\n\n plots = []\n\n\n ### setup the colors for each component\n if int(settings['nr_components']) < 3:\n colors = ['rgb(228,26,28)', 'rgb(55,126,184)']\n elif int(settings['nr_components']) < 13:\n colors = np.array(cl.scales[str(settings['nr_components'])]['qual']['Paired'])\n else:\n colors = cl.interp(cl.scales['10']['qual']['Paired'], 20)\n\n\n ### set up ab list\n ab_list = evaluation_set_kde['contact'].keys()\n\n\n\n\n ####################### plotting of settings\n print_to_table = {}\n for key in sorted(settings.keys()):\n if key not in ['fold_id_dir','plot_name', 'fixed_parameters', 'threads_proteins', 'qijab_dir',\n 'debug_mode', 'parameter_file', 'settings_file', 'optimization_log_file', 'braw_dir', 'pdb_dir', 'paramdir',\n 'mask_sse', 'lambda_w_fix', 'lfactor', 'plotdir', 'psicov_dir', 'contact', 'hessian_pseudocount']:\n print_to_table[key] = settings[key]\n\n print(\"Generate settings table...\")\n table_settings_1 = plot_settings_table(print_to_table, 1)\n table_settings_2 = plot_settings_table(print_to_table, 2)\n table_settings_3 = plot_settings_table(print_to_table, 3)\n plots.append(table_settings_1)\n plots.append(table_settings_2)\n plots.append(table_settings_3)\n\n\n ####################### negLL and realted plots\n if 'step' in log_df.columns and 'pass' in log_df.columns:\n\n if 'negLL' in log_df.columns:\n plot_negll = plot_convergence_trace_plotly(log_df,\n name=['negLL', 'negLL_crossval'],\n plot_title='neg LL trace for training and cross-val set')\n plots.append(plot_negll)\n\n plot_expfit_negll = plot_exponentialFit_negLL(log_df, plot_title='exponential Fit neg LL')\n plots.append(plot_expfit_negll)\n\n if 'timestamp' in log_df.columns:\n plot_timestamps = plot_convergence_trace_plotly(log_df,\n name=['timestamp'],\n plot_title='time (s) per iteration')\n plots.append(plot_timestamps)\n\n\n if 'gradient_norm_weights' in log_df.columns:\n plot_grad_norm_weights = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_weights'],\n plot_title='norm of weight gradients')\n plots.append(plot_grad_norm_weights)\n\n if 'gradient_norm_means' in log_df.columns:\n plot_grad_norm_means = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_means'],\n plot_title='norm of mean gradients')\n plots.append(plot_grad_norm_means)\n\n if 'gradient_norm_prec' in log_df.columns:\n plot_grad_norm_prec = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_prec'],\n plot_title='norm of precMat gradients')\n plots.append(plot_grad_norm_prec)\n\n\n ####################### plotting of parameters\n print(\"Generate distribution of parameters...\")\n\n #weights\n weights_dict = {}\n for component in range(settings['nr_components']):\n weights_dict['component ' + str(component)] = {\n 'weights (contact)': parameters_dict[\"weight_contact_\" + str(component)][0],\n 'weights (bg)': parameters_dict[\"weight_bg_\" + str(component)][0]\n }\n plot_weights = plot_barplot(\n weights_dict,\n 'Distribution of weights',\n 'component weights',\n type='group',\n colors=colors\n #,plot_out=\"/home/vorberg/weights.html\"\n )\n\n #mu\n mu_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'mu' in k))\n plot_means = plot_boxplot(\n mu_df,\n 'Distribution of Means',\n \"values of mean parameters\",\n colors=colors\n #,plot_out=\"/home/vorberg/mus.html\"\n )\n\n #std deviation\n prec_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'prec' in k))\n try:\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/p))\n if settings['prec_wrt_L']:\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/(p*142))) #in case precision is specified depending on L=142\n except ZeroDivisionError as e:\n print(e)\n std_dev=prec_df\n\n std_dev.columns = [column_name.replace(\"prec\", \"std\") for column_name in std_dev.columns]\n plot_stddev = plot_boxplot(\n std_dev,\n 'Distribution of std deviations',\n \"values of std deviation parameters\",\n colors=colors\n #,plot_out=\"/home/vorberg/std.html\"\n )\n\n\n plots.append(plot_weights)\n plots.append(plot_means)\n plots.append(plot_stddev)\n\n ####################### Scatterplot mu vs std dev\n print(\"Generate scatter plot mu vs std...\")\n scatter_dict = {}\n for component in range(settings['nr_components']):\n scatter_dict['mu_'+str(component)] = [\n mu_df['mu_'+str(component)].tolist(),\n std_dev['std_'+str(component)].tolist(),\n AB.values()\n ]\n plot_mu_vs_stddev = plot_scatter(scatter_dict,\n 'Mean vs std deviation',\n 'mean',\n \"std deviation\",\n False,\n colors\n #,plot_out=\"/home/vorberg/mu_vs_std.html\"\n )\n\n plots.append(plot_mu_vs_stddev)\n\n\n ############################################## plotting of gradient norms\n print(\"Generate gradient norms plot...\")\n\n #gradients for mu\n mu_grad_dict = {}\n annotations_dict = {}\n for component in range(settings['nr_components']):\n key = 'mu_'+str(component)\n mu_grad_dict[key] = log_df[key].tolist()[-1]\n annotations_dict[key] = AB\n\n\n plot_gradient_mu_stats = jitter_plot(mu_grad_dict,\n 'Distribution of gradients for mean in last iteration',\n annotations_dict,\n colors,\n None)\n plots.append(plot_gradient_mu_stats)\n\n\n #gradients for precMat\n precMat_grad_dict = {}\n annotations_dict = {}\n for component in range(settings['nr_components']):\n key = 'prec_'+str(component)\n precMat_grad_dict['diagPrecMat_'+str(component)] = log_df[key].tolist()[-1]\n annotations_dict['diagPrecMat_'+str(component)] = AB\n\n\n plot_gradient_precMat_stats = jitter_plot(\n precMat_grad_dict,\n 'Distribution of gradients for precMat in last iteration',\n annotations_dict,\n colors,\n None\n )\n plots.append(plot_gradient_precMat_stats)\n\n ##################################### plotting of gradient trace of a specific ab pair for all components\n print(\"Generate gradient trace plot...\")\n\n gradient_df = log_df.filter(regex=(\"mu_[0-9]*\"))\n plot_gradient_mu_ab_trace = plot_gradient_ab_trace(gradient_df,\n ab_list,\n colors\n )\n plots.append(plot_gradient_mu_ab_trace)\n\n gradient_df = log_df.filter(regex=(\"prec_[0-9]*\"))\n plot_gradient_prec_ab_trace = plot_gradient_ab_trace(\n gradient_df,\n ab_list,\n colors\n )\n plots.append(plot_gradient_prec_ab_trace)\n\n\n ##################################### plotting of univariate mixtures\n if len(evaluation_set_kde['contact']) == 0 or len(evaluation_set_kde['bg']) == 0:\n print \"Evaluation set is empty. Cannot plot Mixture Visualization.\"\n else:\n print(\"Generate parameter visualization 1d plots...\")\n plots.append(plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L']))\n # plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L'], plot_out=\"/home/vorberg/1d_vis.html\")\n\n # ------------------------------------------------------------------------------\n ### define merged plot\n # ------------------------------------------------------------------------------\n cols = 3.0\n rows = int(np.ceil((len(plots)-1) / cols)) + 2\n subplot_titles = []\n\n # set up titles\n for plot in range(len(plots)-1):\n subplot_titles.append(plots[plot]['layout']['title'])\n if len(subplot_titles) < (cols * (rows-2)):\n for i in range(int((cols * (rows-2))) - len(subplot_titles) ):\n subplot_titles.append(\" \")\n subplot_titles.append(plots[-1]['layout']['title'])\n\n\n # plot all plots as subplots\n fig = tools.make_subplots(rows=rows,\n cols=3,\n specs = [ [{} for col in range(int(cols))] for row in range(rows-2)] + \\\n [[{'rowspan':2, 'colspan': 3}, None, None], [None, None, None]],\n subplot_titles=tuple(subplot_titles),\n print_grid=False)\n\n\n\n\n for i, plot in enumerate(plots[:-1]):\n col = i % int(cols)\n row = (i - col) / int(cols)\n\n #add traces to subplot\n for trace in plot['data']:\n trace['showlegend']=False\n fig.append_trace(trace, row + 1, col + 1)\n\n # adjust x and y axis for table plotting\n if 'annotations' in plot['layout'].keys():\n for cell in plot['layout']['annotations']:\n cell['yref'] = 'y' + str(i + 1)\n cell['xref'] = 'x' + str(i + 1)\n fig['layout']['annotations'] += plot['layout']['annotations']\n\n # adjust axis for all plots\n fig['layout']['xaxis' + str(i + 1)].update(plot['layout']['xaxis1'])\n fig['layout']['yaxis' + str(i + 1)].update(plot['layout']['yaxis1'])\n\n ## add mixture visualisation plot - spans 3 columns\n for trace in plots[-1]['data']:\n fig.append_trace(trace, int(rows)-1, 1)\n fig['layout']['xaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['xaxis1'])\n fig['layout']['yaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['yaxis1'])\n\n #check which plots are visible/invisible according to menu selection\n trace_visibility_ab = {}\n for ab in range(len(ab_list)):\n trace_visibility_ab[ab] = []\n for i, plot in enumerate(plots):\n if 'updatemenus' not in plot['layout'].keys():\n trace_visibility_ab[ab].extend([True] * len(plot['data']))\n else:\n trace_visibility_ab[ab].extend(plot['layout']['updatemenus'][0]['buttons'][ab]['args'][1])\n\n\n #use menu of last plot (=vis of mixture) as template for multiplot menu\n fig['layout']['updatemenus'] = plots[-1]['layout']['updatemenus']\n for ab in range(len(ab_list)):\n fig['layout']['updatemenus'][0]['buttons'][ab]['args'][1] = trace_visibility_ab[ab]\n\n\n fig['layout']['legend']['yanchor'] = 'bottom'\n fig['layout']['legend']['y'] = 0\n fig['layout']['height'] = rows * 250\n fig['layout']['font'] = {'size': 18} # set global font size\n\n plotly_plot(fig, filename=plotname, auto_open=False)","def SA_data_display(opt_df, all_df):\n fig, axs = plt.subplots(2, 3)\n\n axs[0,0].set_title(\"Optimal rewire attempts for circularity\")\n axs[0,0].set_ylabel(\"Percent waste %\")\n axs[0,0].set_xlabel(\"Time (s)\")\n axs[0,0].plot(opt_df[\"Time (s)\"], opt_df[\"Percent waste (%)\"])\n\n axs[0,1].set_title(\"Optimal rewire attempts acceptance probability\")\n axs[0,1].set_ylabel(\"Acceptance Probability\")\n axs[0,1].set_xlabel(\"Time (s)\") # time??\n axs[0,1].scatter(opt_df[\"Time (s)\"], opt_df[\"Probability\"])\n\n axs[0,2].set_title(\"Optimal rewire attempts temperature decrease\")\n axs[0,2].set_ylabel(\"Temperature\")\n axs[0,2].set_xlabel(\"Time (s)\") # time??\n axs[0,2].plot(opt_df[\"Time (s)\"], opt_df[\"Temperature\"])\n\n axs[1,0].set_title(\"All rewire attempts for circularity\")\n axs[1,0].set_ylabel(\"Percent waste %\")\n axs[1,0].set_xlabel(\"Time (s)\")\n axs[1,0].plot(all_df[\"Time (s)\"], all_df[\"Percent waste (%)\"])\n\n axs[1,1].set_title(\"All rewire attempts acceptance probability\")\n axs[1,1].set_ylabel(\"Acceptance Probability\")\n axs[1,1].set_xlabel(\"Time (s)\") # time??\n axs[1,1].scatter(all_df[\"Time (s)\"], all_df[\"Probability\"])\n\n axs[1,2].set_title(\"All rewire attempts temperature decrease\")\n axs[1,2].set_ylabel(\"Temperature\")\n axs[1,2].set_xlabel(\"Time (s)\") # time??\n axs[1,2].plot(all_df[\"Time (s)\"], all_df[\"Temperature\"])\n\n return plt.show()","def main():\n save = False\n show = True\n\n #hd_parameter_plots = HDparameterPlots(save=save)\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\n #ice5g_comparison_plots.plotLine()\n #ice5g_comparison_plots.plotFilled()\n #ice5g_comparison_plots.plotCombined()\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\n #flowmapplot = FlowMapPlots(save)\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\n #flowmapplot.Etopo1FlowMap()\n #flowmapplot.ICE5G_data_all_points_0k()\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\n #flowmapplot.Etopo1FlowMap_two_color()\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\n outflowplots = OutflowPlots(save)\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #hd_output_plots = HDOutputPlots()\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\n #lake_plots = LakePlots()\n #lake_plots.plotLakeDepths()\n #lake_plots.LakeAndRiverMap()\n #lake_plots.LakeAndRiverMaps()\n if show:\n plt.show()","def plot_tsnes():\n # Two environments (for main paper figure. All for final figure)\n ENVS = [\n \"BipedalWalker-v3\",\n #\"LunarLander-v2\",\n #\"Pendulum-v0\"\n \"Acrobot-v1\",\n #\"CartPole-v1\"\n ]\n ALGO_TYPES = [\n \"stablebaselines\",\n \"stablebaselines\",\n \"wann\",\n \"wann\",\n ]\n ALGO_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMAES\",\n ]\n ALGO_PRETTY_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMA-ES\"\n ]\n\n REWARD_SCALES = {\n \"Pendulum-v0\": [-1600, -200],\n \"Acrobot-v1\": [-500, -100],\n \"LunarLander-v2\": [-230, 200],\n \"BipedalWalker-v3\": [-100, 300],\n \"CartPole-v1\": [0, 500]\n }\n\n figure, axs = pyplot.subplots(\n figsize=[6.4 * 2, 4.8],\n nrows=2,\n ncols=4,\n gridspec_kw={'hspace': 0, 'wspace': 0},\n )\n\n for plot_i in range(2):\n env = ENVS[plot_i]\n reward_scale = REWARD_SCALES[env]\n for algo_i in range(len(ALGO_TYPES)):\n column_idx = (algo_i % 2) + plot_i * 2\n row_idx = 0 if algo_i <= 1 else 1\n ax = axs[row_idx, column_idx]\n algo_type = ALGO_TYPES[algo_i]\n algo_name = ALGO_NAMES[algo_i]\n algo_pretty_name = ALGO_PRETTY_NAMES[algo_i]\n\n experiment_glob = \"experiments/{}_{}_{}_*\".format(algo_type, env, algo_name)\n experiment_paths = glob(experiment_glob)\n tsnes = []\n rewards = []\n for experiment_path in experiment_paths:\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n population_tsnes = []\n population_rewards = []\n for path in pivector_paths:\n data = np.load(path)\n population_tsnes.append(data[\"tsne\"])\n population_rewards.append(data[\"average_episodic_reward\"])\n data.close()\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n tsnes = np.concatenate(tsnes, axis=0)\n rewards = np.concatenate(rewards, axis=0)\n\n # Min-max normalization\n rewards = (rewards - reward_scale[0]) / (reward_scale[1] - reward_scale[0])\n\n scatter = ax.scatter(\n tsnes[:, 0],\n tsnes[:, 1],\n c=rewards,\n cmap=\"plasma\",\n s=1,\n vmin=0,\n vmax=1\n )\n\n ax.text(0.98, 0.98, algo_pretty_name, horizontalalignment=\"right\", verticalalignment=\"top\", transform=ax.transAxes)\n ax.set_xticks([])\n ax.set_yticks([])\n # Hide spines, the outer edges\n ax.spines[\"top\"].set_alpha(0.2)\n ax.spines[\"bottom\"].set_alpha(0.2)\n ax.spines[\"left\"].set_alpha(0.2)\n ax.spines[\"right\"].set_alpha(0.2)\n # Hide edge spines and bolden mid-spines\n if row_idx == 0:\n ax.spines[\"top\"].set_visible(False)\n else:\n ax.spines[\"bottom\"].set_visible(False)\n if column_idx == 0:\n ax.spines[\"left\"].set_visible(False)\n elif column_idx == 1:\n ax.spines[\"right\"].set_alpha(1.0)\n elif column_idx == 2:\n ax.spines[\"left\"].set_alpha(1.0)\n elif column_idx == 3:\n ax.spines[\"right\"].set_visible(False)\n\n # Add titles\n if row_idx == 0 and (column_idx == 0 or column_idx == 2):\n ax.set_title(env.split(\"-\")[0], x=1.0)\n\n cbaxes = figure.add_axes([0.4, 0.94, 0.2, 0.02])\n cbar = figure.colorbar(scatter, orientation=\"horizontal\", cax=cbaxes)\n cbar.set_ticks([0.0, 0.5, 1.0])\n cbar.set_ticklabels([\"Min\", \"Reward\", \"Max\"])\n cbar.ax.xaxis.set_ticks_position('top')\n cbar.ax.xaxis.set_label_position('top')\n cbar.ax.tick_params(labelsize=\"small\", length=0)\n figure.tight_layout()\n figure.savefig(\"figures/tsnes.png\", dpi=200, bbox_inches=\"tight\", pad_inches=0.0)","def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\n action_legend_location=None):\n\n #get location of files\n running_reward_file, _, actions_file = \\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\n\n #font size\n matplotlib.rcParams.update({'font.size': 14, \"text.usetex\": True,\n 'text.latex.preamble' : r'\\usepackage{amsmath}\\usepackage{physics}'})\n\n #create the axis (subplots)\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\n reward_ax = fig.add_subplot(gs[0, :])\n prot_0_ax = fig.add_subplot(gs[1, 0])\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\n prot_final_ax = fig.add_subplot(gs[2, :])\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \n\n #set the reward axis\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\n custom_color = \"black\", lines_to_mark = [nearest_int(act_0/actions_per_log),\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\n custom_mark_color=\"black\",ylim=reward_ylim,ylabel=reward_ylabel,\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\n legend_labels=reward_legend_labels)\n\n #set the three actions axis\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\n two_xticks=True)\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_1,ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_2, ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\n\n #set the final protocol axis\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\n actions_ylim=large_action_ylim,plot_to_file_line=None,\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\n linewidth = prot_linewidth, xlabel=\"$t[dt]$\",extra_cycles=extra_cycles,\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\n legend_text=action_legend_text, legend_location=action_legend_location)\n\n #add the (a) (b) (c) labels\n reward_ax.text(-0.11,-0.38, r'\\textbf{(a)}', transform=reward_ax.transAxes )\n prot_0_ax.text(-0.4,-0.55, r'\\textbf{(b)}', transform=prot_0_ax.transAxes )\n prot_final_ax.text(-0.11,-0.38, r'\\textbf{(c)}', transform=prot_final_ax.transAxes )\n\n #save if necessary\n if plot_file_name is not None:\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\n plot_file_name = os.path.join(plot_folder, plot_file_name)\n plt.savefig(plot_file_name)\n\n #show\n plt.show()","def plot_noise(data_obj, test_num):\n\n #=======================================================================#\n # Create and plot the page for the X values of the test (NEQ, NPS, MTF) #\n #=======================================================================#\n\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf\n\n # Display the (centered) title of the figures / page\n plt.suptitle('Test ' + str(test_num) +\n ': Noise ($NEQ_x$ at 1 lp/mm: ' +\n \"{:,}\".format(int(data_obj.NEQ_x_1)) + ')')\n\n #--------------------------------------------------------------------------#\n # Display the equation and variables of the test to the middle of the page #\n #--------------------------------------------------------------------------#\n fs3 = 10\n plt.subplot(3, 1, 1)\n plt.axis('off')\n\n # Display the main equation for calculating the NEQ\n str1 = \"$ NEQ = \\\\frac{S_{out}^2 MTF^2}{NPS} $\"\n plt.text(0.3, 0.6, str1, ha='left', fontsize=16)\n\n # Display the values of the different variables in the NEQ equation\n str1 = \"$NPS_x$ (at 1 lp/mm) = \" + \"{0:.1f}\".format((data_obj.NPS_x_1))\n plt.text(0.3, 0.4, str1, ha='left', fontsize=fs3)\n\n str1 = \"$MTF_x$ (at 1 lp/mm) = \" + \"{0:.3f}\".format((data_obj.MTF_x_1))\n plt.text(0.3, 0.3, str1, ha='left', fontsize=fs3)\n\n str1 = \"$S_{out}$ (at 1 lp/mm) = \" + \"{:,}\".format(int(data_obj.S_out))\n plt.text(0.3, 0.2, str1, ha='left', fontsize=fs3)\n\n str1 = \"$NEQ_x$ (at 1 lp/mm) = \" + \"{:,}\".format(int(data_obj.NEQ_x_1))\n str1 = str1 + ' $\\pm$ ' + \"{:,}\".format(int(data_obj.NEQ_x_1_err))\n plt.text(0.3, 0.1, str1, ha='left', fontsize=fs3)\n\n\n #------------------------------------------------#\n # Display the graphs for NEQ_x, MTF_x, and NPS_x #\n #------------------------------------------------#\n\n plt.subplot(3, 2, 3)\n plt.ylabel('$MTF_x$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_x_f, data_obj.MTF_data.MTF_x)\n\n plt.subplot(3, 2, 4)\n plt.ylabel('$\\\\sqrt{NPS_x}$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_x_f[1:], np.sqrt(data_obj.NPS_x_interp[1:]))\n\n plt.subplot(3, 1, 3)\n plt.ylabel('$\\\\sqrt{NEQ_x}$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_x_f, np.sqrt(data_obj.NEQ_x))\n\n ind = int(1 / 0.02)\n plt.plot(data_obj.MTF_data.MTF_x_f[ind], np.sqrt(data_obj.NEQ_x[ind]), 'ro')\n plt.tight_layout()\n\n\n ##=======================================================================#\n # Create and plot the page for the X values of the test (NEQ, NPS, MTF) #\n #=======================================================================#\n\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf\n\n # Display the (centered) title of the figures / page\n plt.suptitle('Test ' + str(test_num) +\n ': Noise ($NEQ_y$ at 1 lp/mm: ' +\n \"{:,}\".format(int(data_obj.NEQ_y_1)) + ')')\n\n # --------------------------------------------------------------------------#\n # Display the equation and variables of the test to the middle of the page #\n # --------------------------------------------------------------------------#\n fs3 = 10\n plt.subplot(3, 1, 1)\n plt.axis('off')\n\n # Display the main equation for calculating the NEQ\n str1 = \"$ NEQ = \\\\frac{S_{out}^2 MTF^2}{NPS} $\"\n plt.text(0.3, 0.6, str1, ha='left', fontsize=16)\n\n # Display the values of the different variables in the NEQ equation\n str1 = \"$NPS_y$ (at 1 lp/mm) = \" + \"{0:.1f}\".format((data_obj.NPS_y_1))\n plt.text(0.3, 0.4, str1, ha='left', fontsize=fs3)\n\n str1 = \"$MTF_y$ (at 1 lp/mm) = \" + \"{0:.3f}\".format((data_obj.MTF_y_1))\n plt.text(0.3, 0.3, str1, ha='left', fontsize=fs3)\n\n str1 = \"$S_{out}$ (at 1 lp/mm) = \" + \"{:,}\".format(int(data_obj.S_out))\n plt.text(0.3, 0.2, str1, ha='left', fontsize=fs3)\n\n str1 = \"$NEQ_y$ (at 1 lp/mm) = \" + \"{:,}\".format(int(data_obj.NEQ_y_1))\n str1 = str1 + ' $\\pm$ ' + \"{:,}\".format(int(data_obj.NEQ_y_1_err))\n plt.text(0.3, 0.1, str1, ha='left', fontsize=fs3)\n\n #------------------------------------------------#\n # Display the graphs for NEQ_y, MTF_y, and NPS_y #\n #------------------------------------------------#\n\n plt.subplot(3, 2, 3)\n plt.ylabel('$MTF_y$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_y_f, data_obj.MTF_data.MTF_y)\n\n plt.subplot(3, 2, 4)\n plt.ylabel('$\\\\sqrt{NPS_y}$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_y_f[1:], np.sqrt(data_obj.NPS_y_interp[1:]))\n\n plt.subplot(3, 1, 3)\n plt.ylabel('$\\\\sqrt{NEQ_y}$')\n plt.xlabel('Line-pairs per mm')\n plt.plot(data_obj.MTF_data.MTF_y_f, np.sqrt(data_obj.NEQ_y))\n\n ind = int(1 / 0.02)\n plt.plot(data_obj.MTF_data.MTF_y_f[ind], np.sqrt(data_obj.NEQ_y[ind]), 'ro')\n plt.tight_layout()","def apolco(a,minfeh=-3,out=None) :\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\n fig=vscat(a[apo],marker='o',density=True)\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\n if out is not None : \n fig[0].savefig(out+'_1.png')\n plt.close()\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\n print('matched {:d} stars'.format(len(i1)))\n fig,ax=plots.multi(1,2)\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[0].set_xlabel(r'$\\Delta$ VHELIO_AVG')\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\n ax[1].set_xlabel(r'$\\Delta$ VSCATTER')\n if out is not None : \n fig.savefig(out+'_2.png')\n plt.close()","def generate_plots(fixed, moving, warped, flows, train_loss, val_loss, reg_loss, epoch):\n moving = moving.detach().cpu().numpy()\n fixed = fixed.detach().cpu().numpy()\n warped = [w.detach().cpu().numpy() for w in warped]\n flows = [f.detach().cpu().numpy() for f in flows]\n\n fig = plt.figure(constrained_layout=True, figsize=(4 * 5, 4 * 3))\n ax_dict = fig.subplot_mosaic(\"\"\"\n FABCD\n LGHIE\n MKJWX\n \"\"\")\n\n ax_dict['F'].imshow(moving[0, 0, ...], cmap='gray')\n ax_dict['F'].set_title('Moving')\n\n ax_dict['W'].imshow(fixed[0, 0, ...], cmap='gray')\n ax_dict['W'].set_title('Fixed')\n\n for i, ax_name in enumerate(list(\"ABCDEX\")):\n ax_dict[ax_name].imshow(warped[i][0, 0, ...], cmap='gray')\n if ax_name == \"A\":\n ax_dict[ax_name].set_title(\"Affine\")\n else:\n ax_dict[ax_name].set_title(f\"Cascade {i}\")\n\n ax_dict['L'].plot(train_loss, color='red', label='train_loss')\n ax_dict['L'].plot(val_loss, label='val_loss', color='blue')\n ax_dict['L'].plot(reg_loss, label='train_reg_loss', color='green')\n ax_dict['L'].set_title(\"Losses\")\n ax_dict['L'].grid()\n ax_dict['L'].set_xlim(0, args.e)\n ax_dict['L'].legend(loc='upper right')\n ax_dict['L'].scatter(len(train_loss) - 1, train_loss[-1], s=20, color='red')\n ax_dict['L'].scatter(len(val_loss) - 1, val_loss[-1], s=20, color='blue')\n ax_dict['L'].scatter(len(reg_loss) - 1, reg_loss[-1], s=20, color='green')\n\n for i, ax_name in enumerate(list(\"GHIJKM\")):\n plot_grid(ax_dict[ax_name], flows[i][0, ...])\n if ax_name == \"G\":\n ax_dict[ax_name].set_title(\"Affine\")\n else:\n ax_dict[ax_name].set_title(f\"Cascade {i}\")\n\n plt.suptitle(f\"Epoch {epoch}\")\n plt.savefig(f'./ckp/visualization/epoch_{epoch}.png')","def build_scatter_plots(dep_vars, cont_corr_data, continous, combined_data, drop_outliers=True, tps=False,\n replacement=0.01):\n\n for i, column in enumerate(dep_vars.columns):\n # Calculating number of graphs\n cont_cols = continous.columns.to_list()\n if i != len(dep_vars.columns) - 1 and not tps:\n cont_cols = cont_cols + dep_vars.columns.to_list()[i + 1:]\n if not tps:\n num_rows = len(cont_cols) + 2 * len(continous.columns) + 2 * len(dep_vars.columns.to_list()[i + 1:])\n else:\n num_rows = 3 * len(cont_cols)\n fig = make_subplots(rows=num_rows, subplot_titles=range(num_rows))\n row_num = 1\n for value in cont_cols:\n # Getting data\n scatter_data = pd.DataFrame({\"x\": combined_data[value],\n \"y\": combined_data[column]})\n if drop_outliers:\n # Apply 3 sigma rule\n scatter_data = scatter_data.loc[rem_outliers(scatter_data[\"x\"])]\n scatter_data = scatter_data.loc[rem_outliers(scatter_data[\"y\"])]\n # Replace zeros with little values and create logarithmic variation\n scatter_data[\"y\"] = scatter_data[\"y\"].apply(lambda x: replacement if x == 0 else x)\n log_y = scatter_data[\"y\"].apply(lambda x: log(x))\n log_x = scatter_data[\"x\"].apply(lambda x: replacement if x == 0 else x).apply(lambda x: log(x))\n\n # Creating graph on initial data, stating first pearson p-value, kendall p-value and sample size\n p_value_pearson = cont_corr_data.loc[f\"pearson_{column}\", value]\n p_value_kendall = cont_corr_data.loc[f\"kendall_{column}\", value]\n sample_size = int(cont_corr_data.loc[f\"sample_size_{column}\", value])\n text = f\"pearson: {p_value_pearson:.4f}, kendall: {p_value_kendall:.4f}, sample: {sample_size}\"\n build_scatter_subplot(fig, scatter_data[\"x\"], scatter_data[\"y\"], row_num, text, value, column)\n row_num = row_num + 1\n\n # Creating graph on log data, stating second pearson p-value, kendall p-value and sample size\n p_value_pearson = cont_corr_data.loc[f\"log_pearson_{column}\", value]\n p_value_kendall = cont_corr_data.loc[f\"kendall_{column}\", value]\n sample_size = int(cont_corr_data.loc[f\"sample_size_{column}\", value])\n text = f\"log({column}) pearson: {p_value_pearson:.4f}, kendall: {p_value_kendall:.4f}, \" \\\n f\"sample: {sample_size}\"\n build_scatter_subplot(fig, scatter_data[\"x\"], log_y, row_num, text, value, column)\n row_num = row_num + 1\n\n # Creating graph on log indep variable, stating first pearson p-value, kendall p-value and sample size\n p_value_pearson = cont_corr_data.loc[f\"log({value})_{column}_pearson\", value]\n sample_size = int(cont_corr_data.loc[f\"sample_size_{column}\", value])\n text = f\"log({value}) pearson: {p_value_pearson:.4f}, sample: {sample_size}\"\n build_scatter_subplot(fig, log_x, scatter_data[\"y\"], row_num, text, value, column)\n row_num = row_num + 1\n if not tps:\n fig.update_layout(height=4800, width=600)\n else:\n fig.update_layout(height=600, width=600)\n fig.update_layout(showlegend=False, plot_bgcolor='rgba(0,0,0,0)')\n fig.write_html(f'figures/scatter_{column}_{time.time()}.html', auto_open=True)","def _plot(self):\n # Read results\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\n x1, y1, _ = read_results('openmc', path)\n if self.code == 'serpent':\n path = self.other_dir / 'input_det0.m'\n else:\n path = self.other_dir / 'outp'\n x2, y2, sd = read_results(self.code, path)\n\n # Convert energies to eV\n x1 *= 1e6\n x2 *= 1e6\n\n # Normalize the spectra\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\n\n # Compute the relative error\n err = np.zeros_like(y2)\n idx = np.where(y2 > 0)\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\n \n # Set up the figure\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\n ax1 = fig.add_subplot(111)\n \n # Create a second y-axis that shares the same x-axis, keeping the first\n # axis in front\n ax2 = ax1.twinx()\n ax1.set_zorder(ax2.get_zorder() + 1)\n ax1.patch.set_visible(False)\n \n # Plot the spectra\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\n \n # Plot the relative error and uncertainties\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\n \n # Set grid and tick marks\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\n ax1.grid(b=False, axis='both', which='both')\n ax2.tick_params(axis='y', which='both', right=False)\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\n \n # Set axes labels and limits\n ax1.set_xlim([self._min_energy, self.energy])\n ax1.set_xlabel('Energy (eV)', size=12)\n ax1.set_ylabel('Spectrum', size=12)\n ax1.legend()\n ax2.set_ylabel(\"Relative error\", size=12)\n title = f'{self.nuclide}'\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n title += f' + {thermal_name}'\n title += f', {self.energy:.1e} eV Source'\n plt.title(title)\n \n # Save plot\n os.makedirs('plots', exist_ok=True)\n if self.name is not None:\n name = self.name\n else:\n name = f'{self.nuclide}'\n if self.thermal is not None:\n name += f'-{thermal_name}'\n name += f'-{self.energy:.1e}eV'\n if self._temperature is not None:\n name += f'-{self._temperature:.1f}K'\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\n plt.close()","def display_analysis_result(column1: pd.Series, column2: pd.Series, name1: str, name2: str):\n\n print(\"Correlation between '%s' and '%s':\" % (name1, name2))\n print(\"Covariance: \" + str(calculate_covariance(column1, column2)))\n print(\"Correlation coefficient: \" + str(calculate_correlation_coefficient(column1, column2)))\n print(\"Significance of coefficient: \" + str(calculate_significance_of_coefficient(column1, column2)))\n print()\n\n draw_scatter_plot(column1, column2, name1, name2)\n draw_residual_plot(column1, column2, name1, name2)","def plot_derivatives_divided(self, show=False):\n\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\n ax[2, 0].set_title('Difference between upper and lower training examples');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n ax[2, 0].legend(frameon=False)\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\n ax[2, 1].set_title('Difference between upper and lower test samples');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def single_decoding_weber_law_plot(data_idxs=2):\n\n\tdecode_plot_size = 8\n\tnum_gain_plots = data_idxs/2\n\tgain_plot_size = 4\n\test_plot_upper_pad = 3\n\test_plot_height = 6\n\tnum_est_plots = 2\n\t\n\t\n\tfig = plt.figure()\n\tgrid_width = decode_plot_size + 1 + gain_plot_size*num_gain_plots\n\tgrid_height = decode_plot_size + est_plot_upper_pad + \\\n\t\t\t\t\test_plot_height*num_est_plots\n\tgs = gridspec.GridSpec(grid_height, grid_width)\n\tgs.update(wspace=6.5, hspace=1.0)\n\tfig.set_size_inches(13, 16)\n\t\n\t# Some font and label sizes for later use\n\ttick_label_size_small = 30\n\ttick_label_size_large = 30\n\taxis_label_size = 34\n\tx_axis_label_pad = 15\n\ty_axis_successes_labelpad = 8\n\tx_tick_label_pad = 11\n\t\n\tax = dict()\n\t\n\t# Success error plots\n\tax['successes'] = plt.subplot(gs[0:decode_plot_size, 0:decode_plot_size])\n\tplt.xscale('log')\n\tplt.xticks(10.**sp.arange(-5, 5), fontsize=tick_label_size_large)\n\tplt.yticks([0, 50, 100], fontsize=tick_label_size_large)\n\tax['successes'].tick_params(axis='x', which='major', pad=x_tick_label_pad)\n\tax['successes'].set_xlabel(r'Background signal', fontsize=axis_label_size, \n\t\t\t\t\t\t\t\tlabelpad=x_axis_label_pad)\n\tax['successes'].set_ylabel(r'Correctly decoded (%)', \n\t\t\t\t\t\t\t\tfontsize=axis_label_size, \n\t\t\t\t\t\t\t\tlabelpad=y_axis_successes_labelpad, \n\t\t\t\t\t\t\t\tmultialignment='center')\n\tax['successes'].set_xlim([1e-1, 1.5e2])\n\t\n\t# Gain plots\n\tfor data_idx in sp.arange(0, data_idxs):\n\t\tif data_idx % 2 == 0: \n\t\t\tax['gains_%s' % data_idx] = \\\n\t\t\t\tplt.subplot(gs[0:gain_plot_size, decode_plot_size + \\\n\t\t\t\t\t\t\t1 + (data_idx/2)*gain_plot_size: decode_plot_size + \\\n\t\t\t\t\t\t\t1 + gain_plot_size + (data_idx/2)*gain_plot_size])\n\t\telif data_idx % 2 == 1:\n\t\t\tax['gains_%s' % data_idx] = \\\n\t\t\t\tplt.subplot(gs[gain_plot_size:2*gain_plot_size, decode_plot_size + \\\n\t\t\t\t\t\t\t1 + (data_idx/2)*gain_plot_size: decode_plot_size + \\\n\t\t\t\t\t\t\t1 + gain_plot_size + (data_idx/2)*gain_plot_size])\n\t\n\t\tax['gains_%s' % data_idx].set_xscale('log')\n\t\tax['gains_%s' % data_idx].set_yscale('log')\n\t\tax['gains_%s' % data_idx].set_xlim(1e-2, 1e0)\n\t\tax['gains_%s' % data_idx].set_xticks([])\n\t\tax['gains_%s' % data_idx].set_yticks([])\n\t\t\n\t\t# Gain plots ticks labels and axis ranges\n\t\tif data_idx / 2 == 0:\n\t\t\tax['gains_%s' % data_idx].set_yticks(10.**sp.arange(-5, 0))\n\t\t\tax['gains_%s' % data_idx].tick_params(labelsize=tick_label_size_large)\n\t\tif data_idx % 2 == 0:\n\t\t\tax['gains_%s' % data_idx].set_ylim(2e-3, 4e-2)\n\t\telif data_idx % 2 == 1:\n\t\t\tax['gains_%s' % data_idx].set_ylim(1.1e-2, 2e-1)\n\t\t\tax['gains_%s' % data_idx].set_xticks([1e-2, 1e-1, 1e0])\t\n\t\t\tax['gains_%s' % data_idx].\\\n\t\t\t\t\ttick_params(axis='x', labelsize=tick_label_size_small)\n\t\t\tax['gains_%s' % data_idx].\\\n\t\t\t\t\ttick_params(axis='y', labelsize=tick_label_size_large)\n\t\tax['gains_%s' % data_idx].set_xlim(0.98e-2, 1.4e-1)\n\t\tax['gains_%s' % data_idx].tick_params(axis='x', which='major', \n\t\t\t\t\t\t\t\t\t\t\t\tpad=x_tick_label_pad)\n\t\t\t\n\t\t# Gaain axis label in center of range of plots\n\t\tif num_gain_plots % 2 == 0:\n\t\t\tif data_idx == data_idxs/2 - 1:\n\t\t\t\tax['gains_%s' % data_idx].set_xlabel(r'Background signal', \n\t\t\t\t\t\t\t\t\t\t\tfontsize=axis_label_size, \n\t\t\t\t\t\t\t\t\t\t\tlabelpad=x_axis_label_pad)\n\t\t\t\tax['gains_%s' % data_idx].xaxis.set_label_coords(1.1, -.455)\n\t\t\t\t\n\t\telif num_gain_plots % 2 == 1:\n\t\t\tif data_idx == data_idxs/2:\n\t\t\t\tax['gains_%s' % data_idx].set_xlabel(r'Background signal', \n\t\t\t\t\t\t\t\t\t\t\tfontsize=axis_label_size, \n\t\t\t\t\t\t\t\t\t\t\tlabelpad=x_axis_label_pad)\n\t\tif data_idx == data_idxs - 2:\n\t\t\tax['gains_%s' % data_idx].yaxis.set_label_position('right')\n\t\t\tax['gains_%s' % data_idx].set_ylabel(\n\t\t\t\t\t\tr'Receptor gain', fontsize=axis_label_size, \n\t\t\t\t\t\trotation=270)\n\t\t\tax['gains_%s' % data_idx].yaxis.set_label_coords(1.4, -0.1)\n\t\t\t\t\n\t# Sample estimation plot\n\tfor est_idx in range(num_est_plots):\n\t\tax['est_%s' % est_idx] = \\\n\t\t\tplt.subplot(gs[decode_plot_size + est_plot_upper_pad\n\t\t\t\t\t\t+ est_idx*est_plot_height:\n\t\t\t\t\t\tdecode_plot_size + est_plot_upper_pad \n\t\t\t\t\t\t+ (est_idx + 1)*est_plot_height, 0:grid_width])\n\t\tax['est_%s' % est_idx].set_yticks([])\n\t\t\n\t\t# Sample estimation plots labels only on outside\n\t\tif est_idx == num_est_plots/2:\n\t\t\tax['est_%s' % est_idx].set_xticks(sp.arange(10, 100, 10))\n\t\t\tax['est_%s' % est_idx].yaxis.set_label_coords(-0.03, 1.1)\n\t\t\tax['est_%s' % est_idx].set_xlabel(r'Odorant identity', \n\t\t\t\t\t\t\t\t\t\t\t\tfontsize=axis_label_size,\n\t\t\t\t\t\t\t\t\t\t\t\tlabelpad=x_axis_label_pad)\n\t\t\tax['est_%s' % est_idx].set_ylabel(r'Odorant intensity', \n\t\t\t\t\t\t\t\t\t\t\t\tfontsize=axis_label_size)\n\t\t\tax['est_%s' % est_idx].tick_params(labelsize=tick_label_size_large, \n\t\t\t\t\t\t\t\t\t\t\t\tpad=x_tick_label_pad)\n\t\telse:\n\t\t\tax['est_%s' % est_idx].set_xticks([])\n\t\tax['est_%s' % est_idx].set_xlim(35, 99)\n\t\t\n\treturn fig, ax"],"string":"[\n \"def Diagnostic_plot2(self):\\n\\n probs = pd.read_csv(self.probfile)\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'SNR')\\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n #plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')\",\n \"def diagnose(self):\\n return self._diagnostic_plot()\",\n \"def galactic_correction_summary(self):\\n t = self.GalacticCorrection(self).x\\n dd = dict()\\n for i,c in enumerate(t.T):\\n dd[i] = dict(offset=c.mean()-1,std=c.std())\\n df = pd.DataFrame(dd).T\\n fig, ax = plt.subplots()\\n ax.errorbar(x=range(8), y=df.offset.values, yerr=df['std'].values, fmt='o')\\n ax.axhline(0, color='grey')\\n ax.set(xlabel='energy band', ylabel='offset', title='galactic correction offsets')\\n return fig\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n for ncl in self._ncl:\\n diagUtilsLib.generate_ncl_plots(env, ncl)\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n for ncl in self._ncl:\\n diagUtilsLib.generate_ncl_plots(env, ncl)\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n for ncl in self._ncl:\\n diagUtilsLib.generate_ncl_plots(env, ncl)\",\n \"def summarize_diagnostics(self):\\n # plot loss\\n pyplot.subplot(211)\\n pyplot.title('Cross Entropy Loss')\\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\\n # plot accuracy\\n pyplot.subplot(212)\\n pyplot.title('Classification Accuracy')\\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\\n # save plot to file\\n pyplot.savefig(f'{self.project_home / \\\"o\\\"}/{self.model.name}_plot.png')\\n pyplot.close()\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def reconstruction_errors(identifier, train_errors, vali_errors,\\n generated_errors, random_errors):\\n print(identifier)\\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\\n axarr[0].set_title(\\\"train reconstruction errors\\\")\\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\\n axarr[1].set_title('vali reconstruction errors')\\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\\n axarr[2].set_title('generated reconstruction errors')\\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\\n axarr[3].set_title('random reconstruction errors')\\n for ax in axarr:\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"left\\\"].set_visible(False)\\n ax.tick_params(bottom='off', left='off')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n axarr[3].set_xlim(0, 0.05)\\n plt.tight_layout()\\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\\n return True\",\n \"def test_plotting():\\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\\n specs['interpolxydecs'][:, 1], specs['xopt'])\\n\\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\\n potdata = np.vstack((xint, yint)).T\\n\\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\\n\\n expvaldata = np.vstack((expval, uncval)).T\\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\\n\\n # qm_plottings('tests/test_data', scale=0.5)\\n # assert True\",\n \"def plot_proof_functions():\\n\\n def thm1_D(x):\\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\\n\\n def thm2_D(x):\\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 2, 1000)\\n\\n plt.plot(x, thm1_D(x))\\n plt.xlim(0, 2)\\n plt.ylim(0.15, 0.22)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\\n plt.xticks(range(3), range(3))\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm1_D.pdf')\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 5, 1000)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.plot(x, thm2_D(x))\\n plt.xlim(0, 5)\\n plt.ylim(0, 0.4)\\n plt.xticks(range(6), range(6))\\n\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm2_D.pdf')\",\n \"def visualize(self):\\n\\t\\tplt.figure(1)\\n\\t\\tax1 = plt.add_suplot(1,2,1)\\n\\t\\t# Plot free energy error\\n\\t\\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\\n\\t\\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\\n\\t\\tplt.legend()\\n\\n\\t\\t# Plot density error\\n\\n\\t\\t# Plot log-likelihood of test set\\n\\n\\t\\t# Plot clustering score\\n\\n\\t\\tplt.show()\\n\\n\\t\\treturn\",\n \"def plot_spectrumxichange(self):\\n countgood = 0 ; countbad = 0\\n for idata in self.datarg:\\n if idata[-1, 0] == 1.: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \\n countgood += 1\\n print countgood , 'good solution'\\n else: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \\n print countbad, 'bad solution'\\n countbad += 1\\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\\\'s what you expected' %(countgood,countbad)\\n #Create custom artistsr[goodline,badline],['solution','breakdown']\\n goodline = pl.Line2D((0,1),(0,0), color='b') \\n badline = pl.Line2D((0,1),(0,0), color='r')\\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\\n self.savefig('xispec')\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def plot_field_uncertainties():\\n\\n resize_size = (1000, 1000)\\n\\n\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n if drug_name == 'DMSO':\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/30_hours/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n\\n def transform(x):\\n if type(x) is np.ndarray:\\n x = change_array_lims(x)\\n x = np.log(x)\\n return x\\n\\n F_unc_vmin = -7\\n F_unc_vmax = -4\\n sigma_vmin = -5\\n sigma_vmax = 0 #0.4\\n sigma_unc_vmin = -6\\n sigma_unc_vmax = -2\\n\\n fig_Fs = [plt.figure() for _ in range(3)]\\n fig_uncertainty = plt.figure()\\n sigma_lists, F_arrays = [], []\\n for idx_fig, dir in enumerate(dirs):\\n\\n p_list = _load_and_resize_list(dir+'p_list_0.pickle')\\n D_list = _load_and_resize_list(dir+'D_list_0.pickle')\\n U_array = pickle.load(open(dir+'U.pickle', 'rb'))\\n U_array = cv2.resize(U_array, resize_size, interpolation = cv2.INTER_LINEAR)\\n Gx, Gy = np.gradient(U_array, 26./resize_size[0], 26./resize_size[0]) # gradients with respect to x and y\\n F_array = (Gx**2+Gy**2)**.5 # gradient magnitude\\n F_array[np.isinf(F_array)] = np.nan\\n F_array[p_list[-1]<1e-3]=np.nan # final PDF\\n sigma_list = []\\n for j in range(9):\\n arr = D_list[2*j] # current PDF\\n arr[p_list[j]<1e-3]=np.nan\\n sigma_list.append(np.sqrt(2*arr))\\n\\n\\n sigma_lists.append(sigma_list)\\n F_arrays.append(F_array)\\n\\n ax = fig_Fs[idx_fig].add_subplot(111)\\n ax.imshow(transform(F_array)[::-1, :], cmap = cmap, vmin = -4.6, vmax = -2)\\n ax.set_title(dir)\\n\\n all_axes = [i for j in fig_Fs for i in j.axes]\\n for ax in all_axes:\\n ax.axis('off')\\n\\n # uncertainties\\n\\n std = np.std(F_arrays, axis = 0)\\n ax = fig_uncertainty.add_subplot(121)\\n ax.imshow(transform(std)[::-1, :], cmap = cmap, vmin = F_unc_vmin, vmax = F_unc_vmax)\\n ax.set_title('F_uncertainty')\\n\\n fig_sigma = plt.figure()\\n ax = fig_sigma.add_subplot(111)\\n ax.imshow(transform(np.nanmean(sigma_lists[0], axis = 0))[::-1, :], cmap = cmap, vmin = sigma_vmin, vmax = sigma_vmax) # index 0 (i.3 'original' is corresponds to the landscapes in other figures)\\n ax.set_title('sigma_mean')\\n\\n sigma_means = [np.nanmean(sigma_list, axis = 0) for sigma_list in sigma_lists]\\n std_array = np.nanstd(sigma_means, axis = 0)\\n ax = fig_uncertainty.add_subplot(122)\\n ax.imshow(transform(std_array)[::-1, :], cmap = cmap, vmin = sigma_unc_vmin, vmax = sigma_unc_vmax)\\n ax.set_title('sigma_uncertainty')\\n\\n fig_sigma.savefig(path_to_here+'/../outputs/{}_mean_sigma.png'.format(drug_name), dpi = 1200)\\n fig_uncertainty.savefig(path_to_here+'/../outputs/{}_uncertainties.png'.format(drug_name), dpi = 1200)\",\n \"def quick_plot(solution):\\n plt.suptitle('GNLSE solution')\\n\\n plt.subplot(1, 2, 1)\\n plot_wavelength_vs_distance(solution)\\n\\n plt.subplot(1, 2, 2)\\n plot_delay_vs_distance(solution)\\n\\n plt.show()\",\n \"def interactions_plot():\\n data = load_data('ints_CC'),load_data('ints_CD')\\n fig,ax = plt.subplots()\\n plot_mean_std(data_CC,ax,'C-C interactions')\\n plot_mean_std(data_CD,ax,'C-D interactions')\\n plt.xlabel('cluster size, n')\\n plt.legend(loc='best')\\n plt.savefig('interactions.pdf')\",\n \"def robustnessPlot(ax):\\n # Setup the range of avidity and ligand concentration we'll look at\\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\\n\\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\\n columns=['gnus', 'Los'])\\n\\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\\n\\n # Change avidities to strings\\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\\\nu=' + str(int(gnu)) + '$')\\n\\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\\n\\n # Plot the calculated crossvalidation performance\\n sns.FacetGrid(pp,\\n hue='gnus',\\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\\n\\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\\n\\n ax.set_xlabel('Assumed IC Conc. (M)')\\n ax.set_ylabel('LOO Prediction R-Squared')\\n ax.set_ylim(0.0, 1.0)\",\n \"def plot_metric_results():\\n from run_metric_comparison_experiments import (\\n PIVECTOR_TEMPLATE,\\n PIVECTOR_DISTANCE_MATRIX_TEMPLATE,\\n DISCRIMINATOR_DISTANCE_MATRIX_TEMPLATE,\\n GAUSSIAN_DISTANCE_MATRIX_TEMPLATE,\\n ENCODER_DISTANCE_MATRIX_TEMPLATE,\\n DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE,\\n NUM_TRAJECTORIES,\\n NUM_COMPONENTS,\\n NUM_REPETITIONS,\\n REWARD_SCALES,\\n ENVS\\n )\\n\\n # Path-templates to each distance matrix to compare\\n # BC = Behavioural Characteristication\\n BC_DISTANCE_MATRIX_TEMPLATES = [\\n PIVECTOR_DISTANCE_MATRIX_TEMPLATE,\\n GAUSSIAN_DISTANCE_MATRIX_TEMPLATE,\\n DISCRIMINATOR_DISTANCE_MATRIX_TEMPLATE,\\n ENCODER_DISTANCE_MATRIX_TEMPLATE,\\n DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE\\n ]\\n\\n BC_LEGEND_NAMES = [\\n \\\"Supervector\\\",\\n \\\"Gaussian\\\",\\n \\\"Discriminator\\\",\\n \\\"Encoder\\\",\\n \\\"Discretization\\\"\\n ]\\n\\n BC_PLOT_COLORS = [\\n \\\"C0\\\",\\n \\\"C1\\\",\\n \\\"C2\\\",\\n \\\"C3\\\",\\n \\\"C4\\\"\\n ]\\n\\n fig, axs = pyplot.subplots(\\n figsize=[4.8 * 3 * 0.75, 4.8 * 0.75],\\n nrows=1,\\n ncols=3,\\n )\\n\\n def get_policy_names(env):\\n policy_names = glob(PIVECTOR_TEMPLATE.format(env=env, num_traj=\\\"*\\\", num_components=\\\"*\\\", policy_name=\\\"*\\\", repetition_num=\\\"*\\\"))\\n policy_names = [\\\"_\\\".join(os.path.basename(x).split(\\\"_\\\")[-4:-2]) for x in policy_names]\\n policy_names = sorted(list(set(policy_names)))\\n return policy_names\\n\\n # For each different distance measurement\\n for distance_matrix_template, plot_legend_name, plot_color in zip(BC_DISTANCE_MATRIX_TEMPLATES, BC_LEGEND_NAMES, BC_PLOT_COLORS):\\n # These will be NUM_TRAJECTORY length lists\\n average_scores = np.ones((len(NUM_TRAJECTORIES),))\\n std_scores = np.ones((len(NUM_TRAJECTORIES),))\\n for num_traj_idx, num_traj in enumerate(NUM_TRAJECTORIES):\\n # Average over environments, policies and repetitions\\n scores = []\\n for env_i, env in enumerate(ENVS):\\n if \\\"Bipedal\\\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\\n print(\\\"[Note] Skipping env {} for discretization distances (OOM)\\\".format(env))\\n continue\\n min_reward, max_reward = REWARD_SCALES[env]\\n policy_names = get_policy_names(env)\\n\\n for policy_name in policy_names:\\n for repetition in range(1, NUM_REPETITIONS + 1):\\n # Ugh bit of messing around because I did not think this through...\\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\\n else:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\\n\\n data = np.load(file_path)\\n distance_matrix = data[\\\"distance_matrix\\\"]\\n rewards = data[\\\"average_episodic_rewards\\\"]\\n\\n raveled_reward_distances = np.abs(rewards - rewards[:, None])\\n # Take upper diagonal, skip diagonal\\n raveled_reward_distances = raveled_reward_distances[np.triu_indices(raveled_reward_distances.shape[0], 1)]\\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\\n\\n # Score is correlation between the two\\n correlation = np.corrcoef(raveled_distances, raveled_reward_distances)[0, 1]\\n scores.append(correlation)\\n\\n scores = np.array(scores)\\n average_score = np.mean(scores)\\n std_score = np.std(scores)\\n average_scores[num_traj_idx] = average_score\\n std_scores[num_traj_idx] = std_score\\n ax = axs[0]\\n ax.plot(NUM_TRAJECTORIES, average_scores, c=plot_color, label=plot_legend_name)\\n ax.scatter(NUM_TRAJECTORIES, average_scores, c=plot_color)\\n #ax.fill_between(\\n # NUM_TRAJECTORIES,\\n # average_scores - std_scores,\\n # average_scores + std_scores,\\n # alpha=0.2,\\n # color=plot_color,\\n # edgecolor=\\\"none\\\",\\n # linewidth=0.0\\n #)\\n ax.set_xticks(NUM_TRAJECTORIES)\\n ax.tick_params(axis='both', which='both', labelsize=\\\"x-large\\\")\\n ax.set_ylabel(\\\"Correlation with return-distances\\\", fontsize=\\\"x-large\\\")\\n ax.set_xlabel(\\\"Number of trajectories\\\", fontsize=\\\"x-large\\\")\\n ax.grid(alpha=0.2)\\n\\n # Amount of error to \\\"ground truth\\\" result,\\n # where \\\"ground truth\\\" is one of the results with 100 trajectories of data.\\n # Because of wonkyness of this, store list [#num-traj] of lists,\\n # each storing results for that num-traj run\\n per_trajectory_relative_errors = [[] for i in NUM_TRAJECTORIES]\\n for env in ENVS:\\n if \\\"Bipedal\\\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\\n print(\\\"[Note] Skipping env {} for discretization distances (OOM)\\\".format(env))\\n continue\\n policy_names = get_policy_names(env)\\n for policy_name in policy_names:\\n # The \\\"ground truth\\\" distances, will be filled with first\\n # result with 100 trajectories.\\n anchor_distance = None\\n for traj_i, num_traj in enumerate(NUM_TRAJECTORIES):\\n for repetition in range(1, NUM_REPETITIONS + 1):\\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\\n else:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\\n distance_matrix = np.load(file_path)[\\\"distance_matrix\\\"]\\n # Normalize to [0, 1]\\n distance_matrix = (distance_matrix - distance_matrix.min()) / (distance_matrix.max() - distance_matrix.min())\\n # Get only upper triangle as distance matrix is symmetric. Exlude diagonal\\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\\n # Check if we use this as the zero-point or compute relative error to\\n if anchor_distance is None:\\n assert num_traj == 100\\n anchor_distance = raveled_distances\\n else:\\n per_trajectory_relative_errors[traj_i].append(\\n np.mean(np.abs(raveled_distances - anchor_distance) / np.abs(anchor_distance))\\n )\\n # Lists are not of equal length, so can not just change into an array\\n mean_average_errors = np.array([np.mean(np.array(results) * 100) for results in per_trajectory_relative_errors])\\n std_average_errors = np.array([np.std(np.array(results) * 100) for results in per_trajectory_relative_errors])\\n ax = axs[1]\\n ax.plot(NUM_TRAJECTORIES, mean_average_errors, c=plot_color, label=plot_legend_name)\\n ax.scatter(NUM_TRAJECTORIES, mean_average_errors, c=plot_color)\\n #ax.fill_between(\\n # NUM_TRAJECTORIES,\\n # mean_average_errors - std_average_errors,\\n # mean_average_errors + std_average_errors,\\n # alpha=0.2,\\n # color=plot_color,\\n # edgecolor=\\\"none\\\",\\n # linewidth=0.0\\n #)\\n ax.set_xticks(NUM_TRAJECTORIES)\\n ax.tick_params(axis='both', which='both', labelsize=\\\"x-large\\\")\\n ax.set_ylabel(\\\"Relative error to ground truth (%)\\\", fontsize=\\\"x-large\\\")\\n ax.set_xlabel(\\\"Number of trajectories\\\", fontsize=\\\"x-large\\\")\\n ax.grid(alpha=0.2)\\n\\n # Variation between results\\n cv_means = np.ones((len(NUM_TRAJECTORIES,)))\\n cv_stds = np.ones((len(NUM_TRAJECTORIES,)))\\n for traj_i, num_traj in enumerate(NUM_TRAJECTORIES):\\n traj_averaged_cvs = []\\n for env in ENVS:\\n if \\\"Bipedal\\\" in env and distance_matrix_template == DISCRETIZATION_DISTANCE_MATRIX_TEMPLATE:\\n print(\\\"[Note] Skipping env {} for discretization distances (OOM)\\\".format(env))\\n continue\\n policy_names = get_policy_names(env)\\n for policy_name in policy_names:\\n # Compute std over repetitions\\n distances = []\\n for repetition in range(1, NUM_REPETITIONS + 1):\\n if distance_matrix_template == PIVECTOR_DISTANCE_MATRIX_TEMPLATE:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, num_components=NUM_COMPONENTS, policy_name=policy_name, repetition_num=repetition)\\n else:\\n file_path = distance_matrix_template.format(env=env, num_traj=num_traj, policy_name=policy_name, repetition_num=repetition)\\n\\n distance_matrix = np.load(file_path)[\\\"distance_matrix\\\"]\\n # Normalize to [0, 1]\\n distance_matrix = (distance_matrix - distance_matrix.min()) / (distance_matrix.max() - distance_matrix.min())\\n # Get only upper triangle as distance matrix is symmetric. Exlude diagonal\\n raveled_distances = distance_matrix[np.triu_indices(distance_matrix.shape[0], 1)]\\n distances.append(raveled_distances)\\n distances = np.stack(distances)\\n # Coefficient of variance (std / mean)\\n average_cv = np.mean(np.std(distances, axis=0) / np.mean(distances, axis=0))\\n traj_averaged_cvs.append(average_cv)\\n traj_averaged_cvs = np.array(traj_averaged_cvs)\\n cv_means[traj_i] = np.mean(traj_averaged_cvs)\\n cv_stds[traj_i] = np.std(traj_averaged_cvs)\\n\\n ax = axs[2]\\n ax.plot(NUM_TRAJECTORIES, cv_means, c=plot_color, label=plot_legend_name)\\n ax.scatter(NUM_TRAJECTORIES, cv_means, c=plot_color)\\n #ax.fill_between(\\n # NUM_TRAJECTORIES,\\n # cv_means - cv_stds,\\n # cv_means + cv_stds,\\n # alpha=0.2,\\n # color=plot_color,\\n # edgecolor=\\\"none\\\",\\n # linewidth=0.0\\n #)\\n ax.set_xticks(NUM_TRAJECTORIES)\\n ax.tick_params(axis='both', which='both', labelsize=\\\"x-large\\\")\\n ax.set_ylabel(\\\"Coefficient of variance $\\\\\\\\sigma/\\\\\\\\mu$\\\", fontsize=\\\"x-large\\\")\\n ax.set_xlabel(\\\"Number of trajectories\\\", fontsize=\\\"x-large\\\")\\n ax.grid(alpha=0.2)\\n\\n axs[1].legend(prop={\\\"size\\\": \\\"large\\\"})\\n pyplot.tight_layout()\\n pyplot.savefig(\\\"figures/metric_comparison.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.0)\",\n \"def analysis_plot(predictions, ys):\\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\\n\\n residuals = ys - predictions\\n\\n # Plot 1 - Predicted vs Actual\\n sns.scatterplot(predictions, ys, ax=ax1)\\n ax1.set_title('Predicted vs Actual', fontsize=20)\\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\\n\\n # Plot 2 - Residuals PLot (predicted vs residuals)\\n sns.scatterplot(predictions, residuals, ax=ax2)\\n ax2.set_title('Residuals Plot', fontsize=20)\\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\\n\\n # Plot 3 - QQ Plot\\n sm.qqplot(residuals, ax=ax3, line='s')\\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\\n\\n plt.show();\",\n \"def compareRepeatability():\\n fc,pc = refCylNoise()\\n fp,pp = flatNoisePellicle()\\n fcgh,pcgh = flatNoiseCGH()\\n fpco,ppco = PCO1S12Noise()\\n\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([fp,fc,fcgh,fpco],[pp,pc,pcgh,ppco])]\\n plt.clf()\\n \\n plt.loglog(fp,pp/fp[0],label='Flat+Pellicle: %.2f' % midfreq[0])\\n plt.loglog(fc,pc/fc[0],label='Cylinder+CGH: % .2f' % midfreq[1])\\n plt.loglog(fcgh,pcgh/fcgh[0],label='Flat+CGH: %.2f' % midfreq[2])\\n plt.loglog(fpco,ppco/fpco[0],label='PCO1S12: %.2f' % midfreq[3])\\n plt.title('Repeatability Comparison')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n plt.legend(loc='lower left')\",\n \"def small_signal_mobility_paperplot(fieldVector, freqVector, df):\\n vcm = np.array(fieldVector)*1e-2\\n n = utilities.calculate_density(df)\\n lw = 1.5\\n fig, ax = plt.subplots()\\n for freq in freqVector:\\n cond = []\\n mu_3 = []\\n for ee in fieldVector:\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\\n cond.append(np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n ax.plot(vcm, np.array(np.real(cond))/c.e/n*100**2, '-', label='{:.1f} GHz'.format(freq),linewidth=lw)\\n ax.plot(vcm,mu_3,'-',label = 'Ohmic Mobility',linewidth=lw)\\n plt.xlabel(r'Field ($\\\\rm V \\\\, cm^{-1}$)')\\n plt.ylabel(r'AC Mobility ($\\\\rm cm^2 \\\\, V^{-1} \\\\, s^{-1}$)')\\n plt.ylim([-0.05*np.max(mu_3),np.max(mu_3)*1.2])\\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\\n plt.legend(ncol=3,loc='lower center')\\n plt.savefig(pp.figureLoc+'ac_mobility.png', bbox_inches='tight',dpi=600)\\n\\n\\n plt.figure(figsize=(2.05, 2.5))\\n ax = plt.axes([0.21, 0.19, 0.75, 0.75])\\n i = 0\\n for ee in fieldVector:\\n colorList = [eq_color, med_color, high_color]\\n cond = []\\n cond_linear = []\\n mu_3 = []\\n for freq in freqVector:\\n mu_3 = []\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\\n cond.append(np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n cond_linear.append(np.load(pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n ax.plot(freqVector, np.array(np.real(cond))/c.e/n*100**2/1000, '-',\\n label='{:.0f} '.format(ee/100)+r'$\\\\rm V \\\\, cm^{-1}$', linewidth=lw, color=colorList[i])\\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\\\, cm^{-1}$',linewidth=lw,color = colorList[i])\\n i = i + 1\\n\\n plt.xlabel(r'Frequency (GHz)')\\n plt.ylabel(r'$\\\\Re(\\\\rm AC\\\\ mobility$) (1000 $\\\\rm cm^2 \\\\, V^{-1}\\\\, s^{-1}$)')\\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\\n plt.xscale('log')\\n plt.legend(frameon=False)\\n plt.ylim([0, 20])\\n plt.xlim([freqs[0], freqs[-1]])\\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\\n ax.yaxis.set_major_formatter(FormatStrFormatter('%.0f'))\\n plt.xlim([freqVector[0],freqVector[-1]])\\n locmaj = matplotlib.ticker.LogLocator(base=10, numticks=6)\\n ax.xaxis.set_major_locator(locmaj)\\n locmin = matplotlib.ticker.LogLocator(base=10.0, subs=np.arange(2, 10) * .1,\\n numticks=100)\\n ax.xaxis.set_minor_locator(locmin)\\n plt.savefig(pp.figureLoc+'Real_ac_mobility.png',dpi=600)\\n\\n fig, ax = plt.subplots()\\n i = 0\\n for ee in fieldVector:\\n colorList = ['black', 'dodgerblue', 'tomato']\\n cond = []\\n cond_linear = []\\n mu_3 = []\\n\\n for freq in freqVector:\\n mu_3 = []\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\\n cond.append(\\n np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n cond_linear.append(np.load(\\n pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n\\n ax.plot(freqVector, np.array(np.imag(cond)) / c.e / n * 100 ** 2, '-',\\n label='{:.0f} '.format(ee / 100) + r'$\\\\rm V \\\\, cm^{-1}$', linewidth=lw, color=colorList[i])\\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\\\, cm^{-1}$',linewidth=lw,color = colorList[i])\\n\\n i = i + 1\\n plt.xlabel(r'Frequency ($\\\\rm GHz$)')\\n plt.ylabel(r'$\\\\Im \\\\, [\\\\mu_{\\\\omega}]$ ($\\\\rm cm^2 \\\\, V^{-1}\\\\, s^{-1}$)')\\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\\n plt.xscale('log')\\n plt.legend(frameon=False)\\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\\n plt.savefig(pp.figureLoc + 'Imag_ac_mobility.png', bbox_inches='tight', dpi=600)\\n\\n\\n fig, ax = plt.subplots()\\n i = 0\\n for ee in fieldVector:\\n colorList = ['black', 'dodgerblue', 'tomato']\\n cond = []\\n cond_linear = []\\n mu_3 = []\\n\\n for freq in freqVector:\\n mu_3 = []\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\\n cond.append(\\n np.load(pp.outputLoc + 'Small_Signal/' + 'cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n cond_linear.append(np.load(\\n pp.outputLoc + 'Small_Signal/' + 'linear_cond_' + '3_' + \\\"f_{:.1e}_E_{:.1e}.npy\\\".format(freq, ee)))\\n\\n ax.plot(freqVector, np.array(np.arctan(np.imag(cond)/np.real(cond)))/np.pi, '-',\\n label='{:.0f} '.format(ee / 100) + r'$\\\\rm V \\\\, cm^{-1}$', linewidth=lw, color=colorList[i])\\n # ax.plot(freqVector, np.array(cond_linear)/c.e/n*100**2, '-.', label='E = {:.0f} L '.format(ee/100)+r'$V \\\\, cm^{-1}$',linewidth=lw,color = colorList[i])\\n i = i + 1\\n ax.yaxis.set_major_formatter(tck.FormatStrFormatter('%g $\\\\pi$'))\\n ax.yaxis.set_major_locator(tck.MultipleLocator(base=1.0))\\n plt.xlabel(r'Frequency ($\\\\rm GHz$)')\\n plt.ylabel(r'AC Mobility Phase Angle (Radians)')\\n # plt.ylim([-0.4*np.max(mu_3),np.max(mu_3)*1.2])\\n plt.xscale('log')\\n plt.legend()\\n yloc = plt.MaxNLocator(6)\\n ax.yaxis.set_major_locator(yloc)\\n # ax.text(0.55, 0.95, textstr, transform=ax.transAxes, fontsize=8, verticalalignment='top', bbox=props)\\n plt.savefig(pp.figureLoc + 'Phase_ac_mobility.png', bbox_inches='tight', dpi=600)\",\n \"def plot_diagnostics(foldspec, flag, mask):\\n \\n plt.figure(figsize=(15,10))\\n \\n plt.subplot(231)\\n plt.plot(foldspec.mean(0).mean(0), color='k')\\n plt.xlabel('phase (bins)')\\n plt.ylabel('I (arb.)')\\n plt.title('Pulse Profile')\\n plt.xlim(0, foldspec.shape[-1])\\n \\n plt.subplot(232)\\n plt.title('RFI flagging parameter (log10)')\\n plt.xlabel('time (bins)')\\n plt.ylabel('freq (bins)')\\n plt.imshow(np.log10(flag).T, aspect='auto')\\n\\n plt.subplot(233)\\n plt.title('Manual off-gate scaling')\\n plt.imshow(mask.T, aspect='auto', cmap='Greys')\\n plt.xlabel('time (bins)')\\n \\n plt.subplot(234)\\n plt.imshow(foldspec.mean(0), aspect='auto')\\n plt.xlabel('phase')\\n plt.ylabel('freq')\\n\\n plt.subplot(235)\\n plt.imshow(foldspec.mean(1), aspect='auto')\\n plt.xlabel('phase')\\n plt.ylabel('time')\\n\\n plt.subplot(236)\\n plt.imshow(foldspec.mean(2).T, aspect='auto')\\n plt.xlabel('time')\\n plt.ylabel('freq')\",\n \"def save_figs(self):\\n if not self._fitted:\\n self.fit()\\n #self._message(\\\"Saving plots...\\\")\\n # 1. Generate the required PNG plots\\n # 1.1 Truncation plots\\n for i,s in enumerate(self.samples):\\n fig,ax=plt.subplots(1,2,figsize=(8,4))\\n cyct=np.arange(self.nvalues)\\n cycf=np.arange(self._cutoffidx[i])\\n cycd=0.5*(cyct[1:]+cyct[:-1])\\n ax[0].plot(cyct,self.samplesdata[:,i],'k.-',linewidth=0.5,label=\\\"Full series\\\")\\n ax[0].plot(cycf,self.samplesdata[:self._cutoffidx[i],i],'r-',linewidth=1,label=\\\"Truncated\\\")\\n ax[0].set_xlim([0,self.nvalues-1])\\n ax[0].set_ylim([0,self.samplesdata.max()*1.1])\\n ax[0].set_xlabel(\\\"Cycle\\\")\\n ax[0].set_ylabel(\\\"Fluorescence (a.u.)\\\")\\n ax[0].set_title(\\\"Detected fluorescence\\\")\\n plt.legend(loc='upper left',frameon=False)\\n # First derivative\\n ax[1].plot(cycd,self.samplesdatadiff[:,i],'k.-',linewidth=0.5)\\n ax[1].axvline(self._cutoffidx[i],color='r')\\n ax[1].set_xlim([0,self.nvalues-1])\\n ax[1].set_ylim([self.samplesdatadiff.min()*1.1,self.samplesdatadiff.max()*1.1])\\n ax[1].set_xlabel(\\\"Cycle\\\")\\n ax[1].set_ylabel(\\\"dF/dCycle (a.u.)\\\")\\n ax[1].set_title(\\\"Fluorescence rate\\\")\\n plt.tight_layout()\\n fn=get_valid_fname(self.samples[i])\\n figname=\\\"%s_%s_%s.svg\\\"%(self.ID,\\\"01truncation\\\",fn)\\n self.info['samples'][s]['Data truncation for fitting']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n plt.close() \\n # 1.2 Fitting plots\\n for i,s in enumerate(self.samples):\\n fig,ax=plt.subplots(1,3,figsize=(12,4))\\n cyct=np.arange(self.nvalues)\\n cycf=np.arange(self._cutoffidx[i])\\n ax[0].plot(cyct,self.samplesdata[:,i],'k:',linewidth=0.5,label=\\\"Full series\\\")\\n ax[0].plot(cycf,self.samplesdata[:self._cutoffidx[i],i],'r.-',linewidth=0.5,label=\\\"Truncated\\\")\\n #ax[0].plot(cycf,self.mak3fpre[s],'y-',linewidth=1,label=\\\"prefit\\\")\\n ax[0].plot(cycf,self.mak3fluorescence[s],'g-',linewidth=1,label=\\\"MAK3 fit\\\")\\n ax[0].axvline(self._cutoffidx[i],color='k')\\n ax[0].set_xlim([0,self.nvalues-1])\\n ax[0].set_ylim([0,self.samplesdata.max()*1.1])\\n ax[0].set_xlabel(\\\"Cycle\\\")\\n ax[0].set_ylabel(\\\"Fluorescence (a.u.)\\\")\\n ax[0].set_title(\\\"Detected fluorescence\\\")\\n ax[0].legend(loc='upper left',frameon=False)\\n # DNA levels\\n ax[1].plot(cycf,self.mak3concentration[s],'g-',linewidth=1,label=\\\"MAK3\\\")\\n ax[1].axvline(self._cutoffidx[i],color='k')\\n ax[1].set_xlim([0,self.nvalues-1])\\n ax[1].set_ylim([0,self.mak3concentration[s].max()*1.1])\\n ax[1].set_xlabel(\\\"Cycle\\\")\\n ax[1].set_ylabel(\\\"concentration (a.u.)\\\")\\n ax[1].set_title(\\\"estimated cDNA levels\\\")\\n # Efficiency\\n ax[2].plot(cycf,self.mak3efficiency[s],'b-',linewidth=1,label=\\\"MAK3\\\")\\n ax[2].axvline(self._cutoffidx[i],color='k')\\n ax[2].set_xlim([0,self.nvalues-1])\\n ax[2].set_ylim([0,1.1])\\n ax[2].set_xlabel(\\\"Cycle\\\")\\n ax[2].set_ylabel(\\\"Efficiency\\\")\\n ax[2].set_title(\\\"Amplification efficiency\\\") \\n plt.tight_layout()\\n fn=get_valid_fname(self.samples[i])\\n figname=\\\"%s_%s_%s.svg\\\"%(self.ID,\\\"02mak3\\\",fn)\\n self.info['samples'][s]['MAK3 Fitting']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n plt.close()\\n # 2 Initial concentrations\\n figwdth=np.maximum(5,0.4*self.nsamples+1)\\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\\n v=list(self.initialConcentration.values())\\n k=list(self.initialConcentration.keys())\\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\\n ax.set_xticks(1+np.arange(self.nsamples))\\n ax.set_xticklabels(k,rotation=90)\\n ax.set_xlim([0,self.nsamples+1])\\n plt.tight_layout()\\n figname=\\\"%s_%s_.svg\\\"%(self.ID,\\\"00initialConcentration\\\")\\n self.info['figname_initialConcentration']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n plt.close()\\n # 3 Fitting Error\\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\\n v=list(self.fitting_error.values())\\n k=list(self.fitting_error.keys())\\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\\n ax.set_xticks(1+np.arange(self.nsamples))\\n ax.set_xticklabels(k,rotation=90)\\n ax.set_xlim([0,self.nsamples+1])\\n ax.set_ylim([0,1e-2])\\n plt.tight_layout()\\n figname=\\\"%s_%s_.svg\\\"%(self.ID,\\\"00fittingError\\\")\\n self.info['figname_fittingError']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n # 4 kinetic constant\\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\\n v=list(self.k.values())\\n k=list(self.k.keys())\\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\\n ax.set_xticks(1+np.arange(self.nsamples))\\n ax.set_xticklabels(k,rotation=90)\\n ax.set_xlim([0,self.nsamples+1])\\n plt.tight_layout()\\n figname=\\\"%s_%s_.svg\\\"%(self.ID,\\\"00kineticConstant\\\")\\n self.info['figname_k']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n # 5 background fluorescence\\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\\n v=list(self.Fb.values())\\n k=list(self.Fb.keys())\\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\\n ax.set_xticks(1+np.arange(self.nsamples))\\n ax.set_xticklabels(k,rotation=90)\\n ax.set_xlim([0,self.nsamples+1])\\n plt.tight_layout()\\n figname=\\\"%s_%s_.svg\\\"%(self.ID,\\\"00bkgFluorescence\\\")\\n self.info['figname_Fb']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\\n # 6 slope\\n fig,ax=plt.subplots(1,1,figsize=(figwdth,7))\\n v=list(self.slope.values())\\n k=list(self.slope.keys())\\n ax.bar(0.75+np.arange(self.nsamples),v,facecolor='k',width=0.5)\\n ax.set_xticks(1+np.arange(self.nsamples))\\n ax.set_xticklabels(k,rotation=90)\\n ax.set_xlim([0,self.nsamples+1])\\n ax.set_ylim([0,0.025])\\n plt.tight_layout()\\n figname=\\\"%s_%s_.svg\\\"%(self.ID,\\\"00fluorescenceSlope\\\")\\n self.info['figname_slope']=figname\\n plt.savefig('%s/%s'%(self.info['resultsdir'],figname))\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def create_plots(initial_condition, flux):\\n \\n# Path to the hdf5 file containing results of computations\\n computations_database = h5py.File(database_path, \\\"r\\\")\\n \\n# Path to the data group containing the computational data\\n group_path = initial_condition + \\\"/\\\" + flux\\n \\n# Path to the highest grid resolution data (k = 16)\\n dataset_path = group_path + \\\"/k = \\\" + str(16)\\n# Adjust the plot window to the maximum and minimum values the computed solution attains \\n ymax = asarray(computations_database[dataset_path]).max()\\n ymin = asarray(computations_database[dataset_path]).min()\\n pyplot.ylim(ymax = ymax*1.2)\\n pyplot.ylim(ymin = ymin*1.2)\\n \\n# Path to the initial condition dataset \\n dataset_initial_path = initial_condition + \\\"/k = \\\" + str(16) + \\\" initial_data\\\"\\n \\n# The title of the plot, containing relevant information about the computation \\n title = \\\"{group_path}: CFL = {CFL}, a = {a}\\\".format(\\n group_path = group_path.replace(\\\"/\\\", \\\", \\\"), \\n CFL = computations_database[group_path].attrs[\\\"CFL\\\"], \\n a = computations_database[group_path].attrs[\\\"a\\\"]\\n )\\n \\n# Define the title and axes' labels; enable grid in the plot's background\\n pyplot.title(title)\\n pyplot.xlabel(\\\"x\\\")\\n pyplot.ylabel(\\\"u(x, t = 9)\\\")\\n pyplot.grid(True)\\n\\n# Define the grid against which data should be ploted, i.e. uniform grid with stepsize 2^(-16)\\n x = numpy.linspace(0, 1, 2**16)\\n# Plot the initial data \\n pyplot.plot(x, computations_database[dataset_initial_path])\\n\\n# Include the initial data legend in the array of all legends which will be displayed in the plot\\n legend_labels = [\\\"Initial Data\\\"]\\n# Plot the legend for the initial data \\n pyplot.legend(legend_labels)\\n\\n# Plot solutions corresponding to grid stepsizes 2^(-10), 2^(-12), 2^(-14), and 2^(-16),\\n for k in range(10, 17, 2):\\n x = numpy.linspace(0, 1, 2**k) \\n \\n dataset_path = group_path + \\\"/k = \\\" + str(k)\\n \\n pyplot.plot(x, computations_database[dataset_path])\\n \\n# Append the legend text corresponding to the current computation to the array of legends\\n legend_labels.append(\\\"k = \\\" + str(k))\\n# Plot the newly appended legend; ncol - number of columns, fancybox - rounded corners of the box enclosing the legend text\\n pyplot.legend(legend_labels, ncol = 3, fancybox = True, fontsize = \\\"small\\\")\\n\\n# Output plots in two formats to be used in the website \\n pyplot.savefig(html_path + \\\"images/\\\" + group_path.replace(\\\"/\\\",\\\"_\\\") + \\\".png\\\")\\n pyplot.savefig(html_path + \\\"pdf/plots/\\\" + group_path.replace(\\\"/\\\",\\\"_\\\") + \\\".pdf\\\")\\n pyplot.close()\\n \\n computations_database.close()\",\n \"def residual_plots(test_data, mods, station=None, squared=False):\\r\\n import config\\r\\n learning_var = config.learning_var\\r\\n data = test_data.get_miniOD()\\r\\n mods.models[0].mod.load()\\r\\n pred = mods.models[0].mod.predict(test_data)\\r\\n test_data.miniOD = None\\r\\n if squared:\\r\\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\\r\\n else:\\r\\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\\r\\n ind = data[data['Annee'] == 0].index\\r\\n data.drop(ind, inplace=True)\\r\\n print(data.columns.values)\\r\\n i = 0\\r\\n if station is None:\\r\\n ch_an = test_data.get_stations_col(2015)\\r\\n else:\\r\\n ch_an = 'End date ' + str(station)\\r\\n for ch in learning_var:\\r\\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\\r\\n # data.boxplot(ch_an, by=ch)\\r\\n # if ch != 'Heure':\\r\\n plt.figure(i // 9)\\r\\n # plt.title('squared error / expectation')\\r\\n fig = plt.subplot(3, 3, (i % 9) + 1)\\r\\n i += 1\\r\\n # fig = plt.figure().add_subplot(111)\\r\\n fig.set_xlabel(ch)\\r\\n if squared:\\r\\n fig.set_ylabel('error²')\\r\\n else:\\r\\n fig.set_ylabel('error')\\r\\n l = []\\r\\n xaxis = np.unique(data[ch])\\r\\n print(ch, xaxis.shape)\\r\\n if xaxis.shape[0] < 20 or ch == 'Heure':\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][data[ch] == u])\\r\\n else:\\r\\n m = np.min(data[ch])\\r\\n M = np.max(data[ch])\\r\\n step = (M - m) / 20\\r\\n xaxis = np.arange(m, M, step)\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\\r\\n xaxis = xaxis.astype(int)\\r\\n # fig = plt.boxplot(ch_an, by=ch)\\r\\n # g = data.groupby(ch).mean()[ch_an]\\r\\n # v = data.groupby(ch).std()[ch_an]\\r\\n plt.boxplot(l, labels=xaxis)\\r\\n if squared:\\r\\n plt.ylim((0, 12))\\r\\n else:\\r\\n plt.ylim((-5, 5))\\r\\n # plt.plot(g, '-r')\\r\\n # plt.plot(g + v, ':r')\\r\\n # plt.plot(g - v, ':r')\\r\\n plt.show()\",\n \"def plot_variables(self, n, show=False, diagnostics=False):\\n\\n if diagnostics:\\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\\n else:\\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\\n\\n plt.subplots_adjust(hspace = 0)\\n end = len(n.history[\\\"det F\\\"])\\n epochs = np.arange(end)\\n a, = ax[0].plot(epochs, n.history[\\\"det F\\\"], label = 'Training data')\\n b, = ax[0].plot(epochs, n.history[\\\"det test F\\\"], label = 'Test data')\\n # ax[0].axhline(y=5,ls='--',color='k')\\n ax[0].legend(frameon = False)\\n ax[0].set_ylabel(r'$|{\\\\bf F}_{\\\\alpha\\\\beta}|$')\\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\\\"det test F\\\"][-1])\\n ax[1].plot(epochs, n.history[\\\"loss\\\"])\\n ax[1].plot(epochs, n.history[\\\"test loss\\\"])\\n # ax[1].set_xlabel('Number of epochs')\\n ax[1].set_ylabel(r'$\\\\Lambda$')\\n ax[1].set_xlim([0, len(epochs)]);\\n \\n if diagnostics:\\n ax[2].plot(epochs, n.history[\\\"det C\\\"])\\n ax[2].plot(epochs, n.history[\\\"det test C\\\"])\\n # ax[2].set_xlabel('Number of epochs')\\n ax[2].set_ylabel(r'$|{\\\\bf C}|$')\\n ax[2].set_xlim([0, len(epochs)]);\\n \\n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,0]\\n , color = 'C0', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,1]\\n , color = 'C0', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n \\\"\\\"\\\"\\n\\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,0]\\n , color = 'C1', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,1]\\n , color = 'C1', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n ax[3].legend(frameon=False)\\n \\\"\\\"\\\"\\n\\n ax[3].set_ylabel(r'$\\\\partial\\\\mu/\\\\partial\\\\theta$')\\n # ax[3].set_xlabel('Number of epochs')\\n ax[3].set_xlim([0, len(epochs)])\\n\\n # Mean of network output summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],alpha=0.5)\\n # Mean of test output network summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"test μ\\\"])[:,0],alpha=0.5)\\n ax[4].set_ylabel('μ')\\n ax[4].set_xlabel('Number of epochs')\\n ax[4].set_xlim([0, len(epochs)])\\n \\n\\n print ('Maximum Fisher info on train data:',np.max(n.history[\\\"det F\\\"]))\\n print ('Final Fisher info on train data:',(n.history[\\\"det F\\\"][-1]))\\n \\n print ('Maximum Fisher info on test data:',np.max(n.history[\\\"det test F\\\"]))\\n print ('Final Fisher info on test data:',(n.history[\\\"det test F\\\"][-1]))\\n\\n if np.max(n.history[\\\"det test F\\\"]) == n.history[\\\"det test F\\\"][-1]:\\n print ('Promising network found, possibly more epochs needed')\\n\\n plt.tight_layout()\\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def all_conditions_visualized(self):\\n # group dataframe based on standard deviation and effect size\\n grouped_df = self.df.groupby([\\\"es\\\", \\\"sd1\\\", \\\"samp2\\\"])\\n results = self.helpers.get_mean_df(grouped_df, False)\\n print(results.sample())\\n\\n # seperate groups based on typeI or typeII error\\n dfs = {\\\"typeI_df\\\": results[:8*7],\\n \\\"ef_0_2\\\": results[8*7:8*7*2],\\n \\\"ef_0_5\\\": results[8*7*2:8*7*3],\\n \\\"ef_0_8\\\": results[8*7*3:]}\\n\\n for i in dfs:\\n sdI = self.get_sd_list(dfs[i], False)\\n dictI = {\\\"xlabel\\\": 'Group sizes', \\\"ylabel\\\": \\\"TypeI error\\\",\\n \\\"title\\\": \\\"Mean typeI error per group size\\\",\\n \\\"xtickslabels\\\": sdI}\\n self.multiple_bars(dfs[i], 2, 2, dictI)\",\n \"def plotPredictedError():\\n\\tglobal normalized\\n\\n\\twarmthPred = []\\n\\twarmthObserved = []\\n\\tcompPred = []\\n\\tcompObserved = []\\n\\tSStotalWarmth = 0\\n\\tSSresWarmth = 0\\n\\tSStotalComp = 0\\n\\tSSresComp = 0\\n\\tkeys = parser.getMappings(normalized)[0].keys()\\n\\tfor key in keys:\\n\\n\\t\\tif \\\"_\\\" in key:\\n\\t\\t\\twarmthAxis, compAxis = getPlotData(key)\\n\\t\\t\\twarmthPred.append(warmthAxis[3])\\n\\t\\t\\twarmthObserved.append(warmthAxis[2])\\n\\t\\t\\tcompPred.append(compAxis[3])\\n\\t\\t\\tcompObserved.append(compAxis[2])\\n\\n\\tmeanObservedWarmth = np.mean(warmthObserved)\\n\\tmeanObservedComp = np.mean(compObserved)\\n\\tfor i in range(0, len(warmthObserved)):\\n\\t\\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\\n\\t\\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\\n\\t\\tSStotalComp += (compObserved[i] - meanObservedComp)**2\\n\\t\\tSSresComp += (compObserved[i] - compPred[i])**2\\n\\n\\n\\tplt.axis([0, 100, 0, 100])\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.title(\\\"Observed vs Predicted Warmth\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(warmthObserved, warmthPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.axis([0, 100, 0, 100])\\n\\tplt.title(\\\"Observed vs Predicted Competence\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(compObserved, compPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\",\n \"def plot(self, solution: Matrix) -> None:\\n plots.plot_matrices(\\\"Total Variation Denoising\\\", self.M, solution)\",\n \"def plotErr(self):\\n if self.xp and self.wp:\\n # plot the spectra\\n w=self.ws.value(np.array(self.xp))\\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\\n if self.dxp and self.dwp:\\n # plot the spectra\\n dw=self.ws.value(np.array(self.dxp))\\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')\",\n \"def AGN_SB_diagnostic(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n\\n fig,ax = plt.subplots()\\n L_CII = getattr(GR,'L_[CII]158_sun')\\n\\n # x = getattr(GR,'L_[CII]158_sun')/getattr(GR,'L_[NII]122_sun')\\n x = getattr(GR,'L_[OIV]25_sun')/getattr(GR,'L_[OIII]88_sun')\\n y = getattr(GR,'L_[NeIII]15_sun')/getattr(GR,'L_[NeII]12_sun')\\n sc = ax.scatter(x,y,marker='o',s=3,alpha=0.6,c=np.log10(getattr(GR,'SFR')))\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlim([8e-5,200])\\n ax.set_ylim([0.02,150])\\n # ax.set_xlabel('[CII]$_{158}$/[NII]$_{122}$')\\n plt.colorbar(sc,label='log(SFR)')\\n ax.set_xlabel('[OIV]$_{25.9}$/[OIII]$_{88}$')\\n ax.set_ylabel('[NeIII]$_{15.6}$/[NeII]$_{12.8}$')\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/ratio_%s' % ratio_name,dpi=300)\",\n \"def plot_hist_snfit_meta(self): \\n \\n self.read_meta()\\n self.read_snfit_results()\\n\\n \\n self.diff_x0 = []\\n self.diff_x0_err = []\\n self.diff_x1 = []\\n self.diff_x1_err = [] \\n self.diff_c = []\\n self.diff_c_err = [] \\n self.diff_mb = []\\n self.diff_mb_err = [] \\n self.diff_cov_x0_x1 = []\\n self.diff_cov_x0_c = []\\n self.diff_cov_x1_c = []\\n self.diff_cov_mb_x1 = []\\n self.diff_cov_mb_c = []\\n\\n for i in range (len(self.sn_name)):\\n for j in range (len(self.meta_sn_name_list)):\\n if self.sn_name[i] == self.meta_sn_name_list[j]:\\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \\n self.diff_c.append(self.c[i] - self.meta_c[j])\\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \\n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\\n# self.diff_cov_x0_x1.append()\\n# self.diff_cov_x0_c.append()\\n# self.diff_cov_x1_c.append()\\n# self.diff_cov_mb_x1.append()\\n# self.diff_cov_mb_c.append()\\n else:\\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\\n\\n\\n fig = plt.figure(figsize=(8.,8.)) \\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x0,25,label='$\\\\Delta$ X0')\\n ax0_2.hist(self.diff_x0_err,25,label='$\\\\Delta$ X0 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x1,25,label='$\\\\Delta$ X1')\\n ax0_2.hist(self.diff_x1_err,25,label='$\\\\Delta$ X1 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_c,25,label='$\\\\Delta$ Color')\\n ax0_2.hist(self.diff_c_err,25,label='$\\\\Delta$ Color error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n\\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_mb,50,label='$\\\\Delta$ mb')\\n ax0_2.hist(self.diff_mb_err,50,label='$\\\\Delta$ mb error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def prob4():\\n #get Omega, F, and initialize\\n Omega = np.array([[-3/2,3/4],[0,1],[0,1/2],[0,1]])\\n f = lambda x: np.exp(np.sum(-x**2/2,axis=0))/(2*np.pi)**(2)\\n means, cov = np.zeros(4), np.eye(4)\\n truth = scipy.stats.mvn.mvnun(list(Omega[:,0]),list(Omega[:,1]), means, cov)[0]\\n domain = np.logspace(1,5,20)\\n approxs = []\\n error = []\\n for N in domain:\\n #calculate approx for various sizes of samples\\n approx = mc_integrate(f,Omega[:,0],Omega[:,1],N)\\n approxs.append(approx)\\n #calculate relative err.\\n error.append(np.abs((truth-approx)/truth))\\n #PLOT it all\\n plt.title(\\\"Error vs Sample Size\\\")\\n plt.plot(domain,1/np.sqrt(domain),label = \\\"1/sqrt(N)\\\")\\n plt.plot(domain,error,label = \\\"Error\\\")\\n plt.loglog()\\n plt.xlabel(\\\"N\\\")\\n plt.ylabel(\\\"Relative Error\\\")\\n plt.legend()\\n plt.show()\",\n \"def test_9(self):\\n\\n sq_qe = gen_step_qe(1.42, 0.9)\\n test_ill = Illumination()\\n # test_qef = qe_filter(sq_qe)\\n\\n filtered_ill = test_ill * sq_qe\\n\\n assert isinstance(filtered_ill, Illumination)\\n\\n #plt.plot(filtered_ill.get_spectrum('eV')[0, :], filtered_ill.get_spectrum('eV')[1, :], label=\\\"filtered\\\")\\n #plt.plot(test_ill.get_spectrum('eV')[0, :], test_ill.get_spectrum('eV')[1, :], label=\\\"original\\\")\\n\\n #plt.xlabel('wavelength (eV)')\\n #plt.ylabel('spectrum (W/eV/m^2)')\\n\\n #plt.legend()\\n\\n #plt.show()\",\n \"def diagnosticos(): \\r\\n global rhoe,Ex,npuntos_malla,itiempo,longitud_malla,rho0,aP,v1,v2,F\\r\\n global EnergiaK, EnergiaP, EnergiaT, emax\\r\\n global iout,igrafica,ifase,ivdist, distribucion\\r\\n global Archivos_Densidades, Archivos_Campo, Archivos_Efase, Archivos_Fdistribucion\\r\\n \\r\\n # Se crea el eje para graficar las cantidades fisicas involucradas:\\r\\n xgrafica = dx * sp.arange(npuntos_malla+1)\\r\\n \\r\\n if (itiempo == 0): \\r\\n plt.figure('Cantidades')\\r\\n plt.clf()\\r\\n \\r\\n if (igrafica > 0):\\r\\n # Se grafica cada paso dado por el contador igrafica:\\r\\n if (sp.fmod(itiempo,igrafica) == 0): \\r\\n # Densidad total\\r\\n plt.figure(1)\\r\\n if (itiempo >0 ): plt.cla()\\r\\n plt.plot(xgrafica, -(rhoe+rho0), 'r', label='Densidad')\\r\\n plt.xlabel('x')\\r\\n plt.xlim(0,longitud_malla)\\r\\n plt.ylim(-1.5,1.5)\\r\\n plt.legend(loc=1)\\r\\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\\r\\n plt.pause(0.0001)\\r\\n plt.draw()\\r\\n filename = '%0*d_densidad'%(5, itiempo)\\r\\n Archivos_Densidades[itiempo] = filename\\r\\n if (iout > 0):\\r\\n if (sp.fmod(itiempo,iout) == 0): \\r\\n plt.savefig(filename+'.png',dpi=720)\\r\\n \\r\\n # Campo electrico\\r\\n plt.figure(2)\\r\\n if (itiempo >0 ): plt.cla()\\r\\n plt.plot(xgrafica, Ex, 'b' , label = 'Ex')\\r\\n plt.xlabel('x', fontsize = 18)\\r\\n plt.ylabel('Ex', fontsize = 18)\\r\\n plt.xticks(np.linspace(0,16,4), fontsize = 18)\\r\\n plt.yticks(np.linspace(-0.0010,0.0010,5), fontsize = 18)\\r\\n plt.xlim(0,longitud_malla)\\r\\n plt.ylim(-0.0015,0.0015)\\r\\n plt.legend(loc = 1)\\r\\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\\r\\n plt.pause(0.0001)\\r\\n plt.draw()\\r\\n filename = '%0*d_campoelectrico'%(5, itiempo)\\r\\n Archivos_Campo[itiempo] = filename\\r\\n if (iout > 0):\\r\\n if (sp.fmod(itiempo,iout) == 0): \\r\\n plt.savefig(filename+'.png',dpi=720)\\r\\n \\r\\n if (ifase > 0):\\r\\n if (sp.fmod(itiempo,ifase) == 0): \\r\\n # Se grafica el espacio de fase en el paso dado por el contador ifase:\\r\\n plt.figure(3)\\r\\n if (itiempo >0 ): plt.cla()\\r\\n v1 = sp.zeros(nparticulas)\\r\\n v2 = sp.zeros(nparticulas)\\r\\n x1 = sp.zeros(nparticulas)\\r\\n x2 = sp.zeros(nparticulas)\\r\\n for i in range(nparticulas):\\r\\n if (v[i-1]>v[i]):\\r\\n v1[i]=v[i]\\r\\n x1[i]=x[i]\\r\\n elif(v[i-1]<v[i]):\\r\\n v2[i]=v[i]\\r\\n x2[i]=x[i] \\r\\n if(distribucion == 0):\\r\\n plt.scatter(x,v,marker='.',s=0.1,color='black') \\r\\n elif(distribucion == 1 or distribucion == 2):\\r\\n plt.scatter(x1,v1,marker='.',s=0.1,color='red') \\r\\n plt.scatter(x2,v2,marker='.',s=0.1,color='blue')\\r\\n plt.xticks(np.linspace(0,100,6), fontsize = 18)\\r\\n plt.yticks(np.linspace(-8,8,5), fontsize = 18)\\r\\n plt.xlabel('x', fontsize = 18)\\r\\n plt.ylabel('v', fontsize = 18)\\r\\n plt.xlim(0,longitud_malla)\\r\\n plt.ylim(-4,8)\\r\\n\\r\\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\\r\\n plt.pause(0.0001)\\r\\n plt.draw()\\r\\n filename = '%0*d_espaciofase'%(5, itiempo)\\r\\n Archivos_Efase[itiempo] = filename\\r\\n if (iout > 0):\\r\\n if (sp.fmod(itiempo,iout) == 0): \\r\\n plt.savefig(filename+'.png',dpi=240)\\r\\n \\r\\n if (ivdist > 0):\\r\\n if (sp.fmod(itiempo,ivdist)==0):\\r\\n plt.figure(4)\\r\\n if (itiempo >0 ): plt.cla() \\r\\n plt.scatter(v,F,marker = '.' , s=0.1, color ='green')\\r\\n plt.xlim(-5*vh,5*vh)\\r\\n plt.ylim(0,1.0)\\r\\n plt.xlabel('v')\\r\\n plt.ylabel('f(v)')\\r\\n #fn_vdist = 'vdist_%0*d'%(5, itiempo)\\r\\n # Se imprimen y se guardan las imagenes de acuerdo a iout:\\r\\n plt.pause(0.0001)\\r\\n plt.draw()\\r\\n filename = '%0*d_fdistribucion'%(5, itiempo)\\r\\n Archivos_Fdistribucion[itiempo] = filename\\r\\n if (iout > 0):\\r\\n if (sp.fmod(itiempo,iout) == 0): \\r\\n plt.savefig(filename+'.png',dpi=720)\\r\\n #Se escriben los datos de la distribucion en un archivo:\\r\\n# sp.savetxt(fn_vdist, sp.column_stack((v,F)),fmt=('%1.4e','%1.4e')) \\r\\n \\r\\n # Energia cinetica:\\r\\n v2 = v**2\\r\\n EnergiaK[itiempo] = 0.5*masa*sum(v2)\\r\\n \\r\\n # Energia potencial:\\r\\n e2 = Ex**2\\r\\n EnergiaP[itiempo] = 0.5*dx*sum(e2)\\r\\n emax = max(Ex) # Campo maximo para analisis de inestabilidad\\r\\n \\r\\n # Energia total: \\r\\n EnergiaT[itiempo] = EnergiaP[itiempo] + EnergiaK[itiempo]\\r\\n \\r\\n return True\",\n \"def showPlot4():\\n overall_data = []\\n per_to_clean = [round(x * 0.1,1) for x in range(0,10)]\\n number_of_robots = list(range(1,6))\\n for per in per_to_clean:\\n proc_sim_data = []\\n for item in number_of_robots:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, per, 10, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n overall_data.append(proc_sim_data)\\n plot(per_to_clean, overall_data)\\n title('cleaning time vs. percentage cleaned')\\n xlabel('percentage clean')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n\\n # chdir into the working directory\\n os.chdir(env['WORKDIR'])\\n\\n for nclPlotFile in self._ncl:\\n # copy the NCL command to the workdir\\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\\n\\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\\n if rc:\\n try:\\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\\n except subprocess.CalledProcessError as e:\\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\\n print(' {0}'.format(e.cmd))\\n print(' rc = {0}'.format(e.returncode))\\n else:\\n print('{0}... continuing with additional plots.'.format(err_msg))\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def spectral_check(self, ):\\r\\n a, b = self.dfa, self.dfm.copy()\\r\\n b['ts_a']=a.ts\\r\\n b['flux_a'] = a.flux\\r\\n b['dflux'] = (b.flux-b.flux_a)/b.flux_unc\\r\\n b['eflux100_a'] = a.eflux100\\r\\n b['deflux'] = (b.eflux100-b.eflux100_a)/b.eflux100_unc\\r\\n b['pindex_a'] = a.pindex\\r\\n b['gdelta'] = (b.pindex-b.pindex_a)/b.pindex_unc\\r\\n self.dfm = b # since copy\\r\\n\\r\\n fig,axx = plt.subplots(1,2, figsize=(10,5), sharey=True)\\r\\n hkw = dict(bins=np.linspace(-5,5,51), histtype='step', lw=2, density=True)\\r\\n\\r\\n cut = (b.ts>50) & ~pd.isnull(b.deflux) & ~pd.isnull(b.gdelta) &\\\\\\r\\n (b.modelname==\\\"LogParabola\\\") & (b.pindex<3) & (b.pindex>0.5) &\\\\\\r\\n (b.e0>500) &(b.eflux100_unc>0) &(b.pindex_unc>0)\\r\\n self.check_total = sum(cut)\\r\\n for ax, title, val in zip(axx.flatten(), ['Energy Flux', 'Spectral index'], [b.deflux, b.gdelta]): \\r\\n\\r\\n df=val[cut]\\r\\n ax.hist(df.clip(-5,5), label='mean {:5.2f}\\\\nstd {:5.2f}'.format(df.mean(),df.std()), **hkw);\\r\\n ax.grid(alpha=0.5); \\r\\n x=np.linspace(-4,4)\\r\\n ax.plot(x, stats.norm.pdf(x), '--g' );\\r\\n ax.set(xlabel='normalized fit deviation', title=title, )\\r\\n ax.legend(loc='upper left',prop=dict(family='monospace'))\\r\\n fig.suptitle('Normalized devations of fit from model', fontsize=16);\\r\\n\\r\\n return fig\",\n \"def debug_plots(basename, rfile, state_prob, corr_w, mass):\\n rfile.cd()\\n prob_h = hist1d(state_prob, min=0, max=1, name=basename + '_state_prob')\\n corr_h = hist1d(corr_w, log=True, name=basename + '_corr_w')\\n w_h = hist1d(state_prob * corr_w, log=True, name=basename + '_final_weight')\\n\\n # Keep the 2d histograms consistent between different bins by setting ranges\\n corr_v_prob = hist2d(state_prob, corr_w, minx=0, maxx=1,\\n miny=1, maxy=1e5, logy=True, y_axis='corr_weight',\\n name=basename + '_corr_w_v_state_prob')\\n w_v_prob = hist2d(state_prob, corr_w * state_prob, minx=0, maxx=1,\\n miny=0.01, maxy=1e4, logy=True, y_axis='final_weight',\\n name=basename + '_final_weight_v_state_prob')\\n\\n mass_h = hist1d(mass, min=3.2, max=3.75, weights=state_prob,\\n name=basename + '_mass_w_state_prob')\\n\\n mass_h_w = hist1d(mass, min=3.2, max=3.75, weights=state_prob * corr_w,\\n name=basename + '_mass_w_final_weight')\\n\\n rej_sp_h = hist1d(state_prob[corr_w == 0], min=0, max=1,\\n name=basename + '_state_prob_rej_ev')\\n\\n for h in [prob_h, corr_h, w_h, corr_v_prob, w_v_prob, mass_h, mass_h_w,\\n rej_sp_h]:\\n h.Write()\",\n \"def plot_correction_diagram(fig_name):\\n dir = \\\"log/circular antenna/around car\\\"\\n files = utils.walk_files(dir)\\n pattern_loc = r'.*\\\\\\\\(.*?) (.*?).csv$'\\n radian_ref = 0.2\\n for i in range(len(files)):\\n file = files[i]\\n match_obj = re.match(pattern_loc, file)\\n if (match_obj.groups()[0] == 'left') & (match_obj.groups()[1] == '2m50'):\\n df = pd.read_csv(file, sep=';', decimal=',')\\n df1 = df[df['RSSI ANTENNA PCB'] != 0]\\n rssi = pd.DataFrame(df1['RSSI ANTENNA PCB'])\\n radian = pd.DataFrame(df1['ORIENTATION_X'])\\n radian_mapped = radian.apply(utils.mapping_radian, args=(radian_ref, match_obj.groups()[0],))\\n rssi_corrected = utils.correct_diagram(rssi, radian_mapped)\\n rssi.columns = ['Original']\\n rssi_corrected.columns = ['Corrected']\\n rssi.index = np.arange(rssi.shape[0]) / utils.FREQ_LOG\\n rssi_corrected.index = np.arange(rssi_corrected.shape[0]) / utils.FREQ_LOG\\n\\n plt.figure(figsize=(12, 8))\\n ax1 = plt.subplot(2, 1, 1)\\n rssi.plot(kind='line', ax=ax1)\\n rssi_corrected.plot(kind='line', ax=ax1)\\n plt.title(match_obj.groups()[0] + ' ' + match_obj.groups()[1])\\n plt.title('RSSI Variation over time')\\n plt.xlabel('Time: s')\\n plt.ylabel('RSSI: dBm')\\n\\n ax3 = plt.subplot(2, 2, 3)\\n rssi.plot(kind='density', ax=ax3)\\n rssi_corrected.plot(kind='density', ax=ax3)\\n plt.title('Distribution')\\n plt.xlabel('RSSI: dBm')\\n\\n ax4 = plt.subplot(2, 2, 4)\\n df = pd.DataFrame()\\n df['Original'] = rssi\\n df['Corrected'] = rssi_corrected\\n df.plot(kind='box', ax=ax4)\\n plt.title('Box')\\n plt.ylabel('RSSI: dBm')\\n if not os.path.exists(dir_fig):\\n os.makedirs(dir_fig)\\n plt.savefig(dir_fig + '/' + fig_name + '.png')\",\n \"def simulationDelayedTreatment(numTrials):\\n \\n numViruses = 100\\n maxPop = 1000\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n resistances = {'guttagonol': False}\\n mutProb = 0.005\\n delays = [300, 150, 75, 0]\\n f, axarr = pylab.subplots(2, 2)\\n x_plot = []\\n\\n for delay in delays:\\n FinalPopSize = [0.0 for x in range(numTrials)]\\n for trial in range(numTrials):\\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\\n patient = TreatedPatient(viruses, maxPop)\\n for i in range(delay):\\n patient.update()\\n patient.addPrescription('guttagonol')\\n for j in range(delay, delay+150):\\n patient.update()\\n FinalPopSize[trial] = patient.getTotalPop()\\n x_plot.append(FinalPopSize)\\n\\n axarr[0, 0].hist(x_plot[0])\\n axarr[0, 1].hist(x_plot[1])\\n axarr[1, 0].hist(x_plot[2])\\n axarr[1, 1].hist(x_plot[3])\\n pylab.show()\\n\\n # pylab.plot(avgPopSize, label = 'avg pop size')\\n # pylab.plot(avgGuttagonolResistantPop, label = 'avg pop size guttagonol-resistant')\\n # pylab.xlabel(\\\"Time\\\")\\n # pylab.ylabel(\\\"Average Population Size\\\")\\n # pylab.title(\\\"Average Size of the Virus Populations\\\")\\n # pylab.legend(loc = 'best')\\n # pylab.show()\",\n \"def showPlot1():\\n\\n interested_in = list(range(5,30,5))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on room size')\\n xlabel('area of the room (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def show_dcr_results(dg):\\n cycle = dg.fileDB['cycle'].values[0]\\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\\n # print(df_dsp.describe()) \\n\\n # compare DCR and A/E distributions\\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\\n \\n elo, ehi, epb = 0, 25000, 100\\n \\n # aoe distribution\\n # ylo, yhi, ypb = -1, 2, 0.1\\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p0.set_ylabel('A/E', ha='right', y=1)\\n\\n # dcr distribution\\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\\n # ylo, yhi, ypb = -3, 2, 0.1\\n ylo, yhi, ypb = 0.9, 1.08, 0.001\\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p1.set_ylabel('DCR', ha='right', y=1)\\n \\n # plt.show()\\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\\n plt.cla()\",\n \"def showPlot3():\\n interested_in = [(20,20),(25,16),(40,10),(50,8),(80,5),(100,4)]\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(2, 1.0, item[0], item[1], 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot([1,1.56,4,6.25,16,25], proc_sim_data)\\n title('Dependence of cleaning time on room shape')\\n xlabel('ratio of width to height')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plot_correct_body_effect():\\n file_with = 'log/influence/body/Left 2m with body.csv'\\n file_without = 'log/influence/body/Left 2m without body.csv'\\n rssi_with_subset = utils.read_file_rssi_37(file_with, correct_index=True)\\n rssi_without_subset = utils.read_file_rssi_37(file_without, correct_index=True)\\n plt.figure(figsize=(16, 6))\\n ax1 = plt.subplot(1, 2, 1)\\n rssi_with_subset.plot(kind='line', ax=ax1)\\n plt.xlabel('Time: s')\\n plt.ylabel('RSSI: dBm')\\n plt.title('With Body Attenuation')\\n ax2 = plt.subplot(1, 2, 2)\\n rssi_without_subset.plot(kind='line', ax=ax2, sharey=ax1)\\n plt.xlabel('Time: s')\\n plt.title('Without Body Attenuation')\\n plt.figure(figsize=(16, 6))\\n rssi_with_subset = rssi_with_subset.apply(lambda x: x - rssi_with_subset[colums[1]])\\n rssi_without_subset = rssi_without_subset.apply(lambda x: x - rssi_without_subset[colums[1]])\\n ax3 = plt.subplot(1, 2, 1)\\n rssi_with_subset.plot(kind='line', ax=ax3)\\n plt.xlabel('Time: s')\\n plt.ylabel('Difference: dB')\\n plt.title('Difference With Body Attenuation')\\n ax4 = plt.subplot(1, 2, 2)\\n rssi_without_subset.plot(kind='line', ax=ax4, sharey=ax3)\\n plt.xlabel('Time: s')\\n plt.title('Difference Without Body Attenuation')\",\n \"def _plot(self, rewards, losses, epsilons):\\n plt.figure(figsize=(20,5))\\n plt.subplot(131)\\n plt.title('Episodic Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('TD Loss')\\n plt.plot(losses)\\n plt.subplot(133)\\n plt.title('Epsilon')\\n plt.plot(epsilons)\\n plt.tight_layout()\\n plt.show()\",\n \"def diagnose_priors(self):\\n if not hasattr(self, \\\"corrected_lc\\\"):\\n raise ValueError(\\n \\\"Please call the `correct()` method before trying to diagnose.\\\"\\n )\\n\\n names = [dm.name for dm in self.dmc]\\n with plt.style.context(MPLSTYLE):\\n _, axs = plt.subplots(\\n 1, len(names), figsize=(len(names) * 4, 4), sharey=True\\n )\\n if not hasattr(axs, \\\"__iter__\\\"):\\n axs = [axs]\\n for idx, ax, X in zip(range(len(names)), axs, self.dmc):\\n X.plot_priors(ax=ax)\\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\\n submatrix_coefficients = self.coefficients[\\n firstcol_idx : firstcol_idx + X.shape[1]\\n ]\\n [ax.axvline(s, color=\\\"red\\\", zorder=-1) for s in submatrix_coefficients]\\n return axs\",\n \"def profil_consommation(params):\\n N = 50; min_val = 120; max_val = 200;\\n df = pd.DataFrame( data = np.random.rand(N, 3), columns = [\\\"a_i\\\",\\\"a_j\\\",\\\"a_k\\\"] );\\n# df = pd.DataFrame( data = np.random.uniform(low=min_val, high=max_val, size=(N, 3)),\\\\\\n# columns = [\\\"a_i\\\",\\\"a_j\\\",\\\"a_k\\\"] );\\n df[\\\"a_j\\\"] = 0.3 + df[\\\"a_i\\\"] *( 1 + np.random.random(N,)*df[\\\"a_i\\\"]);\\n df[\\\"a_k\\\"] = df[\\\"a_k\\\"] ; \\n df[\\\"a_i\\\"] = df[\\\"a_i\\\"] + 0.6;\\n df[\\\"a_j\\\"] = df[\\\"a_j\\\"] + 0.6;\\n \\n fig, ax = plt.subplots()\\n df.plot( ax = ax);\\n ax.set_yticklabels(['{:3.1f}'.format(x*100) \\\\\\n for x in ax.get_yticks()]);\\n ax.legend( df.columns, loc='upper center', bbox_to_anchor=(0.5, 1.00),\\\\\\n ncol=3, fancybox=True, shadow=True); \\n plt.savefig(params[\\\"path_save\\\"]+\\\\\\n \\\"profilDeConsommationSeriesTemporelles.eps\\\",\\\\\\n dpi= 190)\",\n \"def linear_mobility_paperplot(fieldVector,df):\\n vcm = np.array(fieldVector) * 1e-2\\n lw = 1.5\\n mu_1 = []\\n mu_2 = []\\n mu_3 = []\\n meanE_1 = []\\n meanE_2 = []\\n meanE_3 = []\\n for ee in fieldVector:\\n chi_1_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '1_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n mu_1.append(utilities.calc_linear_mobility(chi_1_i, df, ee) * 10 ** 4)\\n mu_2.append(utilities.calc_linear_mobility(chi_2_i, df, ee) * 10 ** 4)\\n mu_3.append(utilities.calc_linear_mobility(chi_3_i, df, ee) * 10 ** 4)\\n meanE_1.append(utilities.mean_energy(chi_1_i,df))\\n meanE_2.append(utilities.mean_energy(chi_2_i,df))\\n meanE_3.append(utilities.mean_energy(chi_3_i,df))\\n\\n plt.figure(figsize=(2.05,2.5))\\n # ax = plt.axes([0.2, 0.19, 0.75, 0.76])\\n ax = plt.axes([0.21, 0.19, 0.75, 0.75])\\n mufac = 1000\\n # mufac = 1000\\n ax.plot(vcm, np.array(mu_3)/mufac, '-', linewidth=lw, label='Warm', color=warm_color)\\n ax.plot(vcm, np.array(mu_2)/mufac, '--', linewidth=lw, label='Cold', color=cold_color)\\n ax.plot(vcm, np.array(mu_1)/mufac, '--', linewidth=lw, label='RTA', color=rta_color)\\n\\n plt.xlim([0,np.max(fieldVector)/100])\\n plt.xlabel(r'Electric field ($\\\\rm V \\\\, cm^{-1}$)')\\n # plt.ylabel(r'$\\\\sigma^{\\\\omega = 0}_{\\\\parallel}$ ($\\\\rm cm^2 \\\\, kV^{-1}\\\\, s^{-1}$)')\\n plt.ylabel(r'DC mobility (1000 $\\\\rm cm^2 \\\\, V^{-1}\\\\, s^{-1}$)')\\n plt.ylim([0.8e4/mufac, 2e4/mufac])\\n ax.locator_params(axis='x', nbins=6)\\n # plt.legend(ncol=3,loc='lower center',frameon=False)\\n plt.legend(frameon=False)\\n plt.savefig(pp.figureLoc +'linear_mobility2.png',dpi=600)\\n\\n plt.figure()\\n lw = 2\\n plt.plot(vcm,(np.array(meanE_1) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='RTA')\\n plt.plot(vcm,(np.array(meanE_2) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='Cold '+r'$e^{-}$')\\n plt.plot(vcm,(np.array(meanE_3) -np.min(df['energy [eV]']))*1000,'-', linewidth=lw, label='Warm '+r'$e^{-}$')\\n plt.xlabel(r'Electric field [$kV/cm$]')\\n plt.ylabel(r'Mean Energy [meV]')\\n plt.title(pp.title_str)\\n plt.savefig(pp.figureLoc +'meanEnergy_vField.png', bbox_inches='tight',dpi=600)\\n plt.legend(frameon=False)\",\n \"def compare(self, plot=False):\\n oldConditionData, newConditionData = self.runSimulations()\\n \\n #For now make print statements about each none matching data\\n conditionsBroken=[]\\n variablesFailed=[]\\n for i in range(len(oldConditionData)):\\n timeOld, dataListOld = oldConditionData[i]\\n timeNew, dataListNew = newConditionData[i]\\n\\n for variableOld, variableNew in zip(dataListOld, dataListNew):\\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\\n if i not in conditionsBroken: conditionsBroken.append(i)\\n\\n if variableOld.species:\\n label = variableOld.species.molecule[0].toSMILES()\\n print \\\"Species profile for {0} does not match between the old model ({1}) and \\\\\\n the new model ({2}) in condition {3:d}.\\\".format(variableOld.species.molecule[0].toSMILES(),\\n variableOld.label, \\n variableNew.label,\\n i+1)\\n else:\\n label = variableOld.label\\n print \\\"{0} does not match between the old model and \\\\\\n the new model in condition {1:d}.\\\".format(variableOld.label, i+1)\\n\\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\\n print ''\\n print 'The following reaction conditions were broken:'\\n print ''\\n for index in conditionsBroken:\\n print \\\"Condition {0:d}:\\\"\\n print str(self.conditions[index])\\n print ''\\n\\n if plot:\\n # Ignore Inerts\\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\\n for i in range(len(oldConditionData)):\\n time, dataList = oldConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n time, dataList = newConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n # Name after the index of the condition\\n # though it may be better to name it after the actual conditions in T, P, etc\\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\\n\\n return variablesFailed\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def test4():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\t#Voigt\\n\\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def test3():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def checkCorr(originalDF):\\n # BEGIN: from https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python\\n # EXPLANATION: This code visualizes the correlation matrix of the data \\n # using heatmap, representing different correlation coefficients by \\n # different colors.\\n corrmat = originalDF.corr()\\n f, ax = plt.subplots(figsize=(12,9))\\n sns.heatmap(corrmat, vmax=.8, square=True)\\n \\n #Zoom in the important variables\\n #saleprice correlation matrix\\n k = 10 #number of variables for heatmap\\n cols = corrmat.nlargest(k, 'SalePrice')['SalePrice'].index\\n cm = np.corrcoef(originalDF[cols].values.T)\\n sns.set(font_scale=1.25)\\n hm = sns.heatmap(cm, cbar=True, annot=True, square=True, fmt='.2f', annot_kws={'size': 10}, yticklabels=cols.values, xticklabels=cols.values)\\n plt.show()\\n # END: from https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python\\n \\n \\\"\\\"\\\"\\n It seems like 1stFlrSF and TotalBsmtSF, \\n TotRmsAbvGr and GrLivArea, YearBuilt and GarageYrBlt, \\n GarageArea and GarageCars are highly correlated respectively.\\n Let us check the specific correlations.\\n \\\"\\\"\\\"\\n cor1 = originalDF.loc[:, \\\"1stFlrSF\\\"].corr(originalDF.loc[:, \\\"TotalBsmtSF\\\"])\\n cor2 = originalDF.loc[:, \\\"TotRmsAbvGrd\\\"].corr(originalDF.loc[:, \\\"GrLivArea\\\"])\\n cor3 = originalDF.loc[:, \\\"YearBuilt\\\"].corr(originalDF.loc[:, \\\"GarageYrBlt\\\"])\\n cor4 = originalDF.loc[:, \\\"GarageArea\\\"].corr(originalDF.loc[:, \\\"GarageCars\\\"])\\n \\n print(\\\"1st Floor SF and Total Basement SF\\\")\\n print(cor1)\\n print(\\\"Total Rooms Above Ground and Ground Living Area\\\")\\n print(cor2)\\n print(\\\"Year Built and Garage Year Built\\\")\\n print(cor3)\\n print(\\\"Garage Area and Garage Cars\\\")\\n print(cor4)\\n \\n # Maybe try dropping those with abs(corr) > 0.9?\",\n \"def make_summary_plot(run_lists, file_descriptor, attr='sipm1.threeSampleAmpl'):\\n biases = []\\n gains = []\\n pes = []\\n currs = []\\n gainerrs = []\\n quad_terms = []\\n quad_errs = []\\n for row in sorted(run_lists):\\n biases.append(row[0])\\n gain_out = fit_gain(row[1], attr=attr)\\n out_tuple = gain_out[0]\\n gains.append(out_tuple[0])\\n gainerrs.append(out_tuple[3])\\n smeans = sorted(gain_out[1])\\n currs.append(0.5*(smeans[-1] + smeans[-2]))\\n pes.append(currs[-1]/gains[-1])\\n quad_terms.append(out_tuple[1])\\n quad_errs.append(out_tuple[4])\\n\\n maxgain = max(gains)\\n gains = np.array(gains)/maxgain\\n gainerrs = np.array(gainerrs)/maxgain\\n # gainerrs = 0.1*gains\\n\\n currs = np.array(currs)/max(currs)\\n pes = np.array(pes)\\n pe_errs = gainerrs/gains*pes\\n maxpe = max(pes)\\n fig, ax1 = plt.subplots()\\n\\n coeffs, V = np.polyfit(biases, gains, 1, w=1.0/gainerrs, cov=True)\\n breakdown = -1*coeffs[1]/coeffs[0]\\n\\n breakdown_sigma = sigma_from_cov(coeffs, V)\\n\\n # calculate sigmas throughout range\\n vals, vecs = np.linalg.eig(V)\\n U = np.transpose(vecs)\\n xs_for_error = np.arange(breakdown - 0.1, max(biases) + 0.1, 0.01)\\n gain_sigmas = sig_from_diag(xs_for_error, U, vals)\\n error_band_ys = np.array([i*coeffs[0] + coeffs[1] for i in xs_for_error])\\n ax1.fill_between(xs_for_error, error_band_ys + gain_sigmas,\\n error_band_ys - gain_sigmas, facecolor='red', alpha=0.5)\\n\\n fitline = [i*coeffs[0] + coeffs[1] for i in biases] + [0]\\n fitbiases = biases + [breakdown]\\n\\n ax1.set_title('bias scan %s' % file_descriptor)\\n fitplot = ax1.plot(fitbiases, fitline, 'r-')\\n gainplot = ax1.errorbar(\\n biases, gains, yerr=gainerrs, fmt='ro', markersize=10)\\n currplot = ax1.plot(biases, currs, 'g*', markersize=15)\\n ax1.set_ylim(0, 1.105)\\n ax1.set_xlim([breakdown - 0.1, max(biases) + 0.1])\\n ax1.set_xlabel('bias voltage [V]')\\n ax1.set_ylabel('relative gain, charge [a.u.]')\\n\\n ticks = [breakdown]\\n ticks.extend([bias for bias in biases[::2]])\\n tick_labels = ['%.1f $\\\\pm$ %.1f' % (breakdown, breakdown_sigma)]\\n tick_labels.extend([str(bias) for bias in biases[::2]])\\n ax1.set_xticks(ticks)\\n ax1.set_xticklabels(tick_labels)\\n ax1.grid()\\n ax1.get_xticklabels()[0].set_color('r')\\n\\n ax2 = ax1.twinx()\\n peplot = ax2.errorbar(biases, pes, yerr=pe_errs, fmt='b^', markersize=10)\\n ax2.set_ylabel('pe', color='b')\\n ax2.set_ylim(0, maxpe*1.105)\\n ax2.set_xlim([breakdown - 0.1, max(biases) + 0.1])\\n for tick in ax2.get_yticklabels():\\n tick.set_color('b')\\n ax1.legend([gainplot[0]]+currplot+[peplot[0]]+fitplot,\\n ['gain', 'charge', 'pes', 'gain fit'],\\n loc='best', numpoints=1)\\n\\n plt.savefig('pdfs/breakdownPlot%s.pdf' % file_descriptor)\\n plt.show()\\n\\n quadploterrs = 0.5/np.sqrt(quad_terms)*quad_errs\\n plt.errorbar(biases, np.sqrt(quad_terms)*100, yerr=quadploterrs*100, fmt='ko')\\n plt.xlim(min(biases) - 0.1, max(biases) + 0.1)\\n plt.xlabel('bias [V]')\\n plt.ylabel('sqrt(quadratic term) [%]')\\n plt.title('quadratic terms %s' % file_descriptor)\\n\\n plt.savefig('pdfs/quadraticTerms%s.pdf' % file_descriptor)\\n plt.show()\",\n \"def figure_3(df):\\n\\n sns.set(style=\\\"white\\\", palette=sns.color_palette(\\\"cubehelix\\\", 6)) #still 6 if osa csa\\n f, axes = plt.subplots(5, 1, figsize=(6, 9)) # 6, 2 if OSA CSA\\n sns.despine(top=True, bottom=True)\\n # f.suptitle(\\\"Outcome, Grouped by Contributing Etiology\\\")\\n\\n # contains used instead of equal to include patients with multiple etio (e.g. cardiac+medication count to both)\\n neurologic_df = df.loc[df['PostDx'].str.contains(\\\"Neurologic\\\")].sort_values(by='Outcome')\\n cardiac_df = df.loc[df['PostDx'].str.contains(\\\"Cardiac\\\")].sort_values(by='Outcome')\\n medication_df = df.loc[df['PostDx'].str.contains(\\\"Medication\\\")].sort_values(by='Outcome')\\n tecsa_df = df.loc[df['PostDx'].str.contains(\\\"TECSA\\\")].sort_values(by='Outcome')\\n # osacsa_df = df.loc[df['PostDx'].str.contains(\\\"OSA-CSA\\\")].sort_values(by='Outcome')\\n primary_df = df.loc[df['PostDx'].str.contains(\\\"Primary\\\")].sort_values(by='Outcome')\\n\\n # collapse possible outcomes\\n neurologic_df['col_outcome'] = neurologic_df.apply(collapse_initial_outcome, axis=1)\\n cardiac_df['col_outcome'] = cardiac_df.apply(collapse_initial_outcome, axis=1)\\n medication_df['col_outcome'] = medication_df.apply(collapse_initial_outcome, axis=1)\\n tecsa_df['col_outcome'] = tecsa_df.apply(collapse_initial_outcome, axis=1)\\n # osacsa_df['col_outcome'] = osacsa_df.apply(collapse_initial_outcome, axis=1)\\n primary_df['col_outcome'] = primary_df.apply(collapse_initial_outcome, axis=1)\\n\\n # Create count plot for each Etio on the left, then a Pie Chart with proportion on the right\\n\\n hatches = ['', '||||', '']\\n face_color = ['white', 'white', 'dimgrey']\\n\\n # Neurologic\\n bar = sns.countplot(y='col_outcome', data=neurologic_df, ax=axes[0])\\n for i, this_bar in enumerate(bar.patches):\\n # Set a different hatch for each bar\\n this_bar.set_edgecolor('black')\\n this_bar.set_facecolor(face_color[i])\\n this_bar.set_hatch(hatches[i])\\n axes[0].set(xlabel=\\\"\\\", ylabel=\\\"Neurologic\\\\nConditions\\\")\\n\\n\\n # Cardiac\\n bar = sns.countplot(y='col_outcome', data=cardiac_df, ax=axes[1])\\n for i, this_bar in enumerate(bar.patches):\\n # Set a different hatch for each bar\\n this_bar.set_edgecolor('black')\\n this_bar.set_facecolor(face_color[i])\\n this_bar.set_hatch(hatches[i])\\n axes[1].set(xlabel=\\\"\\\", ylabel=\\\"Cardiac\\\\nConditions\\\")\\n\\n # Medication\\n bar = sns.countplot(y='col_outcome', data=medication_df, ax=axes[2])\\n for i, this_bar in enumerate(bar.patches):\\n # Set a different hatch for each bar\\n this_bar.set_edgecolor('black')\\n this_bar.set_facecolor(face_color[i])\\n this_bar.set_hatch(hatches[i])\\n axes[2].set(xlabel=\\\"\\\", ylabel=\\\"Opiate Use\\\")\\n\\n # OSA-CSA\\n # bar = sns.countplot(y='col_outcome', data=osacsa_df, ax=axes[3,0])\\n # for i, this_bar in enumerate(bar.patches):\\n # # Set a different hatch for each bar\\n # this_bar.set_hatch(hatches[i])\\n # axes[3].set(xlabel=\\\"\\\", ylabel=\\\"OSA-CSA\\\")\\n # If adding OSA-CSA back, would need to increase by 1 all of the axes indices\\n\\n # TE-CSA\\n bar = sns.countplot(y='col_outcome', data=tecsa_df, ax=axes[3])\\n for i, this_bar in enumerate(bar.patches):\\n # Set a different hatch for each bar\\n this_bar.set_edgecolor('black')\\n this_bar.set_facecolor(face_color[i])\\n this_bar.set_hatch(hatches[i])\\n axes[3].set(xlabel=\\\"\\\", ylabel=\\\"TECSA\\\")\\n\\n #Primary\\n bar = sns.countplot(y='col_outcome', data=primary_df, ax=axes[4])\\n for i, this_bar in enumerate(bar.patches):\\n # Set a different hatch for each bar\\n this_bar.set_edgecolor('black')\\n this_bar.set_facecolor(face_color[i])\\n this_bar.set_hatch(hatches[i])\\n axes[4].set(xlabel=\\\"Number of Patients\\\", ylabel=\\\"Primary CSA\\\")\\n\\n # Combined X axis for L side\\n axes[4].get_shared_x_axes().join(axes[4], axes[3], axes[2], axes[1], axes[0]) # axes[5] would need to be added back\\n axes[0].set_xticklabels(\\\"\\\")\\n axes[1].set_xticklabels(\\\"\\\")\\n axes[2].set_xticklabels(\\\"\\\")\\n axes[3].set_xticklabels(\\\"\\\")\\n # axes[4].set_xticklabels(\\\"\\\")\\n # Leave bottom labels in\\n\\n # Resize all\\n axes[0].autoscale()\\n axes[1].autoscale()\\n axes[2].autoscale()\\n axes[3].autoscale()\\n axes[4].autoscale()\\n # axes[5].autoscale()\\n\\n f.tight_layout(rect=[0, 0, 1, 1])\\n f.savefig('Figure 3 - outcome of cpap by etio.png', dpi=100)\\n # plt.show()\",\n \"def plot_anomalies(data, Species, family, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False):\\n \\n #result = test_stationarity(SpeciesName=Species, data = data)\\n #result.plot()\\n if Species == 'None':\\n vo = data[(data.family == family) & (data.prediction_adjusted == syndrome)]\\n else:\\n vo = data[(data.ScientificName == Species) & (data.prediction_adjusted == syndrome)]\\n \\n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\\n weekly_vo = pd.DataFrame(weekly_vo)\\n weekly_vo.columns = ['ID']\\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\\n\\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\\n \\n def identify_anomalies(c, sigma=sigma):\\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\\n return c.ID\\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\\n \\n upper_bound = go.Scatter(\\n name='upper Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\\n mode='lines',\\n marker=dict(color=\\\"#820101\\\"),\\n line=dict(width=0),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n \\n rolling_m = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['rolling mean'],\\n name='rolling mean',\\n mode='lines',\\n line=dict(color='#1f77b4'),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n\\n lower_bound = go.Scatter(\\n name='lower Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\\n marker=dict(color=\\\"#b7b7b7\\\"),\\n line=dict(width=0),\\n mode='lines',)\\n\\n addmissions = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['# admissions'],\\n name='# admissions',)\\n\\n ano = go.Scatter(\\n x = weekly_vo.index,\\n y =weekly_vo['anomalies'] ,\\n name='anomalies',\\n mode='markers')\\n\\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\\n if Species == 'None':\\n T = \\\"Weekly admissions of \\\"+ str(family)+' ('+syndrome+')',\\n else:\\n T = \\\"Weekly admissions of \\\"+ str(Species)+' ('+syndrome+')',\\n print (T)\\n layout = go.Layout(\\n title= 'Weekly admissions',\\n yaxis=dict( title='number of admissions',), width=900, height=640\\n )\\n\\n fig = go.Figure(data=plottingdata, layout=layout)\\n plot_url = iplot(fig)\\n if verbose:\\n print('number of admissions triggering alert') \\n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\\n if save:\\n name = family+Species+syndrome\\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'.png')\\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\\n\\n #from IPython.display import Image\\n #Image('C:\\\\Users\\\\Falco\\\\Desktop\\\\directory\\\\WMRD\\\\data\\\\TimeSeries.png')\\n \\n return weekly_vo\",\n \"def plot_various_confidences(self, graph_name, drop_rate, data_format,\\n Y, directory='./attack_data/',\\n confs=(0.0, 10.0, 20.0, 30.0, 40.0),\\n get_attack_data_name=lambda c: \\\"example_carlini_\\\"+str(c)):\\n import matplotlib.pyplot as plt\\n import pylab\\n\\n pylab.rcParams['figure.figsize'] = 6, 4\\n fig = plt.figure(1, (6, 4))\\n ax = fig.add_subplot(1, 1, 1)\\n\\n det_only = []\\n ref_only = []\\n both = []\\n none = []\\n\\n print(\\\"Drop Rate:\\\", drop_rate)\\n thrs = self.operator.get_thrs(drop_rate)\\n\\n all_pass, _detector = self.operator.filter(self.operator.data.test_data, thrs)\\n all_on_acc, _, _, _ = self.get_normal_acc(all_pass)\\n\\n print(_detector)\\n print(\\\"Classification accuracy with all defense on:\\\", all_on_acc)\\n\\n for confidence in confs:\\n f = get_attack_data_name(confidence)\\n attack_data = AttackData(f, Y, \\\"Carlini L2 \\\" + str(confidence), directory=directory,\\n input_data_format=CHANNELS_LAST, data_format=data_format)\\n # compute number of all input data and filter out valid data\\n total = len(attack_data.data)\\n valid_adv_idx = np.argwhere(np.sum(attack_data.data, axis=(1, 2, 3)) > [0] * total).flatten()\\n attack_data.data = attack_data.data[valid_adv_idx]\\n attack_data.labels = attack_data.labels[valid_adv_idx]\\n self.load_data(attack_data)\\n\\n print(\\\"Confidence:\\\", confidence)\\n valid_adv_len = len(valid_adv_idx)\\n print(\\\"valid attack %d/%d\\\" % (valid_adv_len, total))\\n all_pass, detector_breakdown = self.operator.filter(self.untrusted_data.data, thrs)\\n both_acc, det_only_acc, ref_only_acc, none_acc = self.get_attack_acc(all_pass)\\n print(detector_breakdown)\\n both.append(both_acc)\\n det_only.append(det_only_acc)\\n ref_only.append(ref_only_acc)\\n none.append(none_acc)\\n\\n size = 2.5\\n plt.plot(confs, none, c=\\\"green\\\", label=\\\"No fefense\\\", marker=\\\"x\\\", markersize=size)\\n plt.plot(confs, det_only, c=\\\"orange\\\", label=\\\"With detector\\\", marker=\\\"o\\\", markersize=size)\\n plt.plot(confs, ref_only, c=\\\"blue\\\", label=\\\"With reformer\\\", marker=\\\"^\\\", markersize=size)\\n plt.plot(confs, both, c=\\\"red\\\", label=\\\"With detector & reformer\\\", marker=\\\"s\\\", markersize=size)\\n\\n pylab.legend(loc='lower left', bbox_to_anchor=(0.02, 0.1), prop={'size':8})\\n plt.grid(linestyle='dotted')\\n plt.xlabel(r\\\"Confidence in Carlini $L^2$ attack\\\")\\n plt.ylabel(\\\"Classification accuracy\\\")\\n plt.xlim(min(confs)-1.0, max(confs)+1.0)\\n plt.ylim(-0.05, 1.05)\\n ax.yaxis.set_major_formatter(FuncFormatter('{0:.0%}'.format))\\n\\n save_path = os.path.join(self.graph_dir, graph_name+\\\".pdf\\\")\\n plt.savefig(save_path)\\n plt.clf()\",\n \"def plot_dereddening():\\n extinction_coefficients = {'2365-2764-1': np.array([0.2622, 0.844]), '4109-638-1': np.array([0.0524, 0.1576]),\\n '2058-56-1': np.array([0.0751, 0.248]), '3642-2459-1': np.array([0.1907, 0.608]),\\n '3999-1391-1': np.array([0.3911, 1.2480]), '2607-1448-1': np.array([0.0430, 0.1310])}\\n cepheids = {'2365-2764-1': np.array([0.959, 2.09]), '4109-638-1': np.array([0.705, 2.385]), '2058-56-1':\\n np.array([1.222, 1.333]), '3642-2459-1': np.array([1.088, 2.0518]), '3999-1391-1':\\n np.array([1.360, 1.2567]), '2607-1448-1': np.array([1.484, 0.6963])}\\n periods = {'2365-2764-1': 1.61, '4109-638-1': 15.31, '2058-56-1': 63.08, '3642-2459-1': 1.86, '3999-1391-1': 24.98,\\n '2607-1448-1': 8.54}\\n max_periods = max(periods.values())\\n\\n new_positions_bv_mv = [] # in M_V vs B-V space\\n colors = []\\n theoretical_position = []\\n for obj in extinction_coefficients.keys():\\n # new_positions_bv_mv.append(cepheids[obj]-extinction_coefficients[obj])\\n new_positions_bv_mv.append(cepheids[obj])\\n colors.append(periods[obj]/max_periods)\\n theoretical_position.append(-2.78*np.log10(periods[obj])-1.35)\\n\\n for pos in range(len(new_positions_bv_mv)):\\n plt.scatter(new_positions_bv_mv[pos][0], new_positions_bv_mv[pos][1], marker='^', facecolor='w', s=40)\\n plt.scatter(new_positions_bv_mv[pos][0], theoretical_position[pos], marker='o', facecolor='r', s=50)\\n return new_positions_bv_mv, colors\",\n \"def report(self, X, y):\\n predict = self.model.predict(X)\\n\\n skplt.estimators.plot_feature_importances(\\n self.model, x_tick_rotation=90)\\n plt.show()\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=predict)\\n lims = [\\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\\n ]\\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\\n ax.set_aspect('equal')\\n ax.set_xlim(lims)\\n ax.set_ylim(lims)\\n ax.set_xlabel(\\\"Observed\\\")\\n ax.set_ylabel(\\\"Predict\\\")\\n ax.set_title(\\\"Predict vs. Observed\\\")\\n plt.show()\\n\\n residuals = y - predict\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=residuals)\\n plt.title(\\\"Residuals vs. Observed\\\")\\n plt.xlabel(\\\"Obserbed\\\")\\n plt.ylabel(\\\"Residuals\\\")\\n plt.show()\\n\\n plt.hist(residuals)\\n plt.title(\\\"Residuals distribution\\\")\\n plt.xlabel(\\\"Residuals value\\\")\\n plt.ylabel(\\\"Count\\\")\\n plt.show()\\n\\n display(\\n pd.DataFrame({\\n \\\"explained_variance_score\\\":\\n metrics.explained_variance_score(y, predict),\\n \\\"mean_absolute_error\\\":\\n metrics.mean_absolute_error(y, predict),\\n \\\"mean_squared_log_error\\\":\\n metrics.mean_squared_log_error(y, predict),\\n \\\"median_absolute_error\\\":\\n metrics.median_absolute_error(y, predict),\\n \\\"r2_score\\\":\\n metrics.r2_score(y, predict)\\n },\\n index=[0]))\",\n \"def simplePlots() -> None:\\r\\n \\r\\n # Univariate data -------------------------\\r\\n \\r\\n # Make sure that always the same random numbers are generated\\r\\n np.random.seed(1234)\\r\\n \\r\\n # Generate data that are normally distributed\\r\\n x = np.random.randn(500)\\r\\n \\r\\n # Other graphics settings\\r\\n # Set \\\" context='poster' \\\" for printouts, and \\\"set_fonts(32)\\\"\\r\\n sns.set(context='notebook', style='ticks', palette='muted')\\r\\n \\r\\n # Set the fonts the way I like them\\r\\n set_fonts(16)\\r\\n \\r\\n # Scatter plot\\r\\n plt.plot(x, '.', markersize=7)\\r\\n plt.xlim([0, len(x)])\\r\\n \\r\\n # Save and show the data, in a systematic format\\r\\n printout('scatterPlot.jpg', xlabel='Datapoints', ylabel='Values', title='Scatter')\\r\\n \\r\\n # Histogram\\r\\n plt.hist(x)\\r\\n printout('histogram_plain.jpg', xlabel='Data Values',\\r\\n ylabel='Frequency', title='Histogram, default settings')\\r\\n \\r\\n plt.hist(x, 25, density=True)\\r\\n printout('density_histogram.jpg', xlabel='Data Values', ylabel='Probability',\\r\\n title='Density Histogram, 25 bins')\\r\\n \\r\\n # Boxplot\\r\\n # The ox consists of the first, second (middle) and third quartile\\r\\n set_fonts(18)\\r\\n plt.boxplot(x, sym='*')\\r\\n printout('boxplot.jpg', xlabel='Values', title='Boxplot')\\r\\n \\r\\n plt.boxplot(x, sym='*', vert=False)\\r\\n plt.title('Boxplot, horizontal')\\r\\n plt.xlabel('Values')\\r\\n plt.show()\\r\\n \\r\\n # Errorbars\\r\\n x = np.arange(5)\\r\\n y = x**2\\r\\n errorBar = x/2\\r\\n plt.errorbar(x,y, yerr=errorBar, fmt='o', capsize=5, capthick=3)\\r\\n plt.xlim([-0.2, 4.2])\\r\\n plt.ylim([-0.2, 19])\\r\\n printout('Errorbars.jpg', xlabel='Data Values', ylabel='Measurements', title='Errorbars')\\r\\n\\r\\n # SD for two groups\\r\\n weight = {'USA':89, 'Austria':74}\\r\\n weight_SD_male = 12\\r\\n plt.errorbar([1,2], weight.values(), yerr=weight_SD_male * np.r_[1,1],\\r\\n capsize=5, LineStyle='', marker='o')\\r\\n plt.xlim([0.5, 2.5])\\r\\n plt.xticks([1,2], weight.keys())\\r\\n plt.ylabel('Weight [kg]')\\r\\n plt.title('Adult male, mean +/- SD')\\r\\n\\r\\n show_data('SD_groups.jpg', out_dir='.')\\r\\n \\r\\n # Barplot\\r\\n # The font-size is set such that the legend does not overlap with the data\\r\\n np.random.seed(1234)\\r\\n set_fonts(16)\\r\\n \\r\\n df = pd.DataFrame(np.random.rand(7, 3), columns=['one', 'two', 'three'])\\r\\n df.plot(kind='bar', grid=False, color=sns.color_palette('muted'))\\r\\n \\r\\n show_data('barplot.jpg')\\r\\n\\r\\n # Bivariate Plots\\r\\n df2 = pd.DataFrame(np.random.rand(50, 3), columns=['a', 'b', 'c'])\\r\\n df2.plot(kind='scatter', x='a', y='b', s=df2['c']*500);\\r\\n plt.axhline(0, ls='--', color='#999999')\\r\\n plt.axvline(0, ls='--', color='#999999')\\r\\n printout('bivariate.jpg')\\r\\n \\r\\n sns.set_style('ticks')\\r\\n\\r\\n # Pieplot\\r\\n txtLabels = 'Cats', 'Dogs', 'Frogs', 'Others'\\r\\n fractions = [45, 30, 15, 10]\\r\\n offsets =(0, 0.05, 0, 0)\\r\\n \\r\\n plt.pie(fractions, explode=offsets, labels=txtLabels,\\r\\n autopct='%1.1f%%', shadow=True, startangle=90,\\r\\n colors=sns.color_palette('muted') )\\r\\n plt.axis('equal')\\r\\n printout('piePlot.jpg', title=' ')\",\n \"def make_asimov_significance_plots(self):\\n import matplotlib.pyplot as plt\\n plt.rcParams['text.usetex'] = True\\n outdir = os.path.join(self.outdir, 'Significances')\\n mkdir(outdir)\\n maintitle = self.make_main_title(\\n end='Asimov Analysis Significances',\\n end_center=True\\n )\\n\\n # Want to ensure the resulting y range can show all of the plots\\n # Therefore find the max and min sig of the whole set of data_sets\\n maxsig = None\\n minsig = None\\n # xrange is easier\\n hrange = self.inj_param_vals[-1]-self.inj_param_vals[0]\\n xlims = [self.inj_param_vals[0]-0.1*hrange,\\n self.inj_param_vals[-1]+0.1*hrange]\\n\\n for i in range(len(self.data_sets)):\\n\\n significances = self.deltachi2_significance(\\n wh_to_th_metrics=self.wh_to_th[i]['metrics'],\\n th_to_wh_metrics=self.th_to_wh[i]['metrics']\\n )\\n\\n truth = self.labels[i][\\n self.labels.keys()[0]].dict['data_name'].split('_')[0]\\n plotlabel = 'True %s'%self.tex_axis_label(truth)\\n \\n self.make_1d_graph(\\n xvals=self.inj_param_vals,\\n yvals=significances,\\n xlabel=self.inj_param_name,\\n xunits=self.inj_param_units,\\n ylabel=None,\\n yunits=None,\\n marker=self.marker_style(truth),\\n color=self.plot_colour(truth),\\n plotlabel=plotlabel,\\n xlims=xlims\\n )\\n\\n if maxsig is None:\\n maxsig = max(significances)\\n else:\\n maxsig = max(maxsig, max(significances))\\n if minsig is None:\\n minsig = min(significances)\\n else:\\n minsig = min(minsig, min(significances))\\n\\n # Give a more descriptive y-axis label if only one thing being plotted\\n if len(self.data_sets) == 1:\\n alt = self.labels[\\n self.labels.keys()[0]].dict['%s_name'%(\\n self.wh_to_th[0]['params']['altfit'])].split('_')[0]\\n plt.ylabel(r'%s from %s Significance $\\\\left(\\\\sigma\\\\right)$'%(\\n self.tex_axis_label(truth),\\n self.tex_axis_label(alt)\\n ))\\n else:\\n plt.ylabel(r'Significance $\\\\left(\\\\sigma\\\\right)$', fontsize=24)\\n\\n vrange = maxsig - minsig\\n plt.ylim(minsig-0.1*vrange, maxsig+0.2*vrange)\\n plt.title(maintitle, fontsize=16)\\n plt.legend(loc='best')\\n plt.tight_layout()\\n save_end = \\\"%s_asimov_significances\\\"%(self.inj_param_name)\\n self.save_plot(outdir=outdir, end=save_end, truth=truth)\\n if self.extra_points is not None:\\n yminextra, ymaxextra = self.add_extra_points()\\n yminall = min(yminextra, minsig)\\n ymaxall = max(ymaxextra, maxsig)\\n vrange = ymaxall - yminall\\n if yminall == 0:\\n plt.ylim(yminall, ymaxall+0.2*vrange)\\n else:\\n plt.ylim(yminall-0.1*vrange, ymaxall+0.3*vrange)\\n plt.legend(loc='upper left')\\n save_end = \\\"%s_asimov_significances_w_extra_points\\\"%(\\n self.inj_param_name)\\n self.save_plot(outdir=outdir, end=save_end, truth=truth)\\n plt.close()\",\n \"def distribution_horizontale_new(args):\\n number_files = [2,5,10,20];\\n rep = args[\\\"path_save\\\"]+args[\\\"correction\\\"]+\\\\\\n \\\"/data_p_\\\"+str(args[\\\"p_value\\\"])+\\\"/distribution/\\\";\\n fig = plt.figure(); default_size = fig.get_size_inches(); \\n f, ax_arrs = plt.subplots(2, 4, figsize=(default_size[0]*2.2, \\\\\\n default_size[1]*1.5), \\\\\\n );\\n cpt1 = 0; cpt2 = 1; tab_bins = [20, 40, 80,100, 100, 100]\\n for ind, k in enumerate(number_files) :\\n df = pd.read_csv(rep+args[\\\"fichier_prefix\\\"] +str(k)+args[\\\"ext\\\"], \\\\\\n names=[\\\"cpt\\\",\\\"moy_dc\\\",\\\"moy_dh\\\", \\\"aretes_matE\\\", \\\"correl_dh_dl\\\"], \\\\\\n sep=';')\\n N_graphs = df[\\\"moy_dc\\\"].count();\\n \\n aretes = find_aretes(args, df)\\n bins = range(0, (ind+1)*args[\\\"num_bins\\\"]);\\n bins = range(0, tab_bins[ind]);\\n max_count_dl, max_count_dh = count_max_df(df)\\n \\n # plot ax1\\n (mu, sigma) = norm.fit(df[\\\"moy_dc\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dc\\\"], ax = ax_arrs[cpt1, ind], bins = bins, kde = False)\\n ax_arrs[cpt1, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance de correction pour \\\\n \\\"+ str(k)+ \\\\\\n \\\" cases modifiees\\\")\\n ax_arrs[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs[cpt1, ind].get_yticks()])\\n \\n #plot ax2\\n (mu, sigma) = norm.fit(df[\\\"moy_dh\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dh\\\"], ax = ax_arrs[cpt2, ind], bins = bins, kde = False)\\n ax_arrs[cpt2, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance Hamming pour \\\\n \\\"+ str(k)+\\\\\\n \\\" cases modifiees\\\")\\n ax_arrs[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs[cpt2, ind].get_yticks()])\\n \\n# fig = ax_arrs[0,0].figure ;\\n# fig.text(0.5,0.04, \\\"Some very long and even longer xlabel\\\", ha=\\\"center\\\", va=\\\"center\\\")\\n# fig.text(0.05,0.5, \\\"Some quite extensive ylabel\\\", ha=\\\"center\\\", va=\\\"center\\\", rotation=90)\\n\\n \\n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\\n plt.grid(True)\\n plt.savefig(args[\\\"path_save\\\"]+args[\\\"correction\\\"]+\\\"/courbes/\\\"+\\\\\\n \\\"distributionMoyDCDHp05k1251020.jpeg\\\",\\\\\\n dpi= 250) #190 \",\n \"def main_paper(mode = 'q-diff'):\\n mode_name = 'Shared Autonomy'\\n if mode== 'override':\\n mode_name = 'Overrider'\\n\\n #trains rl again and fills a q-table\\n _, rl_agent = rl_alone(1000, fill_table = True)\\n\\n #prints the q-table\\n for y in range(7):\\n for x in range(7):\\n state_ind = y*(7)+x\\n q = rl_agent.get_q_values(state_ind)\\n print('Q-table')\\n print(state_ind, [x,y], np.around(q, decimals=5))\\n\\n in_li = []\\n r_li = []\\n rp_li=[]\\n\\n print(\\\"Begin looping through constraint values\\\")\\n for i in np.arange(0.0, 1.025, 0.025):\\n #cooperates and gets results\\n rewards, actionsct, rewardsP = grid_human_co(coagent=rl_agent, threshold=i, verbose=False, mode=mode)\\n print(\\\"Threshold: \\\", i)\\n avgInter = np.mean(actionsct, axis=0)\\n avgR = np.mean(rewards, axis=0)\\n avgRP = np.mean(rewardsP, axis=0)\\n in_li.append(avgInter)\\n r_li.append(avgR)\\n rp_li.append(avgRP)\\n print('Avg num of interventions: ', avgInter)\\n print('Avg reward: ', avgR)\\n print('Avg reward penalized: ', avgRP)\\n print()\\n\\n plt.figure()\\n plt.plot(np.arange(0.0, 1.025, 0.025), in_li)\\n plt.title(mode_name + ' Interventions')\\n plt.xlabel(r\\\"$\\\\alpha$\\\")\\n plt.ylabel('Average intervention count')\\n plt.show()\\n\\n plt.figure()\\n plt.title(mode_name + ' Returns', fontsize=14)\\n plt.xlabel(r\\\"$\\\\alpha$\\\", fontsize=13)\\n plt.ylabel('Average return', fontsize=13)\\n plt.plot(np.arange(0.0, 1.025, 0.025), r_li,label='Average environment return')\\n plt.plot(np.arange(0.0, 1.025, 0.025), rp_li,label=\\\"Average intervention return\\\")\\n plt.legend(fontsize=9)\\n plt.show()\",\n \"def hook_displaysuspicions(self):\\n charMarginal = (np.array(self.hypCountByCharacter,dtype=np.float64)\\n / np.sum(self.hypCountByCharacter))\\n roomMarginal = (np.array(self.hypCountByRoom,dtype=np.float64)\\n / np.sum(self.hypCountByRoom))\\n weapMarginal = (np.array(self.hypCountByWeapon,dtype=np.float64)\\n / np.sum(self.hypCountByWeapon))\\n ui.plotscenariomarginals(charMarginal,roomMarginal,weapMarginal)\\n ui.plotforbidden(self.forbidden)\",\n \"def checkConservation2(nx, nt, c, display=False):\\n \\n # create array of space points\\n x = np.linspace(0, 1, nx)\\n \\n # we use a smooth function\\n phi_ic = ic.squareWave(x, 0, 0.5) \\n\\n\\n if(display):\\n plt.figure()\\n \\n # now we run and plot mass conservation\\n # the name of the scheme is each time in the variable methodName\\n \\n methodName = \\\"FTBS\\\"\\n # make a local copy every time because things get dirty after use\\n # and we don't want to corrupt phi_ic because we'll use it again\\n phi_ic_local = phi_ic.copy()\\n \\n _, phiMean, _ = ad.FTBS(phi_ic_local, c, nt, \\\\\\n calculateConservation=True)\\n \\n if(display):\\n plotConservation2(c, nt, phiMean, methodName)\\n\\n \\n methodName = \\\"CTCS\\\"\\n # make a local copy every time because things get dirty after use\\n # and we don't want to corrupt phi_ic because we'll use it again\\n phi_ic_local = phi_ic.copy()\\n \\n _, phiMean, _ = ad.CTCS(phi_ic_local, c, nt, \\\\\\n calculateConservation=True)\\n \\n if(display):\\n plotConservation2(c, nt, phiMean, methodName)\\n\\n \\n methodName = \\\"CNCS\\\"\\n # make a local copy every time because things get dirty after use\\n # and we don't want to corrupt phi_ic because we'll use it again\\n phi_ic_local = phi_ic.copy()\\n \\n _, phiMean, _ = ad.CNCS(phi_ic_local, c, nt, \\\\\\n calculateConservation=True)\\n \\n if(display):\\n plotConservation2(c, nt, phiMean, methodName)\\n\\n \\n methodName = \\\"LaxWendroff\\\"\\n # make a local copy every time because things get dirty after use\\n # and we don't want to corrupt phi_ic because we'll use it again\\n phi_ic_local = phi_ic.copy()\\n \\n _, phiMean, _ = ad.LaxWendroff(phi_ic_local, c, nt, \\\\\\n calculateConservation=True)\\n \\n if(display):\\n plotConservation2(c, nt, phiMean, methodName)\\n\\n\\n if(display):\\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\\n #plt.ylim([0.2, 0.3])\\n plt.show()\",\n \"def plotDispCoverage(dispData, dye_conc, caliConst, dispConst, outName):\\n z = np.linspace(min(dispData[:,0]), max(dispData[:,0]), 1000)\\n dispCoverage = DispDyeCoverage(z, dye_conc, caliConst[2], dispConst[2], caliConst[3])\\n knownDyeCov = Frac_Cov(dye_conc, caliConst[2], caliConst[3])\\n caliDyeCoverage = DispDyeCoverage(dye_conc, z, caliConst[2], caliConst[3], dispConst[2])\\n #Covert the exp intensities to coverages\\n expCoverages = IntToCoverage(dispData[:,1], dispConst);\\n expCoverages = (expCoverages / expCoverages[0]) * knownDyeCov\\n plt.figure()\\n plt.rcParams.update({'font.size' : 16})\\n plt.plot(z/1000, ((caliDyeCoverage) / caliDyeCoverage[0]) * knownDyeCov)\\n plt.scatter(dispData[:,0]/1000, expCoverages);\\n #plt.ylim([0,1])\\n plt.savefig(outName + \\\"_disp_coverage_plot.png\\\")\\n plt.show()\\n #might as well get R^2 here\\n ss_res = 0\\n ss_total = 0\\n residuals = np.zeros([len(dispData[:,0]), 1])\\n for i in range(len(dispData[:,0])):\\n predictedDyeCov = DispDyeCoverage(dye_conc, dispData[i,0], caliConst[2], caliConst[3], dispConst[2])\\n scaledPredictedDyeCov = (predictedDyeCov / caliDyeCoverage[0]) * knownDyeCov\\n residuals[i] = scaledPredictedDyeCov - expCoverages[i]\\n ss_res += np.square(residuals[i])\\n ss_total += np.square((expCoverages[i] - np.average(expCoverages[:])))\\n print(ss_res)\\n print(ss_total)\\n r_sq = 1 - (ss_res/ss_total)\\n print(r_sq)\",\n \"def _create_plots(self):\\n #########################\\n # Histograms of original data\\n # Generates composite plot of specific variables before correction\\n # We fill these variables by sampling a normal distribution, so we use this plot mainly as evidence for that.\\n if self.generate_bokeh:\\n ws_hist = plotting_functions.histogram_plot(self.data_ws[~np.isnan(self.data_ws)],\\n 'Windspeed', 'black', 'm/s')\\n tmax_hist = plotting_functions.histogram_plot(self.data_tmax[~np.isnan(self.data_tmax)],\\n 'TMax', 'red', 'degrees C')\\n tmin_hist = plotting_functions.histogram_plot(self.data_tmin[~np.isnan(self.data_tmin)],\\n 'TMin', 'blue', 'degrees C')\\n tavg_hist = plotting_functions.histogram_plot(self.data_tmin[~np.isnan(self.data_tmin)],\\n 'TAvg', 'black', 'degrees C')\\n tdew_hist = plotting_functions.histogram_plot(self.data_tdew[~np.isnan(self.data_tdew)],\\n 'TDew', 'black', 'degrees C')\\n k_not_hist = plotting_functions.histogram_plot(self.k_not[~np.isnan(self.k_not)],\\n 'Ko', 'black', 'degrees C')\\n\\n output_file(\\\"correction_files/\\\" + self.station_name + '_histograms.html',\\n title=self.station_name + ' histograms')\\n\\n save(gridplot([ws_hist, tmax_hist, tmin_hist, tavg_hist, tdew_hist, k_not_hist], ncols=2,\\n plot_width=400, plot_height=400, toolbar_location=None))\\n\\n #########################\\n # Generate bokeh composite plot\\n # Creates one large plot featuring all variables as subplots, used to get a concise overview of the full dataset\\n # If user opts to not correct data (sets script_mode = 0), then this plots data before correction\\n # If user does correct data, then this plots data after correction\\n print(\\\"\\\\nSystem: Now creating composite bokeh graph.\\\")\\n if self.generate_bokeh: # Flag to create graphs or not\\n plot_list = []\\n x_size = 500\\n y_size = 350\\n\\n if self.script_mode == 0:\\n output_file(\\\"correction_files/before_graphs/\\\" + self.station_name +\\n \\\"_before_corrections_composite_graph.html\\\")\\n elif self.script_mode == 1:\\n output_file(\\\"correction_files/after_graphs/\\\" + self.station_name +\\n \\\"_after_corrections_composite_graph.html\\\")\\n else:\\n # Incorrect setup of script mode variable, raise an error\\n raise ValueError('Incorrect parameters: script mode is not set to a valid option.')\\n\\n # Temperature Maximum and Minimum Plot\\n plot_tmax_tmin = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_tmax,\\n self.data_tmin, 1, '')\\n plot_list.append(plot_tmax_tmin)\\n # Temperature Minimum and Dewpoint Plot\\n plot_tmin_tdew = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_tmin,\\n self.data_tdew, 2, '', plot_tmax_tmin)\\n plot_list.append(plot_tmin_tdew)\\n\\n # Subplot 3 changes based on what variables are provided\\n if self.column_df.ea != -1: # Vapor pressure was provided\\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ea, self.data_null,\\n 7, 'Provided ', plot_tmax_tmin)\\n\\n elif self.column_df.ea == -1 and self.column_df.tdew != -1: # Tdew was provided, show calculated ea\\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ea, self.data_null,\\n 7, 'Calculated ', plot_tmax_tmin)\\n\\n elif self.column_df.ea == -1 and self.column_df.tdew == -1 and \\\\\\n self.column_df.rhmax != -1 and self.column_df.rhmin != -1: # RH max and RH min\\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhmax,\\n self.data_rhmin, 8, '', plot_tmax_tmin)\\n\\n elif self.column_df.ea == -1 and self.column_df.tdew == -1 and \\\\\\n self.column_df.rhmax == -1 and self.column_df.rhavg != -1: # RH Avg\\n plot_humid = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhavg,\\n self.data_null, 9, '', plot_tmax_tmin)\\n else:\\n # If an unsupported combination of humidity variables is present, raise a value error.\\n raise ValueError('Bokeh figure generation encountered an unexpected combination of humidity inputs.')\\n\\n plot_list.append(plot_humid)\\n\\n # If both ea and rhmax/rhmin are provided, generate a supplementary rhmax/min graph\\n if self.column_df.rhmax != -1 and self.column_df.rhmin != -1 and self.column_df.ea != -1:\\n plot_supplemental_rh = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rhmax,\\n self.data_rhmin, 8, '', plot_tmax_tmin)\\n plot_list.append(plot_supplemental_rh)\\n\\n # Mean Monthly Temperature Minimum and Dewpoint\\n plot_mm_tmin_tdew = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_tmin,\\n self.mm_tdew, 2, 'MM ')\\n plot_list.append(plot_mm_tmin_tdew)\\n\\n # Mean Monthly k0 curve (Tmin-Tdew)\\n plot_mm_k_not = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_k_not,\\n self.data_null, 10, '', plot_mm_tmin_tdew)\\n plot_list.append(plot_mm_k_not)\\n\\n # Solar radiation and clear sky solar radiation\\n plot_rs_rso = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_rs, self.rso,\\n 5, '', plot_tmax_tmin)\\n plot_list.append(plot_rs_rso)\\n\\n # Windspeed\\n plot_ws = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_ws, self.data_null,\\n 3, '', plot_tmax_tmin)\\n plot_list.append(plot_ws)\\n\\n # Precipitation\\n plot_precip = plotting_functions.line_plot(x_size, y_size, self.dt_array, self.data_precip, self.data_null,\\n 4, '', plot_tmax_tmin)\\n plot_list.append(plot_precip)\\n\\n # Optimized mean monthly Thornton-Running solar radiation and Mean Monthly solar radiation\\n plot_mm_opt_rs_tr = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_rs,\\n self.mm_opt_rs_tr, 6, 'MM Optimized ', plot_mm_tmin_tdew)\\n plot_list.append(plot_mm_opt_rs_tr)\\n\\n # Optimized mean monthly Thornton-Running solar radiation and Mean Monthly solar radiation\\n plot_mm_orig_rs_tr = plotting_functions.line_plot(x_size, y_size, self.mm_dt_array, self.mm_rs,\\n self.mm_orig_rs_tr, 6, 'MM Original ', plot_mm_tmin_tdew)\\n plot_list.append(plot_mm_orig_rs_tr)\\n\\n # Now construct grid plot out of all of the subplots\\n number_of_plots = len(plot_list)\\n number_of_rows = ceil(number_of_plots / self.gridplot_columns)\\n\\n grid_of_plots = [([None] * 1) for i in range(number_of_rows)]\\n\\n for i in range(number_of_rows):\\n for j in range(self.gridplot_columns):\\n\\n if len(plot_list) > 0:\\n grid_of_plots[i][j] = plot_list.pop(0)\\n else:\\n pass\\n\\n fig = gridplot(grid_of_plots, toolbar_location='left')\\n save(fig)\\n\\n print(\\\"\\\\nSystem: Composite bokeh graph has been generated.\\\")\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def display_results(experiment, norms, nus, filename):\\n # plot the results of the experiment\\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\\n\\n # plot large scale overview\\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\\n\\n # plot more detailed errors exluding OLS estimate\\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\\n\\n # add title and save\\n plt.savefig(filename, dpi=300)\",\n \"def plot_results(self):\\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))\",\n \"def testNonLinearity():\\n vis = VISinformation()\\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\\n nonlin = CCDnonLinearityModel(data.copy())\\n\\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\\n\\n fig = plt.figure(frameon=False)\\n\\n left, width = 0.1, 0.8\\n rect1 = [left, 0.3, width, 0.65]\\n rect2 = [left, 0.1, width, 0.2]\\n\\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\\n\\n ax1.axhline(y=0, c='k', ls='--')\\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\\n\\n ax2.axhline(y=0, c='k', ls='--')\\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\\n\\n ax1.axvline(x=97, c='k', ls='--')\\n ax2.axvline(x=97, c='k', ls='--')\\n\\n ax1.set_xticklabels([])\\n ax2.set_xlabel('Real Charge [electrons]')\\n ax1.set_ylabel('(Output / Real - 1)*100')\\n ax2.set_ylabel('O - R [ADUs]')\\n\\n ax1.set_xlim(0, vis['fullwellcapacity'])\\n ax2.set_xlim(0, vis['fullwellcapacity'])\\n ax1.set_ylim(-.15, .2)\\n\\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\\n plt.savefig('NonlinearityModel.pdf')\\n\\n ax1.set_ylim(-.1, 8)\\n ax2.set_ylim(0, 2)\\n ax1.set_xlim(50, 800)\\n ax2.set_xlim(50, 800)\\n plt.savefig('NonlinearityModel2.pdf')\\n\\n plt.close()\",\n \"def allDirectionalityRatios(ratioFunction):\\n if not os.path.exists(\\\"savedHeatmaps\\\"):\\n os.mkdir(\\\"savedHeatmaps\\\")\\n wildRatio = np.log(ratioFunction(\\\"Wildtype_0min_BglII_rep1\\\"))\\n for j, dataset in enumerate(datasets):\\n ax = plt.subplot(len(datasets), 1, j + 1)\\n curRatio = (ratioFunction(dataset))\\n plt.title(\\\"{1}, r = {0:.2f}, p={2:.2e}\\\".format(pearsonr(curRatio, wildRatio)[0], names[dataset],\\n pearsonr(curRatio, wildRatio)[1]), fontsize=10)\\n plt.tick_params(axis='both', which='major', labelsize=10)\\n plt.tick_params(axis='both', which='minor', labelsize=8)\\n plt.plot(curRatio)\\n plt.ylim((0.25, 0.75))\\n plt.xlim((0, len(curRatio)))\\n #plt.ylim((0, 1))\\n plt.yticks((0.25, 0.5, 0.75))\\n geneCoor = [1162773, 3509071, 1180887, 543099, 1953250, 2522439, 3328524, 1503879, 900483, 242693, 3677144, 3931680, 3677704, 3762707, 3480870, 3829656, 1424678, 901855, 1439056, 3678537]\\n genePos = [i / 10000. for i in geneCoor]\\n #genePos = []\\n for lpos in genePos:\\n plt.vlines(lpos , -.8, .8, alpha=0.2, linewidth=1, color=\\\"black\\\")\\n plt.xticks([0, 50, 100, 150, 200, 250, 300, 350, 400], [\\\"\\\" for i in xrange(9)], fontsize=98)\\n removeAxes(ax=ax)\\n plt.subplots_adjust(0.07, 0.05, 0.94, 0.95, 0.2, 0.5)\\n\\n\\n\\n plt.show()\\n exit()\",\n \"def PCO1S12Noise():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\\\\n 'NoiseStudy/TestOptics_PCO1S12/'\\n d1,dx1 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas2.fits')\\n d3,dx3 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas3.fits')\\n\\n #Construct power spectra\\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f13,pow13 = fourier.meanPSD((d1-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n\\n #Mid frequency\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([f12,f23,f13],[pow12,pow23,pow13])]\\n\\n #Plot\\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\\n plt.loglog(f13,pow13/f13[0],label='1-3: %.2f' % midfreq[2])\\n plt.legend(loc='lower left')\\n plt.grid()\\n plt.title('4D Repeatability: PCO1S12')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n\\n print midfreq\\n\\n return f12,pow12\",\n \"def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\\\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\\\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\\n \\n # Determine dimensions of plot grid\\n nrows = len(perp_list) + 1\\n ncols = len(data_list)\\n \\n # Configure axes\\n axes = []\\n fig = plt.figure(figsize = (16, 3 * nrows))\\n \\n # Generate plots of starting points (first two columns for high-dimensional)\\n for index, dat in enumerate(data_list):\\n X, labs = dat\\n \\n # Check whether original data should be plotted in 3D, and adjust axes accordingly\\n if plot_3d:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_axis_off()\\n else:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n axes[-1].set_title(\\\"\\\\n\\\".join(wrap(title_list[index], 35))) \\n \\n # Based on function input, generate either perplexity plots of interim iteration plots\\n if perp_plot:\\n # Generate plots of t-SNE output for different perplexities\\n for perp in range(len(perp_list)):\\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \\\"fastest\\\", df = df)\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(perp_list[perp]))\\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n else:\\n # Generate plots of t-SNE output for different iterations\\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \\\"fastest\\\", \\\\\\n df = df)\\n for step in range(len(step_list)):\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(step_plot_perp) + \\\", Step = \\\" + str(step_list[step]))\\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\\\\n edgecolor = None, alpha = 0.8,\\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\",\n \"def plot_anomalies_data_specific(df, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False, adjusted = True):\\n \\n #result = test_stationarity(SpeciesName=Species, data = data)\\n #result.plot()\\n if syndrome:\\n if adjusted:\\n vo = df[df.prediction_adjusted == syndrome]\\n else:\\n vo = df[df.prediction == syndrome]\\n else:\\n vo = df\\n \\n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\\n weekly_vo = pd.DataFrame(weekly_vo)\\n weekly_vo.columns = ['ID']\\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\\n\\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\\n \\n def identify_anomalies(c, sigma=sigma):\\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\\n return c.ID\\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\\n \\n upper_bound = go.Scatter(\\n name='upper Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\\n mode='lines',\\n marker=dict(color=\\\"#820101\\\"),\\n line=dict(width=0),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n \\n rolling_m = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['rolling mean'],\\n name='rolling mean',\\n mode='lines',\\n line=dict(color='#1f77b4'),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n\\n lower_bound = go.Scatter(\\n name='lower Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\\n marker=dict(color=\\\"#b7b7b7\\\"),\\n line=dict(width=0),\\n mode='lines',)\\n\\n addmissions = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['# admissions'],\\n name='# admissions',)\\n\\n ano = go.Scatter(\\n x = weekly_vo.index,\\n y =weekly_vo['anomalies'] ,\\n name='anomalies',\\n mode='markers')\\n\\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\\n \\n T = \\\"Weekly admissions\\\"\\n print (T)\\n layout = go.Layout(\\n title= 'Weekly admissions',\\n yaxis=dict( title='number of admissions',), width=900, height=640\\n )\\n\\n fig = go.Figure(data=plottingdata, layout=layout)\\n plot_url = iplot(fig)\\n if verbose:\\n print('number of admissions triggering alert') \\n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\\n if save:\\n name = 'special_syndrome_study'\\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WRMD_paper/outputs/'+name+'.png')\\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\\n\\n #from IPython.display import Image\\n #Image('C:\\\\Users\\\\Falco\\\\Desktop\\\\directory\\\\WMRD\\\\data\\\\TimeSeries.png')\\n \\n return weekly_vo\",\n \"def dk_plotting():\\n heatmap_mode1_error_x(make_heatmap=False, make_panel=True)\\n\\n #heatmap_mode1_error_x()\\n figure_2_combined_cross_sections()\\n\\n #heatmap_combined_error_c()\\n #heatmap_combined_error_koff()\\n #heatmap_kpr_error_c()\\n #heatmap_kpr_error_koff()\\n\\n #heatmap_kpr2_error_c()\\n #heatmap_kpr2_error_koff()\\n\\n ctildePosterior = [truncate(f, 3) for f in list(np.arange(0.0 * KON / KP, 5.0 * KON / KP + 0.005, 0.005))[1:]]\\n kofftildePosterior = [truncate(f, 2) for f in list(np.arange(0.0 / KP, 50.0 / KP + 0.05, 0.05))[1:]]\\n\\n #heatmap_figure_4()\\n\\n return 0\",\n \"def create_val_plots(x_vals, vals_zeros,vals_ones):\\n plt.plot(x_vals, vals_zeros,label=\\\"non-fraud\\\")\\n plt.plot(x_vals, vals_ones,label=\\\"fraud\\\")\\n plt.title('Accuracy per number of iterations')\\n plt.xlabel('Number of Iterations')\\n plt.ylabel('Accuracy')\\n plt.xticks(np.arange(100, 210, 10))\\n plt.legend() \\n plt.show()\\n # plt.savefig('./analysis_deliverable/visualizations/accuracy_plot.png')\",\n \"def evidence_tuning_plots(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\",\\n x_name=\\\"Mean Predicted\\\",\\n y_name=\\\"Empirical Probability\\\"):\\n\\n def lineplot(x, y, trials, methods, **kwargs):\\n \\\"\\\"\\\"method_lineplot.\\n\\n Args:\\n y:\\n methods:\\n kwargs:\\n \\\"\\\"\\\"\\n uniq_methods = set(methods.values)\\n method_order = sorted(uniq_methods)\\n\\n method_new_names = [f\\\"$\\\\lambda={i:0.4f}$\\\" for i in method_order]\\n method_df = []\\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\\n method_new_names)):\\n lines_y = y[methods == method]\\n lines_x = x[methods == method]\\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\\n\\n to_append = [{x_name : x,\\n y_name: y,\\n \\\"Method\\\": method_new_name,\\n \\\"Trial\\\" : trial}\\n for i, (x,y) in enumerate(zip(xx,yy))]\\n method_df.extend(to_append)\\n method_df = pd.DataFrame(method_df)\\n x = np.linspace(0,1,100)\\n plt.plot(x, x, linestyle='--', color=\\\"black\\\")\\n sns.lineplot(x=x_name, y=y_name, hue=\\\"Method\\\",\\n alpha=0.8,\\n hue_order=method_new_names, data=method_df,)\\n # estimator=None, units = \\\"Trial\\\")\\n\\n df = df.copy()\\n # Query methods that have evidence_new_reg_2.0\\n df = df[[\\\"evidence\\\" in i for i in\\n df['method_name']]].reset_index()\\n\\n # Get the regularizer and reset coeff\\n coeff = [float(i.split(\\\"evidence_new_reg_\\\")[1]) for i in df['method_name']]\\n df[\\\"method_name\\\"] = coeff\\n df[\\\"Data\\\"] = convert_dataset_names(df[\\\"dataset\\\"])\\n df[\\\"Method\\\"] = df[\\\"method_name\\\"]\\n\\n g = sns.FacetGrid(df, col=\\\"Data\\\", height=6, sharex = False, sharey = False)\\n g.map(lineplot, x_input, y_input, \\\"trial_number\\\",\\n methods=df[\\\"Method\\\"]).add_legend()\",\n \"def test_control_loop_example():\\n example.control.print_error_measurement()\\n matplotlib.use('agg')\\n example.control.visualise_error_measurement(fig_file='cs_compare.pdf')\\n assert path.isfile('cs_compare.pdf')\\n example.control.sil_comparison()\",\n \"def plot_pretty():\\n\\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\\n plt.style.use('seaborn-deep')\\n\\n black = '#2B2B2D'\\n red = '#E90039'\\n orange = '#FF1800'\\n white = '#FFFFFF'\\n yellow = '#FF9900'\\n\\n plt.figure(figsize=(12.8, 9.6))\\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\\n\\n plt.gcf().set_facecolor(black)\\n\\n plt.subplot(2, 3, 1)\\n plt.plot(ts, ys[:, 2], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\\n plt.title(r'$C_{FA}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 2)\\n plt.plot(ts, ys[:, 0], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\\n plt.title(r'$C_{G}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 3)\\n plt.plot(ts, ys[:, 3], color=orange)\\n plt.title(r'$C_{E}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 4)\\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\\n plt.title(r'$F_{m, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 5)\\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\\n plt.title(r'$F_{G, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 6)\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 1],\\n color=red\\n )\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 0],\\n color=yellow\\n )\\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\\n plt.title('bias')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n # plt.suptitle('Closedloop bioreactor without noise')\\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\\n plt.savefig('no_noise_pretty.png', transparent=True)\\n plt.show()\",\n \"def plot_evaluation(parameters_dict, log_df, settings, evaluation_set_kde, plotname):\\n\\n\\n plots = []\\n\\n\\n ### setup the colors for each component\\n if int(settings['nr_components']) < 3:\\n colors = ['rgb(228,26,28)', 'rgb(55,126,184)']\\n elif int(settings['nr_components']) < 13:\\n colors = np.array(cl.scales[str(settings['nr_components'])]['qual']['Paired'])\\n else:\\n colors = cl.interp(cl.scales['10']['qual']['Paired'], 20)\\n\\n\\n ### set up ab list\\n ab_list = evaluation_set_kde['contact'].keys()\\n\\n\\n\\n\\n ####################### plotting of settings\\n print_to_table = {}\\n for key in sorted(settings.keys()):\\n if key not in ['fold_id_dir','plot_name', 'fixed_parameters', 'threads_proteins', 'qijab_dir',\\n 'debug_mode', 'parameter_file', 'settings_file', 'optimization_log_file', 'braw_dir', 'pdb_dir', 'paramdir',\\n 'mask_sse', 'lambda_w_fix', 'lfactor', 'plotdir', 'psicov_dir', 'contact', 'hessian_pseudocount']:\\n print_to_table[key] = settings[key]\\n\\n print(\\\"Generate settings table...\\\")\\n table_settings_1 = plot_settings_table(print_to_table, 1)\\n table_settings_2 = plot_settings_table(print_to_table, 2)\\n table_settings_3 = plot_settings_table(print_to_table, 3)\\n plots.append(table_settings_1)\\n plots.append(table_settings_2)\\n plots.append(table_settings_3)\\n\\n\\n ####################### negLL and realted plots\\n if 'step' in log_df.columns and 'pass' in log_df.columns:\\n\\n if 'negLL' in log_df.columns:\\n plot_negll = plot_convergence_trace_plotly(log_df,\\n name=['negLL', 'negLL_crossval'],\\n plot_title='neg LL trace for training and cross-val set')\\n plots.append(plot_negll)\\n\\n plot_expfit_negll = plot_exponentialFit_negLL(log_df, plot_title='exponential Fit neg LL')\\n plots.append(plot_expfit_negll)\\n\\n if 'timestamp' in log_df.columns:\\n plot_timestamps = plot_convergence_trace_plotly(log_df,\\n name=['timestamp'],\\n plot_title='time (s) per iteration')\\n plots.append(plot_timestamps)\\n\\n\\n if 'gradient_norm_weights' in log_df.columns:\\n plot_grad_norm_weights = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_weights'],\\n plot_title='norm of weight gradients')\\n plots.append(plot_grad_norm_weights)\\n\\n if 'gradient_norm_means' in log_df.columns:\\n plot_grad_norm_means = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_means'],\\n plot_title='norm of mean gradients')\\n plots.append(plot_grad_norm_means)\\n\\n if 'gradient_norm_prec' in log_df.columns:\\n plot_grad_norm_prec = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_prec'],\\n plot_title='norm of precMat gradients')\\n plots.append(plot_grad_norm_prec)\\n\\n\\n ####################### plotting of parameters\\n print(\\\"Generate distribution of parameters...\\\")\\n\\n #weights\\n weights_dict = {}\\n for component in range(settings['nr_components']):\\n weights_dict['component ' + str(component)] = {\\n 'weights (contact)': parameters_dict[\\\"weight_contact_\\\" + str(component)][0],\\n 'weights (bg)': parameters_dict[\\\"weight_bg_\\\" + str(component)][0]\\n }\\n plot_weights = plot_barplot(\\n weights_dict,\\n 'Distribution of weights',\\n 'component weights',\\n type='group',\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/weights.html\\\"\\n )\\n\\n #mu\\n mu_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'mu' in k))\\n plot_means = plot_boxplot(\\n mu_df,\\n 'Distribution of Means',\\n \\\"values of mean parameters\\\",\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/mus.html\\\"\\n )\\n\\n #std deviation\\n prec_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'prec' in k))\\n try:\\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/p))\\n if settings['prec_wrt_L']:\\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/(p*142))) #in case precision is specified depending on L=142\\n except ZeroDivisionError as e:\\n print(e)\\n std_dev=prec_df\\n\\n std_dev.columns = [column_name.replace(\\\"prec\\\", \\\"std\\\") for column_name in std_dev.columns]\\n plot_stddev = plot_boxplot(\\n std_dev,\\n 'Distribution of std deviations',\\n \\\"values of std deviation parameters\\\",\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/std.html\\\"\\n )\\n\\n\\n plots.append(plot_weights)\\n plots.append(plot_means)\\n plots.append(plot_stddev)\\n\\n ####################### Scatterplot mu vs std dev\\n print(\\\"Generate scatter plot mu vs std...\\\")\\n scatter_dict = {}\\n for component in range(settings['nr_components']):\\n scatter_dict['mu_'+str(component)] = [\\n mu_df['mu_'+str(component)].tolist(),\\n std_dev['std_'+str(component)].tolist(),\\n AB.values()\\n ]\\n plot_mu_vs_stddev = plot_scatter(scatter_dict,\\n 'Mean vs std deviation',\\n 'mean',\\n \\\"std deviation\\\",\\n False,\\n colors\\n #,plot_out=\\\"/home/vorberg/mu_vs_std.html\\\"\\n )\\n\\n plots.append(plot_mu_vs_stddev)\\n\\n\\n ############################################## plotting of gradient norms\\n print(\\\"Generate gradient norms plot...\\\")\\n\\n #gradients for mu\\n mu_grad_dict = {}\\n annotations_dict = {}\\n for component in range(settings['nr_components']):\\n key = 'mu_'+str(component)\\n mu_grad_dict[key] = log_df[key].tolist()[-1]\\n annotations_dict[key] = AB\\n\\n\\n plot_gradient_mu_stats = jitter_plot(mu_grad_dict,\\n 'Distribution of gradients for mean in last iteration',\\n annotations_dict,\\n colors,\\n None)\\n plots.append(plot_gradient_mu_stats)\\n\\n\\n #gradients for precMat\\n precMat_grad_dict = {}\\n annotations_dict = {}\\n for component in range(settings['nr_components']):\\n key = 'prec_'+str(component)\\n precMat_grad_dict['diagPrecMat_'+str(component)] = log_df[key].tolist()[-1]\\n annotations_dict['diagPrecMat_'+str(component)] = AB\\n\\n\\n plot_gradient_precMat_stats = jitter_plot(\\n precMat_grad_dict,\\n 'Distribution of gradients for precMat in last iteration',\\n annotations_dict,\\n colors,\\n None\\n )\\n plots.append(plot_gradient_precMat_stats)\\n\\n ##################################### plotting of gradient trace of a specific ab pair for all components\\n print(\\\"Generate gradient trace plot...\\\")\\n\\n gradient_df = log_df.filter(regex=(\\\"mu_[0-9]*\\\"))\\n plot_gradient_mu_ab_trace = plot_gradient_ab_trace(gradient_df,\\n ab_list,\\n colors\\n )\\n plots.append(plot_gradient_mu_ab_trace)\\n\\n gradient_df = log_df.filter(regex=(\\\"prec_[0-9]*\\\"))\\n plot_gradient_prec_ab_trace = plot_gradient_ab_trace(\\n gradient_df,\\n ab_list,\\n colors\\n )\\n plots.append(plot_gradient_prec_ab_trace)\\n\\n\\n ##################################### plotting of univariate mixtures\\n if len(evaluation_set_kde['contact']) == 0 or len(evaluation_set_kde['bg']) == 0:\\n print \\\"Evaluation set is empty. Cannot plot Mixture Visualization.\\\"\\n else:\\n print(\\\"Generate parameter visualization 1d plots...\\\")\\n plots.append(plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L']))\\n # plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L'], plot_out=\\\"/home/vorberg/1d_vis.html\\\")\\n\\n # ------------------------------------------------------------------------------\\n ### define merged plot\\n # ------------------------------------------------------------------------------\\n cols = 3.0\\n rows = int(np.ceil((len(plots)-1) / cols)) + 2\\n subplot_titles = []\\n\\n # set up titles\\n for plot in range(len(plots)-1):\\n subplot_titles.append(plots[plot]['layout']['title'])\\n if len(subplot_titles) < (cols * (rows-2)):\\n for i in range(int((cols * (rows-2))) - len(subplot_titles) ):\\n subplot_titles.append(\\\" \\\")\\n subplot_titles.append(plots[-1]['layout']['title'])\\n\\n\\n # plot all plots as subplots\\n fig = tools.make_subplots(rows=rows,\\n cols=3,\\n specs = [ [{} for col in range(int(cols))] for row in range(rows-2)] + \\\\\\n [[{'rowspan':2, 'colspan': 3}, None, None], [None, None, None]],\\n subplot_titles=tuple(subplot_titles),\\n print_grid=False)\\n\\n\\n\\n\\n for i, plot in enumerate(plots[:-1]):\\n col = i % int(cols)\\n row = (i - col) / int(cols)\\n\\n #add traces to subplot\\n for trace in plot['data']:\\n trace['showlegend']=False\\n fig.append_trace(trace, row + 1, col + 1)\\n\\n # adjust x and y axis for table plotting\\n if 'annotations' in plot['layout'].keys():\\n for cell in plot['layout']['annotations']:\\n cell['yref'] = 'y' + str(i + 1)\\n cell['xref'] = 'x' + str(i + 1)\\n fig['layout']['annotations'] += plot['layout']['annotations']\\n\\n # adjust axis for all plots\\n fig['layout']['xaxis' + str(i + 1)].update(plot['layout']['xaxis1'])\\n fig['layout']['yaxis' + str(i + 1)].update(plot['layout']['yaxis1'])\\n\\n ## add mixture visualisation plot - spans 3 columns\\n for trace in plots[-1]['data']:\\n fig.append_trace(trace, int(rows)-1, 1)\\n fig['layout']['xaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['xaxis1'])\\n fig['layout']['yaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['yaxis1'])\\n\\n #check which plots are visible/invisible according to menu selection\\n trace_visibility_ab = {}\\n for ab in range(len(ab_list)):\\n trace_visibility_ab[ab] = []\\n for i, plot in enumerate(plots):\\n if 'updatemenus' not in plot['layout'].keys():\\n trace_visibility_ab[ab].extend([True] * len(plot['data']))\\n else:\\n trace_visibility_ab[ab].extend(plot['layout']['updatemenus'][0]['buttons'][ab]['args'][1])\\n\\n\\n #use menu of last plot (=vis of mixture) as template for multiplot menu\\n fig['layout']['updatemenus'] = plots[-1]['layout']['updatemenus']\\n for ab in range(len(ab_list)):\\n fig['layout']['updatemenus'][0]['buttons'][ab]['args'][1] = trace_visibility_ab[ab]\\n\\n\\n fig['layout']['legend']['yanchor'] = 'bottom'\\n fig['layout']['legend']['y'] = 0\\n fig['layout']['height'] = rows * 250\\n fig['layout']['font'] = {'size': 18} # set global font size\\n\\n plotly_plot(fig, filename=plotname, auto_open=False)\",\n \"def SA_data_display(opt_df, all_df):\\n fig, axs = plt.subplots(2, 3)\\n\\n axs[0,0].set_title(\\\"Optimal rewire attempts for circularity\\\")\\n axs[0,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[0,0].set_xlabel(\\\"Time (s)\\\")\\n axs[0,0].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Percent waste (%)\\\"])\\n\\n axs[0,1].set_title(\\\"Optimal rewire attempts acceptance probability\\\")\\n axs[0,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[0,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,1].scatter(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Probability\\\"])\\n\\n axs[0,2].set_title(\\\"Optimal rewire attempts temperature decrease\\\")\\n axs[0,2].set_ylabel(\\\"Temperature\\\")\\n axs[0,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,2].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Temperature\\\"])\\n\\n axs[1,0].set_title(\\\"All rewire attempts for circularity\\\")\\n axs[1,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[1,0].set_xlabel(\\\"Time (s)\\\")\\n axs[1,0].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Percent waste (%)\\\"])\\n\\n axs[1,1].set_title(\\\"All rewire attempts acceptance probability\\\")\\n axs[1,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[1,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,1].scatter(all_df[\\\"Time (s)\\\"], all_df[\\\"Probability\\\"])\\n\\n axs[1,2].set_title(\\\"All rewire attempts temperature decrease\\\")\\n axs[1,2].set_ylabel(\\\"Temperature\\\")\\n axs[1,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,2].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Temperature\\\"])\\n\\n return plt.show()\",\n \"def main():\\n save = False\\n show = True\\n\\n #hd_parameter_plots = HDparameterPlots(save=save)\\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\\n #ice5g_comparison_plots.plotLine()\\n #ice5g_comparison_plots.plotFilled()\\n #ice5g_comparison_plots.plotCombined()\\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\\n #flowmapplot = FlowMapPlots(save)\\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\\n #flowmapplot.Etopo1FlowMap()\\n #flowmapplot.ICE5G_data_all_points_0k()\\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\\n outflowplots = OutflowPlots(save)\\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #hd_output_plots = HDOutputPlots()\\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\\n #lake_plots = LakePlots()\\n #lake_plots.plotLakeDepths()\\n #lake_plots.LakeAndRiverMap()\\n #lake_plots.LakeAndRiverMaps()\\n if show:\\n plt.show()\",\n \"def plot_tsnes():\\n # Two environments (for main paper figure. All for final figure)\\n ENVS = [\\n \\\"BipedalWalker-v3\\\",\\n #\\\"LunarLander-v2\\\",\\n #\\\"Pendulum-v0\\\"\\n \\\"Acrobot-v1\\\",\\n #\\\"CartPole-v1\\\"\\n ]\\n ALGO_TYPES = [\\n \\\"stablebaselines\\\",\\n \\\"stablebaselines\\\",\\n \\\"wann\\\",\\n \\\"wann\\\",\\n ]\\n ALGO_NAMES = [\\n \\\"A2C\\\",\\n \\\"PPO\\\",\\n \\\"NEAT\\\",\\n \\\"CMAES\\\",\\n ]\\n ALGO_PRETTY_NAMES = [\\n \\\"A2C\\\",\\n \\\"PPO\\\",\\n \\\"NEAT\\\",\\n \\\"CMA-ES\\\"\\n ]\\n\\n REWARD_SCALES = {\\n \\\"Pendulum-v0\\\": [-1600, -200],\\n \\\"Acrobot-v1\\\": [-500, -100],\\n \\\"LunarLander-v2\\\": [-230, 200],\\n \\\"BipedalWalker-v3\\\": [-100, 300],\\n \\\"CartPole-v1\\\": [0, 500]\\n }\\n\\n figure, axs = pyplot.subplots(\\n figsize=[6.4 * 2, 4.8],\\n nrows=2,\\n ncols=4,\\n gridspec_kw={'hspace': 0, 'wspace': 0},\\n )\\n\\n for plot_i in range(2):\\n env = ENVS[plot_i]\\n reward_scale = REWARD_SCALES[env]\\n for algo_i in range(len(ALGO_TYPES)):\\n column_idx = (algo_i % 2) + plot_i * 2\\n row_idx = 0 if algo_i <= 1 else 1\\n ax = axs[row_idx, column_idx]\\n algo_type = ALGO_TYPES[algo_i]\\n algo_name = ALGO_NAMES[algo_i]\\n algo_pretty_name = ALGO_PRETTY_NAMES[algo_i]\\n\\n experiment_glob = \\\"experiments/{}_{}_{}_*\\\".format(algo_type, env, algo_name)\\n experiment_paths = glob(experiment_glob)\\n tsnes = []\\n rewards = []\\n for experiment_path in experiment_paths:\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n population_tsnes = []\\n population_rewards = []\\n for path in pivector_paths:\\n data = np.load(path)\\n population_tsnes.append(data[\\\"tsne\\\"])\\n population_rewards.append(data[\\\"average_episodic_reward\\\"])\\n data.close()\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n tsnes = np.concatenate(tsnes, axis=0)\\n rewards = np.concatenate(rewards, axis=0)\\n\\n # Min-max normalization\\n rewards = (rewards - reward_scale[0]) / (reward_scale[1] - reward_scale[0])\\n\\n scatter = ax.scatter(\\n tsnes[:, 0],\\n tsnes[:, 1],\\n c=rewards,\\n cmap=\\\"plasma\\\",\\n s=1,\\n vmin=0,\\n vmax=1\\n )\\n\\n ax.text(0.98, 0.98, algo_pretty_name, horizontalalignment=\\\"right\\\", verticalalignment=\\\"top\\\", transform=ax.transAxes)\\n ax.set_xticks([])\\n ax.set_yticks([])\\n # Hide spines, the outer edges\\n ax.spines[\\\"top\\\"].set_alpha(0.2)\\n ax.spines[\\\"bottom\\\"].set_alpha(0.2)\\n ax.spines[\\\"left\\\"].set_alpha(0.2)\\n ax.spines[\\\"right\\\"].set_alpha(0.2)\\n # Hide edge spines and bolden mid-spines\\n if row_idx == 0:\\n ax.spines[\\\"top\\\"].set_visible(False)\\n else:\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n if column_idx == 0:\\n ax.spines[\\\"left\\\"].set_visible(False)\\n elif column_idx == 1:\\n ax.spines[\\\"right\\\"].set_alpha(1.0)\\n elif column_idx == 2:\\n ax.spines[\\\"left\\\"].set_alpha(1.0)\\n elif column_idx == 3:\\n ax.spines[\\\"right\\\"].set_visible(False)\\n\\n # Add titles\\n if row_idx == 0 and (column_idx == 0 or column_idx == 2):\\n ax.set_title(env.split(\\\"-\\\")[0], x=1.0)\\n\\n cbaxes = figure.add_axes([0.4, 0.94, 0.2, 0.02])\\n cbar = figure.colorbar(scatter, orientation=\\\"horizontal\\\", cax=cbaxes)\\n cbar.set_ticks([0.0, 0.5, 1.0])\\n cbar.set_ticklabels([\\\"Min\\\", \\\"Reward\\\", \\\"Max\\\"])\\n cbar.ax.xaxis.set_ticks_position('top')\\n cbar.ax.xaxis.set_label_position('top')\\n cbar.ax.tick_params(labelsize=\\\"small\\\", length=0)\\n figure.tight_layout()\\n figure.savefig(\\\"figures/tsnes.png\\\", dpi=200, bbox_inches=\\\"tight\\\", pad_inches=0.0)\",\n \"def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\\n action_legend_location=None):\\n\\n #get location of files\\n running_reward_file, _, actions_file = \\\\\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\\n\\n #font size\\n matplotlib.rcParams.update({'font.size': 14, \\\"text.usetex\\\": True,\\n 'text.latex.preamble' : r'\\\\usepackage{amsmath}\\\\usepackage{physics}'})\\n\\n #create the axis (subplots)\\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\\n reward_ax = fig.add_subplot(gs[0, :])\\n prot_0_ax = fig.add_subplot(gs[1, 0])\\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\\n prot_final_ax = fig.add_subplot(gs[2, :])\\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \\n\\n #set the reward axis\\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\\n custom_color = \\\"black\\\", lines_to_mark = [nearest_int(act_0/actions_per_log),\\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\\n custom_mark_color=\\\"black\\\",ylim=reward_ylim,ylabel=reward_ylabel,\\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\\n legend_labels=reward_legend_labels)\\n\\n #set the three actions axis\\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\\n two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_1,ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_2, ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\\n\\n #set the final protocol axis\\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\\n actions_ylim=large_action_ylim,plot_to_file_line=None,\\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\\n linewidth = prot_linewidth, xlabel=\\\"$t[dt]$\\\",extra_cycles=extra_cycles,\\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\\n legend_text=action_legend_text, legend_location=action_legend_location)\\n\\n #add the (a) (b) (c) labels\\n reward_ax.text(-0.11,-0.38, r'\\\\textbf{(a)}', transform=reward_ax.transAxes )\\n prot_0_ax.text(-0.4,-0.55, r'\\\\textbf{(b)}', transform=prot_0_ax.transAxes )\\n prot_final_ax.text(-0.11,-0.38, r'\\\\textbf{(c)}', transform=prot_final_ax.transAxes )\\n\\n #save if necessary\\n if plot_file_name is not None:\\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\\n plot_file_name = os.path.join(plot_folder, plot_file_name)\\n plt.savefig(plot_file_name)\\n\\n #show\\n plt.show()\",\n \"def plot_noise(data_obj, test_num):\\n\\n #=======================================================================#\\n # Create and plot the page for the X values of the test (NEQ, NPS, MTF) #\\n #=======================================================================#\\n\\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf\\n\\n # Display the (centered) title of the figures / page\\n plt.suptitle('Test ' + str(test_num) +\\n ': Noise ($NEQ_x$ at 1 lp/mm: ' +\\n \\\"{:,}\\\".format(int(data_obj.NEQ_x_1)) + ')')\\n\\n #--------------------------------------------------------------------------#\\n # Display the equation and variables of the test to the middle of the page #\\n #--------------------------------------------------------------------------#\\n fs3 = 10\\n plt.subplot(3, 1, 1)\\n plt.axis('off')\\n\\n # Display the main equation for calculating the NEQ\\n str1 = \\\"$ NEQ = \\\\\\\\frac{S_{out}^2 MTF^2}{NPS} $\\\"\\n plt.text(0.3, 0.6, str1, ha='left', fontsize=16)\\n\\n # Display the values of the different variables in the NEQ equation\\n str1 = \\\"$NPS_x$ (at 1 lp/mm) = \\\" + \\\"{0:.1f}\\\".format((data_obj.NPS_x_1))\\n plt.text(0.3, 0.4, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$MTF_x$ (at 1 lp/mm) = \\\" + \\\"{0:.3f}\\\".format((data_obj.MTF_x_1))\\n plt.text(0.3, 0.3, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$S_{out}$ (at 1 lp/mm) = \\\" + \\\"{:,}\\\".format(int(data_obj.S_out))\\n plt.text(0.3, 0.2, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$NEQ_x$ (at 1 lp/mm) = \\\" + \\\"{:,}\\\".format(int(data_obj.NEQ_x_1))\\n str1 = str1 + ' $\\\\pm$ ' + \\\"{:,}\\\".format(int(data_obj.NEQ_x_1_err))\\n plt.text(0.3, 0.1, str1, ha='left', fontsize=fs3)\\n\\n\\n #------------------------------------------------#\\n # Display the graphs for NEQ_x, MTF_x, and NPS_x #\\n #------------------------------------------------#\\n\\n plt.subplot(3, 2, 3)\\n plt.ylabel('$MTF_x$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_x_f, data_obj.MTF_data.MTF_x)\\n\\n plt.subplot(3, 2, 4)\\n plt.ylabel('$\\\\\\\\sqrt{NPS_x}$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_x_f[1:], np.sqrt(data_obj.NPS_x_interp[1:]))\\n\\n plt.subplot(3, 1, 3)\\n plt.ylabel('$\\\\\\\\sqrt{NEQ_x}$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_x_f, np.sqrt(data_obj.NEQ_x))\\n\\n ind = int(1 / 0.02)\\n plt.plot(data_obj.MTF_data.MTF_x_f[ind], np.sqrt(data_obj.NEQ_x[ind]), 'ro')\\n plt.tight_layout()\\n\\n\\n ##=======================================================================#\\n # Create and plot the page for the X values of the test (NEQ, NPS, MTF) #\\n #=======================================================================#\\n\\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf\\n\\n # Display the (centered) title of the figures / page\\n plt.suptitle('Test ' + str(test_num) +\\n ': Noise ($NEQ_y$ at 1 lp/mm: ' +\\n \\\"{:,}\\\".format(int(data_obj.NEQ_y_1)) + ')')\\n\\n # --------------------------------------------------------------------------#\\n # Display the equation and variables of the test to the middle of the page #\\n # --------------------------------------------------------------------------#\\n fs3 = 10\\n plt.subplot(3, 1, 1)\\n plt.axis('off')\\n\\n # Display the main equation for calculating the NEQ\\n str1 = \\\"$ NEQ = \\\\\\\\frac{S_{out}^2 MTF^2}{NPS} $\\\"\\n plt.text(0.3, 0.6, str1, ha='left', fontsize=16)\\n\\n # Display the values of the different variables in the NEQ equation\\n str1 = \\\"$NPS_y$ (at 1 lp/mm) = \\\" + \\\"{0:.1f}\\\".format((data_obj.NPS_y_1))\\n plt.text(0.3, 0.4, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$MTF_y$ (at 1 lp/mm) = \\\" + \\\"{0:.3f}\\\".format((data_obj.MTF_y_1))\\n plt.text(0.3, 0.3, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$S_{out}$ (at 1 lp/mm) = \\\" + \\\"{:,}\\\".format(int(data_obj.S_out))\\n plt.text(0.3, 0.2, str1, ha='left', fontsize=fs3)\\n\\n str1 = \\\"$NEQ_y$ (at 1 lp/mm) = \\\" + \\\"{:,}\\\".format(int(data_obj.NEQ_y_1))\\n str1 = str1 + ' $\\\\pm$ ' + \\\"{:,}\\\".format(int(data_obj.NEQ_y_1_err))\\n plt.text(0.3, 0.1, str1, ha='left', fontsize=fs3)\\n\\n #------------------------------------------------#\\n # Display the graphs for NEQ_y, MTF_y, and NPS_y #\\n #------------------------------------------------#\\n\\n plt.subplot(3, 2, 3)\\n plt.ylabel('$MTF_y$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_y_f, data_obj.MTF_data.MTF_y)\\n\\n plt.subplot(3, 2, 4)\\n plt.ylabel('$\\\\\\\\sqrt{NPS_y}$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_y_f[1:], np.sqrt(data_obj.NPS_y_interp[1:]))\\n\\n plt.subplot(3, 1, 3)\\n plt.ylabel('$\\\\\\\\sqrt{NEQ_y}$')\\n plt.xlabel('Line-pairs per mm')\\n plt.plot(data_obj.MTF_data.MTF_y_f, np.sqrt(data_obj.NEQ_y))\\n\\n ind = int(1 / 0.02)\\n plt.plot(data_obj.MTF_data.MTF_y_f[ind], np.sqrt(data_obj.NEQ_y[ind]), 'ro')\\n plt.tight_layout()\",\n \"def apolco(a,minfeh=-3,out=None) :\\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\\n fig=vscat(a[apo],marker='o',density=True)\\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\\n print('matched {:d} stars'.format(len(i1)))\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\",\n \"def generate_plots(fixed, moving, warped, flows, train_loss, val_loss, reg_loss, epoch):\\n moving = moving.detach().cpu().numpy()\\n fixed = fixed.detach().cpu().numpy()\\n warped = [w.detach().cpu().numpy() for w in warped]\\n flows = [f.detach().cpu().numpy() for f in flows]\\n\\n fig = plt.figure(constrained_layout=True, figsize=(4 * 5, 4 * 3))\\n ax_dict = fig.subplot_mosaic(\\\"\\\"\\\"\\n FABCD\\n LGHIE\\n MKJWX\\n \\\"\\\"\\\")\\n\\n ax_dict['F'].imshow(moving[0, 0, ...], cmap='gray')\\n ax_dict['F'].set_title('Moving')\\n\\n ax_dict['W'].imshow(fixed[0, 0, ...], cmap='gray')\\n ax_dict['W'].set_title('Fixed')\\n\\n for i, ax_name in enumerate(list(\\\"ABCDEX\\\")):\\n ax_dict[ax_name].imshow(warped[i][0, 0, ...], cmap='gray')\\n if ax_name == \\\"A\\\":\\n ax_dict[ax_name].set_title(\\\"Affine\\\")\\n else:\\n ax_dict[ax_name].set_title(f\\\"Cascade {i}\\\")\\n\\n ax_dict['L'].plot(train_loss, color='red', label='train_loss')\\n ax_dict['L'].plot(val_loss, label='val_loss', color='blue')\\n ax_dict['L'].plot(reg_loss, label='train_reg_loss', color='green')\\n ax_dict['L'].set_title(\\\"Losses\\\")\\n ax_dict['L'].grid()\\n ax_dict['L'].set_xlim(0, args.e)\\n ax_dict['L'].legend(loc='upper right')\\n ax_dict['L'].scatter(len(train_loss) - 1, train_loss[-1], s=20, color='red')\\n ax_dict['L'].scatter(len(val_loss) - 1, val_loss[-1], s=20, color='blue')\\n ax_dict['L'].scatter(len(reg_loss) - 1, reg_loss[-1], s=20, color='green')\\n\\n for i, ax_name in enumerate(list(\\\"GHIJKM\\\")):\\n plot_grid(ax_dict[ax_name], flows[i][0, ...])\\n if ax_name == \\\"G\\\":\\n ax_dict[ax_name].set_title(\\\"Affine\\\")\\n else:\\n ax_dict[ax_name].set_title(f\\\"Cascade {i}\\\")\\n\\n plt.suptitle(f\\\"Epoch {epoch}\\\")\\n plt.savefig(f'./ckp/visualization/epoch_{epoch}.png')\",\n \"def build_scatter_plots(dep_vars, cont_corr_data, continous, combined_data, drop_outliers=True, tps=False,\\n replacement=0.01):\\n\\n for i, column in enumerate(dep_vars.columns):\\n # Calculating number of graphs\\n cont_cols = continous.columns.to_list()\\n if i != len(dep_vars.columns) - 1 and not tps:\\n cont_cols = cont_cols + dep_vars.columns.to_list()[i + 1:]\\n if not tps:\\n num_rows = len(cont_cols) + 2 * len(continous.columns) + 2 * len(dep_vars.columns.to_list()[i + 1:])\\n else:\\n num_rows = 3 * len(cont_cols)\\n fig = make_subplots(rows=num_rows, subplot_titles=range(num_rows))\\n row_num = 1\\n for value in cont_cols:\\n # Getting data\\n scatter_data = pd.DataFrame({\\\"x\\\": combined_data[value],\\n \\\"y\\\": combined_data[column]})\\n if drop_outliers:\\n # Apply 3 sigma rule\\n scatter_data = scatter_data.loc[rem_outliers(scatter_data[\\\"x\\\"])]\\n scatter_data = scatter_data.loc[rem_outliers(scatter_data[\\\"y\\\"])]\\n # Replace zeros with little values and create logarithmic variation\\n scatter_data[\\\"y\\\"] = scatter_data[\\\"y\\\"].apply(lambda x: replacement if x == 0 else x)\\n log_y = scatter_data[\\\"y\\\"].apply(lambda x: log(x))\\n log_x = scatter_data[\\\"x\\\"].apply(lambda x: replacement if x == 0 else x).apply(lambda x: log(x))\\n\\n # Creating graph on initial data, stating first pearson p-value, kendall p-value and sample size\\n p_value_pearson = cont_corr_data.loc[f\\\"pearson_{column}\\\", value]\\n p_value_kendall = cont_corr_data.loc[f\\\"kendall_{column}\\\", value]\\n sample_size = int(cont_corr_data.loc[f\\\"sample_size_{column}\\\", value])\\n text = f\\\"pearson: {p_value_pearson:.4f}, kendall: {p_value_kendall:.4f}, sample: {sample_size}\\\"\\n build_scatter_subplot(fig, scatter_data[\\\"x\\\"], scatter_data[\\\"y\\\"], row_num, text, value, column)\\n row_num = row_num + 1\\n\\n # Creating graph on log data, stating second pearson p-value, kendall p-value and sample size\\n p_value_pearson = cont_corr_data.loc[f\\\"log_pearson_{column}\\\", value]\\n p_value_kendall = cont_corr_data.loc[f\\\"kendall_{column}\\\", value]\\n sample_size = int(cont_corr_data.loc[f\\\"sample_size_{column}\\\", value])\\n text = f\\\"log({column}) pearson: {p_value_pearson:.4f}, kendall: {p_value_kendall:.4f}, \\\" \\\\\\n f\\\"sample: {sample_size}\\\"\\n build_scatter_subplot(fig, scatter_data[\\\"x\\\"], log_y, row_num, text, value, column)\\n row_num = row_num + 1\\n\\n # Creating graph on log indep variable, stating first pearson p-value, kendall p-value and sample size\\n p_value_pearson = cont_corr_data.loc[f\\\"log({value})_{column}_pearson\\\", value]\\n sample_size = int(cont_corr_data.loc[f\\\"sample_size_{column}\\\", value])\\n text = f\\\"log({value}) pearson: {p_value_pearson:.4f}, sample: {sample_size}\\\"\\n build_scatter_subplot(fig, log_x, scatter_data[\\\"y\\\"], row_num, text, value, column)\\n row_num = row_num + 1\\n if not tps:\\n fig.update_layout(height=4800, width=600)\\n else:\\n fig.update_layout(height=600, width=600)\\n fig.update_layout(showlegend=False, plot_bgcolor='rgba(0,0,0,0)')\\n fig.write_html(f'figures/scatter_{column}_{time.time()}.html', auto_open=True)\",\n \"def _plot(self):\\n # Read results\\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\\n x1, y1, _ = read_results('openmc', path)\\n if self.code == 'serpent':\\n path = self.other_dir / 'input_det0.m'\\n else:\\n path = self.other_dir / 'outp'\\n x2, y2, sd = read_results(self.code, path)\\n\\n # Convert energies to eV\\n x1 *= 1e6\\n x2 *= 1e6\\n\\n # Normalize the spectra\\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\\n\\n # Compute the relative error\\n err = np.zeros_like(y2)\\n idx = np.where(y2 > 0)\\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\\n \\n # Set up the figure\\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\\n ax1 = fig.add_subplot(111)\\n \\n # Create a second y-axis that shares the same x-axis, keeping the first\\n # axis in front\\n ax2 = ax1.twinx()\\n ax1.set_zorder(ax2.get_zorder() + 1)\\n ax1.patch.set_visible(False)\\n \\n # Plot the spectra\\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\\n \\n # Plot the relative error and uncertainties\\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\\n \\n # Set grid and tick marks\\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\\n ax1.grid(b=False, axis='both', which='both')\\n ax2.tick_params(axis='y', which='both', right=False)\\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\\n \\n # Set axes labels and limits\\n ax1.set_xlim([self._min_energy, self.energy])\\n ax1.set_xlabel('Energy (eV)', size=12)\\n ax1.set_ylabel('Spectrum', size=12)\\n ax1.legend()\\n ax2.set_ylabel(\\\"Relative error\\\", size=12)\\n title = f'{self.nuclide}'\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n title += f' + {thermal_name}'\\n title += f', {self.energy:.1e} eV Source'\\n plt.title(title)\\n \\n # Save plot\\n os.makedirs('plots', exist_ok=True)\\n if self.name is not None:\\n name = self.name\\n else:\\n name = f'{self.nuclide}'\\n if self.thermal is not None:\\n name += f'-{thermal_name}'\\n name += f'-{self.energy:.1e}eV'\\n if self._temperature is not None:\\n name += f'-{self._temperature:.1f}K'\\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\\n plt.close()\",\n \"def display_analysis_result(column1: pd.Series, column2: pd.Series, name1: str, name2: str):\\n\\n print(\\\"Correlation between '%s' and '%s':\\\" % (name1, name2))\\n print(\\\"Covariance: \\\" + str(calculate_covariance(column1, column2)))\\n print(\\\"Correlation coefficient: \\\" + str(calculate_correlation_coefficient(column1, column2)))\\n print(\\\"Significance of coefficient: \\\" + str(calculate_significance_of_coefficient(column1, column2)))\\n print()\\n\\n draw_scatter_plot(column1, column2, name1, name2)\\n draw_residual_plot(column1, column2, name1, name2)\",\n \"def plot_derivatives_divided(self, show=False):\\n\\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\\n ax[2, 0].set_title('Difference between upper and lower training examples');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n ax[2, 0].legend(frameon=False)\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\\n ax[2, 1].set_title('Difference between upper and lower test samples');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def single_decoding_weber_law_plot(data_idxs=2):\\n\\n\\tdecode_plot_size = 8\\n\\tnum_gain_plots = data_idxs/2\\n\\tgain_plot_size = 4\\n\\test_plot_upper_pad = 3\\n\\test_plot_height = 6\\n\\tnum_est_plots = 2\\n\\t\\n\\t\\n\\tfig = plt.figure()\\n\\tgrid_width = decode_plot_size + 1 + gain_plot_size*num_gain_plots\\n\\tgrid_height = decode_plot_size + est_plot_upper_pad + \\\\\\n\\t\\t\\t\\t\\test_plot_height*num_est_plots\\n\\tgs = gridspec.GridSpec(grid_height, grid_width)\\n\\tgs.update(wspace=6.5, hspace=1.0)\\n\\tfig.set_size_inches(13, 16)\\n\\t\\n\\t# Some font and label sizes for later use\\n\\ttick_label_size_small = 30\\n\\ttick_label_size_large = 30\\n\\taxis_label_size = 34\\n\\tx_axis_label_pad = 15\\n\\ty_axis_successes_labelpad = 8\\n\\tx_tick_label_pad = 11\\n\\t\\n\\tax = dict()\\n\\t\\n\\t# Success error plots\\n\\tax['successes'] = plt.subplot(gs[0:decode_plot_size, 0:decode_plot_size])\\n\\tplt.xscale('log')\\n\\tplt.xticks(10.**sp.arange(-5, 5), fontsize=tick_label_size_large)\\n\\tplt.yticks([0, 50, 100], fontsize=tick_label_size_large)\\n\\tax['successes'].tick_params(axis='x', which='major', pad=x_tick_label_pad)\\n\\tax['successes'].set_xlabel(r'Background signal', fontsize=axis_label_size, \\n\\t\\t\\t\\t\\t\\t\\t\\tlabelpad=x_axis_label_pad)\\n\\tax['successes'].set_ylabel(r'Correctly decoded (%)', \\n\\t\\t\\t\\t\\t\\t\\t\\tfontsize=axis_label_size, \\n\\t\\t\\t\\t\\t\\t\\t\\tlabelpad=y_axis_successes_labelpad, \\n\\t\\t\\t\\t\\t\\t\\t\\tmultialignment='center')\\n\\tax['successes'].set_xlim([1e-1, 1.5e2])\\n\\t\\n\\t# Gain plots\\n\\tfor data_idx in sp.arange(0, data_idxs):\\n\\t\\tif data_idx % 2 == 0: \\n\\t\\t\\tax['gains_%s' % data_idx] = \\\\\\n\\t\\t\\t\\tplt.subplot(gs[0:gain_plot_size, decode_plot_size + \\\\\\n\\t\\t\\t\\t\\t\\t\\t1 + (data_idx/2)*gain_plot_size: decode_plot_size + \\\\\\n\\t\\t\\t\\t\\t\\t\\t1 + gain_plot_size + (data_idx/2)*gain_plot_size])\\n\\t\\telif data_idx % 2 == 1:\\n\\t\\t\\tax['gains_%s' % data_idx] = \\\\\\n\\t\\t\\t\\tplt.subplot(gs[gain_plot_size:2*gain_plot_size, decode_plot_size + \\\\\\n\\t\\t\\t\\t\\t\\t\\t1 + (data_idx/2)*gain_plot_size: decode_plot_size + \\\\\\n\\t\\t\\t\\t\\t\\t\\t1 + gain_plot_size + (data_idx/2)*gain_plot_size])\\n\\t\\n\\t\\tax['gains_%s' % data_idx].set_xscale('log')\\n\\t\\tax['gains_%s' % data_idx].set_yscale('log')\\n\\t\\tax['gains_%s' % data_idx].set_xlim(1e-2, 1e0)\\n\\t\\tax['gains_%s' % data_idx].set_xticks([])\\n\\t\\tax['gains_%s' % data_idx].set_yticks([])\\n\\t\\t\\n\\t\\t# Gain plots ticks labels and axis ranges\\n\\t\\tif data_idx / 2 == 0:\\n\\t\\t\\tax['gains_%s' % data_idx].set_yticks(10.**sp.arange(-5, 0))\\n\\t\\t\\tax['gains_%s' % data_idx].tick_params(labelsize=tick_label_size_large)\\n\\t\\tif data_idx % 2 == 0:\\n\\t\\t\\tax['gains_%s' % data_idx].set_ylim(2e-3, 4e-2)\\n\\t\\telif data_idx % 2 == 1:\\n\\t\\t\\tax['gains_%s' % data_idx].set_ylim(1.1e-2, 2e-1)\\n\\t\\t\\tax['gains_%s' % data_idx].set_xticks([1e-2, 1e-1, 1e0])\\t\\n\\t\\t\\tax['gains_%s' % data_idx].\\\\\\n\\t\\t\\t\\t\\ttick_params(axis='x', labelsize=tick_label_size_small)\\n\\t\\t\\tax['gains_%s' % data_idx].\\\\\\n\\t\\t\\t\\t\\ttick_params(axis='y', labelsize=tick_label_size_large)\\n\\t\\tax['gains_%s' % data_idx].set_xlim(0.98e-2, 1.4e-1)\\n\\t\\tax['gains_%s' % data_idx].tick_params(axis='x', which='major', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tpad=x_tick_label_pad)\\n\\t\\t\\t\\n\\t\\t# Gaain axis label in center of range of plots\\n\\t\\tif num_gain_plots % 2 == 0:\\n\\t\\t\\tif data_idx == data_idxs/2 - 1:\\n\\t\\t\\t\\tax['gains_%s' % data_idx].set_xlabel(r'Background signal', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfontsize=axis_label_size, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlabelpad=x_axis_label_pad)\\n\\t\\t\\t\\tax['gains_%s' % data_idx].xaxis.set_label_coords(1.1, -.455)\\n\\t\\t\\t\\t\\n\\t\\telif num_gain_plots % 2 == 1:\\n\\t\\t\\tif data_idx == data_idxs/2:\\n\\t\\t\\t\\tax['gains_%s' % data_idx].set_xlabel(r'Background signal', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfontsize=axis_label_size, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlabelpad=x_axis_label_pad)\\n\\t\\tif data_idx == data_idxs - 2:\\n\\t\\t\\tax['gains_%s' % data_idx].yaxis.set_label_position('right')\\n\\t\\t\\tax['gains_%s' % data_idx].set_ylabel(\\n\\t\\t\\t\\t\\t\\tr'Receptor gain', fontsize=axis_label_size, \\n\\t\\t\\t\\t\\t\\trotation=270)\\n\\t\\t\\tax['gains_%s' % data_idx].yaxis.set_label_coords(1.4, -0.1)\\n\\t\\t\\t\\t\\n\\t# Sample estimation plot\\n\\tfor est_idx in range(num_est_plots):\\n\\t\\tax['est_%s' % est_idx] = \\\\\\n\\t\\t\\tplt.subplot(gs[decode_plot_size + est_plot_upper_pad\\n\\t\\t\\t\\t\\t\\t+ est_idx*est_plot_height:\\n\\t\\t\\t\\t\\t\\tdecode_plot_size + est_plot_upper_pad \\n\\t\\t\\t\\t\\t\\t+ (est_idx + 1)*est_plot_height, 0:grid_width])\\n\\t\\tax['est_%s' % est_idx].set_yticks([])\\n\\t\\t\\n\\t\\t# Sample estimation plots labels only on outside\\n\\t\\tif est_idx == num_est_plots/2:\\n\\t\\t\\tax['est_%s' % est_idx].set_xticks(sp.arange(10, 100, 10))\\n\\t\\t\\tax['est_%s' % est_idx].yaxis.set_label_coords(-0.03, 1.1)\\n\\t\\t\\tax['est_%s' % est_idx].set_xlabel(r'Odorant identity', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfontsize=axis_label_size,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlabelpad=x_axis_label_pad)\\n\\t\\t\\tax['est_%s' % est_idx].set_ylabel(r'Odorant intensity', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfontsize=axis_label_size)\\n\\t\\t\\tax['est_%s' % est_idx].tick_params(labelsize=tick_label_size_large, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tpad=x_tick_label_pad)\\n\\t\\telse:\\n\\t\\t\\tax['est_%s' % est_idx].set_xticks([])\\n\\t\\tax['est_%s' % est_idx].set_xlim(35, 99)\\n\\t\\t\\n\\treturn fig, ax\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6873683","0.6821231","0.6672336","0.66437536","0.66437536","0.66437536","0.6629172","0.6596364","0.6589779","0.6557499","0.6521361","0.6518009","0.65085554","0.64940095","0.64903545","0.64805514","0.6445851","0.6403377","0.6347727","0.63423556","0.6334893","0.6332524","0.6318154","0.63163507","0.6250694","0.62495553","0.6179467","0.6152781","0.6146424","0.6146058","0.61268073","0.6114172","0.61106074","0.6102876","0.6095858","0.60932213","0.6092561","0.60904497","0.60865337","0.60722667","0.60594195","0.6037516","0.601695","0.60157484","0.6009392","0.60090244","0.599443","0.5990518","0.5989079","0.5980895","0.59602475","0.5953905","0.59467286","0.59386903","0.593014","0.592747","0.59235615","0.5913329","0.59031653","0.58942497","0.5893569","0.58917755","0.5889325","0.588111","0.5880362","0.5879485","0.58747244","0.5867771","0.5864905","0.58640057","0.586396","0.5860585","0.5860109","0.5856881","0.5854581","0.58524394","0.58476675","0.5836987","0.58331376","0.582781","0.58265895","0.58219725","0.5820554","0.58198273","0.5818326","0.5815593","0.58150715","0.5811521","0.58079755","0.58067095","0.5803231","0.5802705","0.58026135","0.5801292","0.5796539","0.57959706","0.57951176","0.5795027","0.57924646","0.57893467"],"string":"[\n \"0.6873683\",\n \"0.6821231\",\n \"0.6672336\",\n \"0.66437536\",\n \"0.66437536\",\n \"0.66437536\",\n \"0.6629172\",\n \"0.6596364\",\n \"0.6589779\",\n \"0.6557499\",\n \"0.6521361\",\n \"0.6518009\",\n \"0.65085554\",\n \"0.64940095\",\n \"0.64903545\",\n \"0.64805514\",\n \"0.6445851\",\n \"0.6403377\",\n \"0.6347727\",\n \"0.63423556\",\n \"0.6334893\",\n \"0.6332524\",\n \"0.6318154\",\n \"0.63163507\",\n \"0.6250694\",\n \"0.62495553\",\n \"0.6179467\",\n \"0.6152781\",\n \"0.6146424\",\n \"0.6146058\",\n \"0.61268073\",\n \"0.6114172\",\n \"0.61106074\",\n \"0.6102876\",\n \"0.6095858\",\n \"0.60932213\",\n \"0.6092561\",\n \"0.60904497\",\n \"0.60865337\",\n \"0.60722667\",\n \"0.60594195\",\n \"0.6037516\",\n \"0.601695\",\n \"0.60157484\",\n \"0.6009392\",\n \"0.60090244\",\n \"0.599443\",\n \"0.5990518\",\n \"0.5989079\",\n \"0.5980895\",\n \"0.59602475\",\n \"0.5953905\",\n \"0.59467286\",\n \"0.59386903\",\n \"0.593014\",\n \"0.592747\",\n \"0.59235615\",\n \"0.5913329\",\n \"0.59031653\",\n \"0.58942497\",\n \"0.5893569\",\n \"0.58917755\",\n \"0.5889325\",\n \"0.588111\",\n \"0.5880362\",\n \"0.5879485\",\n \"0.58747244\",\n \"0.5867771\",\n \"0.5864905\",\n \"0.58640057\",\n \"0.586396\",\n \"0.5860585\",\n \"0.5860109\",\n \"0.5856881\",\n \"0.5854581\",\n \"0.58524394\",\n \"0.58476675\",\n \"0.5836987\",\n \"0.58331376\",\n \"0.582781\",\n \"0.58265895\",\n \"0.58219725\",\n \"0.5820554\",\n \"0.58198273\",\n \"0.5818326\",\n \"0.5815593\",\n \"0.58150715\",\n \"0.5811521\",\n \"0.58079755\",\n \"0.58067095\",\n \"0.5803231\",\n \"0.5802705\",\n \"0.58026135\",\n \"0.5801292\",\n \"0.5796539\",\n \"0.57959706\",\n \"0.57951176\",\n \"0.5795027\",\n \"0.57924646\",\n \"0.57893467\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7091261"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20280,"cells":{"query":{"kind":"string","value":"Returns diagnostic plots to assess the most recent call to `correct()`. If `correct()` has not yet been called, a ``ValueError`` will be raised. Returns `~matplotlib.axes.Axes` The matplotlib axes object."},"document":{"kind":"string","value":"def diagnose(self):\n return self._diagnostic_plot()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _diagnostic_plot(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=True)\n ax = axs[0]\n self.lc.plot(ax=ax, normalize=False, label=\"original\", alpha=0.4)\n for key in self.diagnostic_lightcurves.keys():\n (\n self.diagnostic_lightcurves[key]\n - np.median(self.diagnostic_lightcurves[key].flux)\n + np.median(self.lc.flux)\n ).plot(ax=ax)\n ax.set_xlabel(\"\")\n ax = axs[1]\n self.lc.plot(ax=ax, normalize=False, alpha=0.2, label=\"original\")\n self.corrected_lc[self.outlier_mask].scatter(\n normalize=False, c=\"r\", marker=\"x\", s=10, label=\"outlier_mask\", ax=ax\n )\n self.corrected_lc[~self.cadence_mask].scatter(\n normalize=False,\n c=\"dodgerblue\",\n marker=\"x\",\n s=10,\n label=\"~cadence_mask\",\n ax=ax,\n )\n self.corrected_lc.plot(normalize=False, label=\"corrected\", ax=ax, c=\"k\")\n return axs","def test_get_axes():\n fig, axs = plt.subplots()\n assert all(\n isinstance(ax, mpl.axes.Axes)\n for ax in prettypyplot.tools.get_axes(axs)\n )\n assert all(\n isinstance(ax, mpl.axes.Axes)\n for ax in prettypyplot.tools.get_axes(None)\n )\n with pytest.raises(TypeError):\n prettypyplot.tools.get_axes(fig)","def plot_insta_err(self, ax=None):\n if ax is None:\n ax = plt.gca()\n ax.set_yscale('log')\n ax.plot(list(range(1, self.max_dets)), self.errors[0], label='independent')\n ax.plot(list(range(1, self.max_dets)), self.errors[1], label='correlated')\n ax.set_ylabel(r'Stochastic error in $E_\\mathrm{corr}$ / ha')\n ax.set_xlabel('Number of determinants in estimator')\n ax.axhline(np.sqrt(self.proje_var[0]), linestyle='--', color='black', label='reference')\n ax.legend()\n return ax","def analysis_plot(predictions, ys):\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\n\n residuals = ys - predictions\n\n # Plot 1 - Predicted vs Actual\n sns.scatterplot(predictions, ys, ax=ax1)\n ax1.set_title('Predicted vs Actual', fontsize=20)\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\n\n # Plot 2 - Residuals PLot (predicted vs residuals)\n sns.scatterplot(predictions, residuals, ax=ax2)\n ax2.set_title('Residuals Plot', fontsize=20)\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\n\n # Plot 3 - QQ Plot\n sm.qqplot(residuals, ax=ax3, line='s')\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\n\n plt.show();","def plot_err(self, expect=False, axallerr=None):\n if axallerr is None:\n axallerr = plt.gca()\n axallerr.set_yscale('log')\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[0], label='independent')\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[1], label='correlated (actual)')\n if expect:\n axallerr.plot(list(range(1, self.max_dets)), self.expcor_err, label='correlated (expected)')\n axallerr.set_ylabel(r'Stochastic error in $\\Delta E$ / ha')\n axallerr.set_xlabel('Number of determinants in estimator')\n axallerr.axhline(np.sqrt(self.proje_var[0]) / np.sqrt(self.result.shape[2]),\n linestyle='--', color='black', label='reference')\n axallerr.legend()\n return axallerr","def test_parse_axes():\n fig, ax = plt.subplots()\n\n # parse correct ax in ax\n argsref = (1, 'a', np.arange(2))\n argsax = prettypyplot.tools.parse_axes(*argsref, ax=ax)\n assert all(\n isinstance(ref, type(parse))\n for ref, parse in zip(argsref, argsax[0])\n )\n assert ax is argsax[1]\n\n # multiple axes\n with pytest.raises(ValueError):\n prettypyplot.tools.parse_axes(ax, ax=ax)\n with pytest.raises(ValueError):\n prettypyplot.tools.parse_axes(1, ax, ax=ax)\n with pytest.raises(ValueError):\n prettypyplot.tools.parse_axes(ax, ax, 1, ax=None)\n\n argsax = prettypyplot.tools.parse_axes(ax, ax=None)\n assert ax is argsax[1]\n\n argsax = prettypyplot.tools.parse_axes(ax=ax)\n assert ax is argsax[1]","def robustnessPlot(ax):\n # Setup the range of avidity and ligand concentration we'll look at\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\n\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\n columns=['gnus', 'Los'])\n\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\n\n # Change avidities to strings\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\nu=' + str(int(gnu)) + '$')\n\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\n\n # Plot the calculated crossvalidation performance\n sns.FacetGrid(pp,\n hue='gnus',\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\n\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\n\n ax.set_xlabel('Assumed IC Conc. (M)')\n ax.set_ylabel('LOO Prediction R-Squared')\n ax.set_ylim(0.0, 1.0)","def test_plotting():\n out_dir = _TempDir()\n fname, behf, corrupted = make_raw(out_dir)\n raw = _read_raw(fname, preload=True)\n pd = raw._data[0]\n candidates = _find_pd_candidates(\n pd, max_len=max_len, baseline=baseline,\n zscore=zscore, max_flip_i=max_flip_i, sfreq=raw.info['sfreq'])[0]\n beh = _read_tsv(behf)\n beh_events = np.array(beh['fix_onset_time']) * raw.info['sfreq']\n beh_events_adjusted, alignment, events = _find_best_alignment(\n beh_events, candidates, exclude_shift, resync, raw.info['sfreq'],\n verbose=False)\n errors = beh_events_adjusted - events + alignment\n _plot_trial_errors(beh_events_adjusted, alignment, events,\n errors, exclude_shift, raw.info['sfreq'])\n errors[abs(errors) / raw.info['sfreq'] > 2 * exclude_shift] = np.nan\n np.testing.assert_array_almost_equal(\n plt.gca().lines[0].get_ydata(), errors)\n section_data = [(0, 'test', np.random.random(10))]\n _plot_excluded_events(section_data, 2)\n assert plt.gca().title.get_text() == 'test'\n np.testing.assert_array_equal(plt.gca().lines[0].get_ydata(),\n section_data[0][2])","def plot(guess_log, counter_log, x):\n correct_sqrt = np.sqrt(x)\n x_axis = np.linspace(-1, 1.1*len(guess_log), len(guess_log))\n y_axis = np.ones(len(guess_log))*correct_sqrt\n plt.plot(counter_log, guess_log, 'ok')\n plt.plot(x_axis, y_axis, '--r', linewidth=2.0, label='Correct Answer')\n plt.axis([-1, max(x_axis), -0.1*max(guess_log), 1.1*max(guess_log)])\n plt.xlabel('Iterations')\n plt.ylabel('Guess')\n plt.legend(loc = 'upper right')\n plt.show()\n return 0","def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train reconstruction errors\")\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\n axarr[1].set_title('vali reconstruction errors')\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\n axarr[2].set_title('generated reconstruction errors')\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\n axarr[3].set_title('random reconstruction errors')\n for ax in axarr:\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"bottom\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"left\"].set_visible(False)\n ax.tick_params(bottom='off', left='off')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n axarr[3].set_xlim(0, 0.05)\n plt.tight_layout()\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\n return True","def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\n if axdelta is None:\n axdelta = plt.gca()\n delta = self.means - exact\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\n if blocked:\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\n if blockederr:\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\n axdelta.set_xlabel('Number of determinants in estimator')\n axdelta.set_ylabel(r'$E-E_\\mathrm{CCSD}$ / ha')\n axdelta.legend()\n return axdelta","def plot_result(numerical, exact):\n \n numx, numy = numerical\n exax, exay = exact\n plt.title('Comparison Numerical vs. Analytical Solution')\n plt.xlabel('Distance x (m)')\n plt.ylabel('Temperature $(^{o}C)$')\n plt.plot(numx, numy, 'ro', label='numerical')\n plt.plot(exax, exay, 'y--', label='analytical')\n plt.legend()\n plt.grid()","def test_plotting():\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\n specs['interpolxydecs'][:, 1], specs['xopt'])\n\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\n potdata = np.vstack((xint, yint)).T\n\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\n\n expvaldata = np.vstack((expval, uncval)).T\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\n\n # qm_plottings('tests/test_data', scale=0.5)\n # assert True","def plot_various_confidences(self, graph_name, drop_rate, data_format,\n Y, directory='./attack_data/',\n confs=(0.0, 10.0, 20.0, 30.0, 40.0),\n get_attack_data_name=lambda c: \"example_carlini_\"+str(c)):\n import matplotlib.pyplot as plt\n import pylab\n\n pylab.rcParams['figure.figsize'] = 6, 4\n fig = plt.figure(1, (6, 4))\n ax = fig.add_subplot(1, 1, 1)\n\n det_only = []\n ref_only = []\n both = []\n none = []\n\n print(\"Drop Rate:\", drop_rate)\n thrs = self.operator.get_thrs(drop_rate)\n\n all_pass, _detector = self.operator.filter(self.operator.data.test_data, thrs)\n all_on_acc, _, _, _ = self.get_normal_acc(all_pass)\n\n print(_detector)\n print(\"Classification accuracy with all defense on:\", all_on_acc)\n\n for confidence in confs:\n f = get_attack_data_name(confidence)\n attack_data = AttackData(f, Y, \"Carlini L2 \" + str(confidence), directory=directory,\n input_data_format=CHANNELS_LAST, data_format=data_format)\n # compute number of all input data and filter out valid data\n total = len(attack_data.data)\n valid_adv_idx = np.argwhere(np.sum(attack_data.data, axis=(1, 2, 3)) > [0] * total).flatten()\n attack_data.data = attack_data.data[valid_adv_idx]\n attack_data.labels = attack_data.labels[valid_adv_idx]\n self.load_data(attack_data)\n\n print(\"Confidence:\", confidence)\n valid_adv_len = len(valid_adv_idx)\n print(\"valid attack %d/%d\" % (valid_adv_len, total))\n all_pass, detector_breakdown = self.operator.filter(self.untrusted_data.data, thrs)\n both_acc, det_only_acc, ref_only_acc, none_acc = self.get_attack_acc(all_pass)\n print(detector_breakdown)\n both.append(both_acc)\n det_only.append(det_only_acc)\n ref_only.append(ref_only_acc)\n none.append(none_acc)\n\n size = 2.5\n plt.plot(confs, none, c=\"green\", label=\"No fefense\", marker=\"x\", markersize=size)\n plt.plot(confs, det_only, c=\"orange\", label=\"With detector\", marker=\"o\", markersize=size)\n plt.plot(confs, ref_only, c=\"blue\", label=\"With reformer\", marker=\"^\", markersize=size)\n plt.plot(confs, both, c=\"red\", label=\"With detector & reformer\", marker=\"s\", markersize=size)\n\n pylab.legend(loc='lower left', bbox_to_anchor=(0.02, 0.1), prop={'size':8})\n plt.grid(linestyle='dotted')\n plt.xlabel(r\"Confidence in Carlini $L^2$ attack\")\n plt.ylabel(\"Classification accuracy\")\n plt.xlim(min(confs)-1.0, max(confs)+1.0)\n plt.ylim(-0.05, 1.05)\n ax.yaxis.set_major_formatter(FuncFormatter('{0:.0%}'.format))\n\n save_path = os.path.join(self.graph_dir, graph_name+\".pdf\")\n plt.savefig(save_path)\n plt.clf()","def _check_axes(axes):\n _check_type(axes, (Axes, np.ndarray), \"axes\")\n if isinstance(axes, np.ndarray):\n if axes.ndim == 1:\n for ax in axes:\n _check_type(ax, (Axes,))\n assert hasattr(ax, \"plot\") # sanity-check\n elif axes.ndim == 2:\n for i, j in product(range(axes.shape[0]), range(axes.shape[1])):\n _check_type(axes[i, j], (Axes,))\n assert hasattr(axes[i, j], \"plot\") # sanity-check\n else:\n raise ValueError(\n \"Argument 'axes' should be a matplotib axes or a \"\n \"1D or 2D numpy array of matplotlib axes.\"\n )\n else:\n # sanity-check\n assert hasattr(axes, \"plot\")\n return axes","def getPlot(self):\n return self.axes","def figure1():\n\n plot_settings = {'y_limits': [-80, -50],\n 'x_limits': None,\n 'y_ticks': [-80, -70, -60, -50],\n 'locator_size': 5,\n 'y_label': 'Voltage (mV)',\n 'x_ticks': [],\n 'scale_size': 20,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_1',\n 'legend_size': 8,\n 'legend': None,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n plt.figure(figsize=(5, 2)) # Create figure\n plt.plot(t, y[:, 0], 'k-') # Plot solution\n\n \"\"\"\n Annotate plot with figures\n \"\"\"\n plt.gca().annotate('fAHP', xy=(13.5, -65), xytext=(17, -60),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n plt.gca().annotate('ADP', xy=(15.5, -66), xytext=(25, -65),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n plt.gca().annotate('mAHP', xy=(38, -77), xytext=(43, -72),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n alter_figure(plot_settings, close=True) # Alter figure for publication","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def testPlotCandidateDesign(self):\n\n np.random.seed(0)\n new_data = pd.concat([self.test_data, self.add_pair], sort=False)\n test_class = TrimmedMatchGeoXDesign(\n GeoXType.HEAVY_UP,\n pretest_data=new_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n )\n budget_list = [30, 40]\n iroas_list = [0, 2]\n results, _ = test_class.report_candidate_designs(\n budget_list=budget_list,\n iroas_list=iroas_list,\n use_cross_validation=True,\n num_simulations=10,\n )\n\n axes_dict = test_class.plot_candidate_design(results)\n for budget in budget_list:\n for iroas in iroas_list:\n self.assertIsInstance(axes_dict[(budget, iroas)], plt.Figure)","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def plot_proof_functions():\n\n def thm1_D(x):\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\n\n def thm2_D(x):\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 2, 1000)\n\n plt.plot(x, thm1_D(x))\n plt.xlim(0, 2)\n plt.ylim(0.15, 0.22)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\n plt.xticks(range(3), range(3))\n plt.close()\n\n print(f'Saved plot to: plots/thm1_D.pdf')\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 5, 1000)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\n plt.plot(x, thm2_D(x))\n plt.xlim(0, 5)\n plt.ylim(0, 0.4)\n plt.xticks(range(6), range(6))\n\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\n plt.close()\n\n print(f'Saved plot to: plots/thm2_D.pdf')","def test_plot_ppc_ax(models, kind, fig_ax):\n _, ax = fig_ax\n axes = plot_ppc(models.model_1, kind=kind, ax=ax)\n assert np.asarray(axes).item(0) is ax","def plot_correction_diagram(fig_name):\n dir = \"log/circular antenna/around car\"\n files = utils.walk_files(dir)\n pattern_loc = r'.*\\\\(.*?) (.*?).csv$'\n radian_ref = 0.2\n for i in range(len(files)):\n file = files[i]\n match_obj = re.match(pattern_loc, file)\n if (match_obj.groups()[0] == 'left') & (match_obj.groups()[1] == '2m50'):\n df = pd.read_csv(file, sep=';', decimal=',')\n df1 = df[df['RSSI ANTENNA PCB'] != 0]\n rssi = pd.DataFrame(df1['RSSI ANTENNA PCB'])\n radian = pd.DataFrame(df1['ORIENTATION_X'])\n radian_mapped = radian.apply(utils.mapping_radian, args=(radian_ref, match_obj.groups()[0],))\n rssi_corrected = utils.correct_diagram(rssi, radian_mapped)\n rssi.columns = ['Original']\n rssi_corrected.columns = ['Corrected']\n rssi.index = np.arange(rssi.shape[0]) / utils.FREQ_LOG\n rssi_corrected.index = np.arange(rssi_corrected.shape[0]) / utils.FREQ_LOG\n\n plt.figure(figsize=(12, 8))\n ax1 = plt.subplot(2, 1, 1)\n rssi.plot(kind='line', ax=ax1)\n rssi_corrected.plot(kind='line', ax=ax1)\n plt.title(match_obj.groups()[0] + ' ' + match_obj.groups()[1])\n plt.title('RSSI Variation over time')\n plt.xlabel('Time: s')\n plt.ylabel('RSSI: dBm')\n\n ax3 = plt.subplot(2, 2, 3)\n rssi.plot(kind='density', ax=ax3)\n rssi_corrected.plot(kind='density', ax=ax3)\n plt.title('Distribution')\n plt.xlabel('RSSI: dBm')\n\n ax4 = plt.subplot(2, 2, 4)\n df = pd.DataFrame()\n df['Original'] = rssi\n df['Corrected'] = rssi_corrected\n df.plot(kind='box', ax=ax4)\n plt.title('Box')\n plt.ylabel('RSSI: dBm')\n if not os.path.exists(dir_fig):\n os.makedirs(dir_fig)\n plt.savefig(dir_fig + '/' + fig_name + '.png')","def calibration_plot(self, analytes=None, datarange=True, loglog=False, save=True):\n\n if analytes is None:\n analytes = [a for a in self.analytes if self.internal_standard not in a]\n\n n = len(analytes)\n if n % 3 is 0:\n nrow = n / 3\n else:\n nrow = n // 3 + 1\n\n axes = []\n\n if not datarange:\n fig = plt.figure(figsize=[12, 3 * nrow])\n else:\n fig = plt.figure(figsize=[14, 3 * nrow])\n if not hasattr(self, 'focus'):\n self.get_focus()\n\n gs = mpl.gridspec.GridSpec(nrows=int(nrow), ncols=3,\n hspace=0.3, wspace=0.3)\n\n i = 0\n for a in analytes:\n if not datarange:\n ax = fig.add_axes(gs[i].get_position(fig))\n axes.append(ax)\n i += 1\n else:\n f = 0.8\n p0 = gs[i].get_position(fig)\n p1 = [p0.x0, p0.y0, p0.width * f, p0.height]\n p2 = [p0.x0 + p0.width * f, p0.y0, p0.width * (1 - f), p0.height]\n ax = fig.add_axes(p1)\n axh = fig.add_axes(p2)\n axes.append((ax, axh))\n i += 1\n\n # plot calibration data\n ax.errorbar(self.srmtabs.loc[a, 'meas_mean'].values,\n self.srmtabs.loc[a, 'srm_mean'].values,\n xerr=self.srmtabs.loc[a, 'meas_err'].values,\n yerr=self.srmtabs.loc[a, 'srm_err'].values,\n color=self.cmaps[a], alpha=0.6,\n lw=0, elinewidth=1, marker='o',\n capsize=0, markersize=5)\n\n # work out axis scaling\n if not loglog:\n xlim, ylim = rangecalc(nominal_values(self.srmtabs.loc[a, 'meas_mean'].values),\n nominal_values(self.srmtabs.loc[a, 'srm_mean'].values),\n pad=0.1)\n xlim[0] = 0\n ylim[0] = 0\n else:\n xd = self.srmtabs.loc[a, 'meas_mean'][self.srmtabs.loc[a, 'meas_mean'] > 0].values\n yd = self.srmtabs.loc[a, 'srm_mean'][self.srmtabs.loc[a, 'srm_mean'] > 0].values\n\n xlim = [10**np.floor(np.log10(np.nanmin(xd))),\n 10**np.ceil(np.log10(np.nanmax(xd)))]\n ylim = [10**np.floor(np.log10(np.nanmin(yd))),\n 10**np.ceil(np.log10(np.nanmax(yd)))]\n\n # scale sanity checks\n if xlim[0] == xlim[1]:\n xlim[0] = ylim[0]\n if ylim[0] == ylim[1]:\n ylim[0] = xlim[0]\n\n ax.set_xscale('log')\n ax.set_yscale('log')\n\n ax.set_xlim(xlim)\n ax.set_ylim(ylim)\n\n # calculate line and R2\n if loglog:\n x = np.logspace(*np.log10(xlim), 100)\n else:\n x = np.array(xlim)\n\n coefs = self.calib_params[a][0]\n\n # plot line of best fit\n line = nominal_values(self.calib_fns[a](coefs, x))\n ax.plot(x, line, color=(0, 0, 0, 0.5), ls='dashed')\n\n if len(coefs) == 1:\n force_zero = True\n else:\n force_zero = False\n\n R2 = R2calc(self.srmtabs.loc[a, 'srm_mean'],\n nominal_values(self.calib_fns[a](coefs, self.srmtabs.loc[a, 'meas_mean'])),\n force_zero=force_zero)\n\n # labels\n if len(coefs) == 1:\n label = 'y = {:.2e} x'.format(coefs[0])\n else:\n label = r''\n for n, p in enumerate(coefs):\n if len(coefs) - n - 1 == 0:\n label += '{:.1e}'.format(p)\n elif len(coefs) - n - 1 == 1:\n label += '{:.1e} x\\n+ '.format(p)\n else:\n label += '{:.1e}$ x^'.format(p) + '{' + '{:.0f}'.format(len(coefs) - n - 1) + '}$\\n+ '\n\n if '{:.3f}'.format(R2) == '1.000':\n label += '\\n$R^2$: >0.999'\n else:\n label += '\\n$R^2$: {:.3f}'.format(R2)\n\n ax.text(.05, .95, pretty_element(a), transform=ax.transAxes,\n weight='bold', va='top', ha='left', size=12)\n ax.set_xlabel('counts/counts ' + self.internal_standard)\n ax.set_ylabel('mol/mol ' + self.internal_standard)\n # write calibration equation on graph\n ax.text(0.98, 0.04, label, transform=ax.transAxes,\n va='bottom', ha='right')\n\n # plot data distribution historgram alongside calibration plot\n if datarange:\n # isolate data\n meas = nominal_values(self.focus[a])\n meas = meas[~np.isnan(meas)]\n\n # check and set y scale\n if np.nanmin(meas) < ylim[0]:\n if loglog:\n mmeas = meas[meas > 0]\n ylim[0] = 10**np.floor(np.log10(np.nanmin(mmeas)))\n else:\n ylim[0] = 0\n ax.set_ylim(ylim)\n\n # hist\n if loglog:\n bins = np.logspace(*np.log10(ylim), 30)\n else:\n bins = np.linspace(*ylim, 30)\n\n axh.hist(meas, bins=bins, orientation='horizontal',\n color=self.cmaps[a], lw=0.5, alpha=0.5)\n\n if loglog:\n axh.set_yscale('log')\n axh.set_ylim(ylim)\n axh.set_xticks([])\n axh.set_yticklabels([])\n\n if save:\n fig.savefig(self.report_dir + '/calibration.pdf')\n\n return fig, axes","def plot_all(m, d, m_est, d_pred, equalize=True):\n fig = plt.figure(figsize=(10,6))\n\n ax0 = fig.add_subplot(2,2,1)\n ax0.plot(m)\n t = \"$\\mathrm{{Model}}\\ m.\\ \\mathrm{{norm}}\\ {:.3f}$\"\n ax0.set_title(t.format(norm(m)))\n ax0_mi, ax0_ma = ax0.get_ylim()\n\n ax1 = fig.add_subplot(2,2,2)\n ax1.plot(d, 'o', mew=0)\n ax1.set_title(\"$\\mathrm{Data}\\ d$\")\n ax1_mi, ax1_ma = ax1.get_ylim()\n\n ax2 = fig.add_subplot(2,2,3)\n ax2.plot(m, alpha=0.25)\n ax2.plot(m_est)\n t = \"$\\mathrm{{Estimated\\ model}}\\ m_\\mathrm{{est}}.\\ \\mathrm{{norm}}\\ {:.3f}$\"\n ax2.set_title(t.format(norm(m_est)))\n ax2_mi, ax2_ma = ax2.get_ylim()\n\n ax3 = fig.add_subplot(2,2,4)\n ax3.plot(d, 'o', mew=0, alpha=0.25)\n ax3.plot(d_pred, 'o', mew=0)\n t = \"$\\mathrm{{Predicted\\ data}}\\ d_\\mathrm{{pred}}.\\ \\mathrm{{misfit}}\\ {:.3f}$\"\n ax3.set_title(t.format(misfit(d, d_pred)))\n ax3_mi, ax3_ma = ax3.get_ylim()\n\n if equalize:\n ax0.set_ylim(min(ax0_mi, ax2_mi) - 0.1,\n max(ax0_ma, ax2_ma) + 0.1)\n\n ax2.set_ylim(min(ax0_mi, ax2_mi) - 0.1,\n max(ax0_ma, ax2_ma) + 0.1)\n\n ax1.set_ylim(min(ax1_mi, ax3_mi) - 0.1,\n max(ax1_ma, ax3_ma) + 0.1)\n\n ax3.set_ylim(min(ax1_mi, ax3_mi) - 0.1,\n max(ax1_ma, ax3_ma) + 0.1)\n\n plt.show()","def clean_axes(axl):\n cleanAxes(axl)","def get_safety_vars_plot(self):\n if 'safety_vars_stats' not in self.stats:\n raise ValueError('No safety vars statistics present in this evaluator.')\n\n safety_vars = self.stats['safety_vars_stats'][0].keys()\n n_plots = len(safety_vars)\n fig, axes = plt.subplots(n_plots, 1, figsize=(8, 6 * n_plots))\n\n for idx, var in enumerate(safety_vars):\n series = collections.defaultdict(list)\n for ep in self.stats['safety_vars_stats']:\n for stat in ep[var]:\n series[stat].append(ep[var][stat])\n ax = axes[idx]\n for stat in ['min', 'max']:\n ax.plot(np.squeeze(np.array(series[stat])), label=stat)\n x = range(len(series['mean']))\n\n mean = np.squeeze(np.array(series['mean']))\n std_dev = np.squeeze(np.array(series['std_dev']))\n ax.plot(x, mean, label='Value')\n ax.fill_between(\n range(len(series['mean'])), mean - std_dev, mean + std_dev, alpha=0.3)\n ax.set_title('Stats for {}'.format(var))\n ax.legend()\n ax.spines['top'].set_visible(False)\n\n ax.xaxis.set_ticks_position('bottom')\n ax.set_xlabel('Episode #')\n ax.set_ylabel('Magnitude')\n ax.plot()\n return fig","def Diagnostic_plot2(self):\n\n probs = pd.read_csv(self.probfile)\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'SNR')\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n #plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')","def analyse_plots(plot_dict, data_dict) :\n for component in [ '_x', '_y' ] :\n z_pos = array.array( 'd' )\n trans_pos = array.array( 'd' )\n errors = array.array( 'd' )\n zeros = array.array( 'd' )\n\n plot = plot_dict['beam_positions'+component]\n\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\n projection = plot.ProjectionY( \\\n 'profile'+component+'_pro_'+str(i), i, i )\n if projection.GetEntries() == 0 :\n continue\n\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\n scifi.fit_gaussian( projection )\n\n errors.append( pro_mean_err )\n trans_pos.append( pro_mean )\n z_pos.append( data_dict['station_positions'][ i-6 ] )\n zeros.append(0.0)\n\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\n zeros, errors )\n position_graph.SetName('beam_profile'+component)\n plot_dict['beam_profile'+component] = position_graph\n\n profile_x = plot_dict['beam_profile_x']\n profile_y = plot_dict['beam_profile_y']\n\n up_x_func = ROOT.TF1( \"up_fit_x\", \"pol1\", -5000.0, 0.0 )\n up_y_func = ROOT.TF1( \"up_fit_y\", \"pol1\", -5000.0, 0.0 )\n down_x_func = ROOT.TF1( \"down_fit_x\", \"pol1\", 0.0, 5000.0 )\n down_y_func = ROOT.TF1( \"down_fit_y\", \"pol1\", 0.0, 5000.0 )\n\n up_fit_x = profile_x.Fit( 'up_fit_x', \"QSR\" )\n up_fit_y = profile_y.Fit( 'up_fit_y', \"QSR\" )\n down_fit_x = profile_x.Fit( 'down_fit_x', \"QSR\" )\n down_fit_y = profile_y.Fit( 'down_fit_y', \"QSR\" )\n\n plot_dict['beam_profile_x_up_fit'] = up_x_func\n plot_dict['beam_profile_y_up_fit'] = up_y_func\n plot_dict['beam_profile_x_down_fit'] = down_x_func\n plot_dict['beam_profile_y_down_fit'] = down_y_func\n\n\n up_beam_gra_x = up_x_func.GetParameter(1)\n up_beam_gra_x_err = up_x_func.GetParError(1)\n up_beam_gra_y = up_y_func.GetParameter(1)\n up_beam_gra_y_err = up_y_func.GetParError(1)\n\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\n up_beam_pos_x_err = up_x_func.GetParError(0)\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\n up_beam_pos_y_err = up_y_func.GetParError(0)\n\n up_beam_rot_x = math.atan( up_beam_gra_x )\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\n up_beam_rot_y = math.atan( up_beam_gra_y )\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\n\n\n\n down_beam_gra_x = down_x_func.GetParameter(1)\n down_beam_gra_x_err = down_x_func.GetParError(1)\n down_beam_gra_y = down_y_func.GetParameter(1)\n down_beam_gra_y_err = down_y_func.GetParError(1)\n\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\n down_beam_pos_x_err = down_x_func.GetParError(0)\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\n down_beam_pos_y_err = down_y_func.GetParError(0)\n\n down_beam_rot_x = math.atan( down_beam_gra_x )\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\n down_beam_rot_y = math.atan( down_beam_gra_y )\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\n\n\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\n\n length = TRACKER_SEPARATION\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\n\n down_rot_x = down_beam_rot_x - up_beam_rot_x\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\n down_rot_y = down_beam_rot_y - up_beam_rot_y\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\n\n\n print\n print \"Incoming Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to upstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_x, up_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_y, up_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to downstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_x, down_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_y, down_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Alignment:\"\n print\n print \"Displacement and rotation of between the two trackers:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_x, down_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_y, down_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\n print","def plot(nSamples, expectations, variances, exactE, exactVar, title=\"\"):\n fig, axes = plt.subplots(2, 1)\n\n axes[0].semilogx(nSamples, expectations, color=\"black\", label=\"Empirical E(X)\")\n axes[0].axhline(exactE, color=\"darkgray\", label=\"Exact E(X)\")\n\n axes[1].semilogx(nSamples, variances, color=\"black\", label=\"Empirical Var(X)\")\n axes[1].axhline(exactVar, color=\"darkgray\", label=\"Exact Var(X)\")\n\n for ax in axes:\n ax.set_xlabel(\"N draws in the simulation\")\n ax.legend()\n axes[0].set_ylabel(\"E(X)\")\n axes[0].set_title(title)\n axes[1].set_ylabel(\"Var(X)\")\n plt.show()","def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\n\tcompObserved = []\n\tSStotalWarmth = 0\n\tSSresWarmth = 0\n\tSStotalComp = 0\n\tSSresComp = 0\n\tkeys = parser.getMappings(normalized)[0].keys()\n\tfor key in keys:\n\n\t\tif \"_\" in key:\n\t\t\twarmthAxis, compAxis = getPlotData(key)\n\t\t\twarmthPred.append(warmthAxis[3])\n\t\t\twarmthObserved.append(warmthAxis[2])\n\t\t\tcompPred.append(compAxis[3])\n\t\t\tcompObserved.append(compAxis[2])\n\n\tmeanObservedWarmth = np.mean(warmthObserved)\n\tmeanObservedComp = np.mean(compObserved)\n\tfor i in range(0, len(warmthObserved)):\n\t\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\n\t\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\n\t\tSStotalComp += (compObserved[i] - meanObservedComp)**2\n\t\tSSresComp += (compObserved[i] - compPred[i])**2\n\n\n\tplt.axis([0, 100, 0, 100])\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.title(\"Observed vs Predicted Warmth\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(warmthObserved, warmthPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.axis([0, 100, 0, 100])\n\tplt.title(\"Observed vs Predicted Competence\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(compObserved, compPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()","def plot_dif_eq(self):\n try:\n self.canvas.get_tk_widget().pack_forget()\n self.toolbar.pack_forget()\n except AttributeError:\n pass\n\n f = Figure(figsize=(8, 8), dpi=100)\n p = f.add_subplot(111)\n\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\n\n p.set_ylabel('y')\n p.set_xlabel('x')\n\n p.legend(['Exact', 'EU', \"IEU\", \"RK\"])\n p.set_title(\"Solutions\")\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\n p.set_ylim([-100, 100])\n\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\n p.set_ylim([-100, 100])\n\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\n self.canvas.draw()\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\n\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\n self.toolbar.update()\n\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)","def get_safety_plot(self, do_total=True, do_per_step=True):\n n_plots = int(do_total) + int(do_per_step)\n fig, axes = plt.subplots(1, n_plots, figsize=(8 * n_plots, 6))\n plot_idx = 0\n if do_total:\n self._get_safety_totals_plot(axes[plot_idx], self._stats['safety_stats'])\n plot_idx += 1\n if do_per_step:\n self._get_safety_per_step_plots(axes[plot_idx],\n self._stats['safety_stats'])\n return fig","def display_incorrect_window(self, is_correct_list):\r\n correct_num = sum(is_correct_list)\r\n tried_num = len(self.correct_answers)\r\n if correct_num == tried_num:\r\n correct_num -= 1 # -1 credit if given extra answers\r\n window = SimpleWindow(self.title, msg='{} of {} correct.'.format(\r\n correct_num, tried_num), buttons=['Try Again', 'Show Answers',\r\n 'Show Solution', 'Main Menu'])\r\n window.run()\r\n return window.clicked","def test_gca():\n fig, ax = plt.subplots()\n assert isinstance(prettypyplot.tools.gca(None), mpl.axes.Axes)\n assert isinstance(prettypyplot.tools.gca(plt.gca()), mpl.axes.Axes)","def figure_1():\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n\n # Draw common plots\n print(exp_list)\n data = get_data(exp_list[0])\n plt.figure(num=\"state 1\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"cmd\"],\n **FORMATTING[\"command\"]\n )\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 0],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_1$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"state 2\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 1],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_2$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"control\")\n plt.ylabel(r\"$u$\")\n plt.xlabel(\"Time, sec\")\n\n def general_figures(exp):\n data = get_data(exp)\n plt.figure(num=\"state 1\")\n ax = plt.gca()\n ax.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 0],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"state 2\")\n plt.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 1],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"control\")\n plt.plot(\n data[\"time\"], data[\"control\"],\n **FORMATTING[exp],\n )\n\n for exp in exp_list:\n general_figures(exp)\n\n # Estimation error\n for exp in exp_list:\n data = get_data(exp)\n error = nla.norm(\n data[\"state\"][\"adaptive_system\"] - data[\"real_param\"],\n axis=1\n )\n plt.figure(num=\"Estimation error\")\n plt.plot(data[\"time\"], error, **FORMATTING[exp])\n plt.xlabel(\"Time, sec\")\n plt.ylabel(\"Error norm\")\n\n # Real parameter\n data = get_data(exp_list[0])\n plt.plot(data[\"time\"], data[\"real_param\"].squeeze())\n\n\n exp_list.remove(\"mrac-nullagent\")\n\n def eig_figures(exp, minmax):\n data = get_data(exp)\n if minmax == \"min\":\n eig = np.min(data[\"eigs\"], axis=1)\n elif minmax == \"max\":\n eig = np.max(data[\"eigs\"], axis=1)\n plt.plot(data[\"time\"], eig, **FORMATTING[exp])\n\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\"Eigenvalues\", sharex=True)\n\n plt.subplot(211)\n plt.ticklabel_format(style=\"sci\", scilimits=(0, 0), useOffset=True)\n for exp in exp_list:\n eig_figures(exp, \"min\")\n plt.ylabel(r\"Minimum $\\lambda$\")\n plt.legend()\n\n plt.subplot(212)\n for exp in exp_list:\n eig_figures(exp, \"max\")\n plt.ylabel(r\"Maximum $\\lambda$\")\n plt.xlabel(\"Time, sec\")\n\n # Saving\n def savefig(name):\n path = os.path.join(args.save_dir, name + \".\" + args.save_ext)\n plt.savefig(path, bbox_inches=\"tight\")\n\n plt.figure(num=\"state 1\")\n plt.legend()\n savefig(\"state-1\")\n\n plt.figure(num=\"state 2\")\n plt.legend()\n savefig(\"state-2\")\n\n plt.figure(num=\"control\")\n plt.legend()\n savefig(\"control\")\n\n plt.figure(num=\"Eigenvalues\")\n savefig(\"eigs\")\n\n plt.figure(num=\"Estimation error\")\n plt.legend()\n savefig(\"estim-error\")\n\n plt.show()","def residual_plots(test_data, mods, station=None, squared=False):\r\n import config\r\n learning_var = config.learning_var\r\n data = test_data.get_miniOD()\r\n mods.models[0].mod.load()\r\n pred = mods.models[0].mod.predict(test_data)\r\n test_data.miniOD = None\r\n if squared:\r\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\r\n else:\r\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\r\n ind = data[data['Annee'] == 0].index\r\n data.drop(ind, inplace=True)\r\n print(data.columns.values)\r\n i = 0\r\n if station is None:\r\n ch_an = test_data.get_stations_col(2015)\r\n else:\r\n ch_an = 'End date ' + str(station)\r\n for ch in learning_var:\r\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\r\n # data.boxplot(ch_an, by=ch)\r\n # if ch != 'Heure':\r\n plt.figure(i // 9)\r\n # plt.title('squared error / expectation')\r\n fig = plt.subplot(3, 3, (i % 9) + 1)\r\n i += 1\r\n # fig = plt.figure().add_subplot(111)\r\n fig.set_xlabel(ch)\r\n if squared:\r\n fig.set_ylabel('error²')\r\n else:\r\n fig.set_ylabel('error')\r\n l = []\r\n xaxis = np.unique(data[ch])\r\n print(ch, xaxis.shape)\r\n if xaxis.shape[0] < 20 or ch == 'Heure':\r\n for u in xaxis:\r\n l.append(data[ch_an][data[ch] == u])\r\n else:\r\n m = np.min(data[ch])\r\n M = np.max(data[ch])\r\n step = (M - m) / 20\r\n xaxis = np.arange(m, M, step)\r\n for u in xaxis:\r\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\r\n xaxis = xaxis.astype(int)\r\n # fig = plt.boxplot(ch_an, by=ch)\r\n # g = data.groupby(ch).mean()[ch_an]\r\n # v = data.groupby(ch).std()[ch_an]\r\n plt.boxplot(l, labels=xaxis)\r\n if squared:\r\n plt.ylim((0, 12))\r\n else:\r\n plt.ylim((-5, 5))\r\n # plt.plot(g, '-r')\r\n # plt.plot(g + v, ':r')\r\n # plt.plot(g - v, ':r')\r\n plt.show()","def open(self):\r\n if not plt.fignum_exists(num=1):\r\n config_dict = self.config_dict\r\n config_dict.pop(\"aspect\")\r\n fig = plt.figure(**config_dict)\r\n return fig, plt.gca()\r\n return None, None","def makeFigure():\n # Get list of axis objects\n ax, f = getSetup((7, 3), (1, 2))\n rep = 10\n\n comps = np.arange(1, 11)\n\n try:\n chords_df = pd.read_csv('syserol/data/fig3_chords_df.csv')\n except FileNotFoundError:\n print(\"Building chords...\")\n # Imputing chords dataframe\n chords_df = pd.concat([pd.DataFrame({'Components': comps, 'R2X': evaluate_missing(comps, 15, chords=True)[0]})\n for _ in range(rep)], axis=0)\n chords_df.to_csv('syserol/data/fig3_chords_df.csv', index=False)\n chords_df = chords_df.groupby('Components').agg({'R2X': ['mean', 'sem']})\n\n try:\n single_df = pd.read_csv('syserol/data/fig3_single_df.csv')\n except FileNotFoundError:\n print(\"Building singles...\")\n # Single imputations dataframe\n single_df = pd.concat([pd.DataFrame(np.vstack((evaluate_missing(comps, 15, chords=False)[0:2], comps)).T,\n columns=['CMTF', 'PCA', 'Components']) for _ in range(rep)], axis=0)\n single_df.to_csv('syserol/data/fig3_single_df.csv', index=False)\n single_df = single_df.groupby(['Components']).agg(['mean', 'sem'])\n\n Q2Xchord = chords_df['R2X']['mean']\n Q2Xerrors = chords_df['R2X']['sem']\n ax[0].scatter(comps, Q2Xchord, s=10)\n ax[0].errorbar(comps, Q2Xchord, yerr=Q2Xerrors, fmt='none')\n ax[0].set_ylabel(\"Q2X of Imputation\")\n ax[0].set_xlabel(\"Number of Components\")\n ax[0].set_xticks([x for x in comps])\n ax[0].set_xticklabels([x for x in comps])\n ax[0].set_ylim(0, 1)\n\n CMTFR2X = single_df['CMTF']['mean']\n CMTFErr = single_df['CMTF']['sem']\n PCAR2X = single_df['PCA']['mean']\n PCAErr = single_df['PCA']['sem']\n ax[1].plot(comps - 0.1, CMTFR2X, \".\", label=\"CMTF\")\n ax[1].plot(comps + 0.1, PCAR2X, \".\", label=\"PCA\")\n ax[1].errorbar(comps - 0.1, CMTFR2X, yerr=CMTFErr, fmt='none', ecolor='b')\n ax[1].errorbar(comps + 0.1, PCAR2X, yerr=PCAErr, fmt='none', ecolor='darkorange')\n ax[1].set_ylabel(\"Q2X of Imputation\")\n ax[1].set_xlabel(\"Number of Components\")\n ax[1].set_xticks([x for x in comps])\n ax[1].set_xticklabels([x for x in comps])\n ax[1].set_ylim(0, 1)\n ax[1].legend(loc=4)\n\n # Add subplot labels\n subplotLabel(ax)\n\n return f","def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\n other_program_name, **kw):\n\n #plot absolute error\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\n pan['absolute-difference'][field].values,\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\n ax_abs.set_ylabel('Absolute Difference ' + unit)\n #plot percentage error\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\n pan['percent-difference'][field].values,\n color='firebrick', zorder=-1)\n ax_per.set_ylabel('Percent Difference', color='firebrick')\n #set error axes legend\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\n #ax_per.get_legend().set_zorder(1)\n #plot full results profiles\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\n color=_colormap[1])[0],\n ax_mag.plot(pan['emf.fields-results'][field],\n color=_colormap[0])[0]]\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\n ax_mag.set_xlabel('Distance (ft)')","def galactic_correction_summary(self):\n t = self.GalacticCorrection(self).x\n dd = dict()\n for i,c in enumerate(t.T):\n dd[i] = dict(offset=c.mean()-1,std=c.std())\n df = pd.DataFrame(dd).T\n fig, ax = plt.subplots()\n ax.errorbar(x=range(8), y=df.offset.values, yerr=df['std'].values, fmt='o')\n ax.axhline(0, color='grey')\n ax.set(xlabel='energy band', ylabel='offset', title='galactic correction offsets')\n return fig","def figure():\n fig = plt.figure()\n ax = fig.add_subplot()\n ax.set_aspect('equal')\n return fig, ax","def plot_test(func):\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n\n plt.close('all')\n\n func(*args, **kwargs)\n\n ax = plt.gca()\n assert ax.has_data()\n\n return wrapper","def plotFittingResults(self):\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\n\n #_listExpStdDev = None\n #if self.getDataInput().getExperimentalDataStdDev():\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\n #if _listExpStdDev:\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\"Experimental Data\")\n # pylab.gca().set_yscale(\"log\", nonposy='clip')\n #else: \n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n pylab.semilogy(_listFitQ, _listFitValues, label=\"Fitting curve\")\n pylab.xlabel('q')\n pylab.ylabel('I(q)')\n pylab.suptitle(\"RMax : %3.2f. Fit quality : %1.3f\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\n pylab.legend()\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \"gnomFittingResults.png\"))\n pylab.clf()","def _get_safety_per_step_plots(self, ax, safety_stats):\n meta = self.meta\n violations_labels = meta['safety_constraints']\n per_step_violations = safety_stats['per_step_violations']\n\n for idx, violations in enumerate(per_step_violations.T):\n label = violations_labels[idx]\n ax.plot(\n np.arange(violations.shape[0]), violations, label=label, alpha=0.75)\n\n ax.set_title('Mean violations / timestep')\n ax.legend(loc='upper right')\n ax.set_ylabel('Mean # violations')\n ax.set_xlabel('Timestep')\n ax.plot()","def diagnose_priors(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n names = [dm.name for dm in self.dmc]\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(\n 1, len(names), figsize=(len(names) * 4, 4), sharey=True\n )\n if not hasattr(axs, \"__iter__\"):\n axs = [axs]\n for idx, ax, X in zip(range(len(names)), axs, self.dmc):\n X.plot_priors(ax=ax)\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\n submatrix_coefficients = self.coefficients[\n firstcol_idx : firstcol_idx + X.shape[1]\n ]\n [ax.axvline(s, color=\"red\", zorder=-1) for s in submatrix_coefficients]\n return axs","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n\n # chdir into the working directory\n os.chdir(env['WORKDIR'])\n\n for nclPlotFile in self._ncl:\n # copy the NCL command to the workdir\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\n\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\n if rc:\n try:\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\n except subprocess.CalledProcessError as e:\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\n print(' {0}'.format(e.cmd))\n print(' rc = {0}'.format(e.returncode))\n else:\n print('{0}... continuing with additional plots.'.format(err_msg))","def create_plots(self):\n shutil.rmtree(self.param.path, ignore_errors=True)\n os.makedirs(self.param.path)\n\n ids = list(range(len(self.signs)))\n\n \"\"\"True positives\"\"\"\n values, kinds = self.get_evaluations(ids)\n plots.create_plot(\n kinds,\n [e[0] for e in values], # True positives\n save_dir=self.param.path,\n y_label=\"number_tp\",\n file_name=\"number_tp\",\n title=\"Amount of true positives\",\n )\n\n # Only signs with at least one detection!\n ids = [i for i, _ in enumerate(self.signs) if self.signs[i].evaluate()[2] > 0]\n values, kinds = self.get_evaluations(ids)\n\n \"\"\"Distance\"\"\"\n plots.create_plot(\n kinds,\n values=[e[2] for e in values], # Distances\n save_dir=self.param.path,\n y_label=\"distance\",\n file_name=\"distance\",\n title=\"Distance\",\n )\n \"\"\"Precision\"\"\"\n plots.create_plot(\n kinds,\n # Precision signs with at least one detection are used, e[0]+e[1] > 0)\n values=[e[0] / (e[0] + e[1]) for e in values],\n save_dir=self.param.path,\n y_label=\"precision\",\n file_name=\"precision\",\n title=\"Precision\",\n )","def test_generate_correlogram_empty(self):\r\n obs_fig = self.mc._generate_correlogram([], [], [])\r\n obs_ax = obs_fig.get_axes()[0]\r\n self.assertEqual(obs_ax.get_title(), \"Mantel Correlogram\")\r\n self.assertEqual(obs_ax.get_xlabel(), \"Distance class index\")\r\n self.assertEqual(obs_ax.get_ylabel(), \"Mantel correlation statistic\")","def gen_plots_with_errbars(plots_desc, compared, range_val, func, repeat=3, save_figs=False, verbose=False):\n\n def _init_y_avg():\n y_val = dict()\n for desc in plots_desc:\n y_val[desc['key']] = {'y': list(), 'err': list()}\n\n return y_val\n\n def _init_list():\n y_val = dict()\n for desc in plots_desc:\n y_val[desc['key']] = list()\n\n return y_val\n\n def _calc_avg(y_val, y_avg):\n for desc in plots_desc:\n key = desc['key']\n y_avg[key]['y'].append(np.mean(y_val[key]))\n y_avg[key]['err'].append(np.std(y_val[key]))\n\n def _add_avg_to_data(index, data_lists, y_avg, case_name):\n for desc in plots_desc:\n key = desc['key']\n data_lists[key].extend([range_val, y_avg[key]['y'], case_name, get_color(index) + '-', y_avg[key]['err']])\n\n def _plot_data_lists(data_lists):\n for desc in plots_desc:\n key = desc['key']\n plot_on_one_errorbars(desc['name'], desc['xlabel'], desc['ylabel'],\n data_lists[key], only_ints_on_x=True, save_it=save_figs)\n\n def _print_after_process(j_value, y_avg):\n print('>>> results for value {}: '.format(j_value))\n for desc in plots_desc:\n key = desc['key']\n print(' >>> {} - y: {}, err: {}'.format(key, y_avg[key]['y'][-1], y_avg[key]['err'][-1]))\n\n data_lists = _init_list()\n for i, compared_obj in enumerate(compared):\n case_name = compared_obj['name']\n y_avg = _init_y_avg()\n if verbose:\n print('({}) started calculation for {} case'.format(i, case_name))\n for j in range_val:\n y_val = _init_list()\n\n for _ in range(repeat):\n func(y_val, compared_obj, j)\n _calc_avg(y_val, y_avg)\n\n if verbose:\n _print_after_process(j, y_avg)\n _add_avg_to_data(i, data_lists, y_avg, case_name)\n\n _plot_data_lists(data_lists)","def figures(self):\n if np.size(self.iceicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n if self.site1.archive == 'icecore':\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\n else:\n mpl.xlabel(self.site1.label+' age (yr b1950)')\n if self.site2.archive == 'icecore':\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\n else:\n mpl.ylabel(self.site2.label+' age (yr b1950)')\n if np.size(self.iceicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceicehorizons_depth1),\n self.site2.fct_age_init(self.iceicehorizons_depth2),\n color=pccfg.color_init, linestyle='', marker='o', markersize=2,\n label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceicehorizons_depth1),\n self.site2.fct_age_model(self.iceicehorizons_depth2),\n color=pccfg.color_mod, linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceicehorizons_depth1),\n self.site2.fct_age(self.iceicehorizons_depth2), color=pccfg.color_opt,\n xerr=np.zeros(np.size(self.iceicehorizons_depth1)),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_age(self.iceicehorizons_depth1)-self.iceicehorizons_sigma/2\n ystart = self.site2.fct_age(self.iceicehorizons_depth2)+self.iceicehorizons_sigma/2\n for i in range(np.size(self.iceicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceicehorizons_sigma[i],\n -self.iceicehorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement', zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_ice_synchro.pdf')\n elif self.site1.archive == 'icecore' or self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n if np.size(self.airairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\n if np.size(self.airairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airairhorizons_depth1),\n self.site2.fct_airage_init(self.airairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airairhorizons_depth1),\n self.site2.fct_airage_model(self.airairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airairhorizons_depth1),\n self.site2.fct_airage(self.airairhorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.airairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_airage(self.airairhorizons_depth1)-\\\n self.airairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.airairhorizons_depth2)+\\\n self.airairhorizons_sigma/2\n for i in range(np.size(self.airairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airairhorizons_sigma[i],\n -self.airairhorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site2.archive == 'icecore':\n if np.size(self.iceairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n if self.site1.archive == 'icecore':\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\n else:\n mpl.xlabel(self.site1.label+' age (yr b1950)')\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\n if np.size(self.iceairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceairhorizons_depth1),\n self.site2.fct_airage_init(self.iceairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceairhorizons_depth1),\n self.site2.fct_airage_model(self.iceairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceairhorizons_depth1),\n self.site2.fct_airage(self.iceairhorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.iceairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_age(self.iceairhorizons_depth1)-\\\n self.iceairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.iceairhorizons_depth2)+\\\n self.iceairhorizons_sigma/2\n for i in range(np.size(self.iceairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceairhorizons_sigma[i],\n -self.iceairhorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0) \n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site1.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_air_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore':\n if np.size(self.airicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\n if self.site2.archive == 'icecore':\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\n else:\n mpl.ylabel(self.site2.label+' age (yr b1950)')\n if np.size(self.airicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airicehorizons_depth1),\n self.site2.fct_age_init(self.airicehorizons_depth2),\n color=pccfg.color_init,\n linestyle='', marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airicehorizons_depth1),\n self.site2.fct_age_model(self.airicehorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airicehorizons_depth1),\n self.site2.fct_age(self.airicehorizons_depth2),\n color=pccfg.color_opt,\n xerr=np.zeros_like(self.airicehorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior\")\n xstart = self.site1.fct_airage(self.airicehorizons_depth1)-\\\n self.airicehorizons_sigma/2\n ystart = self.site2.fct_age(self.airicehorizons_depth2)+\\\n self.airicehorizons_sigma/2\n for i in range(np.size(self.airicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airicehorizons_sigma[i],\n -self.airicehorizons_sigma[i], color=pccfg.color_opt,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement')\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n if self.site2.archive == 'icecore':\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_ice_synchro.pdf')\n else:\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()","def make_plots(title, \n chrg_x, csd, \n ele_x, pots, \n csd_x, est_csd, est_pot, \n true_pot=None):\n fig = plt.figure(figsize=(7,10))\n #CSDs\n ax1 = plt.subplot(211)\n if np.array(csd_x).any() != False:\n im1b = ax1.plot(csd_x, est_csd[:,0], 'r', label='kCSD', linewidth=3)\n im1a = ax1.plot(chrg_x, csd, 'g', label = 'CSD', linestyle='--', linewidth=3)\n ax1.plot(ele_x, np.zeros_like(ele_x), 'ko',markersize=2.)\n plt.legend() \n ax1.set_xlim([0.,1.])\n #ax1.set_ylim(ax1.get_ylim()[::-1]) #Zero on the top --ASK?!\n max_csd = np.maximum(max(np.abs(csd)), max(np.abs(est_csd[:,0])))\n max_csd += max_csd*0.2\n ax1.set_ylim([-max_csd, max_csd])\n ax1.set_xlabel('Depth mm')\n ax1.set_ylabel('CSD mA/mm')\n #Potentails\n ax2 = plt.subplot(212)\n ax2.plot( ele_x, np.zeros_like(ele_x),'ko',markersize=2.)\n im2b = ax2.plot(csd_x, est_pot, 'b', label = 'kPOT', linewidth=3)\n im2a = ax2.plot(chrg_x,true_pot, color = 'orange', \n linestyle='--', label='TruePOT', linewidth=3)\n ax2.set_xlim([0.,1.])\n #ax2.set_ylim(ax2.get_ylim()[::-1]) #Zero on the top --ASK?!\n ax2.plot(ele_x, pots, 'kx', markersize=8.)\n max_pots = np.maximum(max(np.abs(true_pot)), max(np.abs(est_pot)))\n max_pots += max_pots*0.2\n ax2.set_xlabel('Depth mm')\n ax2.set_ylabel('Potential mV')\n ax2.set_ylim([-max_pots, max_pots])\n fig.suptitle(title)\n plt.legend()\n plt.show()\n return","def plotErr(self):\n if self.xp and self.wp:\n # plot the spectra\n w=self.ws.value(np.array(self.xp))\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\n if self.dxp and self.dwp:\n # plot the spectra\n dw=self.ws.value(np.array(self.dxp))\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')","def plot_results(\n predictor_names, validation_auc_values, is_forward_test,\n axes_object=None, num_predictors_to_plot=None):\n\n if num_predictors_to_plot is None:\n num_predictors_to_plot = len(predictor_names)\n\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\n num_predictors_to_plot = min([\n num_predictors_to_plot, len(predictor_names)\n ])\n\n y_coords = numpy.linspace(\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\n )[::-1]\n\n if axes_object is None:\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n axes_object.barh(\n y_coords, validation_auc_values[:num_predictors_to_plot],\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\n linewidth=BAR_EDGE_WIDTH\n )\n\n axes_object.set_yticks([], [])\n axes_object.set_xlabel('Validation AUC')\n\n if is_forward_test:\n axes_object.set_ylabel('Predictor added')\n else:\n axes_object.set_ylabel('Predictor removed')\n\n axes_object.set_ylim(\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\n )\n axes_object.set_xlim(\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\n )\n\n for j in range(num_predictors_to_plot):\n axes_object.text(\n 0., y_coords[j], ' ' + predictor_names[j],\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\n horizontalalignment='left', verticalalignment='center'\n )\n\n return axes_object","def test_no_arguments(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n lines = ax.plot()\n assert lines == []","def make_plots(self):\n\n # main fixation times data frame\n average_fixation_df = pd.DataFrame()\n\n # create a data frame with the fixation times for each participant, create a box plot with it,\n # and append it to the main data frame\n for idx, dataframe in enumerate(self.cGOM_dataframes):\n aois = EyeTracking.areas_of_interest(dataframe)\n participant_fixations = EyeTracking.fixations(aois, dataframe)\n\n Plot.make_boxplot(data_frame=participant_fixations,\n figure_save_path=self.PARTICIPANT_FIGURE_PATH.format(idx + 1),\n title='Average fixation duration: participant {}'.format(idx + 1),\n ylabel='Fixation duration [s]',\n xlabel='Area of interest'\n )\n\n average_fixation_df = average_fixation_df.append(participant_fixations, ignore_index=True)\n\n # create a bar plot and a box plot with the fixations of all participants or\n # do nothing if no cGOM data is provided\n try:\n Plot.make_boxplot(data_frame=average_fixation_df,\n figure_save_path=self.BOX_PLOT_FIGURE_PATH,\n title='Average fixation duration',\n ylabel='Fixation duration [s]',\n xlabel='Area of interest'\n )\n Plot.make_barplot(data_frame=average_fixation_df,\n figure_save_path=self.BAR_PLOT_FIGURE_PATH,\n title='Average fixation duration',\n ylabel='Fixation duration [s]',\n xlabel='Area of interest'\n )\n except ValueError:\n pass","def plot_spectrumxichange(self):\n countgood = 0 ; countbad = 0\n for idata in self.datarg:\n if idata[-1, 0] == 1.: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \n countgood += 1\n print countgood , 'good solution'\n else: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \n print countbad, 'bad solution'\n countbad += 1\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\'s what you expected' %(countgood,countbad)\n #Create custom artistsr[goodline,badline],['solution','breakdown']\n goodline = pl.Line2D((0,1),(0,0), color='b') \n badline = pl.Line2D((0,1),(0,0), color='r')\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\n self.savefig('xispec')","def plot_mean(self, exact, exact_label='CCSD', axabs=None):\n if axabs is None:\n axabs = plt.gca()\n axabs.plot(list(range(1, self.max_dets)), self.means[0], label='independent')\n axabs.plot(list(range(1, self.max_dets)), self.means[1], label='correlated')\n axabs.axhline(self.means[0, 0], linestyle='--', color='silver', label='reference')\n if exact:\n axabs.axhline(exact, linestyle='dashdot', color='green', label=exact_label)\n axabs.set_xlabel('Number of determinants in estimator')\n axabs.set_ylabel(r'$E_\\mathrm{corr}$ / ha')\n axabs.legend()\n return axabs","def test_figure_layout(self, study_experiments_config):\n ar1 = AverageResult()\n\n with create_study_experiments(**study_experiments_config) as experiments:\n figure = ar1.analysis(\"task_name\", experiments)\n\n assert_regrets_plot(\n figure[\"AverageResult\"][\"task_name\"][\"regrets\"],\n [\n list(algorithm[\"algorithm\"].keys())[0]\n for algorithm in study_experiments_config[\"algorithms\"]\n ],\n balanced=study_experiments_config[\"max_trial\"],\n with_avg=True,\n )","def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\n\n figure = plt.figure()\n figure.subplots_adjust(top=0.76)\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\n\n functionGraph = figure.add_subplot(311)\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\n functionGraph.set_xlabel('X-values')\n functionGraph.set_ylabel('Y-values')\n\n errorGraph = figure.add_subplot(313)\n errorGraph.set_title('Truncation errors', fontsize=15)\n errorGraph.set_xlabel('X-values')\n errorGraph.set_ylabel('Error-values')\n\n if EU == True:\n euler = EulerMethod(self._IVP)\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\n\n if IEM == True:\n improvedEuler = ImprovedEulerMethod(self._IVP)\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\n \n if RK == True:\n rungeKutta = RungeKutta(self._IVP)\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\n\n if ES == True:\n exactSolution = AnalyticalSolution(self._IVP)\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\n \n functionGraph.legend(loc='lower right')\n errorGraph.legend(loc='lower right')\n\n return figure","def plot(self):\n # plot the data for checking\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\n 3,2, figsize=(10,8))\n\n # Relative height\n self.board_reference.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\n self.board_intervention.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\n\n # Landuse\n self.board_reference.plot(\n column='landuse', legend=True, ax=ax3, cmap='viridis',\n scheme='equal_interval', k=11)\n self.board_intervention.plot(\n column='landuse', legend=True, ax=ax4, cmap='viridis',\n scheme='equal_interval', k=11)\n\n index = np.arange(7)\n xticks = self.PotTax_reference.index.values\n bar_width = 0.3\n\n # plot the initial and new situation comparison\n label = (\"reference: \" +\n str(round(self.PotTax_reference.sum().TFI, 2)))\n reference = ax5.bar(\n index, self.PotTax_reference.values.flatten(), bar_width,\n label=label, tick_label=xticks)\n label = (\"intervention: \" +\n str(round(self.PotTax_intervention.sum().TFI, 2)))\n intervention = ax5.bar(\n index+bar_width, self.PotTax_intervention.values.flatten(),\n bar_width, label=label, tick_label=xticks)\n ax5.set_ylabel(\"total value\")\n ax5.legend(loc='best')\n for tick in ax5.get_xticklabels():\n tick.set_rotation(90)\n\n # plot the percentage increase/decrease between the initial and new\n # situation\n data = self.PotTax_percentage.values.flatten()\n percentage = ax6.bar(\n index, data, bar_width, label=\"percentage\", tick_label=xticks)\n ax6.set_ylabel(\"increase (%)\")\n minimum = min(data)\n maximum = max(data)\n size = len(str(int(round(maximum))))\n maximum = int(str(maximum)[:1])\n maximum = (maximum + 1) * (10**(size-1))\n ax6.set_ylim([min(0, minimum), maximum])\n for tick in ax6.get_xticklabels():\n tick.set_rotation(90)","def test_generate_correlogram(self):\r\n obs_fig = self.mc._generate_correlogram([0, 1, 2], [-0.9, 0, 0.9],\r\n [0.001, 0.1, 0.9])\r\n obs_ax = obs_fig.get_axes()[0]\r\n self.assertEqual(obs_ax.get_title(), \"Mantel Correlogram\")\r\n self.assertEqual(obs_ax.get_xlabel(), \"Distance class index\")\r\n self.assertEqual(obs_ax.get_ylabel(), \"Mantel correlation statistic\")\r\n assert_almost_equal(obs_ax.get_xticks(), [0., 0.5, 1., 1.5, 2.])\r\n assert_almost_equal(obs_ax.get_yticks(), [-1., -0.5, 0., 0.5, 1.])","def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\n \n plt.figure()\n plt.plot(x, phiExact)\n\n plt.plot(x, phi)\n plt.ylim([-0.2, 1.4])\n plt.title(str(methodName)+\" scheme\\nExact vs Numerical solution \"\\\n \"nt=\"+str(nt)+\", nx=\"+str(nx)+\"\\n\"\n \"Courant number: \"+str(c))\n plt.show()","def check_graph(t, RA_main, DEC_main, survey, width,\n gtype=\"all\", add_plotid=True, prefix=None,\n saveplot=True, plotfile=None, plotfile_prefix=None,\n title=None, suptitle=None):\n import math\n import time\n\n import matplotlib.pyplot as plt\n import matplotlib.gridspec as gridspec\n import numpy as np\n from matplotlib.colors import LogNorm\n\n import stats\n import plotid\n\n now = time.localtime(time.time())\n datestamp = time.strftime(\"%Y%m%d\", now)\n function_name = inspect.stack()[0][3]\n\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno + ':')\n print(function_name + '.saveplot:', saveplot)\n print(function_name + '.plotfile:', plotfile)\n print(function_name + '.prefix: ', plotfile_prefix)\n\n ndata = len(t)\n\n n = 0\n xs = []\n ys = []\n while n < len(t):\n x = ((t[RA_main][n] - t[\"RA_\" + survey.upper()][n]) *\n math.cos((t[DEC_main][n] +\n t[\"DEC_\" + survey][n]) * math.pi / 360.0) * 3600.0)\n y = (t[DEC_main][n] - t[\"DEC_\" + survey.upper()][n]) * 3600.0\n\n if not np.isnan(x) and not np.isnan(y):\n xs.append(x)\n ys.append(y)\n n += 1\n\n n = 0\n xs_s = []\n ys_s = []\n if gtype == \"square\":\n w = width / math.sqrt(2.0)\n while n < len(xs):\n x = xs[n]\n y = ys[n]\n if x <= w and x >= -w and y <= w and y >= -w:\n xs_s.append(xs[n])\n ys_s.append(ys[n])\n n += 1\n\n xs = xs_s\n ys = ys_s\n\n xs1 = list(xs) + []\n ys1 = list(ys) + []\n\n RA_med = np.median(xs1)\n DEC_med = np.median(ys1)\n RA_MAD = stats.MAD(xs1, RA_med)\n DEC_MAD = stats.MAD(ys1, DEC_med)\n print(\"Number of points\", len(xs))\n print(\"RA offset\", RA_med, \"DEC offset\", DEC_med)\n print(\"RA MAD\", RA_MAD, \"DEC MAD\", DEC_MAD)\n print(\"RA Sigma MAD\", 1.486 * RA_MAD, \"DEC Sigma DEC\", 1.486 * DEC_MAD)\n print(\"RA Median Error\", 1.486 * RA_MAD / math.sqrt(len(xs)),\n \"DEC Median Error\", 1.486 * DEC_MAD / math.sqrt(len(ys)))\n print()\n if len(xs) == 0:\n print(\"No matches\")\n return RA_med, DEC_med\n\n gs = gridspec.GridSpec(2, 2, width_ratios=[2, 1], height_ratios=[1, 2])\n fig = plt.figure()\n ax1 = plt.subplot(gs[0])\n ax1.hist(xs, bins=100, color=\"r\")\n ax1.set_xlim(-2.0, 2.0)\n ax1.axes.get_xaxis().set_visible(False)\n ax1.set_ylabel(\"Number\")\n\n ax2 = plt.subplot(gs[2])\n # ax2.plot(xs, ys, \"k+\")\n if len(xs) > 100:\n plt.hist2d(xs, ys, bins=100, cmap=\"binary\", norm=LogNorm())\n else:\n plt.plot(xs, ys, \"k.\", ms=2)\n ax2.set_ylim(-2.0, 2.0)\n ax2.set_xlim(-2.0, 2.0)\n ax2.set_xlabel('Delta RA /\"')\n ax2.set_ylabel('Delta Dec /\"')\n labels1 = ax2.get_xticks()\n ax2.set_xticklabels(labels1, rotation=270)\n\n if suptitle is None:\n fig.suptitle(\"Errors in matching: \" +\n survey + ': ' + str(ndata), fontsize='small')\n\n if suptitle is not None:\n fig.suptitle(suptitle + ': ' + str(ndata), fontsize='small')\n\n ax3 = plt.subplot(gs[3])\n ax3.hist(ys, bins=100, orientation=\"horizontal\", color=\"r\")\n ax3.set_ylim(-2.0, 2.0)\n ax3.set_xlabel(\"Number\")\n ax3.axes.get_yaxis().set_visible(False)\n labels2 = ax3.get_xticks()\n ax3.set_xticklabels(labels2, rotation=270)\n\n ax4 = plt.subplot(gs[1])\n ax4.annotate(\"Number of points: \" +\n str(len(xs)), xy=(0.01, 0.1), size=\"small\")\n ax4.annotate(\"RA offset: {0:.4f}\".format(RA_med) +\n '\"', xy=(0.01, 0.90), size=\"small\")\n ax4.annotate(\"DEC offset: {0:.4f}\".format(DEC_med) +\n '\"', xy=(0.01, 0.8), size=\"small\")\n ax4.annotate(\"RA MAD: {0:.4f}\".format(RA_MAD) +\n '\"', xy=(0.01, 0.7), size=\"small\")\n ax4.annotate(\"DEC MAD: {0:.4f}\".format(DEC_MAD) +\n '\"', xy=(0.01, 0.6), size=\"small\")\n ax4.annotate(\"RA median error: {0:.4f}\".\n format(1.486 * RA_MAD / math.sqrt(len(xs))) + '\"',\n xy=(0.01, 0.5), size=\"small\")\n ax4.annotate(\"DEC median error: {0:.4f}\".\n format(1.486 * DEC_MAD / math.sqrt(len(ys))) + '\"',\n xy=(0.01, 0.4), size=\"small\")\n ax4.annotate(\"RA sigma MAD: {0:.4f}\".format(RA_MAD * 1.486) +\n '\"', xy=(0.01, 0.3), size=\"small\")\n ax4.annotate(\"DEC sigma MAD: {0:.4f}\".format(DEC_MAD * 1.486) +\n '\"', xy=(0.01, 0.2), size=\"small\")\n\n ax4.axes.get_xaxis().set_visible(False)\n ax4.axes.get_yaxis().set_visible(False)\n\n if saveplot:\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno)\n if add_plotid:\n plotid.plotid()\n if plotfile is None:\n plotfile = 'match'\n if plotfile_prefix is not None:\n plotfile = plotfile_prefix + '_match_' + datestamp + '.png'\n if plotfile_prefix is None:\n plotfile = 'match_' + datestamp + '.png'\n\n print('Saving: ', plotfile)\n plt.savefig(plotfile)\n\n plt.show()\n\n return RA_med, DEC_med","def plot_solution(self):\n\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \"Analytical\")\n plt.plot(self.x_values, self.numerical, label = \"Numerical\")\n plt.title(\"Numerical vs. Analytical Solution\")\n plt.xlabel(\"x\")\n plt.ylabel(\"u(x)\")\n plt.legend()\n plt.show()","def evidence_tuning_plots(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\",\n x_name=\"Mean Predicted\",\n y_name=\"Empirical Probability\"):\n\n def lineplot(x, y, trials, methods, **kwargs):\n \"\"\"method_lineplot.\n\n Args:\n y:\n methods:\n kwargs:\n \"\"\"\n uniq_methods = set(methods.values)\n method_order = sorted(uniq_methods)\n\n method_new_names = [f\"$\\lambda={i:0.4f}$\" for i in method_order]\n method_df = []\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\n method_new_names)):\n lines_y = y[methods == method]\n lines_x = x[methods == method]\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\n\n to_append = [{x_name : x,\n y_name: y,\n \"Method\": method_new_name,\n \"Trial\" : trial}\n for i, (x,y) in enumerate(zip(xx,yy))]\n method_df.extend(to_append)\n method_df = pd.DataFrame(method_df)\n x = np.linspace(0,1,100)\n plt.plot(x, x, linestyle='--', color=\"black\")\n sns.lineplot(x=x_name, y=y_name, hue=\"Method\",\n alpha=0.8,\n hue_order=method_new_names, data=method_df,)\n # estimator=None, units = \"Trial\")\n\n df = df.copy()\n # Query methods that have evidence_new_reg_2.0\n df = df[[\"evidence\" in i for i in\n df['method_name']]].reset_index()\n\n # Get the regularizer and reset coeff\n coeff = [float(i.split(\"evidence_new_reg_\")[1]) for i in df['method_name']]\n df[\"method_name\"] = coeff\n df[\"Data\"] = convert_dataset_names(df[\"dataset\"])\n df[\"Method\"] = df[\"method_name\"]\n\n g = sns.FacetGrid(df, col=\"Data\", height=6, sharex = False, sharey = False)\n g.map(lineplot, x_input, y_input, \"trial_number\",\n methods=df[\"Method\"]).add_legend()","def plot(self) -> List[matplotlib.figure.Figure]:\n figs = []\n\n # Figure 1, position in 3 subplots\n pos_fig_sub = self.plot_subplots(0, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed)\n figs.append(pos_fig_sub)\n\n # Figure 2, orientation in 3 subplots\n eul_fig_sub = self.plot_subplots(1, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed)\n figs.append(eul_fig_sub)\n\n # Figure 3, position in one axes\n pos_fig_one = self.plot_one_axes(2, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed,\n {'labeled': 'Labeled (X)', 'filled': 'Filled (Y)', 'smoothed': 'Smoothed (Z)'})\n figs.append(pos_fig_one)\n\n # Figure 3, position in one axes\n eul_fig_one = self.plot_one_axes(3, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed,\n {'labeled': 'Labeled (Flex/Ext)', 'filled': 'Filled (Lat Flex)',\n 'smoothed': 'Smoothed (Axial)'})\n figs.append(eul_fig_one)\n\n return figs","def plot(self):\n t = np.linspace(0, self.days, self.days + 1)\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\n ax1.plot(t, self.S, label=\"Susceptible\", color='r')\n ax1.set_ylabel(\"Number of Susceptible People\")\n ax1.set_title(\"Strong Infecitous Model SEIRV Simulation\")\n ax3.plot(t, self.I, label=\"Active Cases\", color='b')\n ax3.set_ylabel(\"Active Cases\")\n ax2.plot(t, self.E, label=\"Exposed\", color='c')\n ax2.set_ylabel(\"# of Exposed\")\n ax4.plot(t, self.R, label=\"Recovered\", color='m')\n ax5.set_xlabel(\"Days\")\n ax4.set_ylabel('Number of Recovered')\n ax5.plot(t, self.V, label=\"Vaccinated\")\n ax5.set_ylabel(\"# Vaccinated\")\n ax1.legend()\n ax2.legend()\n ax3.legend()\n ax4.legend()\n plt.show()\n return fig","def getAxes():\n subjects = load_file(\"meta-subjects\")\n detections = load_file(\"meta-detections\")\n antigens = load_file(\"meta-antigens\")\n # Delete HIV1.Gag and gp140.HXBc2 antigens\n antigens = antigens[(antigens.antigen != \"HIV1.Gag\") & (antigens.antigen != \"gp140.HXBc2\")]\n\n subjects = subjects[\"subject\"].to_list()\n detections = detections[\"detection\"].to_list()\n antigen = antigens[\"antigen\"].to_list()\n\n return subjects, detections, antigen","def validate_totals():\n fig, (ax_prior, ax2_post) = plt.subplots(\n nrows=2, figsize=figsize(aspect=1.2))\n\n # train margin-dependent Elo model\n melo = Melo(lines=np.arange(149.5, 250.5), commutes=True, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, league.totals)\n\n # exact prior distribution\n outcomes = melo.training_data.value[:, np.newaxis] > melo.lines\n sf = np.mean(outcomes, axis=0)\n ax_prior.plot(melo.lines, sf, color='k')\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n plot_args = [\n (ax_prior, melo.first_update, 'prior'),\n (ax2_post, melo.last_update, 'posterior'),\n ]\n\n for ax, time, title in plot_args:\n for n, label2 in enumerate(label2_list):\n\n lines, sf = melo._predict(time, label1, label2)\n label = r'$\\lambda_2={}$'.format(label2)\n\n if ax.is_first_row():\n ax.plot(lines[n::6], sf[n::6], 'o', zorder=2, label=label)\n\n if ax.is_last_row():\n ax.plot(lines, sf, 'o', zorder=2, label=label)\n\n sf = poisson.sf(melo.lines, int(label1) + int(label2))\n ax.plot(melo.lines, sf, color='k')\n\n leg = ax.legend(title=r'$\\lambda_1 = {}$'.format(label1),\n handletextpad=.2, loc=1)\n leg._legend_box.align = 'right'\n\n lines = np.floor(lines)\n ax.set_xticks(lines[::10])\n ax.set_xlim(lines.min(), lines.max())\n\n if ax.is_last_row():\n ax.set_xlabel('line $=$ scored $+$ allowed')\n\n ax.set_ylabel('probability to cover line')\n\n ax.annotate(title, xy=(.05, .05),\n xycoords='axes fraction', fontsize=24)\n\n set_tight(h_pad=1)","def figure4():\n\n plot_settings = {'y_limits': [-80, -50],\n 'x_limits': None,\n 'y_ticks': [-80, -70, -60, -50],\n 'locator_size': 5,\n 'y_label': 'Voltage (mV)',\n 'x_ticks': [],\n 'scale_size': 20,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_4',\n 'legend': ['control', 'apamin'],\n 'legend_size': 8,\n 'y_on': True}\n line_styles = ['-', 'dotted']\n\n plt.figure(figsize=(5, 3), dpi=96)\n\n plt.subplot(2, 1, 1) # Generate figure 1 (top)\n for ix, g_sk_bar in enumerate([0.3, 0]):\n t, y = solver(100, g_sk_bar=g_sk_bar)\n plt.plot(t, y[:, 0], c='k', linestyle=line_styles[ix])\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 1, 2)\n t1 = 1200\n t, y = solver(t1, t_start=50, duration=t1, i_bias_on=0.33, g_sk_bar=0.03)\n plt.plot(t, y[:, 0], 'k-')\n\n plot_settings['y_limits'] = [-100, 30]\n plot_settings['x_limits'] = [0, t1]\n plot_settings['y_ticks'] = [-80, -60, -40, -20, 0, 20]\n plot_settings['locator_size'] = 10\n plot_settings['scale_size'] = 100\n plot_settings['legend'] = None\n alter_figure(plot_settings, close=True) # Alter plot for publication","def plot_corr_normalized(models,data,fit,**kwargs):\n _fnNMod = len(models)\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\n ## -- objects to hold all plot data\n ## - Dat/Fit refers to the correlator data or the fit function\n ## - Central/Error are the central value and errors\n _fnDatCentral = []\n _fnDatError = []\n _fnFitOnes = []\n _fnFitError = []\n #\n ## -- other objects\n _fnTDataNonZero = []\n _fnTFitNonZero = []\n _fnTData = []\n _fnTFit = []\n _fnTRem = [] # number of previous timeslices removed\n fig,ax = plt.subplots(1)\n #\n ## -- setup plot function\n def do_plot_normalized(idx,fig=fig):\n fig.clear()\n ax = fig.add_subplot(111)\n key = models[idx[0]].datatag\n\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\n ax.set_ylim(utp.get_option(\"y_limit\",[0.2,1.8],**kwargs[key]))\n #\n ## -- plot fit\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\n color=utp.get_option(\"color2\",'b',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ## -- plot correlator data\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\n mfc=utp.get_option(\"markerfacecolor1\",'None',**kwargs[key]),\n mec=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n color=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n ls=utp.get_option(\"linestyle1\",'None',**kwargs[key]),\n marker=utp.get_option(\"marker1\",'o',**kwargs[key]),\n ms=utp.get_option(\"markersize\",6,**kwargs[key]))\n ax.scatter(_fnTFitNonZero[idx[0]],\n [ _fnDatCentral[idx[0]][t] for t in\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\n color=utp.get_option(\"color1\",'r',**kwargs[key]),\n marker=utp.get_option(\"marker\",'o',**kwargs[key]),\n s=utp.get_option(\"markersize\",36,**kwargs[key]))\n fig.suptitle(utp.get_option(\"plottitlefn\",str(idx[0])+\" default title \"+str(key),**kwargs[key]),\n fontsize=utp.get_option(\"titlesize\",20,**kwargs[key]))\n ## -- modify some options \n ax.set_xlabel(r'$t$')\n ax.set_ylabel(utp.get_option(\"yaxistitle\",r\"$C(t)/C_{fit}(t)$\",**kwargs[key]))\n for item in ([ax.xaxis.label,ax.yaxis.label]):\n # must be after setting label content (LaTeX ruins it)\n item.set_fontsize(fontsize=utp.get_option(\"fontsize\",20,**kwargs[key]))\n rect =fig.patch\n rect.set_facecolor('white')\n if utp.get_option(\"to_file\",False,**kwargs[key]):\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".pdf\",**kwargs[key])\n plt.savefig(save_dir+'/'+save_name)\n if utp.get_option(\"to_terminal\",True,**kwargs[key]):\n plt.draw()\n pass\n #\n ## -- setup button press action function\n def press_normalized(event,idx=_fnIdx):\n #print('press_normalized', event.key)\n try:\n ## -- manually indicate index\n idx[0] = int(event.key) + (idx[0])*10\n except ValueError:\n if event.key==' ': ## -- space\n ## -- allows for replotting when changing index by typing number keys\n idx[0] = idx[0] % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='left':\n idx[0] = (idx[0] - 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='right':\n idx[0] = (idx[0] + 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='backspace':\n ## -- reset index so can manually flip through using number keys\n idx[0] = 0\n elif event.key=='d':\n ## -- dump plots into ./plotdump directory\n for ix,model in zip(range(len(models)),models):\n key = model.datatag\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".png\",**kwargs[key])\n do_plot_normalized([ix])\n plt.savefig(save_dir+'/'+save_name)\n do_plot_normalized(idx)\n #\n ## -- \n fig.canvas.mpl_connect('key_press_event',press_normalized)\n ## -- save plot data\n for idx,model in zip(range(len(models)),models):\n key = model.datatag\n _fnTData.append(model.tdata)\n _fnTFit.append(model.tfit)\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\n ## -- fit\n _fnFitFunc = utp.create_fit_func(model,fit)\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\n _fnTRem[-1] = \\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\n ## -- data\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean)) )\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean) )\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\n ## -- done saving data\n \n if not(utp.get_option(\"to_terminal\",True,**kwargs[key])) and\\\n utp.get_option(\"to_file\",False,**kwargs[key]):\n for ix in range(len(models)):\n ## -- loops and saves all without creating window\n do_plot_normalized([ix])\n else:\n do_plot_normalized(_fnIdx)","def create_plot():\n\n fig, ax = plt.subplots()\n return fig, ax","def _newax(ax=None):\n from matplotlib import pyplot as plt\n if ax is not None:\n return ax\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1)\n return ax","def plot_ctx_net_analysis(t, recalled_ctx, ctx, ctx_test_env, fig=None):\n if fig is None:\n fig = plt.gcf()\n\n subplots = gridspec.GridSpec(2, 2, width_ratios=(1., 2.))\n ax1 = fig.add_subplot(subplots[0, 0])\n ax1.set_title(\"(a) Norm\")\n ax2 = fig.add_subplot(subplots[1, 0], sharex=ax1)\n ax2.set_title(\"(b) Effective context drift\")\n ax3 = fig.add_subplot(subplots[:, 1], sharex=ax1)\n ax3.set_title(\"(c) Context similarity decay\")\n\n plot_ctx_norm(t, ctx, ax=ax1)\n plot_effective_beta(t, recalled_ctx, ctx, ctx_test_env, ax=ax2)\n plot_similarity_decay(t, ctx, ctx_test_env, ax=ax3)\n\n sns.despine(fig)\n subplots.tight_layout(fig)","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def test_plot_drift(self):\n with patch('matplotlib.pyplot.show') as mock: # don't display the figure\n with patch('matplotlib.pyplot.savefig') as mock2: # don't display the figure\n times = (datetime.datetime(2000, 1, 1), datetime.datetime(2000, 1, 2), datetime.datetime(2000, 1, 3))\n ref_ratio = (0, 0, 0)\n plot = librad_drift.RadiometricDrift.plot_radiometric_drift\n drift = plot(times, ref_ratio, 'target', 'reference', band=0, doplot=False)\n self.assertEqual(drift, 0)","def plot_results(\n train_data: tuple[Tensor, Tensor],\n test_data: tuple[Tensor, Tensor],\n correct_class: Tensor\n):\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\n ax1.set_title('Training data')\n plot_dataset(train_data, ax1)\n\n ax2.set_title('Test data')\n plot_dataset(test_data, ax2)\n\n ax3.set_title('Test prediction correctness')\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\n \n fig1.savefig('plots/datasets')\n fig2.savefig('plots/predictions')\n plt.show()","def PlotAcc(acc_CAL, queries_CAL, acc_random, queries_random):\n\n\t### TODO: make the accuracy plot\n\n\n\tplt.plot(range(1,len(acc_CAL)+1), acc_CAL, label=\"CAL sampling\")\n\tplt.plot(range(1,len(acc_random)+1), acc_random, label=\"Random Sampling\")\n\tplt.legend()\n\tplt.xlabel(\"Query number\")\n\tplt.ylabel(\"Test accuracy\")\n\tplt.title(\"Test Accuracies in CAL & Random Sampling\")\n\tplt.savefig(\"acc.png\")\n\tplt.clf()\n\n\tnames = [\"CAL sampling\", \"Random Sampling\"]\n\tvalues = [queries_CAL, queries_random]\n\n\tplt.scatter(names, values)\n\tplt.title(\"Number Queried\")\n\tplt.savefig(\"queried.png\")\n\tplt.clf()\n\n\tprint(queries_CAL)\n\treturn","def mpl_plot_was_rendered():\n figs_before = plt.gcf().number\n yield\n figs_after = plt.gcf().number\n assert figs_after > figs_before","def plot(self) -> Figure:\n ax = self.setup_plot()\n ax.errorbar(\n self.doses,\n self.means,\n yerr=self.errorbars(),\n label=\"Mean ± 95% CI\",\n **plotting.DATASET_POINT_FORMAT,\n )\n ax.legend(**plotting.LEGEND_OPTS)\n return ax.get_figure()","def plot(self):\n if self._traces is not None:\n strong_form_plot(self)\n else:\n weak_form_plot(self)","def _plot_modal_controllability(self, axes=None, acute=True,\n **parameter_overrides):\n\n par, array_keys, array_len = self._parse_parameter_overrides(\n **parameter_overrides)\n\n betas = self._calc_modal_controllability(acute=acute,\n **parameter_overrides)\n betas = np.rad2deg(betas)\n\n if axes is None:\n fig, axes = plt.subplots(*betas[0].shape, sharex=True)\n\n for i, row in enumerate(axes):\n row[0].set_ylabel('Mode {}'.format(i + 1))\n for j, col in enumerate(row):\n col.plot(par[array_keys[0]], betas[:, i, j])\n\n axes[3, 0].set_xlabel(array_keys[0])\n axes[3, 1].set_xlabel(array_keys[0])\n\n axes[0, 0].set_title(r'Input: $T_\\phi$')\n axes[0, 1].set_title(r'Input: $T_\\delta$')\n\n return axes","def compare(args):\n p = OptionParser(__doc__)\n opts, args, iopts = p.set_image_options(args, figsize=\"15x5\")\n\n if len(args) != 1:\n sys.exit(not p.print_help())\n\n datafile, = args\n pf = datafile.rsplit(\".\", 1)[0]\n fig, (ax1, ax2, ax3) = plt.subplots(ncols=3, nrows=1,\n figsize=(iopts.w, iopts.h))\n plt.tight_layout(pad=2)\n\n # Huntington risk allele\n infected_thr = 40\n ref_thr = 19\n\n # ax1: Multiple callers at lower range\n df = pd.read_csv(\"Evaluation.csv\")\n truth = df[\"Truth\"]\n\n ax1.plot(truth, df[\"Manta\"], 'bx-')\n ax1.plot(truth, df[\"Isaac\"], 'yo-')\n ax1.plot(truth, df[\"GATK\"], 'md-')\n ax1.plot(truth, df[\"lobSTR\"], 'c+-')\n ax1.plot(truth, truth, 'k--') # to show diagonal\n\n bbox = {'facecolor': 'tomato', 'alpha': .2, 'ec': 'w'}\n pad = 2\n ax1.axhline(infected_thr, color='tomato')\n ax1.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\n bbox=bbox, ha=\"right\")\n ax1.axhline(ref_thr, color='tomato')\n ax1.text(max(truth) - pad, ref_thr - pad, 'Reference repeat count',\n bbox=bbox, ha=\"right\", va=\"top\")\n\n ax1.set_xlabel(r'Num of CAG repeats inserted ($\\mathit{h}$)')\n ax1.set_ylabel('Num of CAG repeats called')\n ax1.set_title(r'Simulated haploid $\\mathit{h}$')\n ax1.legend(['Manta', 'Isaac', 'GATK', 'lobSTR', 'Truth'], loc='best')\n\n max_insert = 120\n # ax2: lobSTR vs TREDPARSE with haploid model\n lobstr_results = parse_results(\"lobstr_results_homo.txt\")\n tredparse_results = parse_results(\"tredparse_results_homo.txt\")\n truth = range(10, max_insert + 1)\n lx, ly = zip(*lobstr_results)\n tx, ty = zip(*tredparse_results)\n\n ax2.plot(lx, ly, 'c+-')\n ax2.plot(tx, ty, 'gx-')\n ax2.plot(truth, truth, 'k--')\n\n ax2.set_xlabel(r'Num of CAG repeats inserted ($\\mathit{h}$)')\n ax2.set_ylabel('Num of CAG repeats called')\n ax2.set_title(r'Simulated haploid $\\mathit{h}$')\n ax2.legend(['lobSTR', 'TREDPARSE', 'Truth'], loc='best')\n\n pad *= 2\n ax2.axhline(infected_thr, color='tomato')\n ax2.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\n bbox=bbox, ha=\"right\")\n ax2.set_xlim(10, max_insert)\n\n # ax3: lobSTR vs TREDPARSE with haploid model\n lobstr_results = parse_results(\"lobstr_results_het.txt\", exclude=20)\n tredparse_results = parse_results(\"tredparse_results_het.txt\", exclude=20)\n truth = range(10, max_insert + 1)\n lx, ly = zip(*lobstr_results)\n tx, ty = zip(*tredparse_results)\n\n ax3.plot(lx, ly, 'c+-')\n ax3.plot(tx, ty, 'gx-')\n ax3.plot(truth, truth, 'k--')\n\n ax3.set_xlabel(r'Num of CAG repeats inserted ($\\mathit{h}$)')\n ax3.set_ylabel('Num of CAG repeats called')\n ax3.set_title(r'Simulated diploid $\\mathit{20/h}$')\n ax3.legend(['lobSTR', 'TREDPARSE', 'Truth'], loc='best')\n ax3.axhline(infected_thr, color='tomato')\n ax3.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\n bbox=bbox, ha=\"right\")\n ax3.set_xlim(10, max_insert)\n\n root = fig.add_axes([0, 0, 1, 1])\n pad = .03\n panel_labels(root, ((pad / 2, 1 - pad, \"A\"), (1 / 3., 1 - pad, \"B\"),\n (2 / 3., 1 - pad, \"C\")))\n normalize_axes(root)\n\n image_name = pf + \".\" + iopts.format\n savefig(image_name, dpi=iopts.dpi, iopts=iopts)","def ablationPlot():\n fig, ax = plt.subplots()\n x = pickle.load(open(\"pickles/ablation_tau_x.pkl\", \"rb\"))\n averages = pickle.load(open(\"pickles/ablation_tau_y.pkl\", \"rb\"))\n stds = pickle.load(open(\"pickles/ablation_tau_stds.pkl\", \"rb\"))\n plt.xlabel(\"Intensity Percentile of YFP-tau and DAPI Ablated\", fontname=\"Times New Roman\", fontsize=12) \n x = [val * 100 for val in x]\n x_vals = ax.get_xticks()\n x_vals = np.insert(x_vals, 0, 0)\n ax.set_xticklabels(['{:,.0%}'.format(x_val) for x_val in x_vals], fontname=\"Times New Roman\")\n ax.axhline(.53, linestyle=\"--\", color='black', lw=.80, alpha=0.8)\n ax.errorbar(x, averages, yerr=stds, capsize=1.5, elinewidth=.2, ecolor=\"black\", label=\"ML Model\")\n ax.set_ylabel(\"Average Pearson Correlation Over Test Set\", fontname=\"Times New Roman\", fontsize=12)\n plt.axis((-.02,102,0,1))\n plt.title(\"Pearson Performance with Increasing Ablations\", fontname=\"Times New Roman\", fontsize=14)\n for tick in ax.get_xticklabels():\n tick.set_fontname(\"Times New Roman\")\n for tick in ax.get_yticklabels():\n tick.set_fontname(\"Times New Roman\")\n plt.savefig(\"matplotlib_figures/ablation.png\", dpi=300)","def analyze(data):\n # perform fit\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\n print(regr_results.tvalues)\n \n fig = plt.figure(figsize=(6, 9))\n\n # plot predicted vs. measured mosquito populations from fitted model \n ax0 = fig.add_subplot(3, 1, 1)\n\n parameters = regr_results.params\n predicted = (parameters['Intercept'] + \n parameters['temperature'] * data['temperature'] + \n parameters['rainfall'] * data['rainfall'])\n\n ax0.plot(predicted, data['mosquitos'], 'gd')\n\n ax0.set_xlabel('predicted mosquito population')\n ax0.set_ylabel('measured mosquito population')\n \n # plot mosquitos vs. temperature\n ax1 = fig.add_subplot(3, 1, 2)\n\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\n ax1.set_xlabel('temperature')\n ax1.set_ylabel('mosquitos')\n\n # plot mosquitos vs. rainfall\n ax2 = fig.add_subplot(3, 1, 3)\n\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\n ax2.set_xlabel('rainfall')\n ax2.set_ylabel('mosquitos')\n \n # adjust layout of axes according to label placement\n plt.tight_layout()\n \n return fig","def PlotEX(df, eom=None, show_plot=True):\n # Ensure 'Study' is in header.\n # TODO: Add code.\n # Obtain exceedence probabilities.\n if eom:\n df_excd = stats.AnnualExceedence(df, eom=eom)\n else:\n df_excd = stats.MonthlyExceedence(df)\n # Get list of variables.\n var_list = set(df_excd.columns.get_level_values('Part B'))\n # Determine number of axes in the figure.\n n_var = len(var_list)\n n_row = np.int(np.around(np.sqrt(n_var)))\n if n_row**2 >= n_var:\n n_col = n_row\n else:\n n_col = n_row + 1\n fig, ax = plt.subplots(nrows=n_row, ncols=n_col, figsize=(16, 9))\n # Remove extra axes, if necessary.\n if n_row * n_col != n_var:\n n_empty = n_row * n_col - n_var\n for k in range(n_empty):\n ax[-1, -(1+k)].remove()\n # Initialize variables for updating axes.\n cur_row = 0\n cur_col = 0\n # Plot each variable.\n for var in var_list:\n df_exc = df_excd.xs(var, level='Part B', axis=1)\n # Initialize parameters for current axis.\n y_min = np.min(df_exc.values)\n y_max = np.max(df_exc.values)\n col_var = df_exc.columns\n # Select current axis.\n if n_row == 1 and n_col == 1:\n ax_cur = ax\n elif n_row == 1:\n ax_cur = ax[cur_col]\n else:\n ax_cur = ax[cur_row, cur_col]\n # Plot study results for each variable.\n for c in col_var:\n sr_plot = df_exc[c]\n label_c = '{} {}'.format(*c[:2])\n ax_cur.plot(sr_plot, label=label_c, linewidth=1.0, alpha=0.7)\n # Set plot title.\n if eom:\n month_name = dt.date(1900, eom, 1).strftime('%B')\n temp_title = 'Exceedence Plot of {} (End of {})'\n ax_cur.set_title(temp_title.format(var, month_name))\n else:\n ax_cur.set_title('Exceedence Plot of {} (All Months)'.format(var))\n # Modify x-axis and y-axis.\n label_c = set(df_exc.columns.get_level_values('Part C'))\n _unit = df_exc.columns.get_level_values('Units')\n _dtyp = df_exc.columns.get_level_values('Data Type')\n unit_d = list(zip(_unit, _dtyp))\n combo_unit = [' '.join(i) for i in unit_d]\n label_u = set(combo_unit)\n ax_cur.set_ylabel('{} ({})'.format(r'/'.join(label_c),\n r'/'.join(label_u)))\n ax_cur.set_ylim(bottom=y_min, top=y_max)\n ax_cur.set_xlabel('Exceedance Probability')\n ax_cur.spines['right'].set_visible(False)\n ax_cur.spines['top'].set_visible(False)\n # Set legend.\n ax_cur.legend(title='Study, Part F')\n # Update current axis.\n cur_col += 1\n if cur_col >= n_col:\n cur_col = 0\n cur_row += 1\n # Adjust layout.\n plt.tight_layout()\n # Add figure notes.\n t = PlotChartNotes()\n if n_row * n_col != n_var:\n x_pos = (1 - n_empty / n_col) + 0.025\n y_pos = (1 / n_row) - 0.025\n plt.figtext(x_pos, y_pos, t, ha='left', va='top', wrap=True)\n else:\n plt.figtext(0.05, 0, t, ha='left', va='bottom', wrap=True)\n plt.subplots_adjust(bottom=0.2)\n # Show plot, if requested.\n if show_plot:\n plt.show()\n # Return figure and axes.\n return fig, ax","def compare_plot_outcome(data_lastDV):\n # TODO: These should be box plots, not bar plots\n col_names = data_lastDV.columns.values.tolist() # get the columns' names\n outcome = col_names.pop() # remove the last item in the list\n\n dimension = 2 # TODO: figure out better way to organize plots by location\n\n fig = plt.figure()\n i = 1\n for cond in col_names:\n ax = fig.add_subplot(len(col_names)/dimension, dimension, i)\n #df_compare = pd.concat([data.groupby(cond)[cond].count(), data.groupby(cond)[outcome].mean()], axis=1) # displays num helpers selected in each condition\n df_compare = data_lastDV.groupby(cond)[outcome].mean() # displays num helpers selected in each condition\n ax = df_compare.plot(kind='bar', title=cond)\n ax.set_xlabel(cond)\n ax.set_ylabel(\"mean \" + outcome)\n i += 1\n fig.tight_layout()\n plt.show()","def plot_diagram(probs, labels, y_axis='accuracy'):\n probs_labels = [(prob, labels[i]) for i, prob in enumerate(probs)]\n probs_labels = np.array(sorted(probs_labels, key=lambda x: x[0]))\n window_len = int(len(labels)/100.)\n calibration_errors = []\n confidences = []\n accuracies = []\n # More interesting than length of the window (which is specific to this\n # window) is average distance between datapoints. This normalizes by dividing\n # by the window length.\n distances = []\n for i in range(len(probs_labels)-window_len):\n distances.append((\n probs_labels[i+window_len, 0] - probs_labels[i, 0])/float(window_len))\n # It's pretty sketchy to look for the 100 datapoints around this one.\n # They could be anywhere in the probability simplex. This introduces bias.\n mean_confidences = mean(probs_labels[i:i + window_len, 0])\n confidences.append(mean_confidences)\n class_accuracies = mean(probs_labels[i:i + window_len, 1])\n accuracies.append(class_accuracies)\n calibration_error = class_accuracies-mean_confidences\n calibration_errors.append(calibration_error)\n\n if y_axis == 'accuracy':\n fig, ax = plt.subplots()\n fig.set_size_inches(5, 5)\n xbins = [i/10. for i in range(11)]\n ax.plot(confidences, accuracies, color='green')\n ax.plot(xbins, xbins, color='orange')\n ax.set_xlabel('Model Confidence')\n ax.set_ylabel('Model Accuracy')\n elif y_axis == 'error':\n fig, ax = plt.subplots()\n fig.set_size_inches(5, 5)\n xbins = [i/10. for i in range(11)]\n ax.plot(confidences, calibration_errors, color='green')\n ax.plot(xbins, xbins, color='orange')\n ax.set_xlabel('Model Confidence')\n ax.set_ylabel('Model Calibration Error')\n ax.set_title('Reliability Diagram', fontsize=20)\n return fig","def plot_figures(compare_df, compare_df_without_1_5, over_3, over_6, ppm, \n color_prob, color_count, edgecolor): \n # Create a gridspec to plot in\n fig = plt.figure()\n gs = fig.add_gridspec(2,4)\n ax1 = fig.add_subplot(gs[0,:])\n ax2 = fig.add_subplot(gs[1,:2])\n ax3 = fig.add_subplot(gs[1,2])\n ax4 = fig.add_subplot(gs[1,3])\n \n ##### Plot the total count\n compare_df.plot(kind=\"bar\", ax=ax1,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor )\n ax1.set_title(\"a) Temperature count in AR5 working group reports and special reports until 2020\")\n \n #### Plot without the 1.5 special report\n compare_df_without_1_5.plot(kind=\"bar\", ax=ax2, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax2.set_title(\"b) Excluding special report on 1.5°C warming\")\n plt.setp(ax2.xaxis.get_majorticklabels(), fontsize=6)\n \n #### Plot 3\n over_3.plot(kind=\"bar\", ax=ax3, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax3.set_title(\"c) 3°C and above\")\n plt.setp(ax3.xaxis.get_majorticklabels(), color=\"white\")\n \n #### Plot only 6 degrees and above\n over_6.plot(kind=\"bar\", ax=ax4, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax4.set_title(\"d) 6°C and above\")\n plt.setp(ax4.xaxis.get_majorticklabels(), color=\"white\")\n \n # make nicer\n i = 0\n for ax in [ax1, ax2, ax3, ax4]:\n ax.set_ylabel(\"Percentage [%]\")\n if i == 0:\n plot_nicer(ax)\n else: \n plot_nicer(ax, with_legend=False)\n plt.setp(ax.xaxis.get_majorticklabels(), rotation=0)\n i +=1\n \n fig=plt.gcf()\n fig.set_size_inches(12,6)\n fig.tight_layout()\n plt.savefig(\"Figures\" + os.sep + \"warming_count_\"+str(ppm)+\".png\",dpi=200, bbox_inches=\"tight\")\n plt.close()","def plot_actual_vs_predicted_by_equations(df, x_variable, y_variables, plot_title):\n #Plot results\n df.plot(x=x_variable, y=y_variables, title=plot_title)\n plt.show()","def test_all_plots_working(self):\n optimizer = \"RandomSearch\"\n name = \"test_init_experiment\"\n param_defs = {\n \"x\": MinMaxNumericParamDef(0, 1),\n \"name\": NominalParamDef([\"A\", \"B\", \"C\"])\n }\n minimization = True\n\n LAss = PrettyLabAssistant()\n LAss.init_experiment(name, optimizer, param_defs, minimization=minimization)\n LAss.init_experiment(name + \"2\", optimizer, param_defs, minimization=minimization)\n cand = LAss.get_next_candidate(name)\n cand.result = 1\n LAss.update(name, cand)\n LAss.write_out_plots_current_step()\n LAss.plot_result_per_step([name], show_plot=False)\n LAss.exp_assistants[name].experiment.minimization_problem = False\n LAss.plot_result_per_step(name, show_plot=False)","def isotropic_correction(self):\n isob = self.IsotropicCorrection(self,'back')\n isof = self.IsotropicCorrection(self,'front')\n sindec = np.sin(np.radians(np.array(self.df.dec.values,float)))\n fig, axx = plt.subplots(1,2, figsize=(12,5), sharey=True)\n ax=axx[1]\n for i in range(2):\n ax.plot(sindec, isob(i), '.', label='Energy Bin {}'.format(i));\n ax.set(xlabel='sin(Dec)', title='Back correction vs. Dec.')\n\n ax=axx[0]\n for f, name in [(isof, 'Front'), (isob, 'Back')]:\n means = [f(i)[np.abs(sindec)<0.25].mean() for i in range(8)]\n ax.plot(means, 'o', label=name)\n ax.set_title('Correction factor vs Energy Bin')\n ax.set(xlabel='Energy Bin',ylabel='Correction Factor',)\n\n for ax in axx:\n ax.grid(alpha=0.5);\n ax.axhline(1.0, color='k', ls='--')\n ax.legend()\n\n return fig","def ex1_plots(instance, destination, prefix, save, animate):\n \n plts = ukf_plots(instance, destination, prefix, save, animate)\n\n truths = truth_parser(instance)\n nan_array= nan_array_parser(instance, truths, instance.base_model)\n #obs, obs_key = obs_parser(instance, True)\n obs_key = obs_key_parser(instance, True)\n preds = preds_parser(instance, True)\n #forecasts = forecasts_parser(instance, True)\n \n ukf_params = instance.ukf_params\n index2 = ukf_params[\"index2\"]\n \n \"remove agents not in model to avoid wierd plots\"\n #obs *= nan_array\n truths *= nan_array\n preds *= nan_array\n #forecasts*= nan_array\n \n \"indices for unobserved agents\"\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\n plts.pair_frame(truths, preds, obs_key, 10, destination)\n plts.error_hist(truths[::instance.sample_rate,index2], \n preds[::instance.sample_rate,index2],\"Observed Errors\")\n if len(not_index2)>0:\n plts.error_hist(truths[::instance.sample_rate, not_index2], \n preds[::instance.sample_rate, not_index2],\"Unobserved Errors\")\n \n #plts.path_plots(obs[::instance.sample_rate] , \"Observed\")\n plts.path_plots(preds[::instance.sample_rate], \"Predicted\")\n plts.path_plots(truths, \"True\")\n #plts.path_plots(forecasts[::instance.sample_rate], \"Forecasts\")\n\n if animate:\n #plts.trajectories(truths, \"plots/\")\n plts.pair_frames(truths, preds, obs_key,\n truths.shape[0], \"../../plots/\")","def show_plots(history):\n loss_vals = history['loss']\n val_loss_vals = history['val_loss']\n epochs = range(1, len(history['accuracy'])+1)\n \n f, ax = plt.subplots(nrows=1,ncols=2,figsize=(16,4))\n \n # plot losses on ax[0]\n ax[0].plot(epochs, loss_vals, color='navy',marker='o', linestyle=' ', label='Training Loss')\n ax[0].plot(epochs, val_loss_vals, color='firebrick', marker='*', label='Validation Loss')\n ax[0].set_title('Training & Validation Loss')\n ax[0].set_xlabel('Epochs')\n ax[0].set_ylabel('Loss')\n ax[0].legend(loc='best')\n ax[0].grid(True)\n \n # plot accuracies\n acc_vals = history['accuracy']\n val_acc_vals = history['val_accuracy']\n\n ax[1].plot(epochs, acc_vals, color='navy', marker='o', ls=' ', label='Training Accuracy')\n ax[1].plot(epochs, val_acc_vals, color='firebrick', marker='*', label='Validation Accuracy')\n ax[1].set_title('Training & Validation Accuracy')\n ax[1].set_xlabel('Epochs')\n ax[1].set_ylabel('Accuracy')\n ax[1].legend(loc='best')\n ax[1].grid(True)\n \n plt.show()\n plt.close()\n \n # delete locals from heap before exiting\n del loss_vals, val_loss_vals, epochs, acc_vals, val_acc_vals","def plot(self):\n fig = plt.figure()\n ax = plt.gca()\n ax.errorbar(self.sample_bins, self.test_scores.mean(axis=1),\n yerr=self.test_scores.std(axis=1), fmt='r.-',\n label='test')\n ax.errorbar(self.sample_bins, self.train_scores.mean(axis=1),\n yerr=self.train_scores.std(axis=1), fmt='b.-',\n label='train')\n ax.legend(loc='upper right')\n return ax","def plot(self):\n fig, axes = plt.subplots(math.ceil(len(self.plots) / self.col_wrap), self.col_wrap)\n\n for ps, ax in zip(self.plots, axes.flatten()):\n for p in ps:\n if p.x is not None and p.y is not None:\n p.method(x=p.x, y=p.y, *p.args, ax=ax, **p.kwargs)\n else:\n p.method(*p.args, ax=ax, **p.kwargs)\n\n return fig, axes","def summarize_diagnostics(self):\n # plot loss\n pyplot.subplot(211)\n pyplot.title('Cross Entropy Loss')\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\n # plot accuracy\n pyplot.subplot(212)\n pyplot.title('Classification Accuracy')\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\n # save plot to file\n pyplot.savefig(f'{self.project_home / \"o\"}/{self.model.name}_plot.png')\n pyplot.close()","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plot_variables(self, n, show=False, diagnostics=False):\n\n if diagnostics:\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\n else:\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\n\n plt.subplots_adjust(hspace = 0)\n end = len(n.history[\"det F\"])\n epochs = np.arange(end)\n a, = ax[0].plot(epochs, n.history[\"det F\"], label = 'Training data')\n b, = ax[0].plot(epochs, n.history[\"det test F\"], label = 'Test data')\n # ax[0].axhline(y=5,ls='--',color='k')\n ax[0].legend(frameon = False)\n ax[0].set_ylabel(r'$|{\\bf F}_{\\alpha\\beta}|$')\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\"det test F\"][-1])\n ax[1].plot(epochs, n.history[\"loss\"])\n ax[1].plot(epochs, n.history[\"test loss\"])\n # ax[1].set_xlabel('Number of epochs')\n ax[1].set_ylabel(r'$\\Lambda$')\n ax[1].set_xlim([0, len(epochs)]);\n \n if diagnostics:\n ax[2].plot(epochs, n.history[\"det C\"])\n ax[2].plot(epochs, n.history[\"det test C\"])\n # ax[2].set_xlabel('Number of epochs')\n ax[2].set_ylabel(r'$|{\\bf C}|$')\n ax[2].set_xlim([0, len(epochs)]);\n \n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,0]\n , color = 'C0', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,1]\n , color = 'C0', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n \"\"\"\n\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,0]\n , color = 'C1', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,1]\n , color = 'C1', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n ax[3].legend(frameon=False)\n \"\"\"\n\n ax[3].set_ylabel(r'$\\partial\\mu/\\partial\\theta$')\n # ax[3].set_xlabel('Number of epochs')\n ax[3].set_xlim([0, len(epochs)])\n\n # Mean of network output summary 1\n ax[4].plot(epochs, np.array(n.history[\"μ\"])[:,0],alpha=0.5)\n # Mean of test output network summary 1\n ax[4].plot(epochs, np.array(n.history[\"test μ\"])[:,0],alpha=0.5)\n ax[4].set_ylabel('μ')\n ax[4].set_xlabel('Number of epochs')\n ax[4].set_xlim([0, len(epochs)])\n \n\n print ('Maximum Fisher info on train data:',np.max(n.history[\"det F\"]))\n print ('Final Fisher info on train data:',(n.history[\"det F\"][-1]))\n \n print ('Maximum Fisher info on test data:',np.max(n.history[\"det test F\"]))\n print ('Final Fisher info on test data:',(n.history[\"det test F\"][-1]))\n\n if np.max(n.history[\"det test F\"]) == n.history[\"det test F\"][-1]:\n print ('Promising network found, possibly more epochs needed')\n\n plt.tight_layout()\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\n if show: plt.show()\n plt.close()"],"string":"[\n \"def _diagnostic_plot(self):\\n if not hasattr(self, \\\"corrected_lc\\\"):\\n raise ValueError(\\n \\\"Please call the `correct()` method before trying to diagnose.\\\"\\n )\\n\\n with plt.style.context(MPLSTYLE):\\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=True)\\n ax = axs[0]\\n self.lc.plot(ax=ax, normalize=False, label=\\\"original\\\", alpha=0.4)\\n for key in self.diagnostic_lightcurves.keys():\\n (\\n self.diagnostic_lightcurves[key]\\n - np.median(self.diagnostic_lightcurves[key].flux)\\n + np.median(self.lc.flux)\\n ).plot(ax=ax)\\n ax.set_xlabel(\\\"\\\")\\n ax = axs[1]\\n self.lc.plot(ax=ax, normalize=False, alpha=0.2, label=\\\"original\\\")\\n self.corrected_lc[self.outlier_mask].scatter(\\n normalize=False, c=\\\"r\\\", marker=\\\"x\\\", s=10, label=\\\"outlier_mask\\\", ax=ax\\n )\\n self.corrected_lc[~self.cadence_mask].scatter(\\n normalize=False,\\n c=\\\"dodgerblue\\\",\\n marker=\\\"x\\\",\\n s=10,\\n label=\\\"~cadence_mask\\\",\\n ax=ax,\\n )\\n self.corrected_lc.plot(normalize=False, label=\\\"corrected\\\", ax=ax, c=\\\"k\\\")\\n return axs\",\n \"def test_get_axes():\\n fig, axs = plt.subplots()\\n assert all(\\n isinstance(ax, mpl.axes.Axes)\\n for ax in prettypyplot.tools.get_axes(axs)\\n )\\n assert all(\\n isinstance(ax, mpl.axes.Axes)\\n for ax in prettypyplot.tools.get_axes(None)\\n )\\n with pytest.raises(TypeError):\\n prettypyplot.tools.get_axes(fig)\",\n \"def plot_insta_err(self, ax=None):\\n if ax is None:\\n ax = plt.gca()\\n ax.set_yscale('log')\\n ax.plot(list(range(1, self.max_dets)), self.errors[0], label='independent')\\n ax.plot(list(range(1, self.max_dets)), self.errors[1], label='correlated')\\n ax.set_ylabel(r'Stochastic error in $E_\\\\mathrm{corr}$ / ha')\\n ax.set_xlabel('Number of determinants in estimator')\\n ax.axhline(np.sqrt(self.proje_var[0]), linestyle='--', color='black', label='reference')\\n ax.legend()\\n return ax\",\n \"def analysis_plot(predictions, ys):\\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\\n\\n residuals = ys - predictions\\n\\n # Plot 1 - Predicted vs Actual\\n sns.scatterplot(predictions, ys, ax=ax1)\\n ax1.set_title('Predicted vs Actual', fontsize=20)\\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\\n\\n # Plot 2 - Residuals PLot (predicted vs residuals)\\n sns.scatterplot(predictions, residuals, ax=ax2)\\n ax2.set_title('Residuals Plot', fontsize=20)\\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\\n\\n # Plot 3 - QQ Plot\\n sm.qqplot(residuals, ax=ax3, line='s')\\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\\n\\n plt.show();\",\n \"def plot_err(self, expect=False, axallerr=None):\\n if axallerr is None:\\n axallerr = plt.gca()\\n axallerr.set_yscale('log')\\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[0], label='independent')\\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[1], label='correlated (actual)')\\n if expect:\\n axallerr.plot(list(range(1, self.max_dets)), self.expcor_err, label='correlated (expected)')\\n axallerr.set_ylabel(r'Stochastic error in $\\\\Delta E$ / ha')\\n axallerr.set_xlabel('Number of determinants in estimator')\\n axallerr.axhline(np.sqrt(self.proje_var[0]) / np.sqrt(self.result.shape[2]),\\n linestyle='--', color='black', label='reference')\\n axallerr.legend()\\n return axallerr\",\n \"def test_parse_axes():\\n fig, ax = plt.subplots()\\n\\n # parse correct ax in ax\\n argsref = (1, 'a', np.arange(2))\\n argsax = prettypyplot.tools.parse_axes(*argsref, ax=ax)\\n assert all(\\n isinstance(ref, type(parse))\\n for ref, parse in zip(argsref, argsax[0])\\n )\\n assert ax is argsax[1]\\n\\n # multiple axes\\n with pytest.raises(ValueError):\\n prettypyplot.tools.parse_axes(ax, ax=ax)\\n with pytest.raises(ValueError):\\n prettypyplot.tools.parse_axes(1, ax, ax=ax)\\n with pytest.raises(ValueError):\\n prettypyplot.tools.parse_axes(ax, ax, 1, ax=None)\\n\\n argsax = prettypyplot.tools.parse_axes(ax, ax=None)\\n assert ax is argsax[1]\\n\\n argsax = prettypyplot.tools.parse_axes(ax=ax)\\n assert ax is argsax[1]\",\n \"def robustnessPlot(ax):\\n # Setup the range of avidity and ligand concentration we'll look at\\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\\n\\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\\n columns=['gnus', 'Los'])\\n\\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\\n\\n # Change avidities to strings\\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\\\nu=' + str(int(gnu)) + '$')\\n\\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\\n\\n # Plot the calculated crossvalidation performance\\n sns.FacetGrid(pp,\\n hue='gnus',\\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\\n\\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\\n\\n ax.set_xlabel('Assumed IC Conc. (M)')\\n ax.set_ylabel('LOO Prediction R-Squared')\\n ax.set_ylim(0.0, 1.0)\",\n \"def test_plotting():\\n out_dir = _TempDir()\\n fname, behf, corrupted = make_raw(out_dir)\\n raw = _read_raw(fname, preload=True)\\n pd = raw._data[0]\\n candidates = _find_pd_candidates(\\n pd, max_len=max_len, baseline=baseline,\\n zscore=zscore, max_flip_i=max_flip_i, sfreq=raw.info['sfreq'])[0]\\n beh = _read_tsv(behf)\\n beh_events = np.array(beh['fix_onset_time']) * raw.info['sfreq']\\n beh_events_adjusted, alignment, events = _find_best_alignment(\\n beh_events, candidates, exclude_shift, resync, raw.info['sfreq'],\\n verbose=False)\\n errors = beh_events_adjusted - events + alignment\\n _plot_trial_errors(beh_events_adjusted, alignment, events,\\n errors, exclude_shift, raw.info['sfreq'])\\n errors[abs(errors) / raw.info['sfreq'] > 2 * exclude_shift] = np.nan\\n np.testing.assert_array_almost_equal(\\n plt.gca().lines[0].get_ydata(), errors)\\n section_data = [(0, 'test', np.random.random(10))]\\n _plot_excluded_events(section_data, 2)\\n assert plt.gca().title.get_text() == 'test'\\n np.testing.assert_array_equal(plt.gca().lines[0].get_ydata(),\\n section_data[0][2])\",\n \"def plot(guess_log, counter_log, x):\\n correct_sqrt = np.sqrt(x)\\n x_axis = np.linspace(-1, 1.1*len(guess_log), len(guess_log))\\n y_axis = np.ones(len(guess_log))*correct_sqrt\\n plt.plot(counter_log, guess_log, 'ok')\\n plt.plot(x_axis, y_axis, '--r', linewidth=2.0, label='Correct Answer')\\n plt.axis([-1, max(x_axis), -0.1*max(guess_log), 1.1*max(guess_log)])\\n plt.xlabel('Iterations')\\n plt.ylabel('Guess')\\n plt.legend(loc = 'upper right')\\n plt.show()\\n return 0\",\n \"def reconstruction_errors(identifier, train_errors, vali_errors,\\n generated_errors, random_errors):\\n print(identifier)\\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\\n axarr[0].set_title(\\\"train reconstruction errors\\\")\\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\\n axarr[1].set_title('vali reconstruction errors')\\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\\n axarr[2].set_title('generated reconstruction errors')\\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\\n axarr[3].set_title('random reconstruction errors')\\n for ax in axarr:\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"left\\\"].set_visible(False)\\n ax.tick_params(bottom='off', left='off')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n axarr[3].set_xlim(0, 0.05)\\n plt.tight_layout()\\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\\n return True\",\n \"def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\\n if axdelta is None:\\n axdelta = plt.gca()\\n delta = self.means - exact\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\\n if blocked:\\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\\n if blockederr:\\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\\n axdelta.set_xlabel('Number of determinants in estimator')\\n axdelta.set_ylabel(r'$E-E_\\\\mathrm{CCSD}$ / ha')\\n axdelta.legend()\\n return axdelta\",\n \"def plot_result(numerical, exact):\\n \\n numx, numy = numerical\\n exax, exay = exact\\n plt.title('Comparison Numerical vs. Analytical Solution')\\n plt.xlabel('Distance x (m)')\\n plt.ylabel('Temperature $(^{o}C)$')\\n plt.plot(numx, numy, 'ro', label='numerical')\\n plt.plot(exax, exay, 'y--', label='analytical')\\n plt.legend()\\n plt.grid()\",\n \"def test_plotting():\\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\\n specs['interpolxydecs'][:, 1], specs['xopt'])\\n\\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\\n potdata = np.vstack((xint, yint)).T\\n\\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\\n\\n expvaldata = np.vstack((expval, uncval)).T\\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\\n\\n # qm_plottings('tests/test_data', scale=0.5)\\n # assert True\",\n \"def plot_various_confidences(self, graph_name, drop_rate, data_format,\\n Y, directory='./attack_data/',\\n confs=(0.0, 10.0, 20.0, 30.0, 40.0),\\n get_attack_data_name=lambda c: \\\"example_carlini_\\\"+str(c)):\\n import matplotlib.pyplot as plt\\n import pylab\\n\\n pylab.rcParams['figure.figsize'] = 6, 4\\n fig = plt.figure(1, (6, 4))\\n ax = fig.add_subplot(1, 1, 1)\\n\\n det_only = []\\n ref_only = []\\n both = []\\n none = []\\n\\n print(\\\"Drop Rate:\\\", drop_rate)\\n thrs = self.operator.get_thrs(drop_rate)\\n\\n all_pass, _detector = self.operator.filter(self.operator.data.test_data, thrs)\\n all_on_acc, _, _, _ = self.get_normal_acc(all_pass)\\n\\n print(_detector)\\n print(\\\"Classification accuracy with all defense on:\\\", all_on_acc)\\n\\n for confidence in confs:\\n f = get_attack_data_name(confidence)\\n attack_data = AttackData(f, Y, \\\"Carlini L2 \\\" + str(confidence), directory=directory,\\n input_data_format=CHANNELS_LAST, data_format=data_format)\\n # compute number of all input data and filter out valid data\\n total = len(attack_data.data)\\n valid_adv_idx = np.argwhere(np.sum(attack_data.data, axis=(1, 2, 3)) > [0] * total).flatten()\\n attack_data.data = attack_data.data[valid_adv_idx]\\n attack_data.labels = attack_data.labels[valid_adv_idx]\\n self.load_data(attack_data)\\n\\n print(\\\"Confidence:\\\", confidence)\\n valid_adv_len = len(valid_adv_idx)\\n print(\\\"valid attack %d/%d\\\" % (valid_adv_len, total))\\n all_pass, detector_breakdown = self.operator.filter(self.untrusted_data.data, thrs)\\n both_acc, det_only_acc, ref_only_acc, none_acc = self.get_attack_acc(all_pass)\\n print(detector_breakdown)\\n both.append(both_acc)\\n det_only.append(det_only_acc)\\n ref_only.append(ref_only_acc)\\n none.append(none_acc)\\n\\n size = 2.5\\n plt.plot(confs, none, c=\\\"green\\\", label=\\\"No fefense\\\", marker=\\\"x\\\", markersize=size)\\n plt.plot(confs, det_only, c=\\\"orange\\\", label=\\\"With detector\\\", marker=\\\"o\\\", markersize=size)\\n plt.plot(confs, ref_only, c=\\\"blue\\\", label=\\\"With reformer\\\", marker=\\\"^\\\", markersize=size)\\n plt.plot(confs, both, c=\\\"red\\\", label=\\\"With detector & reformer\\\", marker=\\\"s\\\", markersize=size)\\n\\n pylab.legend(loc='lower left', bbox_to_anchor=(0.02, 0.1), prop={'size':8})\\n plt.grid(linestyle='dotted')\\n plt.xlabel(r\\\"Confidence in Carlini $L^2$ attack\\\")\\n plt.ylabel(\\\"Classification accuracy\\\")\\n plt.xlim(min(confs)-1.0, max(confs)+1.0)\\n plt.ylim(-0.05, 1.05)\\n ax.yaxis.set_major_formatter(FuncFormatter('{0:.0%}'.format))\\n\\n save_path = os.path.join(self.graph_dir, graph_name+\\\".pdf\\\")\\n plt.savefig(save_path)\\n plt.clf()\",\n \"def _check_axes(axes):\\n _check_type(axes, (Axes, np.ndarray), \\\"axes\\\")\\n if isinstance(axes, np.ndarray):\\n if axes.ndim == 1:\\n for ax in axes:\\n _check_type(ax, (Axes,))\\n assert hasattr(ax, \\\"plot\\\") # sanity-check\\n elif axes.ndim == 2:\\n for i, j in product(range(axes.shape[0]), range(axes.shape[1])):\\n _check_type(axes[i, j], (Axes,))\\n assert hasattr(axes[i, j], \\\"plot\\\") # sanity-check\\n else:\\n raise ValueError(\\n \\\"Argument 'axes' should be a matplotib axes or a \\\"\\n \\\"1D or 2D numpy array of matplotlib axes.\\\"\\n )\\n else:\\n # sanity-check\\n assert hasattr(axes, \\\"plot\\\")\\n return axes\",\n \"def getPlot(self):\\n return self.axes\",\n \"def figure1():\\n\\n plot_settings = {'y_limits': [-80, -50],\\n 'x_limits': None,\\n 'y_ticks': [-80, -70, -60, -50],\\n 'locator_size': 5,\\n 'y_label': 'Voltage (mV)',\\n 'x_ticks': [],\\n 'scale_size': 20,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_1',\\n 'legend_size': 8,\\n 'legend': None,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n plt.figure(figsize=(5, 2)) # Create figure\\n plt.plot(t, y[:, 0], 'k-') # Plot solution\\n\\n \\\"\\\"\\\"\\n Annotate plot with figures\\n \\\"\\\"\\\"\\n plt.gca().annotate('fAHP', xy=(13.5, -65), xytext=(17, -60),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n plt.gca().annotate('ADP', xy=(15.5, -66), xytext=(25, -65),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n plt.gca().annotate('mAHP', xy=(38, -77), xytext=(43, -72),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def testPlotCandidateDesign(self):\\n\\n np.random.seed(0)\\n new_data = pd.concat([self.test_data, self.add_pair], sort=False)\\n test_class = TrimmedMatchGeoXDesign(\\n GeoXType.HEAVY_UP,\\n pretest_data=new_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n )\\n budget_list = [30, 40]\\n iroas_list = [0, 2]\\n results, _ = test_class.report_candidate_designs(\\n budget_list=budget_list,\\n iroas_list=iroas_list,\\n use_cross_validation=True,\\n num_simulations=10,\\n )\\n\\n axes_dict = test_class.plot_candidate_design(results)\\n for budget in budget_list:\\n for iroas in iroas_list:\\n self.assertIsInstance(axes_dict[(budget, iroas)], plt.Figure)\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def plot_proof_functions():\\n\\n def thm1_D(x):\\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\\n\\n def thm2_D(x):\\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 2, 1000)\\n\\n plt.plot(x, thm1_D(x))\\n plt.xlim(0, 2)\\n plt.ylim(0.15, 0.22)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\\n plt.xticks(range(3), range(3))\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm1_D.pdf')\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 5, 1000)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.plot(x, thm2_D(x))\\n plt.xlim(0, 5)\\n plt.ylim(0, 0.4)\\n plt.xticks(range(6), range(6))\\n\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm2_D.pdf')\",\n \"def test_plot_ppc_ax(models, kind, fig_ax):\\n _, ax = fig_ax\\n axes = plot_ppc(models.model_1, kind=kind, ax=ax)\\n assert np.asarray(axes).item(0) is ax\",\n \"def plot_correction_diagram(fig_name):\\n dir = \\\"log/circular antenna/around car\\\"\\n files = utils.walk_files(dir)\\n pattern_loc = r'.*\\\\\\\\(.*?) (.*?).csv$'\\n radian_ref = 0.2\\n for i in range(len(files)):\\n file = files[i]\\n match_obj = re.match(pattern_loc, file)\\n if (match_obj.groups()[0] == 'left') & (match_obj.groups()[1] == '2m50'):\\n df = pd.read_csv(file, sep=';', decimal=',')\\n df1 = df[df['RSSI ANTENNA PCB'] != 0]\\n rssi = pd.DataFrame(df1['RSSI ANTENNA PCB'])\\n radian = pd.DataFrame(df1['ORIENTATION_X'])\\n radian_mapped = radian.apply(utils.mapping_radian, args=(radian_ref, match_obj.groups()[0],))\\n rssi_corrected = utils.correct_diagram(rssi, radian_mapped)\\n rssi.columns = ['Original']\\n rssi_corrected.columns = ['Corrected']\\n rssi.index = np.arange(rssi.shape[0]) / utils.FREQ_LOG\\n rssi_corrected.index = np.arange(rssi_corrected.shape[0]) / utils.FREQ_LOG\\n\\n plt.figure(figsize=(12, 8))\\n ax1 = plt.subplot(2, 1, 1)\\n rssi.plot(kind='line', ax=ax1)\\n rssi_corrected.plot(kind='line', ax=ax1)\\n plt.title(match_obj.groups()[0] + ' ' + match_obj.groups()[1])\\n plt.title('RSSI Variation over time')\\n plt.xlabel('Time: s')\\n plt.ylabel('RSSI: dBm')\\n\\n ax3 = plt.subplot(2, 2, 3)\\n rssi.plot(kind='density', ax=ax3)\\n rssi_corrected.plot(kind='density', ax=ax3)\\n plt.title('Distribution')\\n plt.xlabel('RSSI: dBm')\\n\\n ax4 = plt.subplot(2, 2, 4)\\n df = pd.DataFrame()\\n df['Original'] = rssi\\n df['Corrected'] = rssi_corrected\\n df.plot(kind='box', ax=ax4)\\n plt.title('Box')\\n plt.ylabel('RSSI: dBm')\\n if not os.path.exists(dir_fig):\\n os.makedirs(dir_fig)\\n plt.savefig(dir_fig + '/' + fig_name + '.png')\",\n \"def calibration_plot(self, analytes=None, datarange=True, loglog=False, save=True):\\n\\n if analytes is None:\\n analytes = [a for a in self.analytes if self.internal_standard not in a]\\n\\n n = len(analytes)\\n if n % 3 is 0:\\n nrow = n / 3\\n else:\\n nrow = n // 3 + 1\\n\\n axes = []\\n\\n if not datarange:\\n fig = plt.figure(figsize=[12, 3 * nrow])\\n else:\\n fig = plt.figure(figsize=[14, 3 * nrow])\\n if not hasattr(self, 'focus'):\\n self.get_focus()\\n\\n gs = mpl.gridspec.GridSpec(nrows=int(nrow), ncols=3,\\n hspace=0.3, wspace=0.3)\\n\\n i = 0\\n for a in analytes:\\n if not datarange:\\n ax = fig.add_axes(gs[i].get_position(fig))\\n axes.append(ax)\\n i += 1\\n else:\\n f = 0.8\\n p0 = gs[i].get_position(fig)\\n p1 = [p0.x0, p0.y0, p0.width * f, p0.height]\\n p2 = [p0.x0 + p0.width * f, p0.y0, p0.width * (1 - f), p0.height]\\n ax = fig.add_axes(p1)\\n axh = fig.add_axes(p2)\\n axes.append((ax, axh))\\n i += 1\\n\\n # plot calibration data\\n ax.errorbar(self.srmtabs.loc[a, 'meas_mean'].values,\\n self.srmtabs.loc[a, 'srm_mean'].values,\\n xerr=self.srmtabs.loc[a, 'meas_err'].values,\\n yerr=self.srmtabs.loc[a, 'srm_err'].values,\\n color=self.cmaps[a], alpha=0.6,\\n lw=0, elinewidth=1, marker='o',\\n capsize=0, markersize=5)\\n\\n # work out axis scaling\\n if not loglog:\\n xlim, ylim = rangecalc(nominal_values(self.srmtabs.loc[a, 'meas_mean'].values),\\n nominal_values(self.srmtabs.loc[a, 'srm_mean'].values),\\n pad=0.1)\\n xlim[0] = 0\\n ylim[0] = 0\\n else:\\n xd = self.srmtabs.loc[a, 'meas_mean'][self.srmtabs.loc[a, 'meas_mean'] > 0].values\\n yd = self.srmtabs.loc[a, 'srm_mean'][self.srmtabs.loc[a, 'srm_mean'] > 0].values\\n\\n xlim = [10**np.floor(np.log10(np.nanmin(xd))),\\n 10**np.ceil(np.log10(np.nanmax(xd)))]\\n ylim = [10**np.floor(np.log10(np.nanmin(yd))),\\n 10**np.ceil(np.log10(np.nanmax(yd)))]\\n\\n # scale sanity checks\\n if xlim[0] == xlim[1]:\\n xlim[0] = ylim[0]\\n if ylim[0] == ylim[1]:\\n ylim[0] = xlim[0]\\n\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n\\n ax.set_xlim(xlim)\\n ax.set_ylim(ylim)\\n\\n # calculate line and R2\\n if loglog:\\n x = np.logspace(*np.log10(xlim), 100)\\n else:\\n x = np.array(xlim)\\n\\n coefs = self.calib_params[a][0]\\n\\n # plot line of best fit\\n line = nominal_values(self.calib_fns[a](coefs, x))\\n ax.plot(x, line, color=(0, 0, 0, 0.5), ls='dashed')\\n\\n if len(coefs) == 1:\\n force_zero = True\\n else:\\n force_zero = False\\n\\n R2 = R2calc(self.srmtabs.loc[a, 'srm_mean'],\\n nominal_values(self.calib_fns[a](coefs, self.srmtabs.loc[a, 'meas_mean'])),\\n force_zero=force_zero)\\n\\n # labels\\n if len(coefs) == 1:\\n label = 'y = {:.2e} x'.format(coefs[0])\\n else:\\n label = r''\\n for n, p in enumerate(coefs):\\n if len(coefs) - n - 1 == 0:\\n label += '{:.1e}'.format(p)\\n elif len(coefs) - n - 1 == 1:\\n label += '{:.1e} x\\\\n+ '.format(p)\\n else:\\n label += '{:.1e}$ x^'.format(p) + '{' + '{:.0f}'.format(len(coefs) - n - 1) + '}$\\\\n+ '\\n\\n if '{:.3f}'.format(R2) == '1.000':\\n label += '\\\\n$R^2$: >0.999'\\n else:\\n label += '\\\\n$R^2$: {:.3f}'.format(R2)\\n\\n ax.text(.05, .95, pretty_element(a), transform=ax.transAxes,\\n weight='bold', va='top', ha='left', size=12)\\n ax.set_xlabel('counts/counts ' + self.internal_standard)\\n ax.set_ylabel('mol/mol ' + self.internal_standard)\\n # write calibration equation on graph\\n ax.text(0.98, 0.04, label, transform=ax.transAxes,\\n va='bottom', ha='right')\\n\\n # plot data distribution historgram alongside calibration plot\\n if datarange:\\n # isolate data\\n meas = nominal_values(self.focus[a])\\n meas = meas[~np.isnan(meas)]\\n\\n # check and set y scale\\n if np.nanmin(meas) < ylim[0]:\\n if loglog:\\n mmeas = meas[meas > 0]\\n ylim[0] = 10**np.floor(np.log10(np.nanmin(mmeas)))\\n else:\\n ylim[0] = 0\\n ax.set_ylim(ylim)\\n\\n # hist\\n if loglog:\\n bins = np.logspace(*np.log10(ylim), 30)\\n else:\\n bins = np.linspace(*ylim, 30)\\n\\n axh.hist(meas, bins=bins, orientation='horizontal',\\n color=self.cmaps[a], lw=0.5, alpha=0.5)\\n\\n if loglog:\\n axh.set_yscale('log')\\n axh.set_ylim(ylim)\\n axh.set_xticks([])\\n axh.set_yticklabels([])\\n\\n if save:\\n fig.savefig(self.report_dir + '/calibration.pdf')\\n\\n return fig, axes\",\n \"def plot_all(m, d, m_est, d_pred, equalize=True):\\n fig = plt.figure(figsize=(10,6))\\n\\n ax0 = fig.add_subplot(2,2,1)\\n ax0.plot(m)\\n t = \\\"$\\\\mathrm{{Model}}\\\\ m.\\\\ \\\\mathrm{{norm}}\\\\ {:.3f}$\\\"\\n ax0.set_title(t.format(norm(m)))\\n ax0_mi, ax0_ma = ax0.get_ylim()\\n\\n ax1 = fig.add_subplot(2,2,2)\\n ax1.plot(d, 'o', mew=0)\\n ax1.set_title(\\\"$\\\\mathrm{Data}\\\\ d$\\\")\\n ax1_mi, ax1_ma = ax1.get_ylim()\\n\\n ax2 = fig.add_subplot(2,2,3)\\n ax2.plot(m, alpha=0.25)\\n ax2.plot(m_est)\\n t = \\\"$\\\\mathrm{{Estimated\\\\ model}}\\\\ m_\\\\mathrm{{est}}.\\\\ \\\\mathrm{{norm}}\\\\ {:.3f}$\\\"\\n ax2.set_title(t.format(norm(m_est)))\\n ax2_mi, ax2_ma = ax2.get_ylim()\\n\\n ax3 = fig.add_subplot(2,2,4)\\n ax3.plot(d, 'o', mew=0, alpha=0.25)\\n ax3.plot(d_pred, 'o', mew=0)\\n t = \\\"$\\\\mathrm{{Predicted\\\\ data}}\\\\ d_\\\\mathrm{{pred}}.\\\\ \\\\mathrm{{misfit}}\\\\ {:.3f}$\\\"\\n ax3.set_title(t.format(misfit(d, d_pred)))\\n ax3_mi, ax3_ma = ax3.get_ylim()\\n\\n if equalize:\\n ax0.set_ylim(min(ax0_mi, ax2_mi) - 0.1,\\n max(ax0_ma, ax2_ma) + 0.1)\\n\\n ax2.set_ylim(min(ax0_mi, ax2_mi) - 0.1,\\n max(ax0_ma, ax2_ma) + 0.1)\\n\\n ax1.set_ylim(min(ax1_mi, ax3_mi) - 0.1,\\n max(ax1_ma, ax3_ma) + 0.1)\\n\\n ax3.set_ylim(min(ax1_mi, ax3_mi) - 0.1,\\n max(ax1_ma, ax3_ma) + 0.1)\\n\\n plt.show()\",\n \"def clean_axes(axl):\\n cleanAxes(axl)\",\n \"def get_safety_vars_plot(self):\\n if 'safety_vars_stats' not in self.stats:\\n raise ValueError('No safety vars statistics present in this evaluator.')\\n\\n safety_vars = self.stats['safety_vars_stats'][0].keys()\\n n_plots = len(safety_vars)\\n fig, axes = plt.subplots(n_plots, 1, figsize=(8, 6 * n_plots))\\n\\n for idx, var in enumerate(safety_vars):\\n series = collections.defaultdict(list)\\n for ep in self.stats['safety_vars_stats']:\\n for stat in ep[var]:\\n series[stat].append(ep[var][stat])\\n ax = axes[idx]\\n for stat in ['min', 'max']:\\n ax.plot(np.squeeze(np.array(series[stat])), label=stat)\\n x = range(len(series['mean']))\\n\\n mean = np.squeeze(np.array(series['mean']))\\n std_dev = np.squeeze(np.array(series['std_dev']))\\n ax.plot(x, mean, label='Value')\\n ax.fill_between(\\n range(len(series['mean'])), mean - std_dev, mean + std_dev, alpha=0.3)\\n ax.set_title('Stats for {}'.format(var))\\n ax.legend()\\n ax.spines['top'].set_visible(False)\\n\\n ax.xaxis.set_ticks_position('bottom')\\n ax.set_xlabel('Episode #')\\n ax.set_ylabel('Magnitude')\\n ax.plot()\\n return fig\",\n \"def Diagnostic_plot2(self):\\n\\n probs = pd.read_csv(self.probfile)\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'SNR')\\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n #plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')\",\n \"def analyse_plots(plot_dict, data_dict) :\\n for component in [ '_x', '_y' ] :\\n z_pos = array.array( 'd' )\\n trans_pos = array.array( 'd' )\\n errors = array.array( 'd' )\\n zeros = array.array( 'd' )\\n\\n plot = plot_dict['beam_positions'+component]\\n\\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\\n projection = plot.ProjectionY( \\\\\\n 'profile'+component+'_pro_'+str(i), i, i )\\n if projection.GetEntries() == 0 :\\n continue\\n\\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\\\\n scifi.fit_gaussian( projection )\\n\\n errors.append( pro_mean_err )\\n trans_pos.append( pro_mean )\\n z_pos.append( data_dict['station_positions'][ i-6 ] )\\n zeros.append(0.0)\\n\\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\\\\n zeros, errors )\\n position_graph.SetName('beam_profile'+component)\\n plot_dict['beam_profile'+component] = position_graph\\n\\n profile_x = plot_dict['beam_profile_x']\\n profile_y = plot_dict['beam_profile_y']\\n\\n up_x_func = ROOT.TF1( \\\"up_fit_x\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n up_y_func = ROOT.TF1( \\\"up_fit_y\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n down_x_func = ROOT.TF1( \\\"down_fit_x\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n down_y_func = ROOT.TF1( \\\"down_fit_y\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n\\n up_fit_x = profile_x.Fit( 'up_fit_x', \\\"QSR\\\" )\\n up_fit_y = profile_y.Fit( 'up_fit_y', \\\"QSR\\\" )\\n down_fit_x = profile_x.Fit( 'down_fit_x', \\\"QSR\\\" )\\n down_fit_y = profile_y.Fit( 'down_fit_y', \\\"QSR\\\" )\\n\\n plot_dict['beam_profile_x_up_fit'] = up_x_func\\n plot_dict['beam_profile_y_up_fit'] = up_y_func\\n plot_dict['beam_profile_x_down_fit'] = down_x_func\\n plot_dict['beam_profile_y_down_fit'] = down_y_func\\n\\n\\n up_beam_gra_x = up_x_func.GetParameter(1)\\n up_beam_gra_x_err = up_x_func.GetParError(1)\\n up_beam_gra_y = up_y_func.GetParameter(1)\\n up_beam_gra_y_err = up_y_func.GetParError(1)\\n\\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n up_beam_pos_x_err = up_x_func.GetParError(0)\\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n up_beam_pos_y_err = up_y_func.GetParError(0)\\n\\n up_beam_rot_x = math.atan( up_beam_gra_x )\\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\\n up_beam_rot_y = math.atan( up_beam_gra_y )\\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\\n\\n\\n\\n down_beam_gra_x = down_x_func.GetParameter(1)\\n down_beam_gra_x_err = down_x_func.GetParError(1)\\n down_beam_gra_y = down_y_func.GetParameter(1)\\n down_beam_gra_y_err = down_y_func.GetParError(1)\\n\\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\\n down_beam_pos_x_err = down_x_func.GetParError(0)\\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\\n down_beam_pos_y_err = down_y_func.GetParError(0)\\n\\n down_beam_rot_x = math.atan( down_beam_gra_x )\\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\\n down_beam_rot_y = math.atan( down_beam_gra_y )\\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\\n\\n\\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\\n\\n length = TRACKER_SEPARATION\\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\\n\\n down_rot_x = down_beam_rot_x - up_beam_rot_x\\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\\n down_rot_y = down_beam_rot_y - up_beam_rot_y\\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\\n\\n\\n print\\n print \\\"Incoming Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to upstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_x, up_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_y, up_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to downstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_x, down_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_y, down_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Alignment:\\\"\\n print\\n print \\\"Displacement and rotation of between the two trackers:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_x, down_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_y, down_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\\n print\",\n \"def plot(nSamples, expectations, variances, exactE, exactVar, title=\\\"\\\"):\\n fig, axes = plt.subplots(2, 1)\\n\\n axes[0].semilogx(nSamples, expectations, color=\\\"black\\\", label=\\\"Empirical E(X)\\\")\\n axes[0].axhline(exactE, color=\\\"darkgray\\\", label=\\\"Exact E(X)\\\")\\n\\n axes[1].semilogx(nSamples, variances, color=\\\"black\\\", label=\\\"Empirical Var(X)\\\")\\n axes[1].axhline(exactVar, color=\\\"darkgray\\\", label=\\\"Exact Var(X)\\\")\\n\\n for ax in axes:\\n ax.set_xlabel(\\\"N draws in the simulation\\\")\\n ax.legend()\\n axes[0].set_ylabel(\\\"E(X)\\\")\\n axes[0].set_title(title)\\n axes[1].set_ylabel(\\\"Var(X)\\\")\\n plt.show()\",\n \"def plotPredictedError():\\n\\tglobal normalized\\n\\n\\twarmthPred = []\\n\\twarmthObserved = []\\n\\tcompPred = []\\n\\tcompObserved = []\\n\\tSStotalWarmth = 0\\n\\tSSresWarmth = 0\\n\\tSStotalComp = 0\\n\\tSSresComp = 0\\n\\tkeys = parser.getMappings(normalized)[0].keys()\\n\\tfor key in keys:\\n\\n\\t\\tif \\\"_\\\" in key:\\n\\t\\t\\twarmthAxis, compAxis = getPlotData(key)\\n\\t\\t\\twarmthPred.append(warmthAxis[3])\\n\\t\\t\\twarmthObserved.append(warmthAxis[2])\\n\\t\\t\\tcompPred.append(compAxis[3])\\n\\t\\t\\tcompObserved.append(compAxis[2])\\n\\n\\tmeanObservedWarmth = np.mean(warmthObserved)\\n\\tmeanObservedComp = np.mean(compObserved)\\n\\tfor i in range(0, len(warmthObserved)):\\n\\t\\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\\n\\t\\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\\n\\t\\tSStotalComp += (compObserved[i] - meanObservedComp)**2\\n\\t\\tSSresComp += (compObserved[i] - compPred[i])**2\\n\\n\\n\\tplt.axis([0, 100, 0, 100])\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.title(\\\"Observed vs Predicted Warmth\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(warmthObserved, warmthPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.axis([0, 100, 0, 100])\\n\\tplt.title(\\\"Observed vs Predicted Competence\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(compObserved, compPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\",\n \"def plot_dif_eq(self):\\n try:\\n self.canvas.get_tk_widget().pack_forget()\\n self.toolbar.pack_forget()\\n except AttributeError:\\n pass\\n\\n f = Figure(figsize=(8, 8), dpi=100)\\n p = f.add_subplot(111)\\n\\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\\n\\n p.set_ylabel('y')\\n p.set_xlabel('x')\\n\\n p.legend(['Exact', 'EU', \\\"IEU\\\", \\\"RK\\\"])\\n p.set_title(\\\"Solutions\\\")\\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\\\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\\n p.set_ylim([-100, 100])\\n\\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\\\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\\n p.set_ylim([-100, 100])\\n\\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\\n self.canvas.draw()\\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\\n\\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\\n self.toolbar.update()\\n\\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)\",\n \"def get_safety_plot(self, do_total=True, do_per_step=True):\\n n_plots = int(do_total) + int(do_per_step)\\n fig, axes = plt.subplots(1, n_plots, figsize=(8 * n_plots, 6))\\n plot_idx = 0\\n if do_total:\\n self._get_safety_totals_plot(axes[plot_idx], self._stats['safety_stats'])\\n plot_idx += 1\\n if do_per_step:\\n self._get_safety_per_step_plots(axes[plot_idx],\\n self._stats['safety_stats'])\\n return fig\",\n \"def display_incorrect_window(self, is_correct_list):\\r\\n correct_num = sum(is_correct_list)\\r\\n tried_num = len(self.correct_answers)\\r\\n if correct_num == tried_num:\\r\\n correct_num -= 1 # -1 credit if given extra answers\\r\\n window = SimpleWindow(self.title, msg='{} of {} correct.'.format(\\r\\n correct_num, tried_num), buttons=['Try Again', 'Show Answers',\\r\\n 'Show Solution', 'Main Menu'])\\r\\n window.run()\\r\\n return window.clicked\",\n \"def test_gca():\\n fig, ax = plt.subplots()\\n assert isinstance(prettypyplot.tools.gca(None), mpl.axes.Axes)\\n assert isinstance(prettypyplot.tools.gca(plt.gca()), mpl.axes.Axes)\",\n \"def figure_1():\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n\\n # Draw common plots\\n print(exp_list)\\n data = get_data(exp_list[0])\\n plt.figure(num=\\\"state 1\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"cmd\\\"],\\n **FORMATTING[\\\"command\\\"]\\n )\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 0],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_1$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"state 2\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 1],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_2$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.ylabel(r\\\"$u$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n def general_figures(exp):\\n data = get_data(exp)\\n plt.figure(num=\\\"state 1\\\")\\n ax = plt.gca()\\n ax.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"control\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"control\\\"],\\n **FORMATTING[exp],\\n )\\n\\n for exp in exp_list:\\n general_figures(exp)\\n\\n # Estimation error\\n for exp in exp_list:\\n data = get_data(exp)\\n error = nla.norm(\\n data[\\\"state\\\"][\\\"adaptive_system\\\"] - data[\\\"real_param\\\"],\\n axis=1\\n )\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.plot(data[\\\"time\\\"], error, **FORMATTING[exp])\\n plt.xlabel(\\\"Time, sec\\\")\\n plt.ylabel(\\\"Error norm\\\")\\n\\n # Real parameter\\n data = get_data(exp_list[0])\\n plt.plot(data[\\\"time\\\"], data[\\\"real_param\\\"].squeeze())\\n\\n\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n def eig_figures(exp, minmax):\\n data = get_data(exp)\\n if minmax == \\\"min\\\":\\n eig = np.min(data[\\\"eigs\\\"], axis=1)\\n elif minmax == \\\"max\\\":\\n eig = np.max(data[\\\"eigs\\\"], axis=1)\\n plt.plot(data[\\\"time\\\"], eig, **FORMATTING[exp])\\n\\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\\\"Eigenvalues\\\", sharex=True)\\n\\n plt.subplot(211)\\n plt.ticklabel_format(style=\\\"sci\\\", scilimits=(0, 0), useOffset=True)\\n for exp in exp_list:\\n eig_figures(exp, \\\"min\\\")\\n plt.ylabel(r\\\"Minimum $\\\\lambda$\\\")\\n plt.legend()\\n\\n plt.subplot(212)\\n for exp in exp_list:\\n eig_figures(exp, \\\"max\\\")\\n plt.ylabel(r\\\"Maximum $\\\\lambda$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n # Saving\\n def savefig(name):\\n path = os.path.join(args.save_dir, name + \\\".\\\" + args.save_ext)\\n plt.savefig(path, bbox_inches=\\\"tight\\\")\\n\\n plt.figure(num=\\\"state 1\\\")\\n plt.legend()\\n savefig(\\\"state-1\\\")\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.legend()\\n savefig(\\\"state-2\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.legend()\\n savefig(\\\"control\\\")\\n\\n plt.figure(num=\\\"Eigenvalues\\\")\\n savefig(\\\"eigs\\\")\\n\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.legend()\\n savefig(\\\"estim-error\\\")\\n\\n plt.show()\",\n \"def residual_plots(test_data, mods, station=None, squared=False):\\r\\n import config\\r\\n learning_var = config.learning_var\\r\\n data = test_data.get_miniOD()\\r\\n mods.models[0].mod.load()\\r\\n pred = mods.models[0].mod.predict(test_data)\\r\\n test_data.miniOD = None\\r\\n if squared:\\r\\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\\r\\n else:\\r\\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\\r\\n ind = data[data['Annee'] == 0].index\\r\\n data.drop(ind, inplace=True)\\r\\n print(data.columns.values)\\r\\n i = 0\\r\\n if station is None:\\r\\n ch_an = test_data.get_stations_col(2015)\\r\\n else:\\r\\n ch_an = 'End date ' + str(station)\\r\\n for ch in learning_var:\\r\\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\\r\\n # data.boxplot(ch_an, by=ch)\\r\\n # if ch != 'Heure':\\r\\n plt.figure(i // 9)\\r\\n # plt.title('squared error / expectation')\\r\\n fig = plt.subplot(3, 3, (i % 9) + 1)\\r\\n i += 1\\r\\n # fig = plt.figure().add_subplot(111)\\r\\n fig.set_xlabel(ch)\\r\\n if squared:\\r\\n fig.set_ylabel('error²')\\r\\n else:\\r\\n fig.set_ylabel('error')\\r\\n l = []\\r\\n xaxis = np.unique(data[ch])\\r\\n print(ch, xaxis.shape)\\r\\n if xaxis.shape[0] < 20 or ch == 'Heure':\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][data[ch] == u])\\r\\n else:\\r\\n m = np.min(data[ch])\\r\\n M = np.max(data[ch])\\r\\n step = (M - m) / 20\\r\\n xaxis = np.arange(m, M, step)\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\\r\\n xaxis = xaxis.astype(int)\\r\\n # fig = plt.boxplot(ch_an, by=ch)\\r\\n # g = data.groupby(ch).mean()[ch_an]\\r\\n # v = data.groupby(ch).std()[ch_an]\\r\\n plt.boxplot(l, labels=xaxis)\\r\\n if squared:\\r\\n plt.ylim((0, 12))\\r\\n else:\\r\\n plt.ylim((-5, 5))\\r\\n # plt.plot(g, '-r')\\r\\n # plt.plot(g + v, ':r')\\r\\n # plt.plot(g - v, ':r')\\r\\n plt.show()\",\n \"def open(self):\\r\\n if not plt.fignum_exists(num=1):\\r\\n config_dict = self.config_dict\\r\\n config_dict.pop(\\\"aspect\\\")\\r\\n fig = plt.figure(**config_dict)\\r\\n return fig, plt.gca()\\r\\n return None, None\",\n \"def makeFigure():\\n # Get list of axis objects\\n ax, f = getSetup((7, 3), (1, 2))\\n rep = 10\\n\\n comps = np.arange(1, 11)\\n\\n try:\\n chords_df = pd.read_csv('syserol/data/fig3_chords_df.csv')\\n except FileNotFoundError:\\n print(\\\"Building chords...\\\")\\n # Imputing chords dataframe\\n chords_df = pd.concat([pd.DataFrame({'Components': comps, 'R2X': evaluate_missing(comps, 15, chords=True)[0]})\\n for _ in range(rep)], axis=0)\\n chords_df.to_csv('syserol/data/fig3_chords_df.csv', index=False)\\n chords_df = chords_df.groupby('Components').agg({'R2X': ['mean', 'sem']})\\n\\n try:\\n single_df = pd.read_csv('syserol/data/fig3_single_df.csv')\\n except FileNotFoundError:\\n print(\\\"Building singles...\\\")\\n # Single imputations dataframe\\n single_df = pd.concat([pd.DataFrame(np.vstack((evaluate_missing(comps, 15, chords=False)[0:2], comps)).T,\\n columns=['CMTF', 'PCA', 'Components']) for _ in range(rep)], axis=0)\\n single_df.to_csv('syserol/data/fig3_single_df.csv', index=False)\\n single_df = single_df.groupby(['Components']).agg(['mean', 'sem'])\\n\\n Q2Xchord = chords_df['R2X']['mean']\\n Q2Xerrors = chords_df['R2X']['sem']\\n ax[0].scatter(comps, Q2Xchord, s=10)\\n ax[0].errorbar(comps, Q2Xchord, yerr=Q2Xerrors, fmt='none')\\n ax[0].set_ylabel(\\\"Q2X of Imputation\\\")\\n ax[0].set_xlabel(\\\"Number of Components\\\")\\n ax[0].set_xticks([x for x in comps])\\n ax[0].set_xticklabels([x for x in comps])\\n ax[0].set_ylim(0, 1)\\n\\n CMTFR2X = single_df['CMTF']['mean']\\n CMTFErr = single_df['CMTF']['sem']\\n PCAR2X = single_df['PCA']['mean']\\n PCAErr = single_df['PCA']['sem']\\n ax[1].plot(comps - 0.1, CMTFR2X, \\\".\\\", label=\\\"CMTF\\\")\\n ax[1].plot(comps + 0.1, PCAR2X, \\\".\\\", label=\\\"PCA\\\")\\n ax[1].errorbar(comps - 0.1, CMTFR2X, yerr=CMTFErr, fmt='none', ecolor='b')\\n ax[1].errorbar(comps + 0.1, PCAR2X, yerr=PCAErr, fmt='none', ecolor='darkorange')\\n ax[1].set_ylabel(\\\"Q2X of Imputation\\\")\\n ax[1].set_xlabel(\\\"Number of Components\\\")\\n ax[1].set_xticks([x for x in comps])\\n ax[1].set_xticklabels([x for x in comps])\\n ax[1].set_ylim(0, 1)\\n ax[1].legend(loc=4)\\n\\n # Add subplot labels\\n subplotLabel(ax)\\n\\n return f\",\n \"def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\\n other_program_name, **kw):\\n\\n #plot absolute error\\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\\n pan['absolute-difference'][field].values,\\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\\n ax_abs.set_ylabel('Absolute Difference ' + unit)\\n #plot percentage error\\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\\n pan['percent-difference'][field].values,\\n color='firebrick', zorder=-1)\\n ax_per.set_ylabel('Percent Difference', color='firebrick')\\n #set error axes legend\\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\\n #ax_per.get_legend().set_zorder(1)\\n #plot full results profiles\\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\\n color=_colormap[1])[0],\\n ax_mag.plot(pan['emf.fields-results'][field],\\n color=_colormap[0])[0]]\\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\\n ax_mag.set_xlabel('Distance (ft)')\",\n \"def galactic_correction_summary(self):\\n t = self.GalacticCorrection(self).x\\n dd = dict()\\n for i,c in enumerate(t.T):\\n dd[i] = dict(offset=c.mean()-1,std=c.std())\\n df = pd.DataFrame(dd).T\\n fig, ax = plt.subplots()\\n ax.errorbar(x=range(8), y=df.offset.values, yerr=df['std'].values, fmt='o')\\n ax.axhline(0, color='grey')\\n ax.set(xlabel='energy band', ylabel='offset', title='galactic correction offsets')\\n return fig\",\n \"def figure():\\n fig = plt.figure()\\n ax = fig.add_subplot()\\n ax.set_aspect('equal')\\n return fig, ax\",\n \"def plot_test(func):\\n\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n\\n plt.close('all')\\n\\n func(*args, **kwargs)\\n\\n ax = plt.gca()\\n assert ax.has_data()\\n\\n return wrapper\",\n \"def plotFittingResults(self):\\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\\n\\n #_listExpStdDev = None\\n #if self.getDataInput().getExperimentalDataStdDev():\\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\\n #if _listExpStdDev:\\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\\\"Experimental Data\\\")\\n # pylab.gca().set_yscale(\\\"log\\\", nonposy='clip')\\n #else: \\n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n\\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n pylab.semilogy(_listFitQ, _listFitValues, label=\\\"Fitting curve\\\")\\n pylab.xlabel('q')\\n pylab.ylabel('I(q)')\\n pylab.suptitle(\\\"RMax : %3.2f. Fit quality : %1.3f\\\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\\n pylab.legend()\\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \\\"gnomFittingResults.png\\\"))\\n pylab.clf()\",\n \"def _get_safety_per_step_plots(self, ax, safety_stats):\\n meta = self.meta\\n violations_labels = meta['safety_constraints']\\n per_step_violations = safety_stats['per_step_violations']\\n\\n for idx, violations in enumerate(per_step_violations.T):\\n label = violations_labels[idx]\\n ax.plot(\\n np.arange(violations.shape[0]), violations, label=label, alpha=0.75)\\n\\n ax.set_title('Mean violations / timestep')\\n ax.legend(loc='upper right')\\n ax.set_ylabel('Mean # violations')\\n ax.set_xlabel('Timestep')\\n ax.plot()\",\n \"def diagnose_priors(self):\\n if not hasattr(self, \\\"corrected_lc\\\"):\\n raise ValueError(\\n \\\"Please call the `correct()` method before trying to diagnose.\\\"\\n )\\n\\n names = [dm.name for dm in self.dmc]\\n with plt.style.context(MPLSTYLE):\\n _, axs = plt.subplots(\\n 1, len(names), figsize=(len(names) * 4, 4), sharey=True\\n )\\n if not hasattr(axs, \\\"__iter__\\\"):\\n axs = [axs]\\n for idx, ax, X in zip(range(len(names)), axs, self.dmc):\\n X.plot_priors(ax=ax)\\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\\n submatrix_coefficients = self.coefficients[\\n firstcol_idx : firstcol_idx + X.shape[1]\\n ]\\n [ax.axvline(s, color=\\\"red\\\", zorder=-1) for s in submatrix_coefficients]\\n return axs\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n\\n # chdir into the working directory\\n os.chdir(env['WORKDIR'])\\n\\n for nclPlotFile in self._ncl:\\n # copy the NCL command to the workdir\\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\\n\\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\\n if rc:\\n try:\\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\\n except subprocess.CalledProcessError as e:\\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\\n print(' {0}'.format(e.cmd))\\n print(' rc = {0}'.format(e.returncode))\\n else:\\n print('{0}... continuing with additional plots.'.format(err_msg))\",\n \"def create_plots(self):\\n shutil.rmtree(self.param.path, ignore_errors=True)\\n os.makedirs(self.param.path)\\n\\n ids = list(range(len(self.signs)))\\n\\n \\\"\\\"\\\"True positives\\\"\\\"\\\"\\n values, kinds = self.get_evaluations(ids)\\n plots.create_plot(\\n kinds,\\n [e[0] for e in values], # True positives\\n save_dir=self.param.path,\\n y_label=\\\"number_tp\\\",\\n file_name=\\\"number_tp\\\",\\n title=\\\"Amount of true positives\\\",\\n )\\n\\n # Only signs with at least one detection!\\n ids = [i for i, _ in enumerate(self.signs) if self.signs[i].evaluate()[2] > 0]\\n values, kinds = self.get_evaluations(ids)\\n\\n \\\"\\\"\\\"Distance\\\"\\\"\\\"\\n plots.create_plot(\\n kinds,\\n values=[e[2] for e in values], # Distances\\n save_dir=self.param.path,\\n y_label=\\\"distance\\\",\\n file_name=\\\"distance\\\",\\n title=\\\"Distance\\\",\\n )\\n \\\"\\\"\\\"Precision\\\"\\\"\\\"\\n plots.create_plot(\\n kinds,\\n # Precision signs with at least one detection are used, e[0]+e[1] > 0)\\n values=[e[0] / (e[0] + e[1]) for e in values],\\n save_dir=self.param.path,\\n y_label=\\\"precision\\\",\\n file_name=\\\"precision\\\",\\n title=\\\"Precision\\\",\\n )\",\n \"def test_generate_correlogram_empty(self):\\r\\n obs_fig = self.mc._generate_correlogram([], [], [])\\r\\n obs_ax = obs_fig.get_axes()[0]\\r\\n self.assertEqual(obs_ax.get_title(), \\\"Mantel Correlogram\\\")\\r\\n self.assertEqual(obs_ax.get_xlabel(), \\\"Distance class index\\\")\\r\\n self.assertEqual(obs_ax.get_ylabel(), \\\"Mantel correlation statistic\\\")\",\n \"def gen_plots_with_errbars(plots_desc, compared, range_val, func, repeat=3, save_figs=False, verbose=False):\\n\\n def _init_y_avg():\\n y_val = dict()\\n for desc in plots_desc:\\n y_val[desc['key']] = {'y': list(), 'err': list()}\\n\\n return y_val\\n\\n def _init_list():\\n y_val = dict()\\n for desc in plots_desc:\\n y_val[desc['key']] = list()\\n\\n return y_val\\n\\n def _calc_avg(y_val, y_avg):\\n for desc in plots_desc:\\n key = desc['key']\\n y_avg[key]['y'].append(np.mean(y_val[key]))\\n y_avg[key]['err'].append(np.std(y_val[key]))\\n\\n def _add_avg_to_data(index, data_lists, y_avg, case_name):\\n for desc in plots_desc:\\n key = desc['key']\\n data_lists[key].extend([range_val, y_avg[key]['y'], case_name, get_color(index) + '-', y_avg[key]['err']])\\n\\n def _plot_data_lists(data_lists):\\n for desc in plots_desc:\\n key = desc['key']\\n plot_on_one_errorbars(desc['name'], desc['xlabel'], desc['ylabel'],\\n data_lists[key], only_ints_on_x=True, save_it=save_figs)\\n\\n def _print_after_process(j_value, y_avg):\\n print('>>> results for value {}: '.format(j_value))\\n for desc in plots_desc:\\n key = desc['key']\\n print(' >>> {} - y: {}, err: {}'.format(key, y_avg[key]['y'][-1], y_avg[key]['err'][-1]))\\n\\n data_lists = _init_list()\\n for i, compared_obj in enumerate(compared):\\n case_name = compared_obj['name']\\n y_avg = _init_y_avg()\\n if verbose:\\n print('({}) started calculation for {} case'.format(i, case_name))\\n for j in range_val:\\n y_val = _init_list()\\n\\n for _ in range(repeat):\\n func(y_val, compared_obj, j)\\n _calc_avg(y_val, y_avg)\\n\\n if verbose:\\n _print_after_process(j, y_avg)\\n _add_avg_to_data(i, data_lists, y_avg, case_name)\\n\\n _plot_data_lists(data_lists)\",\n \"def figures(self):\\n if np.size(self.iceicehorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n if self.site1.archive == 'icecore':\\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\\n else:\\n mpl.xlabel(self.site1.label+' age (yr b1950)')\\n if self.site2.archive == 'icecore':\\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\\n else:\\n mpl.ylabel(self.site2.label+' age (yr b1950)')\\n if np.size(self.iceicehorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_age_init(self.iceicehorizons_depth1),\\n self.site2.fct_age_init(self.iceicehorizons_depth2),\\n color=pccfg.color_init, linestyle='', marker='o', markersize=2,\\n label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_age_model(self.iceicehorizons_depth1),\\n self.site2.fct_age_model(self.iceicehorizons_depth2),\\n color=pccfg.color_mod, linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_age(self.iceicehorizons_depth1),\\n self.site2.fct_age(self.iceicehorizons_depth2), color=pccfg.color_opt,\\n xerr=np.zeros(np.size(self.iceicehorizons_depth1)),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_age(self.iceicehorizons_depth1)-self.iceicehorizons_sigma/2\\n ystart = self.site2.fct_age(self.iceicehorizons_depth2)+self.iceicehorizons_sigma/2\\n for i in range(np.size(self.iceicehorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.iceicehorizons_sigma[i],\\n -self.iceicehorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement', zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_ice_synchro.pdf')\\n elif self.site1.archive == 'icecore' or self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\\n if np.size(self.airairhorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\\n if np.size(self.airairhorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_airage_init(self.airairhorizons_depth1),\\n self.site2.fct_airage_init(self.airairhorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='',\\n marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_airage_model(self.airairhorizons_depth1),\\n self.site2.fct_airage_model(self.airairhorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_airage(self.airairhorizons_depth1),\\n self.site2.fct_airage(self.airairhorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.airairhorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_airage(self.airairhorizons_depth1)-\\\\\\n self.airairhorizons_sigma/2\\n ystart = self.site2.fct_airage(self.airairhorizons_depth2)+\\\\\\n self.airairhorizons_sigma/2\\n for i in range(np.size(self.airairhorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.airairhorizons_sigma[i],\\n -self.airairhorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\\n zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site2.archive == 'icecore':\\n if np.size(self.iceairhorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n if self.site1.archive == 'icecore':\\n mpl.xlabel(self.site1.label+' ice age (yr b1950)')\\n else:\\n mpl.xlabel(self.site1.label+' age (yr b1950)')\\n mpl.ylabel(self.site2.label+' air age (yr b1950)')\\n if np.size(self.iceairhorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_age_init(self.iceairhorizons_depth1),\\n self.site2.fct_airage_init(self.iceairhorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='',\\n marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_age_model(self.iceairhorizons_depth1),\\n self.site2.fct_airage_model(self.iceairhorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_age(self.iceairhorizons_depth1),\\n self.site2.fct_airage(self.iceairhorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.iceairhorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_age(self.iceairhorizons_depth1)-\\\\\\n self.iceairhorizons_sigma/2\\n ystart = self.site2.fct_airage(self.iceairhorizons_depth2)+\\\\\\n self.iceairhorizons_sigma/2\\n for i in range(np.size(self.iceairhorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.iceairhorizons_sigma[i],\\n -self.iceairhorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0) \\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement',\\n zorder=0)\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site1.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/ice_air_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\\n\\n if self.site1.archive == 'icecore':\\n if np.size(self.airicehorizons_depth1)>0:\\n fig, ax = mpl.subplots()\\n mpl.xlabel(self.site1.label+' air age (yr b1950)')\\n if self.site2.archive == 'icecore':\\n mpl.ylabel(self.site2.label+' ice age (yr b1950)')\\n else:\\n mpl.ylabel(self.site2.label+' age (yr b1950)')\\n if np.size(self.airicehorizons_depth1) > 0:\\n if pccfg.show_initial:\\n mpl.plot(self.site1.fct_airage_init(self.airicehorizons_depth1),\\n self.site2.fct_age_init(self.airicehorizons_depth2),\\n color=pccfg.color_init,\\n linestyle='', marker='o', markersize=2, label=\\\"Initial\\\")\\n mpl.plot(self.site1.fct_airage_model(self.airicehorizons_depth1),\\n self.site2.fct_age_model(self.airicehorizons_depth2),\\n color=pccfg.color_mod,\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Prior\\\")\\n mpl.errorbar(self.site1.fct_airage(self.airicehorizons_depth1),\\n self.site2.fct_age(self.airicehorizons_depth2),\\n color=pccfg.color_opt,\\n xerr=np.zeros_like(self.airicehorizons_sigma),\\n linestyle='', marker='o', markersize=2,\\n label=\\\"Posterior\\\")\\n xstart = self.site1.fct_airage(self.airicehorizons_depth1)-\\\\\\n self.airicehorizons_sigma/2\\n ystart = self.site2.fct_age(self.airicehorizons_depth2)+\\\\\\n self.airicehorizons_sigma/2\\n for i in range(np.size(self.airicehorizons_depth1)):\\n mpl.arrow(xstart[i], ystart[i], self.airicehorizons_sigma[i],\\n -self.airicehorizons_sigma[i], color=pccfg.color_opt,\\n width=0.0, head_length=0.0, head_width=0.0)\\n x_low, x_up, y_low, y_up = mpl.axis()\\n# x_low = self.site1.age_top\\n# y_low = self.site2.age_top\\n# mpl.axis((x_low, x_up, y_low, y_up))\\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='perfect agreement')\\n mpl.legend(loc=\\\"best\\\")\\n ax.set_aspect('equal')\\n if self.site2.archive == 'icecore':\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_ice_synchro.pdf')\\n else:\\n printed_page = PdfPages(pccfg.datadir+self.label+'/air_synchro.pdf')\\n printed_page.savefig(fig)\\n printed_page.close()\\n if not pccfg.show_figures:\\n mpl.close()\",\n \"def make_plots(title, \\n chrg_x, csd, \\n ele_x, pots, \\n csd_x, est_csd, est_pot, \\n true_pot=None):\\n fig = plt.figure(figsize=(7,10))\\n #CSDs\\n ax1 = plt.subplot(211)\\n if np.array(csd_x).any() != False:\\n im1b = ax1.plot(csd_x, est_csd[:,0], 'r', label='kCSD', linewidth=3)\\n im1a = ax1.plot(chrg_x, csd, 'g', label = 'CSD', linestyle='--', linewidth=3)\\n ax1.plot(ele_x, np.zeros_like(ele_x), 'ko',markersize=2.)\\n plt.legend() \\n ax1.set_xlim([0.,1.])\\n #ax1.set_ylim(ax1.get_ylim()[::-1]) #Zero on the top --ASK?!\\n max_csd = np.maximum(max(np.abs(csd)), max(np.abs(est_csd[:,0])))\\n max_csd += max_csd*0.2\\n ax1.set_ylim([-max_csd, max_csd])\\n ax1.set_xlabel('Depth mm')\\n ax1.set_ylabel('CSD mA/mm')\\n #Potentails\\n ax2 = plt.subplot(212)\\n ax2.plot( ele_x, np.zeros_like(ele_x),'ko',markersize=2.)\\n im2b = ax2.plot(csd_x, est_pot, 'b', label = 'kPOT', linewidth=3)\\n im2a = ax2.plot(chrg_x,true_pot, color = 'orange', \\n linestyle='--', label='TruePOT', linewidth=3)\\n ax2.set_xlim([0.,1.])\\n #ax2.set_ylim(ax2.get_ylim()[::-1]) #Zero on the top --ASK?!\\n ax2.plot(ele_x, pots, 'kx', markersize=8.)\\n max_pots = np.maximum(max(np.abs(true_pot)), max(np.abs(est_pot)))\\n max_pots += max_pots*0.2\\n ax2.set_xlabel('Depth mm')\\n ax2.set_ylabel('Potential mV')\\n ax2.set_ylim([-max_pots, max_pots])\\n fig.suptitle(title)\\n plt.legend()\\n plt.show()\\n return\",\n \"def plotErr(self):\\n if self.xp and self.wp:\\n # plot the spectra\\n w=self.ws.value(np.array(self.xp))\\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\\n if self.dxp and self.dwp:\\n # plot the spectra\\n dw=self.ws.value(np.array(self.dxp))\\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')\",\n \"def plot_results(\\n predictor_names, validation_auc_values, is_forward_test,\\n axes_object=None, num_predictors_to_plot=None):\\n\\n if num_predictors_to_plot is None:\\n num_predictors_to_plot = len(predictor_names)\\n\\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\\n num_predictors_to_plot = min([\\n num_predictors_to_plot, len(predictor_names)\\n ])\\n\\n y_coords = numpy.linspace(\\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\\n )[::-1]\\n\\n if axes_object is None:\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n axes_object.barh(\\n y_coords, validation_auc_values[:num_predictors_to_plot],\\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\\n linewidth=BAR_EDGE_WIDTH\\n )\\n\\n axes_object.set_yticks([], [])\\n axes_object.set_xlabel('Validation AUC')\\n\\n if is_forward_test:\\n axes_object.set_ylabel('Predictor added')\\n else:\\n axes_object.set_ylabel('Predictor removed')\\n\\n axes_object.set_ylim(\\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\\n )\\n axes_object.set_xlim(\\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\\n )\\n\\n for j in range(num_predictors_to_plot):\\n axes_object.text(\\n 0., y_coords[j], ' ' + predictor_names[j],\\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\\n horizontalalignment='left', verticalalignment='center'\\n )\\n\\n return axes_object\",\n \"def test_no_arguments(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n lines = ax.plot()\\n assert lines == []\",\n \"def make_plots(self):\\n\\n # main fixation times data frame\\n average_fixation_df = pd.DataFrame()\\n\\n # create a data frame with the fixation times for each participant, create a box plot with it,\\n # and append it to the main data frame\\n for idx, dataframe in enumerate(self.cGOM_dataframes):\\n aois = EyeTracking.areas_of_interest(dataframe)\\n participant_fixations = EyeTracking.fixations(aois, dataframe)\\n\\n Plot.make_boxplot(data_frame=participant_fixations,\\n figure_save_path=self.PARTICIPANT_FIGURE_PATH.format(idx + 1),\\n title='Average fixation duration: participant {}'.format(idx + 1),\\n ylabel='Fixation duration [s]',\\n xlabel='Area of interest'\\n )\\n\\n average_fixation_df = average_fixation_df.append(participant_fixations, ignore_index=True)\\n\\n # create a bar plot and a box plot with the fixations of all participants or\\n # do nothing if no cGOM data is provided\\n try:\\n Plot.make_boxplot(data_frame=average_fixation_df,\\n figure_save_path=self.BOX_PLOT_FIGURE_PATH,\\n title='Average fixation duration',\\n ylabel='Fixation duration [s]',\\n xlabel='Area of interest'\\n )\\n Plot.make_barplot(data_frame=average_fixation_df,\\n figure_save_path=self.BAR_PLOT_FIGURE_PATH,\\n title='Average fixation duration',\\n ylabel='Fixation duration [s]',\\n xlabel='Area of interest'\\n )\\n except ValueError:\\n pass\",\n \"def plot_spectrumxichange(self):\\n countgood = 0 ; countbad = 0\\n for idata in self.datarg:\\n if idata[-1, 0] == 1.: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \\n countgood += 1\\n print countgood , 'good solution'\\n else: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \\n print countbad, 'bad solution'\\n countbad += 1\\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\\\'s what you expected' %(countgood,countbad)\\n #Create custom artistsr[goodline,badline],['solution','breakdown']\\n goodline = pl.Line2D((0,1),(0,0), color='b') \\n badline = pl.Line2D((0,1),(0,0), color='r')\\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\\n self.savefig('xispec')\",\n \"def plot_mean(self, exact, exact_label='CCSD', axabs=None):\\n if axabs is None:\\n axabs = plt.gca()\\n axabs.plot(list(range(1, self.max_dets)), self.means[0], label='independent')\\n axabs.plot(list(range(1, self.max_dets)), self.means[1], label='correlated')\\n axabs.axhline(self.means[0, 0], linestyle='--', color='silver', label='reference')\\n if exact:\\n axabs.axhline(exact, linestyle='dashdot', color='green', label=exact_label)\\n axabs.set_xlabel('Number of determinants in estimator')\\n axabs.set_ylabel(r'$E_\\\\mathrm{corr}$ / ha')\\n axabs.legend()\\n return axabs\",\n \"def test_figure_layout(self, study_experiments_config):\\n ar1 = AverageResult()\\n\\n with create_study_experiments(**study_experiments_config) as experiments:\\n figure = ar1.analysis(\\\"task_name\\\", experiments)\\n\\n assert_regrets_plot(\\n figure[\\\"AverageResult\\\"][\\\"task_name\\\"][\\\"regrets\\\"],\\n [\\n list(algorithm[\\\"algorithm\\\"].keys())[0]\\n for algorithm in study_experiments_config[\\\"algorithms\\\"]\\n ],\\n balanced=study_experiments_config[\\\"max_trial\\\"],\\n with_avg=True,\\n )\",\n \"def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\\n\\n figure = plt.figure()\\n figure.subplots_adjust(top=0.76)\\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\\n\\n functionGraph = figure.add_subplot(311)\\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\\n functionGraph.set_xlabel('X-values')\\n functionGraph.set_ylabel('Y-values')\\n\\n errorGraph = figure.add_subplot(313)\\n errorGraph.set_title('Truncation errors', fontsize=15)\\n errorGraph.set_xlabel('X-values')\\n errorGraph.set_ylabel('Error-values')\\n\\n if EU == True:\\n euler = EulerMethod(self._IVP)\\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\\n\\n if IEM == True:\\n improvedEuler = ImprovedEulerMethod(self._IVP)\\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\\n \\n if RK == True:\\n rungeKutta = RungeKutta(self._IVP)\\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\\n\\n if ES == True:\\n exactSolution = AnalyticalSolution(self._IVP)\\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\\n \\n functionGraph.legend(loc='lower right')\\n errorGraph.legend(loc='lower right')\\n\\n return figure\",\n \"def plot(self):\\n # plot the data for checking\\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\\n 3,2, figsize=(10,8))\\n\\n # Relative height\\n self.board_reference.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\\n self.board_intervention.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\\n\\n # Landuse\\n self.board_reference.plot(\\n column='landuse', legend=True, ax=ax3, cmap='viridis',\\n scheme='equal_interval', k=11)\\n self.board_intervention.plot(\\n column='landuse', legend=True, ax=ax4, cmap='viridis',\\n scheme='equal_interval', k=11)\\n\\n index = np.arange(7)\\n xticks = self.PotTax_reference.index.values\\n bar_width = 0.3\\n\\n # plot the initial and new situation comparison\\n label = (\\\"reference: \\\" +\\n str(round(self.PotTax_reference.sum().TFI, 2)))\\n reference = ax5.bar(\\n index, self.PotTax_reference.values.flatten(), bar_width,\\n label=label, tick_label=xticks)\\n label = (\\\"intervention: \\\" +\\n str(round(self.PotTax_intervention.sum().TFI, 2)))\\n intervention = ax5.bar(\\n index+bar_width, self.PotTax_intervention.values.flatten(),\\n bar_width, label=label, tick_label=xticks)\\n ax5.set_ylabel(\\\"total value\\\")\\n ax5.legend(loc='best')\\n for tick in ax5.get_xticklabels():\\n tick.set_rotation(90)\\n\\n # plot the percentage increase/decrease between the initial and new\\n # situation\\n data = self.PotTax_percentage.values.flatten()\\n percentage = ax6.bar(\\n index, data, bar_width, label=\\\"percentage\\\", tick_label=xticks)\\n ax6.set_ylabel(\\\"increase (%)\\\")\\n minimum = min(data)\\n maximum = max(data)\\n size = len(str(int(round(maximum))))\\n maximum = int(str(maximum)[:1])\\n maximum = (maximum + 1) * (10**(size-1))\\n ax6.set_ylim([min(0, minimum), maximum])\\n for tick in ax6.get_xticklabels():\\n tick.set_rotation(90)\",\n \"def test_generate_correlogram(self):\\r\\n obs_fig = self.mc._generate_correlogram([0, 1, 2], [-0.9, 0, 0.9],\\r\\n [0.001, 0.1, 0.9])\\r\\n obs_ax = obs_fig.get_axes()[0]\\r\\n self.assertEqual(obs_ax.get_title(), \\\"Mantel Correlogram\\\")\\r\\n self.assertEqual(obs_ax.get_xlabel(), \\\"Distance class index\\\")\\r\\n self.assertEqual(obs_ax.get_ylabel(), \\\"Mantel correlation statistic\\\")\\r\\n assert_almost_equal(obs_ax.get_xticks(), [0., 0.5, 1., 1.5, 2.])\\r\\n assert_almost_equal(obs_ax.get_yticks(), [-1., -0.5, 0., 0.5, 1.])\",\n \"def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\\n \\n plt.figure()\\n plt.plot(x, phiExact)\\n\\n plt.plot(x, phi)\\n plt.ylim([-0.2, 1.4])\\n plt.title(str(methodName)+\\\" scheme\\\\nExact vs Numerical solution \\\"\\\\\\n \\\"nt=\\\"+str(nt)+\\\", nx=\\\"+str(nx)+\\\"\\\\n\\\"\\n \\\"Courant number: \\\"+str(c))\\n plt.show()\",\n \"def check_graph(t, RA_main, DEC_main, survey, width,\\n gtype=\\\"all\\\", add_plotid=True, prefix=None,\\n saveplot=True, plotfile=None, plotfile_prefix=None,\\n title=None, suptitle=None):\\n import math\\n import time\\n\\n import matplotlib.pyplot as plt\\n import matplotlib.gridspec as gridspec\\n import numpy as np\\n from matplotlib.colors import LogNorm\\n\\n import stats\\n import plotid\\n\\n now = time.localtime(time.time())\\n datestamp = time.strftime(\\\"%Y%m%d\\\", now)\\n function_name = inspect.stack()[0][3]\\n\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno + ':')\\n print(function_name + '.saveplot:', saveplot)\\n print(function_name + '.plotfile:', plotfile)\\n print(function_name + '.prefix: ', plotfile_prefix)\\n\\n ndata = len(t)\\n\\n n = 0\\n xs = []\\n ys = []\\n while n < len(t):\\n x = ((t[RA_main][n] - t[\\\"RA_\\\" + survey.upper()][n]) *\\n math.cos((t[DEC_main][n] +\\n t[\\\"DEC_\\\" + survey][n]) * math.pi / 360.0) * 3600.0)\\n y = (t[DEC_main][n] - t[\\\"DEC_\\\" + survey.upper()][n]) * 3600.0\\n\\n if not np.isnan(x) and not np.isnan(y):\\n xs.append(x)\\n ys.append(y)\\n n += 1\\n\\n n = 0\\n xs_s = []\\n ys_s = []\\n if gtype == \\\"square\\\":\\n w = width / math.sqrt(2.0)\\n while n < len(xs):\\n x = xs[n]\\n y = ys[n]\\n if x <= w and x >= -w and y <= w and y >= -w:\\n xs_s.append(xs[n])\\n ys_s.append(ys[n])\\n n += 1\\n\\n xs = xs_s\\n ys = ys_s\\n\\n xs1 = list(xs) + []\\n ys1 = list(ys) + []\\n\\n RA_med = np.median(xs1)\\n DEC_med = np.median(ys1)\\n RA_MAD = stats.MAD(xs1, RA_med)\\n DEC_MAD = stats.MAD(ys1, DEC_med)\\n print(\\\"Number of points\\\", len(xs))\\n print(\\\"RA offset\\\", RA_med, \\\"DEC offset\\\", DEC_med)\\n print(\\\"RA MAD\\\", RA_MAD, \\\"DEC MAD\\\", DEC_MAD)\\n print(\\\"RA Sigma MAD\\\", 1.486 * RA_MAD, \\\"DEC Sigma DEC\\\", 1.486 * DEC_MAD)\\n print(\\\"RA Median Error\\\", 1.486 * RA_MAD / math.sqrt(len(xs)),\\n \\\"DEC Median Error\\\", 1.486 * DEC_MAD / math.sqrt(len(ys)))\\n print()\\n if len(xs) == 0:\\n print(\\\"No matches\\\")\\n return RA_med, DEC_med\\n\\n gs = gridspec.GridSpec(2, 2, width_ratios=[2, 1], height_ratios=[1, 2])\\n fig = plt.figure()\\n ax1 = plt.subplot(gs[0])\\n ax1.hist(xs, bins=100, color=\\\"r\\\")\\n ax1.set_xlim(-2.0, 2.0)\\n ax1.axes.get_xaxis().set_visible(False)\\n ax1.set_ylabel(\\\"Number\\\")\\n\\n ax2 = plt.subplot(gs[2])\\n # ax2.plot(xs, ys, \\\"k+\\\")\\n if len(xs) > 100:\\n plt.hist2d(xs, ys, bins=100, cmap=\\\"binary\\\", norm=LogNorm())\\n else:\\n plt.plot(xs, ys, \\\"k.\\\", ms=2)\\n ax2.set_ylim(-2.0, 2.0)\\n ax2.set_xlim(-2.0, 2.0)\\n ax2.set_xlabel('Delta RA /\\\"')\\n ax2.set_ylabel('Delta Dec /\\\"')\\n labels1 = ax2.get_xticks()\\n ax2.set_xticklabels(labels1, rotation=270)\\n\\n if suptitle is None:\\n fig.suptitle(\\\"Errors in matching: \\\" +\\n survey + ': ' + str(ndata), fontsize='small')\\n\\n if suptitle is not None:\\n fig.suptitle(suptitle + ': ' + str(ndata), fontsize='small')\\n\\n ax3 = plt.subplot(gs[3])\\n ax3.hist(ys, bins=100, orientation=\\\"horizontal\\\", color=\\\"r\\\")\\n ax3.set_ylim(-2.0, 2.0)\\n ax3.set_xlabel(\\\"Number\\\")\\n ax3.axes.get_yaxis().set_visible(False)\\n labels2 = ax3.get_xticks()\\n ax3.set_xticklabels(labels2, rotation=270)\\n\\n ax4 = plt.subplot(gs[1])\\n ax4.annotate(\\\"Number of points: \\\" +\\n str(len(xs)), xy=(0.01, 0.1), size=\\\"small\\\")\\n ax4.annotate(\\\"RA offset: {0:.4f}\\\".format(RA_med) +\\n '\\\"', xy=(0.01, 0.90), size=\\\"small\\\")\\n ax4.annotate(\\\"DEC offset: {0:.4f}\\\".format(DEC_med) +\\n '\\\"', xy=(0.01, 0.8), size=\\\"small\\\")\\n ax4.annotate(\\\"RA MAD: {0:.4f}\\\".format(RA_MAD) +\\n '\\\"', xy=(0.01, 0.7), size=\\\"small\\\")\\n ax4.annotate(\\\"DEC MAD: {0:.4f}\\\".format(DEC_MAD) +\\n '\\\"', xy=(0.01, 0.6), size=\\\"small\\\")\\n ax4.annotate(\\\"RA median error: {0:.4f}\\\".\\n format(1.486 * RA_MAD / math.sqrt(len(xs))) + '\\\"',\\n xy=(0.01, 0.5), size=\\\"small\\\")\\n ax4.annotate(\\\"DEC median error: {0:.4f}\\\".\\n format(1.486 * DEC_MAD / math.sqrt(len(ys))) + '\\\"',\\n xy=(0.01, 0.4), size=\\\"small\\\")\\n ax4.annotate(\\\"RA sigma MAD: {0:.4f}\\\".format(RA_MAD * 1.486) +\\n '\\\"', xy=(0.01, 0.3), size=\\\"small\\\")\\n ax4.annotate(\\\"DEC sigma MAD: {0:.4f}\\\".format(DEC_MAD * 1.486) +\\n '\\\"', xy=(0.01, 0.2), size=\\\"small\\\")\\n\\n ax4.axes.get_xaxis().set_visible(False)\\n ax4.axes.get_yaxis().set_visible(False)\\n\\n if saveplot:\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno)\\n if add_plotid:\\n plotid.plotid()\\n if plotfile is None:\\n plotfile = 'match'\\n if plotfile_prefix is not None:\\n plotfile = plotfile_prefix + '_match_' + datestamp + '.png'\\n if plotfile_prefix is None:\\n plotfile = 'match_' + datestamp + '.png'\\n\\n print('Saving: ', plotfile)\\n plt.savefig(plotfile)\\n\\n plt.show()\\n\\n return RA_med, DEC_med\",\n \"def plot_solution(self):\\n\\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \\\"Analytical\\\")\\n plt.plot(self.x_values, self.numerical, label = \\\"Numerical\\\")\\n plt.title(\\\"Numerical vs. Analytical Solution\\\")\\n plt.xlabel(\\\"x\\\")\\n plt.ylabel(\\\"u(x)\\\")\\n plt.legend()\\n plt.show()\",\n \"def evidence_tuning_plots(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\",\\n x_name=\\\"Mean Predicted\\\",\\n y_name=\\\"Empirical Probability\\\"):\\n\\n def lineplot(x, y, trials, methods, **kwargs):\\n \\\"\\\"\\\"method_lineplot.\\n\\n Args:\\n y:\\n methods:\\n kwargs:\\n \\\"\\\"\\\"\\n uniq_methods = set(methods.values)\\n method_order = sorted(uniq_methods)\\n\\n method_new_names = [f\\\"$\\\\lambda={i:0.4f}$\\\" for i in method_order]\\n method_df = []\\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\\n method_new_names)):\\n lines_y = y[methods == method]\\n lines_x = x[methods == method]\\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\\n\\n to_append = [{x_name : x,\\n y_name: y,\\n \\\"Method\\\": method_new_name,\\n \\\"Trial\\\" : trial}\\n for i, (x,y) in enumerate(zip(xx,yy))]\\n method_df.extend(to_append)\\n method_df = pd.DataFrame(method_df)\\n x = np.linspace(0,1,100)\\n plt.plot(x, x, linestyle='--', color=\\\"black\\\")\\n sns.lineplot(x=x_name, y=y_name, hue=\\\"Method\\\",\\n alpha=0.8,\\n hue_order=method_new_names, data=method_df,)\\n # estimator=None, units = \\\"Trial\\\")\\n\\n df = df.copy()\\n # Query methods that have evidence_new_reg_2.0\\n df = df[[\\\"evidence\\\" in i for i in\\n df['method_name']]].reset_index()\\n\\n # Get the regularizer and reset coeff\\n coeff = [float(i.split(\\\"evidence_new_reg_\\\")[1]) for i in df['method_name']]\\n df[\\\"method_name\\\"] = coeff\\n df[\\\"Data\\\"] = convert_dataset_names(df[\\\"dataset\\\"])\\n df[\\\"Method\\\"] = df[\\\"method_name\\\"]\\n\\n g = sns.FacetGrid(df, col=\\\"Data\\\", height=6, sharex = False, sharey = False)\\n g.map(lineplot, x_input, y_input, \\\"trial_number\\\",\\n methods=df[\\\"Method\\\"]).add_legend()\",\n \"def plot(self) -> List[matplotlib.figure.Figure]:\\n figs = []\\n\\n # Figure 1, position in 3 subplots\\n pos_fig_sub = self.plot_subplots(0, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed)\\n figs.append(pos_fig_sub)\\n\\n # Figure 2, orientation in 3 subplots\\n eul_fig_sub = self.plot_subplots(1, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed)\\n figs.append(eul_fig_sub)\\n\\n # Figure 3, position in one axes\\n pos_fig_one = self.plot_one_axes(2, self.trial_name + ' Torso Intrinsic Position', 'Position (mm)',\\n self.torso_pos_labeled, self.torso_pos_filled, self.torso_pos_smoothed,\\n {'labeled': 'Labeled (X)', 'filled': 'Filled (Y)', 'smoothed': 'Smoothed (Z)'})\\n figs.append(pos_fig_one)\\n\\n # Figure 3, position in one axes\\n eul_fig_one = self.plot_one_axes(3, self.trial_name + ' Torso Intrinsic Euler Angles', 'Angle (deg)',\\n self.torso_eul_labeled, self.torso_eul_filled, self.torso_eul_smoothed,\\n {'labeled': 'Labeled (Flex/Ext)', 'filled': 'Filled (Lat Flex)',\\n 'smoothed': 'Smoothed (Axial)'})\\n figs.append(eul_fig_one)\\n\\n return figs\",\n \"def plot(self):\\n t = np.linspace(0, self.days, self.days + 1)\\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\\n ax1.plot(t, self.S, label=\\\"Susceptible\\\", color='r')\\n ax1.set_ylabel(\\\"Number of Susceptible People\\\")\\n ax1.set_title(\\\"Strong Infecitous Model SEIRV Simulation\\\")\\n ax3.plot(t, self.I, label=\\\"Active Cases\\\", color='b')\\n ax3.set_ylabel(\\\"Active Cases\\\")\\n ax2.plot(t, self.E, label=\\\"Exposed\\\", color='c')\\n ax2.set_ylabel(\\\"# of Exposed\\\")\\n ax4.plot(t, self.R, label=\\\"Recovered\\\", color='m')\\n ax5.set_xlabel(\\\"Days\\\")\\n ax4.set_ylabel('Number of Recovered')\\n ax5.plot(t, self.V, label=\\\"Vaccinated\\\")\\n ax5.set_ylabel(\\\"# Vaccinated\\\")\\n ax1.legend()\\n ax2.legend()\\n ax3.legend()\\n ax4.legend()\\n plt.show()\\n return fig\",\n \"def getAxes():\\n subjects = load_file(\\\"meta-subjects\\\")\\n detections = load_file(\\\"meta-detections\\\")\\n antigens = load_file(\\\"meta-antigens\\\")\\n # Delete HIV1.Gag and gp140.HXBc2 antigens\\n antigens = antigens[(antigens.antigen != \\\"HIV1.Gag\\\") & (antigens.antigen != \\\"gp140.HXBc2\\\")]\\n\\n subjects = subjects[\\\"subject\\\"].to_list()\\n detections = detections[\\\"detection\\\"].to_list()\\n antigen = antigens[\\\"antigen\\\"].to_list()\\n\\n return subjects, detections, antigen\",\n \"def validate_totals():\\n fig, (ax_prior, ax2_post) = plt.subplots(\\n nrows=2, figsize=figsize(aspect=1.2))\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=np.arange(149.5, 250.5), commutes=True, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, league.totals)\\n\\n # exact prior distribution\\n outcomes = melo.training_data.value[:, np.newaxis] > melo.lines\\n sf = np.mean(outcomes, axis=0)\\n ax_prior.plot(melo.lines, sf, color='k')\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n plot_args = [\\n (ax_prior, melo.first_update, 'prior'),\\n (ax2_post, melo.last_update, 'posterior'),\\n ]\\n\\n for ax, time, title in plot_args:\\n for n, label2 in enumerate(label2_list):\\n\\n lines, sf = melo._predict(time, label1, label2)\\n label = r'$\\\\lambda_2={}$'.format(label2)\\n\\n if ax.is_first_row():\\n ax.plot(lines[n::6], sf[n::6], 'o', zorder=2, label=label)\\n\\n if ax.is_last_row():\\n ax.plot(lines, sf, 'o', zorder=2, label=label)\\n\\n sf = poisson.sf(melo.lines, int(label1) + int(label2))\\n ax.plot(melo.lines, sf, color='k')\\n\\n leg = ax.legend(title=r'$\\\\lambda_1 = {}$'.format(label1),\\n handletextpad=.2, loc=1)\\n leg._legend_box.align = 'right'\\n\\n lines = np.floor(lines)\\n ax.set_xticks(lines[::10])\\n ax.set_xlim(lines.min(), lines.max())\\n\\n if ax.is_last_row():\\n ax.set_xlabel('line $=$ scored $+$ allowed')\\n\\n ax.set_ylabel('probability to cover line')\\n\\n ax.annotate(title, xy=(.05, .05),\\n xycoords='axes fraction', fontsize=24)\\n\\n set_tight(h_pad=1)\",\n \"def figure4():\\n\\n plot_settings = {'y_limits': [-80, -50],\\n 'x_limits': None,\\n 'y_ticks': [-80, -70, -60, -50],\\n 'locator_size': 5,\\n 'y_label': 'Voltage (mV)',\\n 'x_ticks': [],\\n 'scale_size': 20,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_4',\\n 'legend': ['control', 'apamin'],\\n 'legend_size': 8,\\n 'y_on': True}\\n line_styles = ['-', 'dotted']\\n\\n plt.figure(figsize=(5, 3), dpi=96)\\n\\n plt.subplot(2, 1, 1) # Generate figure 1 (top)\\n for ix, g_sk_bar in enumerate([0.3, 0]):\\n t, y = solver(100, g_sk_bar=g_sk_bar)\\n plt.plot(t, y[:, 0], c='k', linestyle=line_styles[ix])\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 1, 2)\\n t1 = 1200\\n t, y = solver(t1, t_start=50, duration=t1, i_bias_on=0.33, g_sk_bar=0.03)\\n plt.plot(t, y[:, 0], 'k-')\\n\\n plot_settings['y_limits'] = [-100, 30]\\n plot_settings['x_limits'] = [0, t1]\\n plot_settings['y_ticks'] = [-80, -60, -40, -20, 0, 20]\\n plot_settings['locator_size'] = 10\\n plot_settings['scale_size'] = 100\\n plot_settings['legend'] = None\\n alter_figure(plot_settings, close=True) # Alter plot for publication\",\n \"def plot_corr_normalized(models,data,fit,**kwargs):\\n _fnNMod = len(models)\\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\\n ## -- objects to hold all plot data\\n ## - Dat/Fit refers to the correlator data or the fit function\\n ## - Central/Error are the central value and errors\\n _fnDatCentral = []\\n _fnDatError = []\\n _fnFitOnes = []\\n _fnFitError = []\\n #\\n ## -- other objects\\n _fnTDataNonZero = []\\n _fnTFitNonZero = []\\n _fnTData = []\\n _fnTFit = []\\n _fnTRem = [] # number of previous timeslices removed\\n fig,ax = plt.subplots(1)\\n #\\n ## -- setup plot function\\n def do_plot_normalized(idx,fig=fig):\\n fig.clear()\\n ax = fig.add_subplot(111)\\n key = models[idx[0]].datatag\\n\\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\\n ax.set_ylim(utp.get_option(\\\"y_limit\\\",[0.2,1.8],**kwargs[key]))\\n #\\n ## -- plot fit\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\\n color=utp.get_option(\\\"color2\\\",'b',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ## -- plot correlator data\\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\\n mfc=utp.get_option(\\\"markerfacecolor1\\\",'None',**kwargs[key]),\\n mec=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n color=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle1\\\",'None',**kwargs[key]),\\n marker=utp.get_option(\\\"marker1\\\",'o',**kwargs[key]),\\n ms=utp.get_option(\\\"markersize\\\",6,**kwargs[key]))\\n ax.scatter(_fnTFitNonZero[idx[0]],\\n [ _fnDatCentral[idx[0]][t] for t in\\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\\n color=utp.get_option(\\\"color1\\\",'r',**kwargs[key]),\\n marker=utp.get_option(\\\"marker\\\",'o',**kwargs[key]),\\n s=utp.get_option(\\\"markersize\\\",36,**kwargs[key]))\\n fig.suptitle(utp.get_option(\\\"plottitlefn\\\",str(idx[0])+\\\" default title \\\"+str(key),**kwargs[key]),\\n fontsize=utp.get_option(\\\"titlesize\\\",20,**kwargs[key]))\\n ## -- modify some options \\n ax.set_xlabel(r'$t$')\\n ax.set_ylabel(utp.get_option(\\\"yaxistitle\\\",r\\\"$C(t)/C_{fit}(t)$\\\",**kwargs[key]))\\n for item in ([ax.xaxis.label,ax.yaxis.label]):\\n # must be after setting label content (LaTeX ruins it)\\n item.set_fontsize(fontsize=utp.get_option(\\\"fontsize\\\",20,**kwargs[key]))\\n rect =fig.patch\\n rect.set_facecolor('white')\\n if utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".pdf\\\",**kwargs[key])\\n plt.savefig(save_dir+'/'+save_name)\\n if utp.get_option(\\\"to_terminal\\\",True,**kwargs[key]):\\n plt.draw()\\n pass\\n #\\n ## -- setup button press action function\\n def press_normalized(event,idx=_fnIdx):\\n #print('press_normalized', event.key)\\n try:\\n ## -- manually indicate index\\n idx[0] = int(event.key) + (idx[0])*10\\n except ValueError:\\n if event.key==' ': ## -- space\\n ## -- allows for replotting when changing index by typing number keys\\n idx[0] = idx[0] % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='left':\\n idx[0] = (idx[0] - 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='right':\\n idx[0] = (idx[0] + 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='backspace':\\n ## -- reset index so can manually flip through using number keys\\n idx[0] = 0\\n elif event.key=='d':\\n ## -- dump plots into ./plotdump directory\\n for ix,model in zip(range(len(models)),models):\\n key = model.datatag\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".png\\\",**kwargs[key])\\n do_plot_normalized([ix])\\n plt.savefig(save_dir+'/'+save_name)\\n do_plot_normalized(idx)\\n #\\n ## -- \\n fig.canvas.mpl_connect('key_press_event',press_normalized)\\n ## -- save plot data\\n for idx,model in zip(range(len(models)),models):\\n key = model.datatag\\n _fnTData.append(model.tdata)\\n _fnTFit.append(model.tfit)\\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\\n ## -- fit\\n _fnFitFunc = utp.create_fit_func(model,fit)\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\\n _fnTRem[-1] = \\\\\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\\n ## -- data\\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean)) )\\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean) )\\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\\n ## -- done saving data\\n \\n if not(utp.get_option(\\\"to_terminal\\\",True,**kwargs[key])) and\\\\\\n utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n for ix in range(len(models)):\\n ## -- loops and saves all without creating window\\n do_plot_normalized([ix])\\n else:\\n do_plot_normalized(_fnIdx)\",\n \"def create_plot():\\n\\n fig, ax = plt.subplots()\\n return fig, ax\",\n \"def _newax(ax=None):\\n from matplotlib import pyplot as plt\\n if ax is not None:\\n return ax\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 1, 1)\\n return ax\",\n \"def plot_ctx_net_analysis(t, recalled_ctx, ctx, ctx_test_env, fig=None):\\n if fig is None:\\n fig = plt.gcf()\\n\\n subplots = gridspec.GridSpec(2, 2, width_ratios=(1., 2.))\\n ax1 = fig.add_subplot(subplots[0, 0])\\n ax1.set_title(\\\"(a) Norm\\\")\\n ax2 = fig.add_subplot(subplots[1, 0], sharex=ax1)\\n ax2.set_title(\\\"(b) Effective context drift\\\")\\n ax3 = fig.add_subplot(subplots[:, 1], sharex=ax1)\\n ax3.set_title(\\\"(c) Context similarity decay\\\")\\n\\n plot_ctx_norm(t, ctx, ax=ax1)\\n plot_effective_beta(t, recalled_ctx, ctx, ctx_test_env, ax=ax2)\\n plot_similarity_decay(t, ctx, ctx_test_env, ax=ax3)\\n\\n sns.despine(fig)\\n subplots.tight_layout(fig)\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def test_plot_drift(self):\\n with patch('matplotlib.pyplot.show') as mock: # don't display the figure\\n with patch('matplotlib.pyplot.savefig') as mock2: # don't display the figure\\n times = (datetime.datetime(2000, 1, 1), datetime.datetime(2000, 1, 2), datetime.datetime(2000, 1, 3))\\n ref_ratio = (0, 0, 0)\\n plot = librad_drift.RadiometricDrift.plot_radiometric_drift\\n drift = plot(times, ref_ratio, 'target', 'reference', band=0, doplot=False)\\n self.assertEqual(drift, 0)\",\n \"def plot_results(\\n train_data: tuple[Tensor, Tensor],\\n test_data: tuple[Tensor, Tensor],\\n correct_class: Tensor\\n):\\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\\n ax1.set_title('Training data')\\n plot_dataset(train_data, ax1)\\n\\n ax2.set_title('Test data')\\n plot_dataset(test_data, ax2)\\n\\n ax3.set_title('Test prediction correctness')\\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\\n \\n fig1.savefig('plots/datasets')\\n fig2.savefig('plots/predictions')\\n plt.show()\",\n \"def PlotAcc(acc_CAL, queries_CAL, acc_random, queries_random):\\n\\n\\t### TODO: make the accuracy plot\\n\\n\\n\\tplt.plot(range(1,len(acc_CAL)+1), acc_CAL, label=\\\"CAL sampling\\\")\\n\\tplt.plot(range(1,len(acc_random)+1), acc_random, label=\\\"Random Sampling\\\")\\n\\tplt.legend()\\n\\tplt.xlabel(\\\"Query number\\\")\\n\\tplt.ylabel(\\\"Test accuracy\\\")\\n\\tplt.title(\\\"Test Accuracies in CAL & Random Sampling\\\")\\n\\tplt.savefig(\\\"acc.png\\\")\\n\\tplt.clf()\\n\\n\\tnames = [\\\"CAL sampling\\\", \\\"Random Sampling\\\"]\\n\\tvalues = [queries_CAL, queries_random]\\n\\n\\tplt.scatter(names, values)\\n\\tplt.title(\\\"Number Queried\\\")\\n\\tplt.savefig(\\\"queried.png\\\")\\n\\tplt.clf()\\n\\n\\tprint(queries_CAL)\\n\\treturn\",\n \"def mpl_plot_was_rendered():\\n figs_before = plt.gcf().number\\n yield\\n figs_after = plt.gcf().number\\n assert figs_after > figs_before\",\n \"def plot(self) -> Figure:\\n ax = self.setup_plot()\\n ax.errorbar(\\n self.doses,\\n self.means,\\n yerr=self.errorbars(),\\n label=\\\"Mean ± 95% CI\\\",\\n **plotting.DATASET_POINT_FORMAT,\\n )\\n ax.legend(**plotting.LEGEND_OPTS)\\n return ax.get_figure()\",\n \"def plot(self):\\n if self._traces is not None:\\n strong_form_plot(self)\\n else:\\n weak_form_plot(self)\",\n \"def _plot_modal_controllability(self, axes=None, acute=True,\\n **parameter_overrides):\\n\\n par, array_keys, array_len = self._parse_parameter_overrides(\\n **parameter_overrides)\\n\\n betas = self._calc_modal_controllability(acute=acute,\\n **parameter_overrides)\\n betas = np.rad2deg(betas)\\n\\n if axes is None:\\n fig, axes = plt.subplots(*betas[0].shape, sharex=True)\\n\\n for i, row in enumerate(axes):\\n row[0].set_ylabel('Mode {}'.format(i + 1))\\n for j, col in enumerate(row):\\n col.plot(par[array_keys[0]], betas[:, i, j])\\n\\n axes[3, 0].set_xlabel(array_keys[0])\\n axes[3, 1].set_xlabel(array_keys[0])\\n\\n axes[0, 0].set_title(r'Input: $T_\\\\phi$')\\n axes[0, 1].set_title(r'Input: $T_\\\\delta$')\\n\\n return axes\",\n \"def compare(args):\\n p = OptionParser(__doc__)\\n opts, args, iopts = p.set_image_options(args, figsize=\\\"15x5\\\")\\n\\n if len(args) != 1:\\n sys.exit(not p.print_help())\\n\\n datafile, = args\\n pf = datafile.rsplit(\\\".\\\", 1)[0]\\n fig, (ax1, ax2, ax3) = plt.subplots(ncols=3, nrows=1,\\n figsize=(iopts.w, iopts.h))\\n plt.tight_layout(pad=2)\\n\\n # Huntington risk allele\\n infected_thr = 40\\n ref_thr = 19\\n\\n # ax1: Multiple callers at lower range\\n df = pd.read_csv(\\\"Evaluation.csv\\\")\\n truth = df[\\\"Truth\\\"]\\n\\n ax1.plot(truth, df[\\\"Manta\\\"], 'bx-')\\n ax1.plot(truth, df[\\\"Isaac\\\"], 'yo-')\\n ax1.plot(truth, df[\\\"GATK\\\"], 'md-')\\n ax1.plot(truth, df[\\\"lobSTR\\\"], 'c+-')\\n ax1.plot(truth, truth, 'k--') # to show diagonal\\n\\n bbox = {'facecolor': 'tomato', 'alpha': .2, 'ec': 'w'}\\n pad = 2\\n ax1.axhline(infected_thr, color='tomato')\\n ax1.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\\n bbox=bbox, ha=\\\"right\\\")\\n ax1.axhline(ref_thr, color='tomato')\\n ax1.text(max(truth) - pad, ref_thr - pad, 'Reference repeat count',\\n bbox=bbox, ha=\\\"right\\\", va=\\\"top\\\")\\n\\n ax1.set_xlabel(r'Num of CAG repeats inserted ($\\\\mathit{h}$)')\\n ax1.set_ylabel('Num of CAG repeats called')\\n ax1.set_title(r'Simulated haploid $\\\\mathit{h}$')\\n ax1.legend(['Manta', 'Isaac', 'GATK', 'lobSTR', 'Truth'], loc='best')\\n\\n max_insert = 120\\n # ax2: lobSTR vs TREDPARSE with haploid model\\n lobstr_results = parse_results(\\\"lobstr_results_homo.txt\\\")\\n tredparse_results = parse_results(\\\"tredparse_results_homo.txt\\\")\\n truth = range(10, max_insert + 1)\\n lx, ly = zip(*lobstr_results)\\n tx, ty = zip(*tredparse_results)\\n\\n ax2.plot(lx, ly, 'c+-')\\n ax2.plot(tx, ty, 'gx-')\\n ax2.plot(truth, truth, 'k--')\\n\\n ax2.set_xlabel(r'Num of CAG repeats inserted ($\\\\mathit{h}$)')\\n ax2.set_ylabel('Num of CAG repeats called')\\n ax2.set_title(r'Simulated haploid $\\\\mathit{h}$')\\n ax2.legend(['lobSTR', 'TREDPARSE', 'Truth'], loc='best')\\n\\n pad *= 2\\n ax2.axhline(infected_thr, color='tomato')\\n ax2.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\\n bbox=bbox, ha=\\\"right\\\")\\n ax2.set_xlim(10, max_insert)\\n\\n # ax3: lobSTR vs TREDPARSE with haploid model\\n lobstr_results = parse_results(\\\"lobstr_results_het.txt\\\", exclude=20)\\n tredparse_results = parse_results(\\\"tredparse_results_het.txt\\\", exclude=20)\\n truth = range(10, max_insert + 1)\\n lx, ly = zip(*lobstr_results)\\n tx, ty = zip(*tredparse_results)\\n\\n ax3.plot(lx, ly, 'c+-')\\n ax3.plot(tx, ty, 'gx-')\\n ax3.plot(truth, truth, 'k--')\\n\\n ax3.set_xlabel(r'Num of CAG repeats inserted ($\\\\mathit{h}$)')\\n ax3.set_ylabel('Num of CAG repeats called')\\n ax3.set_title(r'Simulated diploid $\\\\mathit{20/h}$')\\n ax3.legend(['lobSTR', 'TREDPARSE', 'Truth'], loc='best')\\n ax3.axhline(infected_thr, color='tomato')\\n ax3.text(max(truth) - pad, infected_thr + pad, 'Risk threshold',\\n bbox=bbox, ha=\\\"right\\\")\\n ax3.set_xlim(10, max_insert)\\n\\n root = fig.add_axes([0, 0, 1, 1])\\n pad = .03\\n panel_labels(root, ((pad / 2, 1 - pad, \\\"A\\\"), (1 / 3., 1 - pad, \\\"B\\\"),\\n (2 / 3., 1 - pad, \\\"C\\\")))\\n normalize_axes(root)\\n\\n image_name = pf + \\\".\\\" + iopts.format\\n savefig(image_name, dpi=iopts.dpi, iopts=iopts)\",\n \"def ablationPlot():\\n fig, ax = plt.subplots()\\n x = pickle.load(open(\\\"pickles/ablation_tau_x.pkl\\\", \\\"rb\\\"))\\n averages = pickle.load(open(\\\"pickles/ablation_tau_y.pkl\\\", \\\"rb\\\"))\\n stds = pickle.load(open(\\\"pickles/ablation_tau_stds.pkl\\\", \\\"rb\\\"))\\n plt.xlabel(\\\"Intensity Percentile of YFP-tau and DAPI Ablated\\\", fontname=\\\"Times New Roman\\\", fontsize=12) \\n x = [val * 100 for val in x]\\n x_vals = ax.get_xticks()\\n x_vals = np.insert(x_vals, 0, 0)\\n ax.set_xticklabels(['{:,.0%}'.format(x_val) for x_val in x_vals], fontname=\\\"Times New Roman\\\")\\n ax.axhline(.53, linestyle=\\\"--\\\", color='black', lw=.80, alpha=0.8)\\n ax.errorbar(x, averages, yerr=stds, capsize=1.5, elinewidth=.2, ecolor=\\\"black\\\", label=\\\"ML Model\\\")\\n ax.set_ylabel(\\\"Average Pearson Correlation Over Test Set\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n plt.axis((-.02,102,0,1))\\n plt.title(\\\"Pearson Performance with Increasing Ablations\\\", fontname=\\\"Times New Roman\\\", fontsize=14)\\n for tick in ax.get_xticklabels():\\n tick.set_fontname(\\\"Times New Roman\\\")\\n for tick in ax.get_yticklabels():\\n tick.set_fontname(\\\"Times New Roman\\\")\\n plt.savefig(\\\"matplotlib_figures/ablation.png\\\", dpi=300)\",\n \"def analyze(data):\\n # perform fit\\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\\n print(regr_results.tvalues)\\n \\n fig = plt.figure(figsize=(6, 9))\\n\\n # plot predicted vs. measured mosquito populations from fitted model \\n ax0 = fig.add_subplot(3, 1, 1)\\n\\n parameters = regr_results.params\\n predicted = (parameters['Intercept'] + \\n parameters['temperature'] * data['temperature'] + \\n parameters['rainfall'] * data['rainfall'])\\n\\n ax0.plot(predicted, data['mosquitos'], 'gd')\\n\\n ax0.set_xlabel('predicted mosquito population')\\n ax0.set_ylabel('measured mosquito population')\\n \\n # plot mosquitos vs. temperature\\n ax1 = fig.add_subplot(3, 1, 2)\\n\\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\\n ax1.set_xlabel('temperature')\\n ax1.set_ylabel('mosquitos')\\n\\n # plot mosquitos vs. rainfall\\n ax2 = fig.add_subplot(3, 1, 3)\\n\\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\\n ax2.set_xlabel('rainfall')\\n ax2.set_ylabel('mosquitos')\\n \\n # adjust layout of axes according to label placement\\n plt.tight_layout()\\n \\n return fig\",\n \"def PlotEX(df, eom=None, show_plot=True):\\n # Ensure 'Study' is in header.\\n # TODO: Add code.\\n # Obtain exceedence probabilities.\\n if eom:\\n df_excd = stats.AnnualExceedence(df, eom=eom)\\n else:\\n df_excd = stats.MonthlyExceedence(df)\\n # Get list of variables.\\n var_list = set(df_excd.columns.get_level_values('Part B'))\\n # Determine number of axes in the figure.\\n n_var = len(var_list)\\n n_row = np.int(np.around(np.sqrt(n_var)))\\n if n_row**2 >= n_var:\\n n_col = n_row\\n else:\\n n_col = n_row + 1\\n fig, ax = plt.subplots(nrows=n_row, ncols=n_col, figsize=(16, 9))\\n # Remove extra axes, if necessary.\\n if n_row * n_col != n_var:\\n n_empty = n_row * n_col - n_var\\n for k in range(n_empty):\\n ax[-1, -(1+k)].remove()\\n # Initialize variables for updating axes.\\n cur_row = 0\\n cur_col = 0\\n # Plot each variable.\\n for var in var_list:\\n df_exc = df_excd.xs(var, level='Part B', axis=1)\\n # Initialize parameters for current axis.\\n y_min = np.min(df_exc.values)\\n y_max = np.max(df_exc.values)\\n col_var = df_exc.columns\\n # Select current axis.\\n if n_row == 1 and n_col == 1:\\n ax_cur = ax\\n elif n_row == 1:\\n ax_cur = ax[cur_col]\\n else:\\n ax_cur = ax[cur_row, cur_col]\\n # Plot study results for each variable.\\n for c in col_var:\\n sr_plot = df_exc[c]\\n label_c = '{} {}'.format(*c[:2])\\n ax_cur.plot(sr_plot, label=label_c, linewidth=1.0, alpha=0.7)\\n # Set plot title.\\n if eom:\\n month_name = dt.date(1900, eom, 1).strftime('%B')\\n temp_title = 'Exceedence Plot of {} (End of {})'\\n ax_cur.set_title(temp_title.format(var, month_name))\\n else:\\n ax_cur.set_title('Exceedence Plot of {} (All Months)'.format(var))\\n # Modify x-axis and y-axis.\\n label_c = set(df_exc.columns.get_level_values('Part C'))\\n _unit = df_exc.columns.get_level_values('Units')\\n _dtyp = df_exc.columns.get_level_values('Data Type')\\n unit_d = list(zip(_unit, _dtyp))\\n combo_unit = [' '.join(i) for i in unit_d]\\n label_u = set(combo_unit)\\n ax_cur.set_ylabel('{} ({})'.format(r'/'.join(label_c),\\n r'/'.join(label_u)))\\n ax_cur.set_ylim(bottom=y_min, top=y_max)\\n ax_cur.set_xlabel('Exceedance Probability')\\n ax_cur.spines['right'].set_visible(False)\\n ax_cur.spines['top'].set_visible(False)\\n # Set legend.\\n ax_cur.legend(title='Study, Part F')\\n # Update current axis.\\n cur_col += 1\\n if cur_col >= n_col:\\n cur_col = 0\\n cur_row += 1\\n # Adjust layout.\\n plt.tight_layout()\\n # Add figure notes.\\n t = PlotChartNotes()\\n if n_row * n_col != n_var:\\n x_pos = (1 - n_empty / n_col) + 0.025\\n y_pos = (1 / n_row) - 0.025\\n plt.figtext(x_pos, y_pos, t, ha='left', va='top', wrap=True)\\n else:\\n plt.figtext(0.05, 0, t, ha='left', va='bottom', wrap=True)\\n plt.subplots_adjust(bottom=0.2)\\n # Show plot, if requested.\\n if show_plot:\\n plt.show()\\n # Return figure and axes.\\n return fig, ax\",\n \"def compare_plot_outcome(data_lastDV):\\n # TODO: These should be box plots, not bar plots\\n col_names = data_lastDV.columns.values.tolist() # get the columns' names\\n outcome = col_names.pop() # remove the last item in the list\\n\\n dimension = 2 # TODO: figure out better way to organize plots by location\\n\\n fig = plt.figure()\\n i = 1\\n for cond in col_names:\\n ax = fig.add_subplot(len(col_names)/dimension, dimension, i)\\n #df_compare = pd.concat([data.groupby(cond)[cond].count(), data.groupby(cond)[outcome].mean()], axis=1) # displays num helpers selected in each condition\\n df_compare = data_lastDV.groupby(cond)[outcome].mean() # displays num helpers selected in each condition\\n ax = df_compare.plot(kind='bar', title=cond)\\n ax.set_xlabel(cond)\\n ax.set_ylabel(\\\"mean \\\" + outcome)\\n i += 1\\n fig.tight_layout()\\n plt.show()\",\n \"def plot_diagram(probs, labels, y_axis='accuracy'):\\n probs_labels = [(prob, labels[i]) for i, prob in enumerate(probs)]\\n probs_labels = np.array(sorted(probs_labels, key=lambda x: x[0]))\\n window_len = int(len(labels)/100.)\\n calibration_errors = []\\n confidences = []\\n accuracies = []\\n # More interesting than length of the window (which is specific to this\\n # window) is average distance between datapoints. This normalizes by dividing\\n # by the window length.\\n distances = []\\n for i in range(len(probs_labels)-window_len):\\n distances.append((\\n probs_labels[i+window_len, 0] - probs_labels[i, 0])/float(window_len))\\n # It's pretty sketchy to look for the 100 datapoints around this one.\\n # They could be anywhere in the probability simplex. This introduces bias.\\n mean_confidences = mean(probs_labels[i:i + window_len, 0])\\n confidences.append(mean_confidences)\\n class_accuracies = mean(probs_labels[i:i + window_len, 1])\\n accuracies.append(class_accuracies)\\n calibration_error = class_accuracies-mean_confidences\\n calibration_errors.append(calibration_error)\\n\\n if y_axis == 'accuracy':\\n fig, ax = plt.subplots()\\n fig.set_size_inches(5, 5)\\n xbins = [i/10. for i in range(11)]\\n ax.plot(confidences, accuracies, color='green')\\n ax.plot(xbins, xbins, color='orange')\\n ax.set_xlabel('Model Confidence')\\n ax.set_ylabel('Model Accuracy')\\n elif y_axis == 'error':\\n fig, ax = plt.subplots()\\n fig.set_size_inches(5, 5)\\n xbins = [i/10. for i in range(11)]\\n ax.plot(confidences, calibration_errors, color='green')\\n ax.plot(xbins, xbins, color='orange')\\n ax.set_xlabel('Model Confidence')\\n ax.set_ylabel('Model Calibration Error')\\n ax.set_title('Reliability Diagram', fontsize=20)\\n return fig\",\n \"def plot_figures(compare_df, compare_df_without_1_5, over_3, over_6, ppm, \\n color_prob, color_count, edgecolor): \\n # Create a gridspec to plot in\\n fig = plt.figure()\\n gs = fig.add_gridspec(2,4)\\n ax1 = fig.add_subplot(gs[0,:])\\n ax2 = fig.add_subplot(gs[1,:2])\\n ax3 = fig.add_subplot(gs[1,2])\\n ax4 = fig.add_subplot(gs[1,3])\\n \\n ##### Plot the total count\\n compare_df.plot(kind=\\\"bar\\\", ax=ax1,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor )\\n ax1.set_title(\\\"a) Temperature count in AR5 working group reports and special reports until 2020\\\")\\n \\n #### Plot without the 1.5 special report\\n compare_df_without_1_5.plot(kind=\\\"bar\\\", ax=ax2, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax2.set_title(\\\"b) Excluding special report on 1.5°C warming\\\")\\n plt.setp(ax2.xaxis.get_majorticklabels(), fontsize=6)\\n \\n #### Plot 3\\n over_3.plot(kind=\\\"bar\\\", ax=ax3, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax3.set_title(\\\"c) 3°C and above\\\")\\n plt.setp(ax3.xaxis.get_majorticklabels(), color=\\\"white\\\")\\n \\n #### Plot only 6 degrees and above\\n over_6.plot(kind=\\\"bar\\\", ax=ax4, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax4.set_title(\\\"d) 6°C and above\\\")\\n plt.setp(ax4.xaxis.get_majorticklabels(), color=\\\"white\\\")\\n \\n # make nicer\\n i = 0\\n for ax in [ax1, ax2, ax3, ax4]:\\n ax.set_ylabel(\\\"Percentage [%]\\\")\\n if i == 0:\\n plot_nicer(ax)\\n else: \\n plot_nicer(ax, with_legend=False)\\n plt.setp(ax.xaxis.get_majorticklabels(), rotation=0)\\n i +=1\\n \\n fig=plt.gcf()\\n fig.set_size_inches(12,6)\\n fig.tight_layout()\\n plt.savefig(\\\"Figures\\\" + os.sep + \\\"warming_count_\\\"+str(ppm)+\\\".png\\\",dpi=200, bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def plot_actual_vs_predicted_by_equations(df, x_variable, y_variables, plot_title):\\n #Plot results\\n df.plot(x=x_variable, y=y_variables, title=plot_title)\\n plt.show()\",\n \"def test_all_plots_working(self):\\n optimizer = \\\"RandomSearch\\\"\\n name = \\\"test_init_experiment\\\"\\n param_defs = {\\n \\\"x\\\": MinMaxNumericParamDef(0, 1),\\n \\\"name\\\": NominalParamDef([\\\"A\\\", \\\"B\\\", \\\"C\\\"])\\n }\\n minimization = True\\n\\n LAss = PrettyLabAssistant()\\n LAss.init_experiment(name, optimizer, param_defs, minimization=minimization)\\n LAss.init_experiment(name + \\\"2\\\", optimizer, param_defs, minimization=minimization)\\n cand = LAss.get_next_candidate(name)\\n cand.result = 1\\n LAss.update(name, cand)\\n LAss.write_out_plots_current_step()\\n LAss.plot_result_per_step([name], show_plot=False)\\n LAss.exp_assistants[name].experiment.minimization_problem = False\\n LAss.plot_result_per_step(name, show_plot=False)\",\n \"def isotropic_correction(self):\\n isob = self.IsotropicCorrection(self,'back')\\n isof = self.IsotropicCorrection(self,'front')\\n sindec = np.sin(np.radians(np.array(self.df.dec.values,float)))\\n fig, axx = plt.subplots(1,2, figsize=(12,5), sharey=True)\\n ax=axx[1]\\n for i in range(2):\\n ax.plot(sindec, isob(i), '.', label='Energy Bin {}'.format(i));\\n ax.set(xlabel='sin(Dec)', title='Back correction vs. Dec.')\\n\\n ax=axx[0]\\n for f, name in [(isof, 'Front'), (isob, 'Back')]:\\n means = [f(i)[np.abs(sindec)<0.25].mean() for i in range(8)]\\n ax.plot(means, 'o', label=name)\\n ax.set_title('Correction factor vs Energy Bin')\\n ax.set(xlabel='Energy Bin',ylabel='Correction Factor',)\\n\\n for ax in axx:\\n ax.grid(alpha=0.5);\\n ax.axhline(1.0, color='k', ls='--')\\n ax.legend()\\n\\n return fig\",\n \"def ex1_plots(instance, destination, prefix, save, animate):\\n \\n plts = ukf_plots(instance, destination, prefix, save, animate)\\n\\n truths = truth_parser(instance)\\n nan_array= nan_array_parser(instance, truths, instance.base_model)\\n #obs, obs_key = obs_parser(instance, True)\\n obs_key = obs_key_parser(instance, True)\\n preds = preds_parser(instance, True)\\n #forecasts = forecasts_parser(instance, True)\\n \\n ukf_params = instance.ukf_params\\n index2 = ukf_params[\\\"index2\\\"]\\n \\n \\\"remove agents not in model to avoid wierd plots\\\"\\n #obs *= nan_array\\n truths *= nan_array\\n preds *= nan_array\\n #forecasts*= nan_array\\n \\n \\\"indices for unobserved agents\\\"\\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\\n plts.pair_frame(truths, preds, obs_key, 10, destination)\\n plts.error_hist(truths[::instance.sample_rate,index2], \\n preds[::instance.sample_rate,index2],\\\"Observed Errors\\\")\\n if len(not_index2)>0:\\n plts.error_hist(truths[::instance.sample_rate, not_index2], \\n preds[::instance.sample_rate, not_index2],\\\"Unobserved Errors\\\")\\n \\n #plts.path_plots(obs[::instance.sample_rate] , \\\"Observed\\\")\\n plts.path_plots(preds[::instance.sample_rate], \\\"Predicted\\\")\\n plts.path_plots(truths, \\\"True\\\")\\n #plts.path_plots(forecasts[::instance.sample_rate], \\\"Forecasts\\\")\\n\\n if animate:\\n #plts.trajectories(truths, \\\"plots/\\\")\\n plts.pair_frames(truths, preds, obs_key,\\n truths.shape[0], \\\"../../plots/\\\")\",\n \"def show_plots(history):\\n loss_vals = history['loss']\\n val_loss_vals = history['val_loss']\\n epochs = range(1, len(history['accuracy'])+1)\\n \\n f, ax = plt.subplots(nrows=1,ncols=2,figsize=(16,4))\\n \\n # plot losses on ax[0]\\n ax[0].plot(epochs, loss_vals, color='navy',marker='o', linestyle=' ', label='Training Loss')\\n ax[0].plot(epochs, val_loss_vals, color='firebrick', marker='*', label='Validation Loss')\\n ax[0].set_title('Training & Validation Loss')\\n ax[0].set_xlabel('Epochs')\\n ax[0].set_ylabel('Loss')\\n ax[0].legend(loc='best')\\n ax[0].grid(True)\\n \\n # plot accuracies\\n acc_vals = history['accuracy']\\n val_acc_vals = history['val_accuracy']\\n\\n ax[1].plot(epochs, acc_vals, color='navy', marker='o', ls=' ', label='Training Accuracy')\\n ax[1].plot(epochs, val_acc_vals, color='firebrick', marker='*', label='Validation Accuracy')\\n ax[1].set_title('Training & Validation Accuracy')\\n ax[1].set_xlabel('Epochs')\\n ax[1].set_ylabel('Accuracy')\\n ax[1].legend(loc='best')\\n ax[1].grid(True)\\n \\n plt.show()\\n plt.close()\\n \\n # delete locals from heap before exiting\\n del loss_vals, val_loss_vals, epochs, acc_vals, val_acc_vals\",\n \"def plot(self):\\n fig = plt.figure()\\n ax = plt.gca()\\n ax.errorbar(self.sample_bins, self.test_scores.mean(axis=1),\\n yerr=self.test_scores.std(axis=1), fmt='r.-',\\n label='test')\\n ax.errorbar(self.sample_bins, self.train_scores.mean(axis=1),\\n yerr=self.train_scores.std(axis=1), fmt='b.-',\\n label='train')\\n ax.legend(loc='upper right')\\n return ax\",\n \"def plot(self):\\n fig, axes = plt.subplots(math.ceil(len(self.plots) / self.col_wrap), self.col_wrap)\\n\\n for ps, ax in zip(self.plots, axes.flatten()):\\n for p in ps:\\n if p.x is not None and p.y is not None:\\n p.method(x=p.x, y=p.y, *p.args, ax=ax, **p.kwargs)\\n else:\\n p.method(*p.args, ax=ax, **p.kwargs)\\n\\n return fig, axes\",\n \"def summarize_diagnostics(self):\\n # plot loss\\n pyplot.subplot(211)\\n pyplot.title('Cross Entropy Loss')\\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\\n # plot accuracy\\n pyplot.subplot(212)\\n pyplot.title('Classification Accuracy')\\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\\n # save plot to file\\n pyplot.savefig(f'{self.project_home / \\\"o\\\"}/{self.model.name}_plot.png')\\n pyplot.close()\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plot_variables(self, n, show=False, diagnostics=False):\\n\\n if diagnostics:\\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\\n else:\\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\\n\\n plt.subplots_adjust(hspace = 0)\\n end = len(n.history[\\\"det F\\\"])\\n epochs = np.arange(end)\\n a, = ax[0].plot(epochs, n.history[\\\"det F\\\"], label = 'Training data')\\n b, = ax[0].plot(epochs, n.history[\\\"det test F\\\"], label = 'Test data')\\n # ax[0].axhline(y=5,ls='--',color='k')\\n ax[0].legend(frameon = False)\\n ax[0].set_ylabel(r'$|{\\\\bf F}_{\\\\alpha\\\\beta}|$')\\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\\\"det test F\\\"][-1])\\n ax[1].plot(epochs, n.history[\\\"loss\\\"])\\n ax[1].plot(epochs, n.history[\\\"test loss\\\"])\\n # ax[1].set_xlabel('Number of epochs')\\n ax[1].set_ylabel(r'$\\\\Lambda$')\\n ax[1].set_xlim([0, len(epochs)]);\\n \\n if diagnostics:\\n ax[2].plot(epochs, n.history[\\\"det C\\\"])\\n ax[2].plot(epochs, n.history[\\\"det test C\\\"])\\n # ax[2].set_xlabel('Number of epochs')\\n ax[2].set_ylabel(r'$|{\\\\bf C}|$')\\n ax[2].set_xlim([0, len(epochs)]);\\n \\n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,0]\\n , color = 'C0', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,1]\\n , color = 'C0', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n \\\"\\\"\\\"\\n\\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,0]\\n , color = 'C1', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,1]\\n , color = 'C1', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n ax[3].legend(frameon=False)\\n \\\"\\\"\\\"\\n\\n ax[3].set_ylabel(r'$\\\\partial\\\\mu/\\\\partial\\\\theta$')\\n # ax[3].set_xlabel('Number of epochs')\\n ax[3].set_xlim([0, len(epochs)])\\n\\n # Mean of network output summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],alpha=0.5)\\n # Mean of test output network summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"test μ\\\"])[:,0],alpha=0.5)\\n ax[4].set_ylabel('μ')\\n ax[4].set_xlabel('Number of epochs')\\n ax[4].set_xlim([0, len(epochs)])\\n \\n\\n print ('Maximum Fisher info on train data:',np.max(n.history[\\\"det F\\\"]))\\n print ('Final Fisher info on train data:',(n.history[\\\"det F\\\"][-1]))\\n \\n print ('Maximum Fisher info on test data:',np.max(n.history[\\\"det test F\\\"]))\\n print ('Final Fisher info on test data:',(n.history[\\\"det test F\\\"][-1]))\\n\\n if np.max(n.history[\\\"det test F\\\"]) == n.history[\\\"det test F\\\"][-1]:\\n print ('Promising network found, possibly more epochs needed')\\n\\n plt.tight_layout()\\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62973243","0.5582412","0.54954946","0.5457916","0.5377934","0.53028226","0.52979976","0.5198705","0.5156626","0.51140463","0.5106329","0.50978374","0.5094472","0.5083405","0.49963522","0.49693686","0.4965705","0.49536103","0.4950388","0.4943999","0.4924295","0.49204746","0.49081248","0.4894345","0.4881188","0.48806962","0.48762208","0.4873615","0.48722315","0.48545069","0.48530665","0.48478726","0.48476928","0.4836212","0.48349318","0.48146427","0.48071754","0.4798919","0.47945967","0.4790765","0.47906047","0.47904646","0.47855622","0.4783384","0.47800413","0.47715986","0.47665685","0.47656357","0.47649303","0.47605065","0.47580022","0.47411093","0.47377336","0.4733164","0.4731572","0.47314867","0.47169828","0.47015855","0.4699333","0.46940273","0.4693302","0.46913925","0.468925","0.4685268","0.46814263","0.46750313","0.46722737","0.4671269","0.466883","0.4661759","0.46566874","0.46503457","0.46464324","0.4643099","0.4639505","0.46342927","0.46336955","0.46283922","0.46244854","0.4623763","0.46236363","0.4618435","0.46145147","0.4611766","0.46110758","0.46099156","0.46082285","0.46078852","0.46007833","0.45995954","0.45985225","0.45934972","0.45930046","0.45924744","0.459058","0.45877194","0.458551","0.45852378","0.457302","0.4572345"],"string":"[\n \"0.62973243\",\n \"0.5582412\",\n \"0.54954946\",\n \"0.5457916\",\n \"0.5377934\",\n \"0.53028226\",\n \"0.52979976\",\n \"0.5198705\",\n \"0.5156626\",\n \"0.51140463\",\n \"0.5106329\",\n \"0.50978374\",\n \"0.5094472\",\n \"0.5083405\",\n \"0.49963522\",\n \"0.49693686\",\n \"0.4965705\",\n \"0.49536103\",\n \"0.4950388\",\n \"0.4943999\",\n \"0.4924295\",\n \"0.49204746\",\n \"0.49081248\",\n \"0.4894345\",\n \"0.4881188\",\n \"0.48806962\",\n \"0.48762208\",\n \"0.4873615\",\n \"0.48722315\",\n \"0.48545069\",\n \"0.48530665\",\n \"0.48478726\",\n \"0.48476928\",\n \"0.4836212\",\n \"0.48349318\",\n \"0.48146427\",\n \"0.48071754\",\n \"0.4798919\",\n \"0.47945967\",\n \"0.4790765\",\n \"0.47906047\",\n \"0.47904646\",\n \"0.47855622\",\n \"0.4783384\",\n \"0.47800413\",\n \"0.47715986\",\n \"0.47665685\",\n \"0.47656357\",\n \"0.47649303\",\n \"0.47605065\",\n \"0.47580022\",\n \"0.47411093\",\n \"0.47377336\",\n \"0.4733164\",\n \"0.4731572\",\n \"0.47314867\",\n \"0.47169828\",\n \"0.47015855\",\n \"0.4699333\",\n \"0.46940273\",\n \"0.4693302\",\n \"0.46913925\",\n \"0.468925\",\n \"0.4685268\",\n \"0.46814263\",\n \"0.46750313\",\n \"0.46722737\",\n \"0.4671269\",\n \"0.466883\",\n \"0.4661759\",\n \"0.46566874\",\n \"0.46503457\",\n \"0.46464324\",\n \"0.4643099\",\n \"0.4639505\",\n \"0.46342927\",\n \"0.46336955\",\n \"0.46283922\",\n \"0.46244854\",\n \"0.4623763\",\n \"0.46236363\",\n \"0.4618435\",\n \"0.46145147\",\n \"0.4611766\",\n \"0.46110758\",\n \"0.46099156\",\n \"0.46082285\",\n \"0.46078852\",\n \"0.46007833\",\n \"0.45995954\",\n \"0.45985225\",\n \"0.45934972\",\n \"0.45930046\",\n \"0.45924744\",\n \"0.459058\",\n \"0.45877194\",\n \"0.458551\",\n \"0.45852378\",\n \"0.457302\",\n \"0.4572345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5505739"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":20281,"cells":{"query":{"kind":"string","value":"Returns a diagnostic plot visualizing how the bestfit coefficients compare against the priors. The method will show the results obtained during the most recent call to `correct()`. If `correct()` has not yet been called, a ``ValueError`` will be raised. Returns `~matplotlib.axes.Axes` The matplotlib axes object."},"document":{"kind":"string","value":"def diagnose_priors(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n names = [dm.name for dm in self.dmc]\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(\n 1, len(names), figsize=(len(names) * 4, 4), sharey=True\n )\n if not hasattr(axs, \"__iter__\"):\n axs = [axs]\n for idx, ax, X in zip(range(len(names)), axs, self.dmc):\n X.plot_priors(ax=ax)\n firstcol_idx = sum([m.shape[1] for m in self.dmc.matrices[:idx]])\n submatrix_coefficients = self.coefficients[\n firstcol_idx : firstcol_idx + X.shape[1]\n ]\n [ax.axvline(s, color=\"red\", zorder=-1) for s in submatrix_coefficients]\n return axs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def robustnessPlot(ax):\n # Setup the range of avidity and ligand concentration we'll look at\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\n\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\n columns=['gnus', 'Los'])\n\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\n\n # Change avidities to strings\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\nu=' + str(int(gnu)) + '$')\n\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\n\n # Plot the calculated crossvalidation performance\n sns.FacetGrid(pp,\n hue='gnus',\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\n\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\n\n ax.set_xlabel('Assumed IC Conc. (M)')\n ax.set_ylabel('LOO Prediction R-Squared')\n ax.set_ylim(0.0, 1.0)","def plotFittingResults(self):\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\n\n #_listExpStdDev = None\n #if self.getDataInput().getExperimentalDataStdDev():\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\n #if _listExpStdDev:\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\"Experimental Data\")\n # pylab.gca().set_yscale(\"log\", nonposy='clip')\n #else: \n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n pylab.semilogy(_listFitQ, _listFitValues, label=\"Fitting curve\")\n pylab.xlabel('q')\n pylab.ylabel('I(q)')\n pylab.suptitle(\"RMax : %3.2f. Fit quality : %1.3f\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\n pylab.legend()\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \"gnomFittingResults.png\"))\n pylab.clf()","def plot_result(numerical, exact):\n \n numx, numy = numerical\n exax, exay = exact\n plt.title('Comparison Numerical vs. Analytical Solution')\n plt.xlabel('Distance x (m)')\n plt.ylabel('Temperature $(^{o}C)$')\n plt.plot(numx, numy, 'ro', label='numerical')\n plt.plot(exax, exay, 'y--', label='analytical')\n plt.legend()\n plt.grid()","def analysis_plot(predictions, ys):\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\n\n residuals = ys - predictions\n\n # Plot 1 - Predicted vs Actual\n sns.scatterplot(predictions, ys, ax=ax1)\n ax1.set_title('Predicted vs Actual', fontsize=20)\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\n\n # Plot 2 - Residuals PLot (predicted vs residuals)\n sns.scatterplot(predictions, residuals, ax=ax2)\n ax2.set_title('Residuals Plot', fontsize=20)\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\n\n # Plot 3 - QQ Plot\n sm.qqplot(residuals, ax=ax3, line='s')\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\n\n plt.show();","def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\n \n plt.figure()\n plt.plot(x, phiExact)\n\n plt.plot(x, phi)\n plt.ylim([-0.2, 1.4])\n plt.title(str(methodName)+\" scheme\\nExact vs Numerical solution \"\\\n \"nt=\"+str(nt)+\", nx=\"+str(nx)+\"\\n\"\n \"Courant number: \"+str(c))\n plt.show()","def plot_insta_err(self, ax=None):\n if ax is None:\n ax = plt.gca()\n ax.set_yscale('log')\n ax.plot(list(range(1, self.max_dets)), self.errors[0], label='independent')\n ax.plot(list(range(1, self.max_dets)), self.errors[1], label='correlated')\n ax.set_ylabel(r'Stochastic error in $E_\\mathrm{corr}$ / ha')\n ax.set_xlabel('Number of determinants in estimator')\n ax.axhline(np.sqrt(self.proje_var[0]), linestyle='--', color='black', label='reference')\n ax.legend()\n return ax","def plot_fitting_coefficients(self):\n from matplotlib import pyplot as plt\n coeff = self.linear_fit[\"coeff\"]\n order = self.linear_fit[\"order\"]\n\n data = {}\n annotations = {}\n for c, o in zip(coeff, order):\n if len(o) == 0:\n continue\n n = len(o)\n if n not in data.keys():\n data[n] = [c]\n annotations[n] = [WulffConstruction.order2string(o)]\n else:\n data[n].append(c)\n annotations[n].append(WulffConstruction.order2string(o))\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1)\n start = 0\n keys = list(data.keys())\n keys.sort()\n for k in keys:\n x = list(range(start, start+len(data[k])))\n ax.bar(x, data[k], label=str(k))\n start += len(data[k]) + 1\n for i in range(len(data[k])):\n ax.annotate(annotations[k][i], xy=(x[i], data[k][i]))\n ax.set_ylabel(\"Fitting coefficient\")\n ax.set_xticklabels([])\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend(frameon=False)\n return fig","def _plot_resid_vs_fitted(self, ax):\n\n res = self._model.fit()\n\n ax.plot(res.fittedvalues, res.resid, '.')\n ax.set_xlabel('Fitted ' + self._model.endog_names)\n ax.set_ylabel('Raw residual')\n plt.sca(ax)\n plt.axhline(color='k')","def plot(self):\n # Sufficient to check a single existence condition\n if self._idx_coefs is None:\n raise NotFittedError('You must estimate the regression by calling fit prior to plotting.')\n\n plt.figure(figsize=(15,8))\n plt.plot(self._idx_coefs, color='black')\n plt.axhline(y=0, linestyle='--', color='black')\n plt.fill_between(\n self._idx_cis.index.values,\n self._idx_cis.lower.values.reshape(-1),\n self._idx_cis.upper.values.reshape(-1),\n color='cyan',\n alpha=0.3\n )\n plt.title(self._depvar_label)\n plt.ylabel('Estimated Coefficient')\n plt.xlabel('Days since Event')","def _diagnostic_plot(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=True)\n ax = axs[0]\n self.lc.plot(ax=ax, normalize=False, label=\"original\", alpha=0.4)\n for key in self.diagnostic_lightcurves.keys():\n (\n self.diagnostic_lightcurves[key]\n - np.median(self.diagnostic_lightcurves[key].flux)\n + np.median(self.lc.flux)\n ).plot(ax=ax)\n ax.set_xlabel(\"\")\n ax = axs[1]\n self.lc.plot(ax=ax, normalize=False, alpha=0.2, label=\"original\")\n self.corrected_lc[self.outlier_mask].scatter(\n normalize=False, c=\"r\", marker=\"x\", s=10, label=\"outlier_mask\", ax=ax\n )\n self.corrected_lc[~self.cadence_mask].scatter(\n normalize=False,\n c=\"dodgerblue\",\n marker=\"x\",\n s=10,\n label=\"~cadence_mask\",\n ax=ax,\n )\n self.corrected_lc.plot(normalize=False, label=\"corrected\", ax=ax, c=\"k\")\n return axs","def plot_solution(self):\n\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \"Analytical\")\n plt.plot(self.x_values, self.numerical, label = \"Numerical\")\n plt.title(\"Numerical vs. Analytical Solution\")\n plt.xlabel(\"x\")\n plt.ylabel(\"u(x)\")\n plt.legend()\n plt.show()","def testPlotCandidateDesign(self):\n\n np.random.seed(0)\n new_data = pd.concat([self.test_data, self.add_pair], sort=False)\n test_class = TrimmedMatchGeoXDesign(\n GeoXType.HEAVY_UP,\n pretest_data=new_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n )\n budget_list = [30, 40]\n iroas_list = [0, 2]\n results, _ = test_class.report_candidate_designs(\n budget_list=budget_list,\n iroas_list=iroas_list,\n use_cross_validation=True,\n num_simulations=10,\n )\n\n axes_dict = test_class.plot_candidate_design(results)\n for budget in budget_list:\n for iroas in iroas_list:\n self.assertIsInstance(axes_dict[(budget, iroas)], plt.Figure)","def plot_cnf_matrix(self):\n\t\tplt.figure()\n\t\tanalysis.plot_cnf_matrix(self.y_pred, self.y_test)","def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\n if axdelta is None:\n axdelta = plt.gca()\n delta = self.means - exact\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\n if blocked:\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\n if blockederr:\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\n axdelta.set_xlabel('Number of determinants in estimator')\n axdelta.set_ylabel(r'$E-E_\\mathrm{CCSD}$ / ha')\n axdelta.legend()\n return axdelta","def deviance_plot(est, X_test, y_test, ax=None, label='',train_color='#2c7bb6', test_color='#d7191c', alpha=1.0):\r\n\ttest_dev = np.empty(n_estimators) #创建数组\r\n\tfor i, pred in enumerate(est.staged_predict(X_test)):\r\n\t\ttest_dev[i] = est.loss_(y_test, pred)\r\n\tif ax is None:\r\n\t\tfig = plt.figure(figsize=(8,5))\r\n\t\tax = plt.gca();\r\n\tax.plot(np.arange(n_estimators)+1, test_dev, color=test_color, label='Test Error max_depth=1 %s' % label, linewidth=2, alpha=alpha)\r\n\tax.plot(np.arange(n_estimators)+1, est.train_score_, color=train_color, label='Train Error max_depth=1 %s' % label, linewidth=2, alpha=alpha)\r\n\tax.set_ylabel('Error')\r\n\tax.set_xlabel('n_estimators')\r\n\tax.set_ylim((0,2))\r\n\treturn test_dev, ax","def plot(guess_log, counter_log, x):\n correct_sqrt = np.sqrt(x)\n x_axis = np.linspace(-1, 1.1*len(guess_log), len(guess_log))\n y_axis = np.ones(len(guess_log))*correct_sqrt\n plt.plot(counter_log, guess_log, 'ok')\n plt.plot(x_axis, y_axis, '--r', linewidth=2.0, label='Correct Answer')\n plt.axis([-1, max(x_axis), -0.1*max(guess_log), 1.1*max(guess_log)])\n plt.xlabel('Iterations')\n plt.ylabel('Guess')\n plt.legend(loc = 'upper right')\n plt.show()\n return 0","def plot_dif_eq(self):\n try:\n self.canvas.get_tk_widget().pack_forget()\n self.toolbar.pack_forget()\n except AttributeError:\n pass\n\n f = Figure(figsize=(8, 8), dpi=100)\n p = f.add_subplot(111)\n\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\n\n p.set_ylabel('y')\n p.set_xlabel('x')\n\n p.legend(['Exact', 'EU', \"IEU\", \"RK\"])\n p.set_title(\"Solutions\")\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\n p.set_ylim([-100, 100])\n\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\n p.set_ylim([-100, 100])\n\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\n self.canvas.draw()\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\n\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\n self.toolbar.update()\n\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)","def plot_calibration_curve(est, name, fig_index, data):\n\n X_train = data[0]\n X_test = data[1]\n y_train = data[2]\n y_test = data[3]\n\n y = np.concatenate([y_train, y_test], axis=0)\n\n # Calibrated with isotonic calibration\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\n\n # Calibrated with sigmoid calibration\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\n\n # Logistic regression with no calibration as baseline\n lr = LogisticRegression(C=1., solver='lbfgs')\n\n fig = plt.figure(1, figsize=(15, 10))\n ax1 = plt.subplot2grid((4, 6), (0, 0), colspan=2, rowspan=2)\n ax2 = plt.subplot2grid((4, 6), (0, 2), colspan=2, rowspan=2)\n ax3 = plt.subplot2grid((4, 6), (0, 4), colspan=2, rowspan=2)\n ax4 = plt.subplot2grid((4, 6), (2, 0), colspan=6, rowspan=2)\n\n ax1.plot([0, 1], [0, 1], \"k:\", label=\"Perfectly calibrated\")\n for clf, name in [(lr, 'Logistic'),\n (est, name),\n (isotonic, name + ' + Isotonic'),\n (sigmoid, name + ' + Sigmoid')]:\n clf.fit(X_train, y_train)\n y_pred = clf.predict(X_test)\n if hasattr(clf, \"predict_proba\"):\n prob_pos = clf.predict_proba(X_test)[:, 1]\n y_proba = prob_pos.copy()\n else: # use decision function\n prob_pos = clf.decision_function(X_test)\n y_proba = prob_pos.copy()\n prob_pos = \\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\n\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\n print(\"%s:\" % name)\n print(\"\\tBrier: %1.3f\" % (clf_score))\n print(\"\\tPrecision: %1.3f\" % precision_score(y_test, y_pred))\n print(\"\\tRecall: %1.3f\" % recall_score(y_test, y_pred))\n print(\"\\tF1: %1.3f\" % f1_score(y_test, y_pred))\n print(\"\\tAve. Precision Score: %1.3f\\n\" % \\\n average_precision_score(y_test, y_proba))\n\n fraction_of_positives, mean_predicted_value = \\\n calibration_curve(y_test, prob_pos, n_bins=10)\n\n ax1.plot(mean_predicted_value, fraction_of_positives, \"s-\",\n label=\"%s (%1.3f)\" % (name, clf_score))\n\n fpr, tpr, thresholds = roc_curve(y_test, y_proba, drop_intermediate=False)\n roc_auc = roc_auc_score(y_test, y_proba)\n ax2.plot(fpr, tpr, ls='-', label=\"%s (%1.3f)\" % (name, roc_auc))\n\n precision, recall, _ = precision_recall_curve(y_test, y_proba)\n ax3.plot(recall, precision)\n\n ax4.hist(prob_pos, range=(0, 1), bins=10,\n label='%s' % name, histtype=\"step\", lw=2)\n\n ax1.set_xlabel(\"Score\", fontsize=14)\n ax1.set_ylabel(\"Fraction of positives\", fontsize=14)\n ax1.set_ylim([-0.05, 1.05])\n ax1.legend(loc=\"lower right\")\n ax1.set_title('Calibration plots (reliability curve)', fontsize=16)\n\n ax2.set_xlabel(\"False Positive Rate\", fontsize=14)\n ax2.set_ylabel(\"True Positive Rate\", fontsize=14)\n ax2.set_ylim([-0.05, 1.05])\n ax2.legend(loc=\"lower right\")\n ax2.set_title('ROC Curve', fontsize=16)\n\n ax3.set_xlabel(\"Recall\", fontsize=14)\n ax3.set_ylabel(\"Precision\", fontsize=14)\n ax3.set_ylim([-0.05, 1.05])\n ax3.legend(loc=\"lower center\")\n ax3.set_title('Precision-Recall Curve', fontsize=16)\n\n ax4.set_xlabel(\"Mean predicted value\", fontsize=14)\n ax4.set_ylabel(\"Count\", fontsize=14)\n ax4.legend(loc=\"upper center\")\n ax4.set_title('Classification Result', fontsize=16)\n\n plt.tight_layout()\n\n plt.show()\n\n return","def plot_coefs(results):\n coefs_noisy = pd.concat([\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\n vec_to_df(results['dist_neg'], n_arr, 'neg')\n ])\n\n xlim = (min(n_arr), max(n_arr))\n ylim = (-1.1, 1.1)\n\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\n ylim = ylim)\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\n g.set_xticklabels(rotation = 45)\n\n for i, val in enumerate(results['obj_true']):\n ax = g.axes[0, i]\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['pos_true']):\n ax = g.axes[1, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['neg_true']):\n ax = g.axes[2, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())","def plot_actual_vs_predicted_by_equations(df, x_variable, y_variables, plot_title):\n #Plot results\n df.plot(x=x_variable, y=y_variables, title=plot_title)\n plt.show()","def test_plotting():\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\n specs['interpolxydecs'][:, 1], specs['xopt'])\n\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\n potdata = np.vstack((xint, yint)).T\n\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\n\n expvaldata = np.vstack((expval, uncval)).T\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\n\n # qm_plottings('tests/test_data', scale=0.5)\n # assert True","def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\n\n # useful display and computational data\n y_fitted = poly_fit(x_data)\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\n x_fitted_display = np.linspace(min_x_display, max_x_display)\n y_fitted_display = poly_fit(x_fitted_display)\n\n # goodness of fit indicators\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\n R2 = 1.0 - SSE/SST # R squared\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\n\n fig = plt.figure()\n ax = fig.add_subplot(1, 2, 1)\n\n # plot of the fitted polynomial itself\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\n ax.scatter(x_data, y_data, color='C7')\n ax.set(title=\"Fitted polynomial (deg{}) for \\'{}\\'\".format(poly_fit.order, fit_name), xlabel=\"x\", ylabel=\"y\")\n\n # histogram of residuals\n ax2 = fig.add_subplot(1, 2, 2)\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\n ax2.set(title=\"Histogram of residuals\", xlabel=\"Residual value $y_k - \\\\widehat{y_k}$\", ylabel=\"Count\")\n\n # display of fit indicators\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\n\n fig.tight_layout()\n fig.subplots_adjust(bottom=0.2)\n\n figurefiles.save_in_perfs_fits_folder(fig, \"Polyfit_{}_order_{}.pdf\".format(fit_name, poly_fit.order))","def plot_err(self, expect=False, axallerr=None):\n if axallerr is None:\n axallerr = plt.gca()\n axallerr.set_yscale('log')\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[0], label='independent')\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[1], label='correlated (actual)')\n if expect:\n axallerr.plot(list(range(1, self.max_dets)), self.expcor_err, label='correlated (expected)')\n axallerr.set_ylabel(r'Stochastic error in $\\Delta E$ / ha')\n axallerr.set_xlabel('Number of determinants in estimator')\n axallerr.axhline(np.sqrt(self.proje_var[0]) / np.sqrt(self.result.shape[2]),\n linestyle='--', color='black', label='reference')\n axallerr.legend()\n return axallerr","def visualize(self):\n\t\tplt.figure(1)\n\t\tax1 = plt.add_suplot(1,2,1)\n\t\t# Plot free energy error\n\t\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\n\t\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\n\t\tplt.legend()\n\n\t\t# Plot density error\n\n\t\t# Plot log-likelihood of test set\n\n\t\t# Plot clustering score\n\n\t\tplt.show()\n\n\t\treturn","def plot_calibration_curve(est, name, fig_index):\n # Calibrated with isotonic calibration\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\n\n # Calibrated with sigmoid calibration\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\n\n # Logistic regression with no calibration as baseline\n lr = LogisticRegression(C=1.)\n\n fig = plt.figure(fig_index, figsize=(10, 10))\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\n ax2 = plt.subplot2grid((3, 1), (2, 0))\n\n ax1.plot([0, 1], [0, 1], \"k:\", label=\"Perfectly calibrated\")\n for clf, name in [(lr, 'Logistic'),(est, name),(isotonic, name + ' + Isotonic'),(sigmoid, name + ' + Sigmoid')]:\n #Para cada modelo, entrenamos y predecimos \n clf.fit(X_train, y_train)\n y_pred = clf.predict(X_test)\n if hasattr(clf, \"predict_proba\"):\n prob_pos = clf.predict_proba(X_test)[:, 1]\n else: # use decision function\n prob_pos = clf.decision_function(X_test)\n prob_pos = \\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\n\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\n print(\"%s:\" % name)\n print(\"\\tBrier: %1.3f\" % (clf_score))\n print(\"\\tPrecision: %1.3f\" % precision_score(y_test, y_pred))\n print(\"\\tRecall: %1.3f\" % recall_score(y_test, y_pred))\n print(\"\\tF1: %1.3f\\n\" % f1_score(y_test, y_pred))\n\n fraction_of_positives, mean_predicted_value = \\\n calibration_curve(y_test, prob_pos, n_bins=10)\n\n ax1.plot(mean_predicted_value, fraction_of_positives, \"s-\",\n label=\"%s (%1.3f)\" % (name, clf_score))\n\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\n histtype=\"step\", lw=2)\n\n ax1.set_ylabel(\"Fraction of positives\")\n ax1.set_ylim([-0.05, 1.05])\n ax1.legend(loc=\"lower right\")\n ax1.set_title('Calibration plots (reliability curve)')\n\n ax2.set_xlabel(\"Mean predicted value\")\n ax2.set_ylabel(\"Count\")\n ax2.legend(loc=\"upper center\", ncol=2)\n\n plt.tight_layout()","def plot(nSamples, expectations, variances, exactE, exactVar, title=\"\"):\n fig, axes = plt.subplots(2, 1)\n\n axes[0].semilogx(nSamples, expectations, color=\"black\", label=\"Empirical E(X)\")\n axes[0].axhline(exactE, color=\"darkgray\", label=\"Exact E(X)\")\n\n axes[1].semilogx(nSamples, variances, color=\"black\", label=\"Empirical Var(X)\")\n axes[1].axhline(exactVar, color=\"darkgray\", label=\"Exact Var(X)\")\n\n for ax in axes:\n ax.set_xlabel(\"N draws in the simulation\")\n ax.legend()\n axes[0].set_ylabel(\"E(X)\")\n axes[0].set_title(title)\n axes[1].set_ylabel(\"Var(X)\")\n plt.show()","def plot_results(\n train_data: tuple[Tensor, Tensor],\n test_data: tuple[Tensor, Tensor],\n correct_class: Tensor\n):\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\n ax1.set_title('Training data')\n plot_dataset(train_data, ax1)\n\n ax2.set_title('Test data')\n plot_dataset(test_data, ax2)\n\n ax3.set_title('Test prediction correctness')\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\n \n fig1.savefig('plots/datasets')\n fig2.savefig('plots/predictions')\n plt.show()","def plot(self, solution: Matrix) -> None:\n plots.plot_matrices(\"Total Variation Denoising\", self.M, solution)","def show_predictions(model, test_set, val_set, image_guess, img_res, data='OSNR', GRAY=True):\n \n ## Uses model to predict some amount of images\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\n \n ## Initialises variables for loop\n correctly_guessed = 0\n\n ## Defines figure dimensions\n fig = plt.figure(figsize=(20,30))\n\n ## Begins loop to find correct predictions and relay results to user\n ## Searches through the prediction array and compares it to the actual array.\n ## Displays image with the prediction and answer on the title\n for i in range(image_guess):\n correct = False\n actual = np.argmax(val_set[i])\n\n if predict[i] == actual:\n correctly_guessed += 1\n correct = True\n\n plt.subplot(6,3,i+1)\n fig.subplots_adjust(left=0.01,\n right=0.7,\n bottom=0.1,\n top=1.2,\n wspace=0.5,\n hspace=0.2\n )\n if GRAY == False:\n plt.imshow(test_set[i].reshape(img_res,img_res,3))\n else:\n plt.imshow(test_set[i].reshape(img_res,img_res), cmap='gray')\n\n if correct == True:\n if data == 'disp':\n plt.title('Correct! \\nPrediction = {}ps/nm Truth = {}ps/nm'\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\n \n if data == 'disp-short':\n plt.title('Correct! \\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\n \n if data == 'OSNR':\n plt.title('Correct! \\nPrediction = {}dB Truth = {}dB'\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\n \n \n else:\n if data == 'disp':\n plt.title('\\nPrediction = {}ps/nm Truth = {}ps/nm'\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\n \n if data == 'disp-short':\n plt.title('\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\n \n if data == 'OSNR':\n plt.title('\\nPrediction = {}dB Truth = {}dB'\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\n\n ## Returns amount of predictions that were correct\n print('Correctly guessed = ', correctly_guessed)\n print('Inorrectly guessed = ', (image_guess-correctly_guessed))","def plot_results(self, predictions: list):\n fig, ax = plt.subplots()\n cm = confusion_matrix(self.test[1], predictions)\n conf = confusion_matrix(self.test[1], predictions).ravel()\n nbr_labels = len(set(self.test[1]))\n cm = conf.reshape(nbr_labels, nbr_labels)\n sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Spectral\")\n ax.set_xlabel(\"predicted label\")\n ax.set_ylabel(\"true label\")\n fig.savefig(\"confusion_matrix\")\n\n fig, ax = plt.subplots()\n x = self.train[0] + self.test[0]\n y = self.train[1] + self.test[1]\n x = [i[0] for i in x]\n y = [i for i in y]\n results = pd.DataFrame({\"polarity strength\": x, \"true label\": y})\n sns.boxplot(data=results, x=\"true label\", y=\"polarity strength\")\n fig.savefig(\"boxplot\")","def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_time):\n ax.plot([y_true.min(), y_true.max()],\n [y_true.min(), y_true.max()],\n '--r', linewidth=2)\n ax.scatter(y_true, y_pred, alpha=0.2)\n\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.get_xaxis().tick_bottom()\n ax.get_yaxis().tick_left()\n ax.spines['left'].set_position(('outward', 10))\n ax.spines['bottom'].set_position(('outward', 10))\n ax.set_xlim([y_true.min(), y_true.max()])\n ax.set_ylim([y_true.min(), y_true.max()])\n ax.set_xlabel('Measured')\n ax.set_ylabel('Predicted')\n extra = plt.Rectangle((0, 0), 0, 0, fc=\"w\", fill=False,\n edgecolor='none', linewidth=0)\n ax.legend([extra], [scores], loc='upper left')\n title = title + '\\n Evaluation in {:.2f} seconds'.format(elapsed_time)\n ax.set_title(title)","def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\n\tcompObserved = []\n\tSStotalWarmth = 0\n\tSSresWarmth = 0\n\tSStotalComp = 0\n\tSSresComp = 0\n\tkeys = parser.getMappings(normalized)[0].keys()\n\tfor key in keys:\n\n\t\tif \"_\" in key:\n\t\t\twarmthAxis, compAxis = getPlotData(key)\n\t\t\twarmthPred.append(warmthAxis[3])\n\t\t\twarmthObserved.append(warmthAxis[2])\n\t\t\tcompPred.append(compAxis[3])\n\t\t\tcompObserved.append(compAxis[2])\n\n\tmeanObservedWarmth = np.mean(warmthObserved)\n\tmeanObservedComp = np.mean(compObserved)\n\tfor i in range(0, len(warmthObserved)):\n\t\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\n\t\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\n\t\tSStotalComp += (compObserved[i] - meanObservedComp)**2\n\t\tSSresComp += (compObserved[i] - compPred[i])**2\n\n\n\tplt.axis([0, 100, 0, 100])\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.title(\"Observed vs Predicted Warmth\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(warmthObserved, warmthPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.axis([0, 100, 0, 100])\n\tplt.title(\"Observed vs Predicted Competence\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(compObserved, compPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()","def display_fit(x,y,p,func,fig=None):\n if fig is None:\n fig = plots.tac_figure('x','y','fitting')\n fig.plot(x,np.log(y),label='data')\n \n \n fig.plot(x,np.log(func(p,x)),'--x',label=func.__name__ + '('+\n ','.join(['%.1e'%k for k in p])+ ')')\n \n return fig","def validate_and_plot_one_class(normal,outliers):\n print \"running a validation\"\n \n #classifier\n \n train_data = genfromtxt(normal, delimiter='\\t',skip_header=0)\n test_data = genfromtxt(outliers, delimiter='\\t',skip_header=0)\n\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\n outliers_proportion=0.01\n\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\n #processing data without targets\n X_train = clf.scale(train_data)\n X_test = clf.scale(test_data)\n\n y_pred_train = clf.predict(X_train)\n y_pred_test = clf.predict(X_test)\n n_error_train = y_pred_train[y_pred_train == 1].size\n n_error_test = y_pred_test[y_pred_test == -1].size\n \n X=np.vstack((X_train,X_test))\n y_score = clf.predict(X)\n\n Y1=np.ones((X_train.shape[0],))\n Y2=(np.ones((X_test.shape[0],))*-1)\n y_true=np.concatenate((Y1,Y2))\n \n # Compute ROC curve and area the curve\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\n roc_auc = metrics.auc(fpr, tpr)\n print \"Area under the ROC curve : %f\" % roc_auc\n \n # Plot ROC curve\n\n fig = matplotlib.pyplot.gcf()\n fig.set_size_inches(6.5,6.5)\n #font = {'family' : 'sans-serif',\n # 'weight' : 'normal',\n # 'size' : 18}\n\n #matplotlib.rc('font', **font)\n pl.clf()\n #modify plot area\n #modify tick label font size\n ax = pl.gca() # get the current axes\n for l in ax.get_xticklabels() + ax.get_yticklabels():\n l.set_fontsize('x-large')\n\n #color from html code table, linewidth x2.0\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\"#00CC66\",linewidth=3.0)\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#009900\",linewidth=3.0)\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n #for more lines with different kernels\n #default_kernel=\"sigmoid\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#00CC66\",linewidth=2.0)\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n pl.plot([0, 1], [0, 1], 'k--')\n #modify base font size\n pl.xlim([0.0, 1.0])\n pl.ylim([0.0, 1.0])\n pl.xlabel('False positive rate',fontsize='xx-large')\n pl.ylabel('True positive rate',fontsize='xx-large')\n #pl.title('Receiver operating characteristic example')\n pl.legend(loc=\"lower right\",prop={'size':18})\n pl.show()\n sys.exit(0)\n ##the code here below was used to create the ROC curve for europar 13","def fittingPlots(ax, loadFile, drug1, drug2, df):\n # Read model from saved pickle file\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=True)\n\n if drug1 == \"Erl\":\n drug1 = \"Erlotinib\"\n if drug2 == \"Erl\":\n drug2 = \"Erlotinib\"\n\n df.iloc[:, :] = np.median(M.samples[\"conflResid\"], axis=0).reshape(df.shape)\n\n sns.heatmap(df, ax=ax[0], cmap=\"PiYG\", vmin=-0.5, vmax=0.5, cbar=False, square=True)\n ax[0].set_title(\"Full Model\")\n\n df3 = pd.DataFrame({\"drug\": drug1, \"param\": \"Growth\", \"value\": M.samples[\"EmaxGrowthEffect\"][:, 0]})\n df4 = pd.DataFrame({\"drug\": drug2, \"param\": \"Growth\", \"value\": M.samples[\"EmaxGrowthEffect\"][:, 1]})\n df5 = pd.DataFrame({\"drug\": drug1, \"param\": \"Death\", \"value\": M.samples[\"EmaxDeath\"][:, 0]})\n df6 = pd.DataFrame({\"drug\": drug2, \"param\": \"Death\", \"value\": M.samples[\"EmaxDeath\"][:, 1]})\n\n dfplot = pd.concat([df3, df4, df5, df6])\n dfplot[\"value\"] = dfplot[\"value\"]\n\n # TODO: Report IC50 in the text.\n sns.violinplot(x=\"param\", y=\"value\", hue=\"drug\", data=dfplot, ax=ax[1], linewidth=0.1)\n ax[1].set_xticklabels(ax[1].get_xticklabels(), rotation=25, horizontalalignment=\"right\")\n ax[1].set_ylabel(\"Emax [1/hr]\")\n ax[1].set_ylim(bottom=0.0, top=0.10)\n ax[1].set_xlabel(\"\")\n\n # Remove legend title\n handles, labels = ax[1].get_legend_handles_labels()\n ax[1].legend(handles=handles, labels=labels)","def plot_brute_leastsquares_results(result, best_vals=True, varlabels=None,\r\n output=None, leastsq_fit_result=None):\r\n from matplotlib.colors import LogNorm\r\n import matplotlib.cm as cm\r\n \r\n npars = len(result.var_names)\r\n _fig, axes = plt.subplots(npars, npars)\r\n\r\n if not varlabels:\r\n varlabels = result.var_names\r\n if best_vals and isinstance(best_vals, bool):\r\n best_vals = result.params\r\n if leastsq_fit_result is not None:\r\n best_vals_leastsq = leastsq_fit_result.params\r\n\r\n for i, par1 in enumerate(result.var_names):\r\n for j, par2 in enumerate(result.var_names):\r\n\r\n # parameter vs chi2 in case of only one parameter\r\n if npars == 1:\r\n axes.plot(result.brute_grid, result.brute_Jout, 'o', ms=3)\r\n axes.set_ylabel(r'$\\chi^{2}$')\r\n axes.set_xlabel(varlabels[i])\r\n if best_vals:\r\n axes.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n axes.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n\r\n # parameter vs chi2 profile on top\r\n elif i == j and j < npars-1:\r\n if i == 0:\r\n axes[0, 0].axis('off')\r\n ax = axes[i, j+1]\r\n red_axis = tuple([a for a in range(npars) if a != i])\r\n ax.plot(np.unique(result.brute_grid[i]),\r\n np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n 'o', ms=3)\r\n ax.set_ylabel(r'$\\chi^{2}$')\r\n ax.yaxis.set_label_position(\"right\")\r\n ax.yaxis.set_ticks_position('right')\r\n ax.set_xticks([])\r\n if best_vals:\r\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n # parameter vs chi2 profile on the left\r\n elif j == 0 and i > 0:\r\n ax = axes[i, j]\r\n red_axis = tuple([a for a in range(npars) if a != i])\r\n ax.plot(np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n np.unique(result.brute_grid[i]), 'o', ms=3)\r\n ax.invert_xaxis()\r\n ax.set_ylabel(varlabels[i])\r\n if i != npars-1:\r\n ax.set_xticks([])\r\n else:\r\n ax.set_xlabel(r'$\\chi^{2}$')\r\n if best_vals:\r\n ax.axhline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n ax.axhline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n\r\n # contour plots for all combinations of two parameters\r\n elif j > i:\r\n ax = axes[j, i+1]\r\n red_axis = tuple([a for a in range(npars) if a not in (i, j)])\r\n X, Y = np.meshgrid(np.unique(result.brute_grid[i]),\r\n np.unique(result.brute_grid[j]))\r\n lvls1 = np.linspace(result.brute_Jout.min(),\r\n np.median(result.brute_Jout)/2.0, 20, dtype='int')\r\n lvls2 = np.linspace(np.median(result.brute_Jout)/2.0,\r\n np.median(result.brute_Jout), 20, dtype='int')\r\n \r\n lvls = np.unique(np.concatenate((lvls1, lvls2)))\r\n \r\n ax.contourf(X.T, Y.T, np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n lvls, norm=LogNorm(),\r\n cmap=cm.nipy_spectral)\r\n ax.set_yticks([])\r\n if best_vals:\r\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n ax.axhline(best_vals[par2].value, ls='dashed', color='b')\r\n ax.plot(best_vals[par1].value, best_vals[par2].value, 'bs', ms=3)\r\n if best_vals_leastsq:\r\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n ax.axhline(best_vals_leastsq[par2].value, ls='dashed', color='r')\r\n ax.plot(best_vals_leastsq[par1].value, best_vals_leastsq[par2].value, 'rs', ms=3)\r\n if j != npars-1:\r\n ax.set_xticks([])\r\n else:\r\n ax.set_xlabel(varlabels[i])\r\n if j - i >= 2:\r\n axes[i, j].axis('off')\r\n\r\n if output is not None:\r\n plt.savefig(output)\r\n else: \r\n plt.tight_layout()\r\n plt.show()","def plot_ece(confidences, accuracies, label='', ax=None, **kwargs):\n if not ax:\n plt.figure()\n ax = plt.gca()\n # ax.figure.set_size_inches(6, 4)\n ax.plot(confidences, accuracies, label=label, **kwargs)\n xbins = [i / 10. for i in range(11)]\n ax.plot(xbins, xbins, linestyle=':', color='black')\n ax.set_xlabel('Model Confidence')\n ax.set_ylabel('Model Accuracy')\n # ax.set_title(\n # f\"Reliability Diagram Trained on {train_name}, Evaluated on {ood_name}\")\n # ax.set_title(f\"Reliability Diagram\")\n ax.legend(loc=4, facecolor='white')\n return ax","def plot(self):\n fig = plt.figure()\n ax = plt.gca()\n ax.errorbar(self.sample_bins, self.test_scores.mean(axis=1),\n yerr=self.test_scores.std(axis=1), fmt='r.-',\n label='test')\n ax.errorbar(self.sample_bins, self.train_scores.mean(axis=1),\n yerr=self.train_scores.std(axis=1), fmt='b.-',\n label='train')\n ax.legend(loc='upper right')\n return ax","def testNonLinearity():\n vis = VISinformation()\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\n nonlin = CCDnonLinearityModel(data.copy())\n\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\n\n fig = plt.figure(frameon=False)\n\n left, width = 0.1, 0.8\n rect1 = [left, 0.3, width, 0.65]\n rect2 = [left, 0.1, width, 0.2]\n\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\n\n ax1.axhline(y=0, c='k', ls='--')\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\n\n ax2.axhline(y=0, c='k', ls='--')\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\n\n ax1.axvline(x=97, c='k', ls='--')\n ax2.axvline(x=97, c='k', ls='--')\n\n ax1.set_xticklabels([])\n ax2.set_xlabel('Real Charge [electrons]')\n ax1.set_ylabel('(Output / Real - 1)*100')\n ax2.set_ylabel('O - R [ADUs]')\n\n ax1.set_xlim(0, vis['fullwellcapacity'])\n ax2.set_xlim(0, vis['fullwellcapacity'])\n ax1.set_ylim(-.15, .2)\n\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\n plt.savefig('NonlinearityModel.pdf')\n\n ax1.set_ylim(-.1, 8)\n ax2.set_ylim(0, 2)\n ax1.set_xlim(50, 800)\n ax2.set_xlim(50, 800)\n plt.savefig('NonlinearityModel2.pdf')\n\n plt.close()","def nonlinear_fit(X, Y, fitfunction, initial_guess=None, dY=None, \n showplot=True, plot_some_errors=(False, 20), \n **kwargs):\n \n if not isinstance(X, np.ndarray):\n raise TypeError(\"X should be a np.array\")\n if not isinstance(Y, np.ndarray):\n raise TypeError(\"Y should be a np.array\")\n if not isinstance(dY, np.ndarray) and dY is not None:\n raise TypeError(\"dY shouuld be a np.array\")\n if len(X) != len(Y):\n raise IndexError(\"X and Y must have same lenght\")\n if dY is not None and len(dY) != len(Y):\n raise IndexError(\"dY and Y must have same lenght\")\n \n if dY is None:\n W = None\n else:\n W = 1/dY**2\n \n parameters, covariance = curve_fit(fitfunction, X, Y,\n p0=initial_guess, sigma=W) \n rsq = sum( (Y - fitfunction(X, *parameters))**2 )\n rsq = rsq/sum( (Y - np.mean(Y))**2 )\n rsq = 1 - rsq\n\n if showplot:\n \n plt.figure()\n if dY is None:\n plt.plot(X, Y, 'b.', zorder=0)\n else:\n if plot_some_errors[0] == False:\n plt.errorbar(X, Y, yerr=dY, linestyle='b', marker='.',\n ecolor='b', elinewidth=1.5, zorder=0)\n else:\n plt.errorbar(X, Y, yerr=dY, linestyle='-', marker='.',\n color='b', ecolor='b', elinewidth=1.5,\n errorevery=len(Y)/plot_some_errors[1], \n zorder=0)\n plt.plot(X, fitfunction(X, *parameters), 'r-', zorder=100) \n plt.legend([\"Ajuste lineal ponderado\",\"Datos\"])\n \n n = len(parameters)\n kwargs_list = ['text_position', 'par_units', 'par_string_scale', \n 'par_error_digits', 'rsq_decimal_digits']\n kwargs_default = [(.02,'up'), ['' for i in range(n)], \n [False for i in range(n)], \n [3 for i in range(n)], 3]\n for key, value in zip(kwargs_list, kwargs_default):\n try:\n kwargs[key]\n if key != 'text_position':\n try:\n if len(kwargs[key]) != n:\n print(\"Wrong number of parameters\",\n \"on '{}'\".format(key))\n kwargs[key] = value\n except TypeError:\n kwargs[key] = [kwargs[key] for i in len(n)]\n except KeyError:\n kwargs[key] = value\n \n if kwargs['text_position'][1] == 'up':\n vertical = [.9-i*.08 for i in range(n+1)]\n elif kwargs['text_position'][1] == 'down':\n vertical = [.05+i*.08 for i in range(n+1)]\n else:\n if kwargs['text_position'][1] <= .08:\n fact = .08\n else:\n fact = -.08\n vertical = [\n kwargs['text_position'][1]+fact*i for i in range(n+1)]\n \n for i in range(n):\n plt.annotate(\n 'a{} = {}'.format(\n i,\n fst.error_value(\n parameters[i], \n sqrt(covariance[i,i]),\n error_digits=kwargs['par_error_digits'][i],\n units=kwargs['par_units'][i],\n string_scale=kwargs['par_string_scale'][i],\n one_point_scale=True,\n legend=True)),\n (kwargs['text_position'][0], vertical[i]),\n xycoords='axes fraction')\n rsqft = r'$R^2$ = {:.' + str(kwargs['rsq_decimal_digits'])+'f}'\n plt.annotate(rsqft.format(rsq),\n (kwargs['text_position'][0], vertical[-i]),\n xycoords='axes fraction')\n \n plt.show()\n \n parameters_error = np.array(\n [sqrt(covariance[i,i]) for i in range(n)])\n parameters = list(zip(parameters, parameters_error))\n \n return rsq, parameters","def plot_results(\n predictor_names, validation_auc_values, is_forward_test,\n axes_object=None, num_predictors_to_plot=None):\n\n if num_predictors_to_plot is None:\n num_predictors_to_plot = len(predictor_names)\n\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\n num_predictors_to_plot = min([\n num_predictors_to_plot, len(predictor_names)\n ])\n\n y_coords = numpy.linspace(\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\n )[::-1]\n\n if axes_object is None:\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n axes_object.barh(\n y_coords, validation_auc_values[:num_predictors_to_plot],\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\n linewidth=BAR_EDGE_WIDTH\n )\n\n axes_object.set_yticks([], [])\n axes_object.set_xlabel('Validation AUC')\n\n if is_forward_test:\n axes_object.set_ylabel('Predictor added')\n else:\n axes_object.set_ylabel('Predictor removed')\n\n axes_object.set_ylim(\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\n )\n axes_object.set_xlim(\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\n )\n\n for j in range(num_predictors_to_plot):\n axes_object.text(\n 0., y_coords[j], ' ' + predictor_names[j],\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\n horizontalalignment='left', verticalalignment='center'\n )\n\n return axes_object","def plot_convergence_(OptimizeResult, fig_savepath, figsize=(5.51, 3.54), format='PNG', dpi=300): # (5.51,3.54)\n fig = plt.figure(figsize=figsize)\n ax0 = fig.add_subplot(111)\n plot_convergence(OptimizeResult, ax=ax0, true_minimum=0.0, )\n plt.title(\"\")\n ax0.set_ylabel(r\"minimum MSE after $n$ calls\")\n # plt.tight_layout()\n plt.subplots_adjust(left=0.12, bottom=0.12, right=0.96, top=0.94, hspace=0.1, wspace=0.2)\n plt.savefig(fig_savepath, format=format, dpi=dpi)\n # plt.show()","def plot_confusion_matrix(self):\r\n interp = ClassificationInterpretation.from_learner(self.learn)\r\n interp.plot_confusion_matrix()","def display_comparison(self, X_val, y_val):\n import matplotlib.pyplot as plt\n x = []\n y = []\n for model_tuple in self.model_list:\n x.append(model_tuple[1])\n y.append(model_tuple[0].score(X_val, y_val))\n plt.scatter(x, y)\n plt.show()","def problemOne(self):\n self.hot_volt = self.data['calibration']['hot volt'].tolist()\n self.pitot_vel = self.data['calibration']['pitot vel'].tolist()\n # Create interpolation function of FFT data for finding coefficients\n self.v_hot = np.poly1d(np.array(self.cal_coeffs))\n # Create string to print coefficients on plot\n print_coeffs = 'Curve Coefficients:'\n coeff_index = [4, 3, 2, 1, 0]\n for i in range(0, 5):\n print_coeffs += f'\\n$a_{i}$ = {self.cal_coeffs[coeff_index[i]]}'\n # Create curve fit data to plot\n fit_plot_y = [self.v_hot(j) for j in self.hot_volt]\n # Calculate difference and standard deviation b/w the interpolation curve and experimental data\n difference = []\n for i in self.hot_volt:\n index = self.hot_volt.index(i)\n difference.append(self.pitot_vel[index] - self.v_hot(i))\n std_dev = statistics.stdev(difference)\n print(f'prob one std dev = {std_dev}')\n # Plot velocities vs voltage\n plot_1 = plt.figure(figsize=(8, 8))\n vv = plot_1.add_subplot(1, 1, 1)\n props = dict(boxstyle='round', facecolor='white', alpha=0.2)\n vv.set_xlabel('Hotwire $E_v$ [Volts]', fontsize=14)\n vv.set_ylabel('Velocity [m/s]', fontsize=14)\n vv.grid(linewidth=0.5, color='gray', linestyle='--')\n vv.plot(self.hot_volt, fit_plot_y, color='k', linewidth=1, label='Hotwire Curve Fit')\n vv.scatter(self.hot_volt, self.pitot_vel, color='r', s=15, label='Pitot Exp. Data', marker='o')\n vv.text(0.02, 0.9, print_coeffs, transform=vv.transAxes, fontsize=11, verticalalignment='top', bbox=props)\n vv.legend(loc='upper left')\n plot_1.savefig(os.path.join(os.getcwd(), r'plots\\prob1'))\n plt.draw()","def find_best(results, show_plot=True):\n max_point = max(results)\n print(\"Maximum achieved at d={} and class prior={}. Accuracy of {}%.\".format(max_point[1],max_point[2],max_point[0]))\n if show_plot:\n import matplotlib.pyplot as plt\n from matplotlib import cm\n from mpl_toolkits.mplot3d import Axes3D\n z,x,y = zip(*results)\n fig = plt.figure()\n ax = fig.gca(projection='3d')\n ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)\n ax.text(max_point[1],max_point[2],max_point[0]+2, \"MAX\")\n plt.title('Parameter Tuning Results')\n plt.xlabel('d value')\n plt.ylabel('class prior')\n ax.set_zlabel('Accuracy')\n plt.show()","def show_trap_results():\n df_grid = pd.read_hdf('./temp_results.h5', '/optimize_grid')\n print(df_grid)\n \n print('Minimum fwhm:')\n print(df_grid[df_grid.fwhm_ovr_mean==df_grid.fwhm_ovr_mean.min()])\n \n plt.plot(df_grid.e_fit, df_grid.fwhm_ovr_mean, '.b')\n plt.show()","def get_accuracy_and_plot_confusion(y_correct, y_pred, classes, plot=True, title='Confusion matrix'):\n if plot:\n cm = confusion_matrix(y_correct, y_pred)\n plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n plt.title(title)\n plt.colorbar()\n tick_marks = np.arange(len(classes))\n plt.xticks(tick_marks, classes, rotation=45)\n plt.yticks(tick_marks, classes)\n\n thresh = cm.max() / 2.\n for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n plt.text(j, i, cm[i, j],\n horizontalalignment=\"center\",\n color=\"white\" if cm[i, j] > thresh else \"black\")\n\n plt.tight_layout()\n plt.ylabel('True label')\n plt.xlabel('Predicted label')\n plt.show()\n return accuracy_score(y_correct, y_pred)","def plot_correction_in_fibre_p_fibre(fig_size,\n wlm,\n espectro_old,\n espectro_fit_median,\n espectro_new,\n fibre_p,\n clip_high, \n show_plot=False):\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\n ax.plot(\n wlm,\n old_div(espectro_old, espectro_fit_median),\n \"r\",\n label=\"Uncorrected\",\n alpha=0.5,\n )\n ax.plot(\n wlm,\n old_div(espectro_new, espectro_fit_median),\n \"b\",\n label=\"Corrected\",\n alpha=0.5,\n )\n const = old_div((np.nanmax(espectro_new) - np.nanmin(espectro_new)), 2)\n ax.plot(\n wlm,\n old_div((const + espectro_new - espectro_old), espectro_fit_median),\n \"k\",\n label=\"Dif + const\",\n alpha=0.5,\n )\n ax.axhline(y=clip_high, color=\"k\", linestyle=\":\", alpha=0.5)\n ax.set_ylabel(\"Flux / Continuum\")\n\n ax.set_xlabel(r\"Wavelength [$\\AA$]\")\n ax.set_title(\"Checking correction in fibre {}\".format(str(fibre_p)))\n ax.legend(frameon=False, loc=1, ncol=4)\n\n if show_plot:\n plt.show()\n return fig","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def make_accuracy_plot(ax,\n groundtruth_boxes,\n hpu_boxes,\n cpu_boxes,\n hpu_strategy,\n label,\n N=10,\n num_graph_points=20,\n match_mode=\"ellipse\",\n):\n print \"Making plot for\", repr(label)\n print \"TODO: this should graph seconds per image\"\n mix_fractions = np.linspace(0, 1.0, num_graph_points)\n # Plot confidence intervals\n min_ci = []\n max_ci = []\n mean_accs = []\n stderr_accs = []\n for mix_fraction in mix_fractions:\n accuracies = [\n maximum_F_score(\n groundtruth_boxes,\n hpu_strategy(hpu_boxes, cpu_boxes, mix_fraction),\n match_mode=match_mode,\n )\n for _ in xrange(N)\n ]\n mean_accs.append(np.mean(accuracies))\n stderr_accs.append(np.std(accuracies, ddof=1) / np.sqrt(N))\n #print mix_fraction, np.mean(accuracies)\n ax.errorbar(mix_fractions, mean_accs, stderr_accs, label=label)\n ax.set_xlabel(\"Fraction of HPU-labeled images\")\n ax.set_ylabel(\"Maximum F-score\")","def quick_plot(solution):\n plt.suptitle('GNLSE solution')\n\n plt.subplot(1, 2, 1)\n plot_wavelength_vs_distance(solution)\n\n plt.subplot(1, 2, 2)\n plot_delay_vs_distance(solution)\n\n plt.show()","def show_fit(self):\n self.fft_fit_plotter.plot(self.ax)\n plt.draw()","def plot_metrics(results, epsilon_pos, epsilon_neg):\n ## Plot risk and fairness gaps as a function of sample size,\n ## with true minimum risk and true fairness gaps for reference.\n\n metrics_Y0 = pd.concat(results['metrics_Y0_noisy'], keys=n_arr)\n metrics_Y0 = metrics_Y0.reset_index().drop(columns='level_1').rename(\n columns={'level_0': 'n'})\n metrics_Y = pd.concat(results['metrics_Y_noisy'], keys=n_arr)\n metrics_Y = metrics_Y.reset_index().drop(columns='level_1').rename(\n columns={'level_0': 'n'})\n metrics = pd.concat([metrics_Y0, metrics_Y])\n\n m = results['metrics_Y0_best']\n risk = m.loc[m.Metric == 'Risk', 'Value'].values[0]\n\n g = sns.FacetGrid(metrics, row='Outcome', col='Metric',\n col_order=['risk', 'gap_FPR', 'gap_FNR'])\n g.map(sns.pointplot, 'n', 'value', order=n_arr)\n g.set_xticklabels(rotation=45)\n\n g.axes[0, 0].hlines(risk, *g.axes[0, 0].get_xlim())\n g.axes[1, 0].hlines(risk, *g.axes[1, 0].get_xlim())\n\n g.axes[0, 1].hlines(epsilon_pos, *g.axes[0, 1].get_xlim())\n g.axes[1, 1].hlines(epsilon_pos, *g.axes[1, 1].get_xlim())\n\n g.axes[0, 2].hlines(epsilon_neg, *g.axes[0, 2].get_xlim())\n g.axes[1, 2].hlines(epsilon_neg, *g.axes[1, 2].get_xlim())","def report(self, X, y):\n predict = self.model.predict(X)\n\n skplt.estimators.plot_feature_importances(\n self.model, x_tick_rotation=90)\n plt.show()\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=predict)\n lims = [\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\n ]\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\n ax.set_aspect('equal')\n ax.set_xlim(lims)\n ax.set_ylim(lims)\n ax.set_xlabel(\"Observed\")\n ax.set_ylabel(\"Predict\")\n ax.set_title(\"Predict vs. Observed\")\n plt.show()\n\n residuals = y - predict\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=residuals)\n plt.title(\"Residuals vs. Observed\")\n plt.xlabel(\"Obserbed\")\n plt.ylabel(\"Residuals\")\n plt.show()\n\n plt.hist(residuals)\n plt.title(\"Residuals distribution\")\n plt.xlabel(\"Residuals value\")\n plt.ylabel(\"Count\")\n plt.show()\n\n display(\n pd.DataFrame({\n \"explained_variance_score\":\n metrics.explained_variance_score(y, predict),\n \"mean_absolute_error\":\n metrics.mean_absolute_error(y, predict),\n \"mean_squared_log_error\":\n metrics.mean_squared_log_error(y, predict),\n \"median_absolute_error\":\n metrics.median_absolute_error(y, predict),\n \"r2_score\":\n metrics.r2_score(y, predict)\n },\n index=[0]))","def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \n plt.title(\"Polynomial function regression\")\n plt.grid()\n plt.plot(x_poly, y_poly, c='black', label='true function')\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\n plt.legend()\n plt.show()","def plot_diagram(probs, labels, y_axis='accuracy'):\n probs_labels = [(prob, labels[i]) for i, prob in enumerate(probs)]\n probs_labels = np.array(sorted(probs_labels, key=lambda x: x[0]))\n window_len = int(len(labels)/100.)\n calibration_errors = []\n confidences = []\n accuracies = []\n # More interesting than length of the window (which is specific to this\n # window) is average distance between datapoints. This normalizes by dividing\n # by the window length.\n distances = []\n for i in range(len(probs_labels)-window_len):\n distances.append((\n probs_labels[i+window_len, 0] - probs_labels[i, 0])/float(window_len))\n # It's pretty sketchy to look for the 100 datapoints around this one.\n # They could be anywhere in the probability simplex. This introduces bias.\n mean_confidences = mean(probs_labels[i:i + window_len, 0])\n confidences.append(mean_confidences)\n class_accuracies = mean(probs_labels[i:i + window_len, 1])\n accuracies.append(class_accuracies)\n calibration_error = class_accuracies-mean_confidences\n calibration_errors.append(calibration_error)\n\n if y_axis == 'accuracy':\n fig, ax = plt.subplots()\n fig.set_size_inches(5, 5)\n xbins = [i/10. for i in range(11)]\n ax.plot(confidences, accuracies, color='green')\n ax.plot(xbins, xbins, color='orange')\n ax.set_xlabel('Model Confidence')\n ax.set_ylabel('Model Accuracy')\n elif y_axis == 'error':\n fig, ax = plt.subplots()\n fig.set_size_inches(5, 5)\n xbins = [i/10. for i in range(11)]\n ax.plot(confidences, calibration_errors, color='green')\n ax.plot(xbins, xbins, color='orange')\n ax.set_xlabel('Model Confidence')\n ax.set_ylabel('Model Calibration Error')\n ax.set_title('Reliability Diagram', fontsize=20)\n return fig","def calibrationPlot(predictions, truth, classes = None, label = \"Model\", newFigure = None, n_bins = 5):\n predictions, truth = selection(predictions, truth, classes)\n predictions, truth = flatten(predictions, truth)\n predictions = ((predictions - predictions.min()) / (predictions.max() - predictions.min())).flatten()\n fraction_of_positives, mean_predicted_value = calibration_curve(truth, predictions, n_bins = n_bins)\n bins = np.linspace(0., 1. + 1e-8, n_bins + 1)\n binids = np.digitize(predictions, bins) - 1\n bin_sums = np.bincount(binids, minlength=len(bins))\n bin_sums = bin_sums[bin_sums != 0] * 500 / np.sum(bin_sums)\n\n if newFigure is not None:\n plt.figure(newFigure)\n else:\n plt.xlabel('Mean Predicted Value')\n plt.ylabel('Fraction Positive')\n plt.title('Calibration')\n\n p = plt.plot(mean_predicted_value, fraction_of_positives, alpha = 0.5, ls=':')\n plt.scatter(mean_predicted_value, fraction_of_positives, s = bin_sums, label = label + \" ({:.2f})\".format(brier_score_loss(truth, predictions)), color = p[0].get_color(), alpha = 0.5)","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\n train_x_pos = [0, 4, 8, 12]\n cv_x_pos = [1, 5, 9, 13]\n test_x_pos = [2, 6, 10, 14]\n ticks = cv_x_pos\n\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\n\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\n\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\n\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\n\n fig, ax = plt.subplots()\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\n ax.set_ylabel('Accuracy')\n ax.set_xticks(ticks)\n ax.set_xticklabels(labels)\n ax.set_title('Models')\n ax.yaxis.grid(True)\n ax.legend()\n plt.tight_layout()","def plot(self) -> Figure:\n ax = self.setup_plot()\n ax.errorbar(\n self.doses,\n self.means,\n yerr=self.errorbars(),\n label=\"Mean ± 95% CI\",\n **plotting.DATASET_POINT_FORMAT,\n )\n ax.legend(**plotting.LEGEND_OPTS)\n return ax.get_figure()","def _plot_good_pred_whitout_reject(self, test: Set, title=None, fig_size=None):\r\n if fig_size is not None:\r\n fig = plt.figure(figsize=fig_size)\r\n else:\r\n fig = plt.figure()\r\n ax = fig.add_subplot(111)\r\n goodclassified_index = []\r\n for idx_preds in range(self.preds.shape[1]):\r\n new_good_index = []\r\n for idx in range(self.preds.shape[0]):\r\n if test.labels[idx] == self.preds[idx, idx_preds]:\r\n new_good_index.append(idx)\r\n if new_good_index:\r\n ax.scatter(test.features[new_good_index, 0], self.features[new_good_index, 1],\r\n label='Good classified top{0}'.format(int(idx_preds + 1)))\r\n goodclassified_index += new_good_index\r\n misclassified = [idx for idx in range(self.preds.shape[0]) if idx not in goodclassified_index]\r\n if misclassified:\r\n ax.scatter(test.features[misclassified, 0], test.features[misclassified, 1],\r\n label='Misclassified', marker='x', c='red')\r\n box = ax.get_position()\r\n ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\r\n # Put a legend to the right of the current axis\r\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\r\n if title is not None:\r\n ax.set_title(title)\r\n plt.show()","def plot(self, fit_result, axes, x, linewidth=None, alpha=None, color=None, normalize=None):\n y = self.predict(fit_result, x)\n if normalize is not None:\n y = normalize(y)\n result = axes.plot(x, y, color,\n lw=linewidth, alpha=alpha,\n scalex=False, scaley=False)\n return result","def plot_results(\n data,\n xparam,\n yparam,\n pxrange=None,\n pyrange=None,\n data_comp=None,\n data_bohlin=None,\n figsize=None,\n alpha=0.25,\n):\n # set the plotting defaults\n set_params(lw=2, fontsize=22)\n\n fig, ax = plt.subplots(figsize=figsize)\n\n if data_bohlin is not None:\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\n xcol = data_bohlin[xparam]\n xcol_unc = get_unc(xparam, data_bohlin)\n ycol = data_bohlin[yparam]\n ycol_unc = get_unc(yparam, data_bohlin)\n ax.errorbar(\n xcol,\n ycol,\n xerr=xcol_unc,\n yerr=ycol_unc,\n fmt=\"ro\",\n label=\"Bohlin (1978)\",\n alpha=alpha,\n )\n if data_comp is not None:\n xcol = data_comp[xparam]\n xcol_unc = get_unc(xparam, data_comp)\n ycol = data_comp[yparam]\n ycol_unc = get_unc(yparam, data_comp)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\n ax.plot(xcol, ycol, \"go\")\n # plot the error bars as ellipses illustrating the covariance\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data_comp[\"AV\"].data,\n cterm_unc=data_comp[\"AV_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"g\"\n )\n\n xcol = data[xparam].data\n xcol_unc = get_unc(xparam, data)\n ycol = data[yparam].data\n ycol_unc = get_unc(yparam, data)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\n ax.plot(xcol, ycol, \"bo\")\n\n # plot the error bars as ellipses illustrating the covariance\n if yparam[0:3] == \"CAV\":\n cparam = \"AV\"\n elif yparam[0:1] == \"C\":\n cparam = \"EBV\"\n else:\n cparam = \"AV\"\n\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data[cparam].data,\n cterm_unc=data[cparam + \"_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"b\", pellipse=True\n )\n\n ax.set_xlabel(format_colname(xparam))\n ax.set_ylabel(format_colname(yparam))\n\n # fit a line\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\n # line_init = models.Polynomial1D(1)\n line_init = models.Linear1D()\n fit = fitting.LinearLSQFitter()\n # fitter with outlier rejection\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\n\n # fit the data w/o weights\n fitted_model = fit(line_init, xcol, ycol)\n print(fitted_model)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\n\n # print(\"linear fit params [slope, y-intercept]\")\n # print(params)\n xlim = ax.get_xlim()\n x_mod = np.linspace(xlim[0], xlim[1])\n # y_mod = params[1] + x_mod * params[0]\n # ax.plot(x_mod, y_mod, \"k--\")\n\n ax.plot(x_mod, fitted_model(x_mod), \"k-\")\n ax.plot(x_mod, fitted_model_weights(x_mod), \"k--\")\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \"k.\")\n\n ax.plot(xcol, data_sc, 'ko')\n print(data_sc)\n\n if pxrange is not None:\n ax.set_xlim(pxrange)\n if pyrange is not None:\n ax.set_ylim(pyrange)\n\n return fig","def check_fit(truth, prob):\n fpr, tpr, _ = roc_curve(truth, prob) # drop_intermediate:(default=True)\n roc_auc = auc(fpr, tpr) # calculate the AUC\n plt.figure()\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n plt.xlim([-0.1, 1.05])\n plt.ylim([-0.1, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic example')\n plt.legend(loc=\"lower right\")\n plt.show()\n print('results are RMSE, accuracy, ROC, loss function')\n print(sqrt(mean_squared_error(truth, prob)), accuracy_score(truth, prob), roc_auc, zero_one_loss(truth, prob))","def convergence():\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n # point spread and point total subplots\n subplots = [\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\n (True, [200.5], league.totals, 'probability total > 200.5'),\n ]\n\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\n\n # train margin-dependent Elo model\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, values)\n\n line = lines[-1]\n\n for label2 in label2_list:\n\n # evaluation times and labels\n times = np.arange(league.times.size)[::1000]\n labels1 = times.size * [label1]\n labels2 = times.size * [label2]\n\n # observed win probability\n prob = melo.probability(times, labels1, labels2, lines=line)\n ax.plot(times, prob)\n\n # true (analytic) win probability\n if ax.is_first_row():\n prob = skellam.sf(line, int(label1), int(label2))\n ax.axhline(prob, color='k')\n else:\n prob = poisson.sf(line, int(label1) + int(label2))\n ax.axhline(prob, color='k')\n\n # axes labels\n if ax.is_last_row():\n ax.set_xlabel('Iterations')\n ax.set_ylabel(ylabel)\n\n set_tight(w_pad=.5)","def plot(self, ylog=False, category=\"Accuracy\", figsize=(12, 5)):\n if self.CV == False: # no Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n if self.CV == True: # has Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n\n return fig, ax","def visualize_cross_validation_results(cross_val_results, plots_filepath):\n\n pair_model_scores, pair_model_stds, \\\n siamese_model_scores_2, siamese_model_stds_2, \\\n siamese_model_scores_10, siamese_model_stds_10 = cross_val_results\n param_names = (\"NBCH1\", \"NBCH2\", \"NBFCH\", \"BATCH_NORM\", \"SKIP_CON\", \"LR\")\n\n def aggregate_results(scores, stds):\n \"\"\"\n Helper function to aggregate score means and standard deviations for a model across parameter values\n\n :param scores: dictionary of score means {param_combo: score_mean}\n :param stds: dictionary of score stds {param_combo: score_std}\n\n :returns: list of tuples of pandas.Dataframe objects containing aggregated mean and std data\n \"\"\"\n\n scores = pd.DataFrame(scores.values(),\n index=scores.keys(),\n columns=[\"SCORE MEAN\", ])\n stds = pd.DataFrame(stds.values(),\n index=stds.keys(),\n columns=[\"SCORE STD\", ])\n scores.index.name = param_names\n stds.index.name = param_names\n data = []\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\n data.append((aggregate_scores, aggregate_stds))\n return data\n\n pair_model_data = aggregate_results(pair_model_scores, pair_model_stds)\n siamese_model_2_data = aggregate_results(siamese_model_scores_2, siamese_model_stds_2)\n siamese_model_10_data = aggregate_results(siamese_model_scores_10, siamese_model_stds_10)\n\n # Group results for all models\n model_names = (\"Pair\", \"Siamese 2\", \"Siamese 10\")\n grouped_data = []\n for pair_model_group_data, siamese_model_2_group_data, siamese_model_10_group_data in zip(pair_model_data,\n siamese_model_2_data,\n siamese_model_10_data):\n score_means = (pair_model_group_data[0], siamese_model_2_group_data[0], siamese_model_10_group_data[0])\n score_mean_data = pd.concat(score_means, axis=1)\n score_mean_data.columns = model_names\n\n score_stds = (pair_model_group_data[1], siamese_model_2_group_data[1], siamese_model_10_group_data[1])\n score_std_data = pd.concat(score_stds, axis=1)\n score_std_data.columns = model_names\n\n grouped_data.append((score_mean_data, score_std_data))\n\n plots_param_names = (\"nbch1\", \"nbch2\", \"nbfch\", \"batch_norm+skip_con\", \"lr\")\n for i, (plot_param_names, (score_mean_data, score_std_data)) in enumerate(zip(plots_param_names, grouped_data)):\n plt.figure(figsize=(10, 5))\n score_mean_data.plot(kind=\"line\" if plot_param_names == \"lr\" else \"bar\",\n yerr=score_std_data,\n capsize=5,\n ylim=(0.4, 1.1),\n colormap=colormap_brg_darker)\n plt.title(\"Cross validation results for parameters:\\n{}\".format(plot_param_names), fontsize=18)\n plt.xlabel(\"Parameter value\", fontsize=14)\n plt.ylabel(\"Average accuracy\", fontsize=14)\n plt.xticks(fontsize=12, rotation=30)\n plt.yticks(fontsize=12)\n plt.legend(title=\"Model\", title_fontsize=10)\n plt.tight_layout()\n plt.savefig(fname=plots_filepath + \"cross_validation_{}.eps\".format(plot_param_names),\n dpi=\"figure\", format=\"eps\")\n plt.close()","def _th_plot(self, y_true, y_pred_proba, pos_label, pos_label_ind,\n best_th_, q, tpr, fpr, th_, th_range, index, roc_auc_kwargs):\n fig, axs = plt.subplots(nrows=2, ncols=1)\n fig.set_size_inches(10, 10)\n # Roc score.\n y_type = sklearn.utils.multiclass.type_of_target(y_true)\n if y_type == \"binary\":\n roc_auc = sklearn.metrics.roc_auc_score(\n y_true, y_pred_proba[:, pos_label_ind], **roc_auc_kwargs)\n elif y_type == \"multiclass\":\n roc_auc = sklearn.metrics.roc_auc_score(\n y_true, y_pred_proba, **roc_auc_kwargs)\n else:\n assert False, f\"Unhandled y_type {y_type}\"\n # Roc curve.\n axs[0].plot(fpr, tpr, 'darkorange',\n label=f\"ROC curve (AUC = {roc_auc:.3f}).\")\n axs[0].scatter(fpr[index], tpr[index], c='b', marker=\"o\")\n axs[0].plot([0, 1], [0, 1], color='navy', linestyle='--')\n axs[0].set_xlabel('False Positive Rate')\n axs[0].set_ylabel('True Positive Rate')\n axs[0].set_title(f\"Receiver operating characteristic \"\n f\"(label '{pos_label}')\")\n axs[0].legend(loc=\"lower right\")\n # Metric q.\n axs[1].plot(th_, q, 'green')\n axs[1].vlines(best_th_, np.min(q), np.max(q))\n axs[1].vlines(th_range, np.min(q), np.max(q), colors='b',\n linestyles=':')\n axs[1].set_xlim([0.0, 1.0])\n axs[1].set_xlabel('Threshold')\n axs[1].set_ylabel('TPR/(TPR+FPR)')\n axs[1].set_title('Selected th values objective maximum')\n # plt.plot(th_, fpr, 'red')\n plt.show()","def residuals(y_true, y_pred, ax=None):\n\n _check_parameter_validity(y_true, y_pred)\n\n if ax is None:\n ax = plt.gca()\n\n # horizontal line for residual=0\n ax.axhline(y=0)\n\n ax.scatter(y_pred, y_true - y_pred)\n\n _set_ax_settings(ax, \"Predicted Value\", \"Residuals\", \"Residuals Plot\")\n return ax","def analyse_algorithms(R, u_t, inverse_transform, true_weight_vect, algo_list, equation, preconditioner):\n\n # Generate the model list for each sparse regression algorithm\n algo_model_list_list = []\n for algo_index, algo in enumerate(algo_list):\n model_list = generate_models(R, u_t, inverse_transform, algo)\n algo_model_list_list.append(model_list)\n\n # set up plot\n symbol_list = ['v', 's', 'o', '+', '*', 'D']\n color_list = [(162 / 256., 173 / 256., 0., 0.9), (156 / 256., 157 / 256., 159 / 256., 0.8),\n (0., 101 / 256., 189 / 256., 1.), (227 / 256., 114 / 256., 34 / 256., 0.9)]\n fig, ax = plt.subplots(figsize=(1.8 * 2.6, 1.8 * 1.95))\n\n # iterate all models of all algorithms and plot the summaries\n for algo_index, algo in enumerate(algo_list):\n model_list = algo_model_list_list[algo_index]\n for i_model, model in enumerate(model_list):\n set_model_correctness_and_error(model, true_weight_vect) # calculate absolute and relative error\n # plot model properties\n ax.semilogy(model.terms, model.mean_rel_err, marker=symbol_list[algo_index], markerfacecolor='none',\n linestyle='None', color=color_list[algo_index], label=algo if i_model == 0 else \"\")\n\n # finish plot\n ax.plot((-1., 10.), (1.5, 1.5), color='k')\n # xlim needs to be adjusted with respect to the maximum number of correct term in the model\n ax.set(ylim=[1.e-9, 75.], xlim=[0.5, 6.5], xlabel='Number of Terms', ylabel='MRE')\n ax.legend(loc=4)\n ax.set_yticks(ax.get_yticks()[:-3])\n ax.set_xticks(np.arange(1, 7, 1))\n plt.savefig('Regression_accuracy_comparison_' + str(equation) + '_' + preconditioner + '_test.png')\n plt.savefig('Regression_accuracy_comparison_' + str(equation) + '_' + preconditioner + '_test.pgf')","def PlotComparison(result_values, descrete, continuous, jitter=100):\n df = result_values.copy()\n np.random.seed(0)\n df[continuous] = df[continuous] + np.random.randint(low=-jitter, high=jitter, size=len(df))\n base = alt.Chart(df).transform_calculate(\n ymin=\"datum.mean-2*datum.std\",\n ymax=\"datum.mean+2*datum.std\",\n ).properties(\n title = '[Interactive] Accuracy by Params'\n )\n \n points = base.mark_point(\n filled=True,\n size=10\n ).encode(\n x=continuous,\n y=alt.Y('mean:Q'),#, scale=alt.Scale(domain=(0.55, 0.7))),\n color=descrete,\n tooltip=['mean','std']\n )\n\n errorbars = base.mark_errorbar().encode(\n x=continuous,\n y=alt.Y(\"ymin:Q\",title='Accuracy'),\n y2=\"ymax:Q\",\n color=descrete,\n )\n\n return(points + errorbars)","def plotProfits(confidence, title=\"\"):\r\n profits = []\r\n ticks = range(5, 101)\r\n for i in ticks:\r\n p = profitComputation(i, confidence)\r\n profits.append(p)\r\n plt.plot(ticks, profits)\r\n plt.xticks(range(0, 101, 5))\r\n plt.xlabel(\"% of matches we bet on\")\r\n plt.ylabel(\"Return on investment (%)\")\r\n plt.suptitle(title)","def compare_parameter_plots(result_file, result_file_eccentric, fitted_params, resultType, planet,\n plotPublished = False, publishedDataFile = None, saveplot=True, foldext=''):\n\n # Check if we are wanting to compare the eccentric and circular resutls.\n\n inputData_circular = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\n inputData_eccentric = np.genfromtxt(result_file_eccentric, dtype=None, delimiter=', ', comments='#', encoding = None)\n\n inputData = [inputData_circular, inputData_eccentric]\n\n # Find out the indices of the type of average and the error\n if 't0' in str(inputData[0][0]):\n values = [s for i, s in enumerate(inputData[0][0]) if 't0' in s]\n indices = [i for i, s in enumerate(inputData[0][0]) if 't0' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t0_mu') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t0_med') + Nbefore\n e = values.index('t0_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t0_lqs') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n elif 't_secondary' in str(inputData[0]):\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t_secondary_mu') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t_secondary_med') + Nbefore\n e = values.index('t_secondary_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t_secondary_lqs') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n else:\n raise ValueError(\"Not implemented indices selection if we have not fit for t0\")\n\n # If we have some published values, create a table of the Nsigma difference\n if plotPublished:\n print \"\\nOpening file for writing nsigma from published...\"\n f = open(\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFEccentricCircular.txt\".format(planet, foldext), 'w')\n print >> f, (\"Param\\tAOR\\tChannel\\tMethod\\tCirc_val\\tCirc_err\\tEcc_val\\tEcc_err\\tSigma\\tNsigdiff\")\n print >> f, (\"==============================================================================================\")\n\n for p in range(len(fitted_params)):\n\n # Figure out which parameter we are looking at\n param = fitted_params[p]\n\n # Initialise plotting the parameters\n fig = plt.figure(figsize=(8,5))\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\n ax1.set_title(r'Ch1 ($3.6\\mu m$)')\n ax2.set_title(r'Ch2 ($4.5\\mu m$)')\n ax1.set_ylabel(param)\n\n markers = ['o', '*']\n offset = [0,0.01]\n lab = [' cir',' ecc']\n\n # create lists to save the parameters to so that we can compare the circular and elliptical results\n ch1polyMean_list, ch1PLDMean_list, ch1polyStds_list, ch1PLDStds_list = [],[],[],[]\n ch2polyMean_list, ch2PLDMean_list, ch2polyStds_list, ch2PLDStds_list = [],[],[],[]\n\n for c in range(len(inputData)):\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\n ch1polyAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'poly' in line]\n ch1PLDAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'PLD' in line]\n\n if ch1polyAORs != ch1PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line]\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line])\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymetric errors\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'poly' in line]).T\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'PLD' in line]).T\n\n ch1polyMean_list.append(ch1polyMean)\n ch1PLDMean_list.append(ch1PLDMean)\n ch1polyStds_list.append(ch1polyStds)\n ch1PLDStds_list.append(ch1PLDStds)\n\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\n ch2polyAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'poly' in line]\n ch2PLDAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'PLD' in line]\n\n if ch2polyAORs != ch2PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line]\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line])\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymmetric errors\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'poly' in line]).T\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'PLD' in line]).T\n\n ch2polyMean_list.append(ch2polyMean)\n ch2PLDMean_list.append(ch2PLDMean)\n ch2polyStds_list.append(ch2polyStds)\n ch2PLDStds_list.append(ch2PLDStds)\n\n # Calculate the weighted means...\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean), np.array(ch1PLDStds))\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\n\n # Channel 1\n # polynomial\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05+offset[c], ch1polyMean, yerr = ch1polyStds, marker = markers[c], linestyle='', color ='b', label = 'Poly' + lab[c])\n # PLD\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05+offset[c], ch1PLDMean, yerr = ch1PLDStds, marker = markers[c], linestyle='', color = 'r', label = 'PLD' + lab[c])\n # labels\n ax1.set_xticks(range(len(ch1PLDMean)))\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\n\n\n # Channel2\n # polynomial\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05+offset[c], ch2polyMean, yerr = ch2polyStds, marker = markers[c], linestyle='', color ='b')\n # PLD\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05+offset[c], ch2PLDMean, yerr = ch2PLDStds, marker = markers[c], linestyle='', color = 'r')\n # labmarkers[c]\n ax2.set_xticks(range(len(ch2PLDMean)))\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\n\n # Plot the weighted means\n if len(ch1polyMean) > 1.:\n ax1.axhline(WMch1poly, color = 'b')\n ax1.axhspan(WMch1poly - TSch1poly,\n WMch1poly + TSch1poly,\n alpha = 0.3, color='b',label='Weighted Mean')\n ax1.axhline(WMch1PLD, color = 'r')\n ax1.axhspan(WMch1PLD - TSch1PLD,\n WMch1PLD + TSch1PLD,\n alpha = 0.3, color='r',label='Weighted Mean')\n\n ax2.axhline(WMch2poly, color = 'b')\n ax2.axhspan(WMch2poly - TSch2poly,\n WMch2poly + TSch2poly,\n alpha = 0.3, color='b')\n ax2.axhline(WMch2PLD, color = 'r')\n ax2.axhspan(WMch2PLD - TSch2PLD,\n WMch2PLD + TSch2PLD,\n alpha = 0.3, color='r')\n\n\n if plotPublished:\n # Plot the published values if they they are given\n # and calculate Nsigma from published and save to a file\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\n\n if param in data.T[0].tolist():\n\n pIdx = data.T[0].tolist().index(param)\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\n float(data[pIdx][1]) + float(data[pIdx][2]),\n alpha = 0.3, color='k',label='Literature')\n\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\n float(data[pIdx][3]) + float(data[pIdx][4]),\n alpha = 0.3, color='k',label='Literature')\n\n\n # Save the number of sigma to a file\n # This doesn't need to be in param loop because we want to do it for all the parameters\n # regardless if we have published values.\n # polynomial\n for i in range(len(ch1polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1polyAORs[i], 'ch1', 'poly',\n float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()), #channel 1\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()),\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[0].T[i].max()))))\n\n for i in range(len(ch2polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2polyAORs[i], 'ch2', 'poly',\n float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()), #channel 1\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()),\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[0].T[i].max()))))\n #PLD\n for i in range(len(ch1PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1PLDAORs[i], 'ch1', 'PLD',\n float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()), #channel 1\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()),\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[0].T[i].max()))))\n\n for i in range(len(ch2PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2PLDAORs[i], 'ch2', 'PLD',\n float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()), #channel 1\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()),\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[0].T[i].max()))))\n pass\n\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\n axis1ylim = ax1.get_ylim()\n axis2ylim = ax2.get_ylim()\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\n ymin = ax1.get_ylim()[0]\n else:\n ymin = ax2.get_ylim()[0]\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\n ymax = ax2.get_ylim()[1]\n else:\n ymax = ax1.get_ylim()[1]\n ax1.set_ylim(ymin,ymax)\n ax2.set_ylim(ax1.get_ylim())\n ax2.get_yaxis().set_visible(False)\n\n ax1.legend(loc = 'best')\n\n\n # Save if required\n if saveplot:\n plt.savefig(\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}_eccentricCircular.png\".format(planet,foldext,param, os.getenv('HOME')),bbox_inches='tight')\n #plt.close()\n if plotPublished:\n f.close()\n else:\n pass","def plot_fit_results(tool):\n fig, ax = plt.subplots()\n\n model_meyer_ref = CrabSpectrum(\"meyer\").model\n model_meyer_ref.plot(\n [10 * u.GeV, 100 * u.TeV],\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=\":\",\n lw=2.2,\n color=\"#555555\",\n label=\"Meyer et al. (2010)\",\n )\n\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"VERITAS\", \"FACT\", \"H.E.S.S.\", \"joint fit\"]\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n colors = COLORS\n # with one loop we realize all the butterfly plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n\n path = (\n config.repo_path\n / f\"results/fit/{tool}/{instrument}/fit_results_logparabola.yaml\"\n )\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n results = load_yaml(path)\n parameters = results[\"parameters\"]\n\n model_lp = LogParabola.from_log10(\n amplitude=parameters[0][\"value\"] * u.Unit(parameters[0][\"unit\"]),\n reference=parameters[1][\"value\"] * u.Unit(parameters[1][\"unit\"]),\n alpha=parameters[2][\"value\"] * u.Unit(parameters[2][\"unit\"]),\n beta=parameters[3][\"value\"] * u.Unit(parameters[3][\"unit\"]),\n )\n\n # energy range for the plot\n dataset = config.get_dataset(instrument)\n energy_range = dataset.energy_range\n\n # just in case of the joint fit put a thicker line and a less transparent butterfly\n if instrument == \"joint\":\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=3,\n color=color,\n label=label,\n )\n else:\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=2.2,\n color=color,\n label=label,\n )\n\n # read the butterfly from the multivariate sampling results\n table_path = Path(\n f\"{config.repo_path}/results/figures/stat_err/{instrument}_flux_errorband.dat\"\n )\n log.info(f\"reading butterfly values from {table_path}\")\n t = Table.read(table_path, format=\"ascii.ecsv\")\n energies = t[\"energies\"].data * t[\"energies\"].unit\n flux_lo = t[\"flux_lo\"].data * t[\"flux_lo\"].unit\n flux_hi = t[\"flux_hi\"].data * t[\"flux_hi\"].unit\n\n if instrument == \"joint\":\n alpha = 0.38\n else:\n alpha = 0.28\n\n plt.fill_between(\n energies.to(\"TeV\"),\n (energies ** 2 * flux_lo).to(\"erg cm-2 s-1\"),\n (energies ** 2 * flux_hi).to(\"erg cm-2 s-1\"),\n color=color,\n alpha=alpha,\n label=\"\",\n )\n\n ax.legend(fontsize=FONTSIZE)\n ax.set_ylim([1e-12, 2e-10])\n\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax.spines[axis].set_linewidth(1.6)\n ax.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n plt.tight_layout()\n\n filename = f\"results/figures/crab_sed_{tool}_fit.png\"\n filename_pdf = f\"results/figures/crab_sed_{tool}_fit.pdf\"\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)","def plotComparison2(x, nt, nx, c, phi, phiExact, methodName): \n plt.plot(x, phiExact)\n\n plt.plot(x, phi, label=methodName)\n plt.ylim([-0.2, 1.4])","def plot(self):\n # plot the data for checking\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\n 3,2, figsize=(10,8))\n\n # Relative height\n self.board_reference.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\n self.board_intervention.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\n\n # Landuse\n self.board_reference.plot(\n column='landuse', legend=True, ax=ax3, cmap='viridis',\n scheme='equal_interval', k=11)\n self.board_intervention.plot(\n column='landuse', legend=True, ax=ax4, cmap='viridis',\n scheme='equal_interval', k=11)\n\n index = np.arange(7)\n xticks = self.PotTax_reference.index.values\n bar_width = 0.3\n\n # plot the initial and new situation comparison\n label = (\"reference: \" +\n str(round(self.PotTax_reference.sum().TFI, 2)))\n reference = ax5.bar(\n index, self.PotTax_reference.values.flatten(), bar_width,\n label=label, tick_label=xticks)\n label = (\"intervention: \" +\n str(round(self.PotTax_intervention.sum().TFI, 2)))\n intervention = ax5.bar(\n index+bar_width, self.PotTax_intervention.values.flatten(),\n bar_width, label=label, tick_label=xticks)\n ax5.set_ylabel(\"total value\")\n ax5.legend(loc='best')\n for tick in ax5.get_xticklabels():\n tick.set_rotation(90)\n\n # plot the percentage increase/decrease between the initial and new\n # situation\n data = self.PotTax_percentage.values.flatten()\n percentage = ax6.bar(\n index, data, bar_width, label=\"percentage\", tick_label=xticks)\n ax6.set_ylabel(\"increase (%)\")\n minimum = min(data)\n maximum = max(data)\n size = len(str(int(round(maximum))))\n maximum = int(str(maximum)[:1])\n maximum = (maximum + 1) * (10**(size-1))\n ax6.set_ylim([min(0, minimum), maximum])\n for tick in ax6.get_xticklabels():\n tick.set_rotation(90)","def plot_corr_normalized(models,data,fit,**kwargs):\n _fnNMod = len(models)\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\n ## -- objects to hold all plot data\n ## - Dat/Fit refers to the correlator data or the fit function\n ## - Central/Error are the central value and errors\n _fnDatCentral = []\n _fnDatError = []\n _fnFitOnes = []\n _fnFitError = []\n #\n ## -- other objects\n _fnTDataNonZero = []\n _fnTFitNonZero = []\n _fnTData = []\n _fnTFit = []\n _fnTRem = [] # number of previous timeslices removed\n fig,ax = plt.subplots(1)\n #\n ## -- setup plot function\n def do_plot_normalized(idx,fig=fig):\n fig.clear()\n ax = fig.add_subplot(111)\n key = models[idx[0]].datatag\n\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\n ax.set_ylim(utp.get_option(\"y_limit\",[0.2,1.8],**kwargs[key]))\n #\n ## -- plot fit\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\n color=utp.get_option(\"color2\",'b',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ## -- plot correlator data\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\n mfc=utp.get_option(\"markerfacecolor1\",'None',**kwargs[key]),\n mec=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n color=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n ls=utp.get_option(\"linestyle1\",'None',**kwargs[key]),\n marker=utp.get_option(\"marker1\",'o',**kwargs[key]),\n ms=utp.get_option(\"markersize\",6,**kwargs[key]))\n ax.scatter(_fnTFitNonZero[idx[0]],\n [ _fnDatCentral[idx[0]][t] for t in\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\n color=utp.get_option(\"color1\",'r',**kwargs[key]),\n marker=utp.get_option(\"marker\",'o',**kwargs[key]),\n s=utp.get_option(\"markersize\",36,**kwargs[key]))\n fig.suptitle(utp.get_option(\"plottitlefn\",str(idx[0])+\" default title \"+str(key),**kwargs[key]),\n fontsize=utp.get_option(\"titlesize\",20,**kwargs[key]))\n ## -- modify some options \n ax.set_xlabel(r'$t$')\n ax.set_ylabel(utp.get_option(\"yaxistitle\",r\"$C(t)/C_{fit}(t)$\",**kwargs[key]))\n for item in ([ax.xaxis.label,ax.yaxis.label]):\n # must be after setting label content (LaTeX ruins it)\n item.set_fontsize(fontsize=utp.get_option(\"fontsize\",20,**kwargs[key]))\n rect =fig.patch\n rect.set_facecolor('white')\n if utp.get_option(\"to_file\",False,**kwargs[key]):\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".pdf\",**kwargs[key])\n plt.savefig(save_dir+'/'+save_name)\n if utp.get_option(\"to_terminal\",True,**kwargs[key]):\n plt.draw()\n pass\n #\n ## -- setup button press action function\n def press_normalized(event,idx=_fnIdx):\n #print('press_normalized', event.key)\n try:\n ## -- manually indicate index\n idx[0] = int(event.key) + (idx[0])*10\n except ValueError:\n if event.key==' ': ## -- space\n ## -- allows for replotting when changing index by typing number keys\n idx[0] = idx[0] % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='left':\n idx[0] = (idx[0] - 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='right':\n idx[0] = (idx[0] + 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='backspace':\n ## -- reset index so can manually flip through using number keys\n idx[0] = 0\n elif event.key=='d':\n ## -- dump plots into ./plotdump directory\n for ix,model in zip(range(len(models)),models):\n key = model.datatag\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".png\",**kwargs[key])\n do_plot_normalized([ix])\n plt.savefig(save_dir+'/'+save_name)\n do_plot_normalized(idx)\n #\n ## -- \n fig.canvas.mpl_connect('key_press_event',press_normalized)\n ## -- save plot data\n for idx,model in zip(range(len(models)),models):\n key = model.datatag\n _fnTData.append(model.tdata)\n _fnTFit.append(model.tfit)\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\n ## -- fit\n _fnFitFunc = utp.create_fit_func(model,fit)\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\n _fnTRem[-1] = \\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\n ## -- data\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean)) )\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean) )\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\n ## -- done saving data\n \n if not(utp.get_option(\"to_terminal\",True,**kwargs[key])) and\\\n utp.get_option(\"to_file\",False,**kwargs[key]):\n for ix in range(len(models)):\n ## -- loops and saves all without creating window\n do_plot_normalized([ix])\n else:\n do_plot_normalized(_fnIdx)","def plot_results(self):\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))","def display_results(experiment, norms, nus, filename):\n # plot the results of the experiment\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\n\n # plot large scale overview\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\n\n # plot more detailed errors exluding OLS estimate\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\n\n # add title and save\n plt.savefig(filename, dpi=300)","def plot(self):\n\t\traw_labels = self.make_raw_data()[1]\n\t\tbalanced_labels = self.get_extra()[1]\n\t\tfig, ax1 = subplots()\n\t\tax2 = ax1.twinx()\n\t\tx = array(range(1, NCLASSES + 1))\n\t\tl1 = ax1.bar(x - 0.3, self.prior_sizes, width = 0.25, color = 'b', align = 'center', label = 'train')\n\t\tl2 = ax2.bar(x, bincount(raw_labels - 1), width = 0.25, color = 'r', align = 'center', label = 'confident')\n\t\tl3 = ax2.bar(x + 0.3, bincount(balanced_labels - 1), width = 0.25, color = 'g', align = 'center', label = 'rebalanced')\n\t\tconfident_frac = len(raw_labels) / float(self.predictions.shape[0])\n\t\tusable_frac = len(balanced_labels) / float(self.predictions.shape[0])\n\t\tax1.set_title('at >{0:.1f}%, {1:.1f}% reliable, {2:.1f}% usable'.format(self.confidence * 100, confident_frac * 100, usable_frac * 100))\n\t\tax1.legend([l1, l2, l3], [l1.get_label(), l2.get_label(), l3.get_label()], loc = 'upper right')\n\t\tax1.set_xticks(x)","def plot(self, fname=None):\n x = np.linspace(self.bounds[0], self.bounds[-1], 200)\n y = [self.evaluate(xi) for xi in x]\n plt.figure()\n plt.plot(x, y, label='Class func')\n plt.plot(self.bounds, self.gis, 'o', label='Algorithm')\n plt.grid(color='0.7')\n plt.xlabel('Dependent Variable')\n plt.ylabel('PP Transformed Class Value')\n if fname:\n plt.savefig(fname)\n else:\n plt.show()","def get_convergence_plot(self):\n fig, ax = plt.subplots()\n first_episode = self.get_convergence_episode()\n\n values = self.stats['return_stats']['episode_totals']\n ax.plot(np.arange(len(values)), values, color='steelblue', lw=2, alpha=.9,\n label='Return')\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\n ax.set_xlim(left=0, right=first_episode * 2)\n\n ax.set_title('Normalized regret = {:.3f}'.format(\n self.get_normalized_regret()))\n ax.legend()\n ax.set_ylabel('Return')\n ax.set_xlabel('Episode')\n return fig","def plot_ordination(res, choices=[1,2],\n axis_names='PC', constrained_names=None,\n samples_kw={}, species_kw={}, centroids_kw={}, biplot_kw={},\n axline_kw={}):\n choices = asarray(choices) -1\n samples, species, centroids, biplot, evals = [asarray(res.get(k, None))\n for k in ['samples', 'species', 'centroids', 'biplot', 'eigvals']]\n if isinstance(axis_names, str):\n axis_names = ['%s%i' % (axis_names, i+1) for i in range(len(evals))]\n # draw the axis lines\n axline_kw = dict({'color':'gray'}, **axline_kw)\n pylab.axvline(**axline_kw)\n pylab.axhline(**axline_kw)\n # calc percentages from evals and label them\n evals = asarray(evals)\n evals[evals<0] = 0\n percs = 100 * (evals / evals.sum())\n pylab.xlabel('%s - %.2f%%' % (axis_names[choices[0]], percs[choices[0]]))\n pylab.ylabel('%s - %.2f%%' % (axis_names[choices[1]], percs[choices[1]]))\n #plot the speceies points in red +\n if any(species):\n species_kw = dict({'cml': 'r+', 'label_kw':{'size':'smaller'}},\n **species_kw) #set default\n plot_points(species[:, choices], **species_kw)\n # scatter the sample points in black\n default = {'c': 'k', 's': 50, 'alpha': 0.5, 'label_kw': {'size': 'medium'}}\n scatter_points(samples[:, choices], **dict(default, **samples_kw))\n # scatter the centroids\n if any(centroids):\n default = {'c':'b', 's':0, 'label': 'X', 'label_kw':{'size':'larger',\n 'color':'b', 'ha':'center', 'va':'center'}}\n scatter_points(centroids[:, choices], **dict(default, **centroids_kw))\n # arrow the biplot points\n if any(biplot):\n default = {'c':'b', 'label_kw':{'size':'larger', 'color':'b'}}\n arrows([[0,0]] * len(biplot), biplot[:, choices],\n **dict(default, **biplot_kw))\n # calc the constrained percentage and title it\n if constrained_names:\n if isinstance(constrained_names, str): #a prefix\n constrained_names = [n for n in axis_names if\n n.startswith(constrained_names)]\n con_idxs = [i for i, n in enumerate(axis_names)\n if n in constrained_names]\n con_perc = percs[con_idxs].sum()\n pylab.title('%.2f%% constrained' % con_perc)","def plot_data(self, plot_input=True, plot_fitted=True,plotfile=None, show=None):\n if not self.fitted:\n raise RuntimeError(\"Please run fit() before attempting to plot the results\")\n\n fitted_data = self.data_summary(printout=False)\n fitted_mean = fitted_data['mean'].to_numpy().reshape((self.npoints,self.ndim))\n print(fitted_mean.shape)\n fitted_sigma = fitted_data['sd'].to_numpy().reshape((self.npoints,self.ndim))\n if self.ndim==np.int(2) and isinstance(self.ndim, int):\n blue, _, red, *_ = sns.color_palette()\n f, ax = plt.subplots(1, 1, figsize=(5, 4))#, gridspec_kw=dict(width_ratios=[4, 3]))\n\n sns.scatterplot(x=self.data[:,0], y=self.data[:,1])\n if plot_input:\n ax.errorbar(x=self.data[:,0], y=self.data[:,1],\n xerr=self.sigma[:,0], yerr=self.sigma[:,1],fmt='o',label='input data')\n \n if plot_fitted:\n ax.errorbar(x=fitted_mean[:,0], y=fitted_mean[:,1],\n xerr=fitted_sigma[:,0], yerr=fitted_sigma[:,1],fmt='o',label='inferred data')\n \n mu_post = self.trace.posterior[\"mu\"].mean(axis=(0, 1)).data\n \n sigma_post = self.trace.posterior[\"cov\"].mean(axis=(0, 1)).data\n \n var_post, U_post = np.linalg.eig(sigma_post)\n angle_post = 180.0 / np.pi * np.arccos(np.abs(U_post[0, 0]))\n\n e_post = Ellipse(\n mu_post,\n 2 * np.sqrt(5.991 * var_post[0]),\n 2 * np.sqrt(5.991 * var_post[1]),\n angle=angle_post,\n )\n e_post.set_alpha(0.5)\n e_post.set_facecolor(blue)\n e_post.set_zorder(10)\n ax.add_artist(e_post)\n rect_post = plt.Rectangle((0, 0), 1, 1, fc=blue, alpha=0.5)\n ax.legend(\n [rect_post],\n [\"Estimated 95% density region\"],\n loc=2,\n )\n #plt.show()\n\n elif self.ndim > 2 and isinstance(int, self.ndim) and np.isfinite(self.ndim):\n #raise NotImplementedError(\"This routine doesn't support plotting correlations in more than 2 dimensions yet!\")\n rows = self.ndim - 1\n cols = self.ndim - 1\n fig = plt.figure()\n gs = fig.add_gridSpec(rows, cols,left=0.1, right=0.9, bottom=0.1, top=0.9,\n wspace=0.05, hspace=0.05)\n for i in range(self.ndim - 1):\n for j in range(i+1,self.ndim - 1):\n ax = fig.add_subplot(gs[i,j])\n #plot the data points\n sns.scatterplot(self.data[:,i], self.data[:,j], ax=ax)\n if plot_input:\n ax.errorbar(x=self.data[:,i], y=self.data[:,j],\n xerr=self.sigma[:,i], yerr=self.sigma[:,j])\n \n if plot_fitted:\n ax.errorbar(x=fitted_mean[:,i], y=fitted_mean[:,j],\n xerr=fitted_sigma[:,i], yerr=fitted_sigma[:,j])\n \n mu_post = self.trace.posterior[\"mu\"].mean(axis=(i, j)).data\n \n sigma_post = self.trace.posterior[\"cov\"].mean(axis=(i, j)).data\n \n var_post, U_post = np.linalg.eig(sigma_post)\n angle_post = 180.0 / np.pi * np.arccos(np.abs(U_post[0, 0]))\n \n e_post = Ellipse(\n mu_post,\n 2 * np.sqrt(5.991 * var_post[0]),\n 2 * np.sqrt(5.991 * var_post[1]),\n angle=angle_post,\n )\n e_post.set_alpha(0.5)\n e_post.set_facecolor(blue)\n e_post.set_zorder(10)\n ax.add_artist(e_post)\n \n else:\n raise ValueError(\"Ndim is either less than 2 or is not an integer!\")\n \n if isinstance(plotfile, str):\n plt.save(plotfile)\n elif not show:\n raise TypeError(\"plotfile must be a string\")\n if show:\n plt.show()\n elif plotfile is not None:\n plt.close()","def check_fit(data, data_fit, time_points):\n plt.figure()\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\"Cases\", \"Deaths\", \"Hospitalized\", \"ICU\"])):\n if data[ii] is not None:\n plt.plot(time_points, data[ii], c=f\"C{jj}\", label=lab)\n plt.plot(time_points, data_fit[ii], '--', c=f\"C{jj}\", label=f\"{lab} fit\")\n plt.yscale(\"log\")\n plt.legend()\n # plt.savefig(\"Test_fitting\", format=\"png\")\n plt.show()","def plot_rank_sensitivity(\n dmd_train_error, dmd_test_error, optdmd_train_error, optdmd_test_error\n):\n\n # Generate figure.\n fig, axes = plt.subplots(\n 1, 2, figsize=(fig_width, fig_width / 4), sharex=True, sharey=True\n )\n\n # Misc.\n rank = np.arange(1, dmd_test_error.shape[0] + 1)\n\n #####\n # TRAINING ERROR\n #####\n\n # Plot the vanilla DMD error.\n axes[0].plot(rank, dmd_train_error)\n # Plot the OptDMD error.\n axes[0].plot(rank, optdmd_train_error, ls=\"--\")\n # Add decorators.\n axes[0].set(\n xlabel=r\"Rank of the DMD model\",\n ylabel=r\"Normalized error\",\n title=r\"Training dataset\",\n )\n axes[0].grid(True)\n\n #####\n # TESTING ERROR\n #####\n\n # Plot the vanilla DMD error.\n axes[1].plot(rank, np.mean(dmd_test_error, axis=1), label=r\"Regular DMD\")\n axes[1].fill_between(\n rank,\n np.mean(dmd_test_error, axis=1) + np.std(dmd_test_error, axis=1),\n np.mean(dmd_test_error, axis=1) - np.std(dmd_test_error, axis=1),\n alpha=0.25,\n )\n # Plot the OptDMD error.\n axes[1].plot(\n rank, np.mean(optdmd_test_error, axis=1), ls=\"--\", label=r\"Optimal DMD\"\n )\n axes[1].fill_between(\n rank,\n np.mean(optdmd_test_error, axis=1) + np.std(optdmd_test_error, axis=1),\n np.mean(optdmd_test_error, axis=1) - np.std(optdmd_test_error, axis=1),\n alpha=0.25,\n )\n # Add decorators.\n axes[1].set(\n xlim=(0, rank.max()),\n xlabel=r\"Rank of the DMD model\",\n ylim=(0, 1),\n title=r\"Testing dataset\",\n )\n axes[1].grid(True)\n axes[1].legend(loc=0)\n\n return","def visualize_best_model_params(df, model_name, model_params, score_names, is_higher_score_better, err_param_name,\n title, x_log=False, y_log=False, max_n_cols=2):\n dfs = [df_ for df_ in split_df_by_model(df) if re.match(model_name + r\"(?:|Clean) #\\d+\", df_.name)]\n\n for df_ in dfs:\n n_rows, n_cols = get_n_rows_cols(len(score_names), max_n_cols)\n fig, axs = plt.subplots(n_rows, n_cols, figsize=(n_cols * 5, n_rows * 4), squeeze=False,\n constrained_layout=True)\n for i, ax in enumerate(axs.ravel()):\n for j, score_name in enumerate(score_names):\n df_opt = filter_optimized_results(df_, err_param_name, score_name, is_higher_score_better[j])\n if x_log and y_log:\n ax.loglog(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\n elif x_log:\n ax.semilogx(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\n elif y_log:\n ax.semilogy(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\n else:\n ax.plot(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\n ax.set_xlabel(err_param_name)\n ax.set_ylabel(model_params[i])\n ax.legend(fontsize=\"small\")\n\n fig.suptitle(title + \" (\" + df_.name + \")\", fontsize=10)\n path_to_plot = generate_unique_path(\"out\", \"png\")\n fig.savefig(path_to_plot)","def plotModelResults(model, X_train=X_train, X_test=X_test, plot_intervals=False, plot_anomalies=False):\n\n prediction = model.predict(X_test)\n\n plt.figure(figsize=(15, 7))\n\n plt.plot(prediction, \"g\", label=\"prediction\", linewidth=2.0)\n plt.plot(y_test.values, label=\"actual\", linewidth=2.0)\n plt.draw()\n if plot_intervals:\n cv = cross_val_score(model, X_train, y_train,\n cv=tscv,\n scoring=\"neg_mean_absolute_error\")\n mae = cv.mean() * (-1)\n deviation = cv.std()\n\n scale = 1.96\n lower = prediction - (mae + scale * deviation)\n upper = prediction + (mae + scale * deviation)\n\n plt.plot(lower, \"r--\", label=\"upper bond / lower bond\", alpha=0.5)\n plt.plot(upper, \"r--\", alpha=0.5)\n plt.draw()\n\n if plot_anomalies:\n anomalies = np.array([np.NaN]*len(y_test))\n anomalies[y_test<lower] = y_test[y_test<lower]\n anomalies[y_test>upper] = y_test[y_test>upper]\n plt.plot(anomalies, \"o\", markersize=10, label = \"Anomalies\")\n plt.draw()\n def mean_absolute_percentage_error(y_true, y_pred):\n return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\n\n error = mean_absolute_percentage_error(prediction, y_test)\n plt.title(\"Mean absolute percentage error {0:.2f}%\".format(error))\n plt.legend(loc=\"best\")\n plt.tight_layout()\n plt.grid(True)\n plt.draw()","def plot(self):\r\n \r\n\r\n print(\"Printing decision surfaces of decision trees\")\r\n plot_colors = \"rb\"\r\n plot_step = 0.02\r\n n_classes = 2\r\n for _ in range (self.n_estimators):\r\n plt.subplot(2, 3, _ + 1)\r\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\r\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\r\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\r\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\r\n Z = self.clfs[_].predict(np.c_[xx.ravel(), yy.ravel()])\r\n Z = np.array(Z)\r\n Z = Z.reshape(xx.shape)\r\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\r\n for i, color in zip(range(n_classes), plot_colors):\r\n if i == 0:\r\n idx = np.where(self.y == -1)\r\n if i == 1:\r\n idx = np.where(self.y == 1)\r\n for i in range (len(idx[0])):\r\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\r\n plt.suptitle(\"Decision surface of a decision tree using paired features\")\r\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\r\n plt.axis(\"tight\")\r\n\r\n plt.show()\r\n fig1 = plt\r\n\r\n # Figure 2\r\n print(\"Printing decision surface by combining the individual estimators\")\r\n plot_colors = \"rb\"\r\n plot_step = 0.02\r\n n_classes = 2\r\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\r\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\r\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\r\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\r\n Z = config.Classifier_AB.predict(np.c_[xx.ravel(), yy.ravel()])\r\n Z = np.array(Z)\r\n Z = Z.reshape(xx.shape)\r\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\r\n for i, color in zip(range(n_classes), plot_colors):\r\n if i == 0:\r\n idx = np.where(self.y == -1)\r\n if i == 1:\r\n idx = np.where(self.y == 1)\r\n for i in range (len(idx[0])):\r\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\r\n plt.suptitle(\"Decision surface by combining individual estimators\")\r\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\r\n plt.axis(\"tight\")\r\n\r\n plt.show()\r\n fig2 = plt\r\n\r\n return [fig1,fig2]","def plot_mean(self, exact, exact_label='CCSD', axabs=None):\n if axabs is None:\n axabs = plt.gca()\n axabs.plot(list(range(1, self.max_dets)), self.means[0], label='independent')\n axabs.plot(list(range(1, self.max_dets)), self.means[1], label='correlated')\n axabs.axhline(self.means[0, 0], linestyle='--', color='silver', label='reference')\n if exact:\n axabs.axhline(exact, linestyle='dashdot', color='green', label=exact_label)\n axabs.set_xlabel('Number of determinants in estimator')\n axabs.set_ylabel(r'$E_\\mathrm{corr}$ / ha')\n axabs.legend()\n return axabs","def PlotEnsemblePredictions(self,ens, sampling_freq=10, fontSizeLabels=24, fontSizeLegend=20,rescale=1.,pow10first=False):\n pylab.figure()\n\tpylab.axes([0.15,0.35,0.95-0.15,0.95-0.35])\n\tdata_experiments = self.data.experiments\n for independentValues in data_experiments:\n Xdata = self.data.X[independentValues]\n Ydata = self.data.Y[independentValues]\n\t Xtheory = scipy.logspace(scipy.log10(min(Xdata)),scipy.log10(max(Xdata)),num=100)\n\t pointType = self.data.pointType[independentValues]\n\t errorBar = self.data.errorBar[independentValues]\n\t mean_theory = scipy.zeros(len(Xtheory))\n\t std_theory = scipy.zeros(len(Xtheory))\n for i in range(0, num_to_count):\n\t\t ens_theory = self.theory.Y(Xtheory,ens[i*sampling_freq],independentValues)\n\t\t mean_theory += ens_theory\n\t\t std_theory += (ens_theory)**2\n\t mean_theory = mean_theory/(1.0*num_to_count)\n\t std_theory = scipy.sqrt((std_theory-num_to_count*mean_theory**2)/(num_to_count-1.))\n\t pylab.loglog(Xdata,Ydata,pointType[1])\n\t lb = self.getLabel(self.theory.independentNames,independentValues,pow10first=pow10first)\n\t pylab.errorbar(Xdata,Ydata, yerr=errorBar, fmt=pointType,label=lb)\n\t pylab.loglog(Xtheory,mean_theory,pointType[0])\n\t axis_dep=self.getAxis(Xdata,Ydata)\n\t #upper_bound = mean_theory+std_theory\n\t #lower_bound = mean_theory-std_theory\n\t upper_bound = scipy.exp(scipy.log(mean_theory) + scipy.log(1.+std_theory/mean_theory)*rescale)\n\t lower_bound = scipy.exp(scipy.log(mean_theory)+scipy.log(1.-std_theory/mean_theory)*rescale)\n\t for i in range(0, len(lower_bound)):\n\t\t if lower_bound[i]<=0:\n\t\t\t lower_bound[i]=10.**(-16)\n\t pylab.fill_between(Xtheory,lower_bound,y2=upper_bound,color=pointType[0],alpha=0.2)\n\n\t for i, Ax in enumerate(axis_dep):\n\t\t ax0[i] =i%2 and max(ax0[i],Ax) or min(ax0[i],Ax)\n\tpylab.axis(tuple(ax0))\n\tpylab.legend(loc=(-0.15,-0.52),ncol=3)","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def compute(self):\n # update parameters with the values of widgets\n initguess = str(self.ptext.toPlainText())\n if not self.checkUserInput(initguess):\n return\n stguess = initguess.replace('\\n', ',')\n # update self.parmVal\n self.guessToParms(stguess)\n try:\n self.parent.app.setOverrideCursor(Qt.WaitCursor)\n result = least_squares(self.residuals, self.parmVal, bounds=self.bounds,\n args=(self.data[1], self.data[0]))\n self.parent.app.restoreOverrideCursor()\n except ValueError as err:\n errmsg = \"Fitting process failure:\\n{0}\".format(err)\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\n return\n RMSE = np.sqrt(np.sum(np.square(result.fun)) / len(self.data[1]))\n msg = \"Initial guess : \\n{0}\\n\".format(initguess)\n msg += \"Number of peaks = {0:d}\\n\".format(self.npeaks)\n logmsg = msg + 'Fitting results:\\n'\n res = np.reshape(result.x, (self.npeaks, self.maxparm))\n strres = self.resToStr(res)\n logmsg += '[xm, amp, fwhm, asym, m] = \\n{0}\\n'.format(strres)\n rmsemsg = 'RMSE = {0:g}\\n\\n'.format(RMSE)\n msg += rmsemsg\n logmsg += rmsemsg\n self.parmVal = result.x\n\n # Show results in log windows\n self.log.setText(msg)\n self.log.moveCursor(QtGui.QTextCursor.End)\n self.saveToLogFile(logmsg)\n self.data[2] = self.fitfunc(self.data[0], result.x)\n self.data[3] = self.data[2] - self.data[1] - self.diffshift\n\n self.updatePlot()\n self.updateParmsEdit()","def cross_validation_visualization(lambds, score_tr, score_te):\n plt.semilogx(lambds, score_tr, marker=\".\", color='b', label='train score');\n plt.semilogx(lambds, score_te, marker=\".\", color='r', label='test score');\n plt.xlabel(\"lambda\")\n plt.ylabel(\"score\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_test\")","def plot_spectrumxichange(self):\n countgood = 0 ; countbad = 0\n for idata in self.datarg:\n if idata[-1, 0] == 1.: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \n countgood += 1\n print countgood , 'good solution'\n else: \n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \n print countbad, 'bad solution'\n countbad += 1\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\'s what you expected' %(countgood,countbad)\n #Create custom artistsr[goodline,badline],['solution','breakdown']\n goodline = pl.Line2D((0,1),(0,0), color='b') \n badline = pl.Line2D((0,1),(0,0), color='r')\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\n self.savefig('xispec')","def diagnose(self):\n return self._diagnostic_plot()","def residual_vs_actual(\n y_true: ArrayLike | str,\n y_pred: ArrayLike | str,\n df: pd.DataFrame | None = None,\n ax: plt.Axes | None = None,\n xlabel: str = r\"Actual value\",\n ylabel: str = r\"Residual ($y_\\mathrm{true} - y_\\mathrm{pred}$)\",\n **kwargs: Any,\n) -> plt.Axes:\n y_true, y_pred = df_to_arrays(df, y_true, y_pred)\n assert isinstance(y_true, np.ndarray)\n assert isinstance(y_pred, np.ndarray)\n ax = ax or plt.gca()\n\n y_err = y_true - y_pred\n\n ax.plot(y_true, y_err, \"o\", alpha=0.5, label=None, mew=1.2, ms=5.2, **kwargs)\n ax.axline(\n [1, 0], [2, 0], linestyle=\"dashed\", color=\"black\", alpha=0.5, label=\"ideal\"\n )\n\n ax.set(xlabel=xlabel, ylabel=ylabel)\n ax.legend(loc=\"lower right\")\n\n return ax","def eval_classifier(clf, X, y_correct, classes, plot_cm=True):\n y_pred = clf.predict(X)\n return get_accuracy_and_plot_confusion(y_correct, list(y_pred), classes, plot=plot_cm)"],"string":"[\n \"def robustnessPlot(ax):\\n # Setup the range of avidity and ligand concentration we'll look at\\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\\n\\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\\n columns=['gnus', 'Los'])\\n\\n pp['CPredict'] = pp.apply(lambda x: InVivoPredict(x.values)[1], axis=1)\\n\\n # Change avidities to strings\\n pp['gnus'] = pp['gnus'].apply(lambda gnu: r'$\\\\nu=' + str(int(gnu)) + '$')\\n\\n avcolors = dict(zip(pp['gnus'].unique(), sns.color_palette()[1:]))\\n\\n # Plot the calculated crossvalidation performance\\n sns.FacetGrid(pp,\\n hue='gnus',\\n palette=sns.color_palette()[1:]).map(ax.semilogx, 'Los', 'CPredict')\\n\\n ax.legend(handles=Legend(pp['gnus'].unique(), avcolors, [], {}), bbox_to_anchor=(1, 1), loc=2)\\n\\n ax.set_xlabel('Assumed IC Conc. (M)')\\n ax.set_ylabel('LOO Prediction R-Squared')\\n ax.set_ylim(0.0, 1.0)\",\n \"def plotFittingResults(self):\\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\\n\\n #_listExpStdDev = None\\n #if self.getDataInput().getExperimentalDataStdDev():\\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\\n #if _listExpStdDev:\\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\\\"Experimental Data\\\")\\n # pylab.gca().set_yscale(\\\"log\\\", nonposy='clip')\\n #else: \\n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n\\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n pylab.semilogy(_listFitQ, _listFitValues, label=\\\"Fitting curve\\\")\\n pylab.xlabel('q')\\n pylab.ylabel('I(q)')\\n pylab.suptitle(\\\"RMax : %3.2f. Fit quality : %1.3f\\\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\\n pylab.legend()\\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \\\"gnomFittingResults.png\\\"))\\n pylab.clf()\",\n \"def plot_result(numerical, exact):\\n \\n numx, numy = numerical\\n exax, exay = exact\\n plt.title('Comparison Numerical vs. Analytical Solution')\\n plt.xlabel('Distance x (m)')\\n plt.ylabel('Temperature $(^{o}C)$')\\n plt.plot(numx, numy, 'ro', label='numerical')\\n plt.plot(exax, exay, 'y--', label='analytical')\\n plt.legend()\\n plt.grid()\",\n \"def analysis_plot(predictions, ys):\\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\\n\\n residuals = ys - predictions\\n\\n # Plot 1 - Predicted vs Actual\\n sns.scatterplot(predictions, ys, ax=ax1)\\n ax1.set_title('Predicted vs Actual', fontsize=20)\\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\\n\\n # Plot 2 - Residuals PLot (predicted vs residuals)\\n sns.scatterplot(predictions, residuals, ax=ax2)\\n ax2.set_title('Residuals Plot', fontsize=20)\\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\\n\\n # Plot 3 - QQ Plot\\n sm.qqplot(residuals, ax=ax3, line='s')\\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\\n\\n plt.show();\",\n \"def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\\n \\n plt.figure()\\n plt.plot(x, phiExact)\\n\\n plt.plot(x, phi)\\n plt.ylim([-0.2, 1.4])\\n plt.title(str(methodName)+\\\" scheme\\\\nExact vs Numerical solution \\\"\\\\\\n \\\"nt=\\\"+str(nt)+\\\", nx=\\\"+str(nx)+\\\"\\\\n\\\"\\n \\\"Courant number: \\\"+str(c))\\n plt.show()\",\n \"def plot_insta_err(self, ax=None):\\n if ax is None:\\n ax = plt.gca()\\n ax.set_yscale('log')\\n ax.plot(list(range(1, self.max_dets)), self.errors[0], label='independent')\\n ax.plot(list(range(1, self.max_dets)), self.errors[1], label='correlated')\\n ax.set_ylabel(r'Stochastic error in $E_\\\\mathrm{corr}$ / ha')\\n ax.set_xlabel('Number of determinants in estimator')\\n ax.axhline(np.sqrt(self.proje_var[0]), linestyle='--', color='black', label='reference')\\n ax.legend()\\n return ax\",\n \"def plot_fitting_coefficients(self):\\n from matplotlib import pyplot as plt\\n coeff = self.linear_fit[\\\"coeff\\\"]\\n order = self.linear_fit[\\\"order\\\"]\\n\\n data = {}\\n annotations = {}\\n for c, o in zip(coeff, order):\\n if len(o) == 0:\\n continue\\n n = len(o)\\n if n not in data.keys():\\n data[n] = [c]\\n annotations[n] = [WulffConstruction.order2string(o)]\\n else:\\n data[n].append(c)\\n annotations[n].append(WulffConstruction.order2string(o))\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 1, 1)\\n start = 0\\n keys = list(data.keys())\\n keys.sort()\\n for k in keys:\\n x = list(range(start, start+len(data[k])))\\n ax.bar(x, data[k], label=str(k))\\n start += len(data[k]) + 1\\n for i in range(len(data[k])):\\n ax.annotate(annotations[k][i], xy=(x[i], data[k][i]))\\n ax.set_ylabel(\\\"Fitting coefficient\\\")\\n ax.set_xticklabels([])\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend(frameon=False)\\n return fig\",\n \"def _plot_resid_vs_fitted(self, ax):\\n\\n res = self._model.fit()\\n\\n ax.plot(res.fittedvalues, res.resid, '.')\\n ax.set_xlabel('Fitted ' + self._model.endog_names)\\n ax.set_ylabel('Raw residual')\\n plt.sca(ax)\\n plt.axhline(color='k')\",\n \"def plot(self):\\n # Sufficient to check a single existence condition\\n if self._idx_coefs is None:\\n raise NotFittedError('You must estimate the regression by calling fit prior to plotting.')\\n\\n plt.figure(figsize=(15,8))\\n plt.plot(self._idx_coefs, color='black')\\n plt.axhline(y=0, linestyle='--', color='black')\\n plt.fill_between(\\n self._idx_cis.index.values,\\n self._idx_cis.lower.values.reshape(-1),\\n self._idx_cis.upper.values.reshape(-1),\\n color='cyan',\\n alpha=0.3\\n )\\n plt.title(self._depvar_label)\\n plt.ylabel('Estimated Coefficient')\\n plt.xlabel('Days since Event')\",\n \"def _diagnostic_plot(self):\\n if not hasattr(self, \\\"corrected_lc\\\"):\\n raise ValueError(\\n \\\"Please call the `correct()` method before trying to diagnose.\\\"\\n )\\n\\n with plt.style.context(MPLSTYLE):\\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=True)\\n ax = axs[0]\\n self.lc.plot(ax=ax, normalize=False, label=\\\"original\\\", alpha=0.4)\\n for key in self.diagnostic_lightcurves.keys():\\n (\\n self.diagnostic_lightcurves[key]\\n - np.median(self.diagnostic_lightcurves[key].flux)\\n + np.median(self.lc.flux)\\n ).plot(ax=ax)\\n ax.set_xlabel(\\\"\\\")\\n ax = axs[1]\\n self.lc.plot(ax=ax, normalize=False, alpha=0.2, label=\\\"original\\\")\\n self.corrected_lc[self.outlier_mask].scatter(\\n normalize=False, c=\\\"r\\\", marker=\\\"x\\\", s=10, label=\\\"outlier_mask\\\", ax=ax\\n )\\n self.corrected_lc[~self.cadence_mask].scatter(\\n normalize=False,\\n c=\\\"dodgerblue\\\",\\n marker=\\\"x\\\",\\n s=10,\\n label=\\\"~cadence_mask\\\",\\n ax=ax,\\n )\\n self.corrected_lc.plot(normalize=False, label=\\\"corrected\\\", ax=ax, c=\\\"k\\\")\\n return axs\",\n \"def plot_solution(self):\\n\\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \\\"Analytical\\\")\\n plt.plot(self.x_values, self.numerical, label = \\\"Numerical\\\")\\n plt.title(\\\"Numerical vs. Analytical Solution\\\")\\n plt.xlabel(\\\"x\\\")\\n plt.ylabel(\\\"u(x)\\\")\\n plt.legend()\\n plt.show()\",\n \"def testPlotCandidateDesign(self):\\n\\n np.random.seed(0)\\n new_data = pd.concat([self.test_data, self.add_pair], sort=False)\\n test_class = TrimmedMatchGeoXDesign(\\n GeoXType.HEAVY_UP,\\n pretest_data=new_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n )\\n budget_list = [30, 40]\\n iroas_list = [0, 2]\\n results, _ = test_class.report_candidate_designs(\\n budget_list=budget_list,\\n iroas_list=iroas_list,\\n use_cross_validation=True,\\n num_simulations=10,\\n )\\n\\n axes_dict = test_class.plot_candidate_design(results)\\n for budget in budget_list:\\n for iroas in iroas_list:\\n self.assertIsInstance(axes_dict[(budget, iroas)], plt.Figure)\",\n \"def plot_cnf_matrix(self):\\n\\t\\tplt.figure()\\n\\t\\tanalysis.plot_cnf_matrix(self.y_pred, self.y_test)\",\n \"def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\\n if axdelta is None:\\n axdelta = plt.gca()\\n delta = self.means - exact\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\\n if blocked:\\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\\n if blockederr:\\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\\n axdelta.set_xlabel('Number of determinants in estimator')\\n axdelta.set_ylabel(r'$E-E_\\\\mathrm{CCSD}$ / ha')\\n axdelta.legend()\\n return axdelta\",\n \"def deviance_plot(est, X_test, y_test, ax=None, label='',train_color='#2c7bb6', test_color='#d7191c', alpha=1.0):\\r\\n\\ttest_dev = np.empty(n_estimators) #创建数组\\r\\n\\tfor i, pred in enumerate(est.staged_predict(X_test)):\\r\\n\\t\\ttest_dev[i] = est.loss_(y_test, pred)\\r\\n\\tif ax is None:\\r\\n\\t\\tfig = plt.figure(figsize=(8,5))\\r\\n\\t\\tax = plt.gca();\\r\\n\\tax.plot(np.arange(n_estimators)+1, test_dev, color=test_color, label='Test Error max_depth=1 %s' % label, linewidth=2, alpha=alpha)\\r\\n\\tax.plot(np.arange(n_estimators)+1, est.train_score_, color=train_color, label='Train Error max_depth=1 %s' % label, linewidth=2, alpha=alpha)\\r\\n\\tax.set_ylabel('Error')\\r\\n\\tax.set_xlabel('n_estimators')\\r\\n\\tax.set_ylim((0,2))\\r\\n\\treturn test_dev, ax\",\n \"def plot(guess_log, counter_log, x):\\n correct_sqrt = np.sqrt(x)\\n x_axis = np.linspace(-1, 1.1*len(guess_log), len(guess_log))\\n y_axis = np.ones(len(guess_log))*correct_sqrt\\n plt.plot(counter_log, guess_log, 'ok')\\n plt.plot(x_axis, y_axis, '--r', linewidth=2.0, label='Correct Answer')\\n plt.axis([-1, max(x_axis), -0.1*max(guess_log), 1.1*max(guess_log)])\\n plt.xlabel('Iterations')\\n plt.ylabel('Guess')\\n plt.legend(loc = 'upper right')\\n plt.show()\\n return 0\",\n \"def plot_dif_eq(self):\\n try:\\n self.canvas.get_tk_widget().pack_forget()\\n self.toolbar.pack_forget()\\n except AttributeError:\\n pass\\n\\n f = Figure(figsize=(8, 8), dpi=100)\\n p = f.add_subplot(111)\\n\\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\\n\\n p.set_ylabel('y')\\n p.set_xlabel('x')\\n\\n p.legend(['Exact', 'EU', \\\"IEU\\\", \\\"RK\\\"])\\n p.set_title(\\\"Solutions\\\")\\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\\\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\\n p.set_ylim([-100, 100])\\n\\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\\\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\\n p.set_ylim([-100, 100])\\n\\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\\n self.canvas.draw()\\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\\n\\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\\n self.toolbar.update()\\n\\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)\",\n \"def plot_calibration_curve(est, name, fig_index, data):\\n\\n X_train = data[0]\\n X_test = data[1]\\n y_train = data[2]\\n y_test = data[3]\\n\\n y = np.concatenate([y_train, y_test], axis=0)\\n\\n # Calibrated with isotonic calibration\\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\\n\\n # Calibrated with sigmoid calibration\\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\\n\\n # Logistic regression with no calibration as baseline\\n lr = LogisticRegression(C=1., solver='lbfgs')\\n\\n fig = plt.figure(1, figsize=(15, 10))\\n ax1 = plt.subplot2grid((4, 6), (0, 0), colspan=2, rowspan=2)\\n ax2 = plt.subplot2grid((4, 6), (0, 2), colspan=2, rowspan=2)\\n ax3 = plt.subplot2grid((4, 6), (0, 4), colspan=2, rowspan=2)\\n ax4 = plt.subplot2grid((4, 6), (2, 0), colspan=6, rowspan=2)\\n\\n ax1.plot([0, 1], [0, 1], \\\"k:\\\", label=\\\"Perfectly calibrated\\\")\\n for clf, name in [(lr, 'Logistic'),\\n (est, name),\\n (isotonic, name + ' + Isotonic'),\\n (sigmoid, name + ' + Sigmoid')]:\\n clf.fit(X_train, y_train)\\n y_pred = clf.predict(X_test)\\n if hasattr(clf, \\\"predict_proba\\\"):\\n prob_pos = clf.predict_proba(X_test)[:, 1]\\n y_proba = prob_pos.copy()\\n else: # use decision function\\n prob_pos = clf.decision_function(X_test)\\n y_proba = prob_pos.copy()\\n prob_pos = \\\\\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\\n\\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\\n print(\\\"%s:\\\" % name)\\n print(\\\"\\\\tBrier: %1.3f\\\" % (clf_score))\\n print(\\\"\\\\tPrecision: %1.3f\\\" % precision_score(y_test, y_pred))\\n print(\\\"\\\\tRecall: %1.3f\\\" % recall_score(y_test, y_pred))\\n print(\\\"\\\\tF1: %1.3f\\\" % f1_score(y_test, y_pred))\\n print(\\\"\\\\tAve. Precision Score: %1.3f\\\\n\\\" % \\\\\\n average_precision_score(y_test, y_proba))\\n\\n fraction_of_positives, mean_predicted_value = \\\\\\n calibration_curve(y_test, prob_pos, n_bins=10)\\n\\n ax1.plot(mean_predicted_value, fraction_of_positives, \\\"s-\\\",\\n label=\\\"%s (%1.3f)\\\" % (name, clf_score))\\n\\n fpr, tpr, thresholds = roc_curve(y_test, y_proba, drop_intermediate=False)\\n roc_auc = roc_auc_score(y_test, y_proba)\\n ax2.plot(fpr, tpr, ls='-', label=\\\"%s (%1.3f)\\\" % (name, roc_auc))\\n\\n precision, recall, _ = precision_recall_curve(y_test, y_proba)\\n ax3.plot(recall, precision)\\n\\n ax4.hist(prob_pos, range=(0, 1), bins=10,\\n label='%s' % name, histtype=\\\"step\\\", lw=2)\\n\\n ax1.set_xlabel(\\\"Score\\\", fontsize=14)\\n ax1.set_ylabel(\\\"Fraction of positives\\\", fontsize=14)\\n ax1.set_ylim([-0.05, 1.05])\\n ax1.legend(loc=\\\"lower right\\\")\\n ax1.set_title('Calibration plots (reliability curve)', fontsize=16)\\n\\n ax2.set_xlabel(\\\"False Positive Rate\\\", fontsize=14)\\n ax2.set_ylabel(\\\"True Positive Rate\\\", fontsize=14)\\n ax2.set_ylim([-0.05, 1.05])\\n ax2.legend(loc=\\\"lower right\\\")\\n ax2.set_title('ROC Curve', fontsize=16)\\n\\n ax3.set_xlabel(\\\"Recall\\\", fontsize=14)\\n ax3.set_ylabel(\\\"Precision\\\", fontsize=14)\\n ax3.set_ylim([-0.05, 1.05])\\n ax3.legend(loc=\\\"lower center\\\")\\n ax3.set_title('Precision-Recall Curve', fontsize=16)\\n\\n ax4.set_xlabel(\\\"Mean predicted value\\\", fontsize=14)\\n ax4.set_ylabel(\\\"Count\\\", fontsize=14)\\n ax4.legend(loc=\\\"upper center\\\")\\n ax4.set_title('Classification Result', fontsize=16)\\n\\n plt.tight_layout()\\n\\n plt.show()\\n\\n return\",\n \"def plot_coefs(results):\\n coefs_noisy = pd.concat([\\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\\n vec_to_df(results['dist_neg'], n_arr, 'neg')\\n ])\\n\\n xlim = (min(n_arr), max(n_arr))\\n ylim = (-1.1, 1.1)\\n\\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\\n ylim = ylim)\\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\\n g.set_xticklabels(rotation = 45)\\n\\n for i, val in enumerate(results['obj_true']):\\n ax = g.axes[0, i]\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['pos_true']):\\n ax = g.axes[1, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['neg_true']):\\n ax = g.axes[2, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\",\n \"def plot_actual_vs_predicted_by_equations(df, x_variable, y_variables, plot_title):\\n #Plot results\\n df.plot(x=x_variable, y=y_variables, title=plot_title)\\n plt.show()\",\n \"def test_plotting():\\n specs = _read_schrodinger('tests/test_data/{}.inp'.format(PROBLEM))\\n xint, yint = _interpolate(specs['interpolxydecs'][:, 0],\\n specs['interpolxydecs'][:, 1], specs['xopt'])\\n\\n energies = np.loadtxt('tests/test_data/energies_{}.ref'.format(PROBLEM))\\n wfuncsdata = np.loadtxt('tests/test_data/wfuncs_{}.ref'.format(PROBLEM))\\n potdata = np.vstack((xint, yint)).T\\n\\n expval = calculate_expval(xint, wfuncsdata[:, 1:].T)\\n uncval = calculate_uncertainty(xint, wfuncsdata[:, 1:].T)\\n\\n expvaldata = np.vstack((expval, uncval)).T\\n _write_data('tests/test_data', potdata, energies, wfuncsdata, expvaldata)\\n\\n # qm_plottings('tests/test_data', scale=0.5)\\n # assert True\",\n \"def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\\n\\n # useful display and computational data\\n y_fitted = poly_fit(x_data)\\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\\n x_fitted_display = np.linspace(min_x_display, max_x_display)\\n y_fitted_display = poly_fit(x_fitted_display)\\n\\n # goodness of fit indicators\\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\\n R2 = 1.0 - SSE/SST # R squared\\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 2, 1)\\n\\n # plot of the fitted polynomial itself\\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\\n ax.scatter(x_data, y_data, color='C7')\\n ax.set(title=\\\"Fitted polynomial (deg{}) for \\\\'{}\\\\'\\\".format(poly_fit.order, fit_name), xlabel=\\\"x\\\", ylabel=\\\"y\\\")\\n\\n # histogram of residuals\\n ax2 = fig.add_subplot(1, 2, 2)\\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\\n ax2.set(title=\\\"Histogram of residuals\\\", xlabel=\\\"Residual value $y_k - \\\\\\\\widehat{y_k}$\\\", ylabel=\\\"Count\\\")\\n\\n # display of fit indicators\\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\\n\\n fig.tight_layout()\\n fig.subplots_adjust(bottom=0.2)\\n\\n figurefiles.save_in_perfs_fits_folder(fig, \\\"Polyfit_{}_order_{}.pdf\\\".format(fit_name, poly_fit.order))\",\n \"def plot_err(self, expect=False, axallerr=None):\\n if axallerr is None:\\n axallerr = plt.gca()\\n axallerr.set_yscale('log')\\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[0], label='independent')\\n axallerr.plot(list(range(1, self.max_dets)), self.stderr[1], label='correlated (actual)')\\n if expect:\\n axallerr.plot(list(range(1, self.max_dets)), self.expcor_err, label='correlated (expected)')\\n axallerr.set_ylabel(r'Stochastic error in $\\\\Delta E$ / ha')\\n axallerr.set_xlabel('Number of determinants in estimator')\\n axallerr.axhline(np.sqrt(self.proje_var[0]) / np.sqrt(self.result.shape[2]),\\n linestyle='--', color='black', label='reference')\\n axallerr.legend()\\n return axallerr\",\n \"def visualize(self):\\n\\t\\tplt.figure(1)\\n\\t\\tax1 = plt.add_suplot(1,2,1)\\n\\t\\t# Plot free energy error\\n\\t\\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\\n\\t\\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\\n\\t\\tplt.legend()\\n\\n\\t\\t# Plot density error\\n\\n\\t\\t# Plot log-likelihood of test set\\n\\n\\t\\t# Plot clustering score\\n\\n\\t\\tplt.show()\\n\\n\\t\\treturn\",\n \"def plot_calibration_curve(est, name, fig_index):\\n # Calibrated with isotonic calibration\\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\\n\\n # Calibrated with sigmoid calibration\\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\\n\\n # Logistic regression with no calibration as baseline\\n lr = LogisticRegression(C=1.)\\n\\n fig = plt.figure(fig_index, figsize=(10, 10))\\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\\n ax2 = plt.subplot2grid((3, 1), (2, 0))\\n\\n ax1.plot([0, 1], [0, 1], \\\"k:\\\", label=\\\"Perfectly calibrated\\\")\\n for clf, name in [(lr, 'Logistic'),(est, name),(isotonic, name + ' + Isotonic'),(sigmoid, name + ' + Sigmoid')]:\\n #Para cada modelo, entrenamos y predecimos \\n clf.fit(X_train, y_train)\\n y_pred = clf.predict(X_test)\\n if hasattr(clf, \\\"predict_proba\\\"):\\n prob_pos = clf.predict_proba(X_test)[:, 1]\\n else: # use decision function\\n prob_pos = clf.decision_function(X_test)\\n prob_pos = \\\\\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\\n\\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\\n print(\\\"%s:\\\" % name)\\n print(\\\"\\\\tBrier: %1.3f\\\" % (clf_score))\\n print(\\\"\\\\tPrecision: %1.3f\\\" % precision_score(y_test, y_pred))\\n print(\\\"\\\\tRecall: %1.3f\\\" % recall_score(y_test, y_pred))\\n print(\\\"\\\\tF1: %1.3f\\\\n\\\" % f1_score(y_test, y_pred))\\n\\n fraction_of_positives, mean_predicted_value = \\\\\\n calibration_curve(y_test, prob_pos, n_bins=10)\\n\\n ax1.plot(mean_predicted_value, fraction_of_positives, \\\"s-\\\",\\n label=\\\"%s (%1.3f)\\\" % (name, clf_score))\\n\\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\\n histtype=\\\"step\\\", lw=2)\\n\\n ax1.set_ylabel(\\\"Fraction of positives\\\")\\n ax1.set_ylim([-0.05, 1.05])\\n ax1.legend(loc=\\\"lower right\\\")\\n ax1.set_title('Calibration plots (reliability curve)')\\n\\n ax2.set_xlabel(\\\"Mean predicted value\\\")\\n ax2.set_ylabel(\\\"Count\\\")\\n ax2.legend(loc=\\\"upper center\\\", ncol=2)\\n\\n plt.tight_layout()\",\n \"def plot(nSamples, expectations, variances, exactE, exactVar, title=\\\"\\\"):\\n fig, axes = plt.subplots(2, 1)\\n\\n axes[0].semilogx(nSamples, expectations, color=\\\"black\\\", label=\\\"Empirical E(X)\\\")\\n axes[0].axhline(exactE, color=\\\"darkgray\\\", label=\\\"Exact E(X)\\\")\\n\\n axes[1].semilogx(nSamples, variances, color=\\\"black\\\", label=\\\"Empirical Var(X)\\\")\\n axes[1].axhline(exactVar, color=\\\"darkgray\\\", label=\\\"Exact Var(X)\\\")\\n\\n for ax in axes:\\n ax.set_xlabel(\\\"N draws in the simulation\\\")\\n ax.legend()\\n axes[0].set_ylabel(\\\"E(X)\\\")\\n axes[0].set_title(title)\\n axes[1].set_ylabel(\\\"Var(X)\\\")\\n plt.show()\",\n \"def plot_results(\\n train_data: tuple[Tensor, Tensor],\\n test_data: tuple[Tensor, Tensor],\\n correct_class: Tensor\\n):\\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\\n ax1.set_title('Training data')\\n plot_dataset(train_data, ax1)\\n\\n ax2.set_title('Test data')\\n plot_dataset(test_data, ax2)\\n\\n ax3.set_title('Test prediction correctness')\\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\\n \\n fig1.savefig('plots/datasets')\\n fig2.savefig('plots/predictions')\\n plt.show()\",\n \"def plot(self, solution: Matrix) -> None:\\n plots.plot_matrices(\\\"Total Variation Denoising\\\", self.M, solution)\",\n \"def show_predictions(model, test_set, val_set, image_guess, img_res, data='OSNR', GRAY=True):\\n \\n ## Uses model to predict some amount of images\\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\\n \\n ## Initialises variables for loop\\n correctly_guessed = 0\\n\\n ## Defines figure dimensions\\n fig = plt.figure(figsize=(20,30))\\n\\n ## Begins loop to find correct predictions and relay results to user\\n ## Searches through the prediction array and compares it to the actual array.\\n ## Displays image with the prediction and answer on the title\\n for i in range(image_guess):\\n correct = False\\n actual = np.argmax(val_set[i])\\n\\n if predict[i] == actual:\\n correctly_guessed += 1\\n correct = True\\n\\n plt.subplot(6,3,i+1)\\n fig.subplots_adjust(left=0.01,\\n right=0.7,\\n bottom=0.1,\\n top=1.2,\\n wspace=0.5,\\n hspace=0.2\\n )\\n if GRAY == False:\\n plt.imshow(test_set[i].reshape(img_res,img_res,3))\\n else:\\n plt.imshow(test_set[i].reshape(img_res,img_res), cmap='gray')\\n\\n if correct == True:\\n if data == 'disp':\\n plt.title('Correct! \\\\nPrediction = {}ps/nm Truth = {}ps/nm'\\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\\n \\n if data == 'disp-short':\\n plt.title('Correct! \\\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\\n \\n if data == 'OSNR':\\n plt.title('Correct! \\\\nPrediction = {}dB Truth = {}dB'\\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\\n \\n \\n else:\\n if data == 'disp':\\n plt.title('\\\\nPrediction = {}ps/nm Truth = {}ps/nm'\\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\\n \\n if data == 'disp-short':\\n plt.title('\\\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\\n \\n if data == 'OSNR':\\n plt.title('\\\\nPrediction = {}dB Truth = {}dB'\\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\\n\\n ## Returns amount of predictions that were correct\\n print('Correctly guessed = ', correctly_guessed)\\n print('Inorrectly guessed = ', (image_guess-correctly_guessed))\",\n \"def plot_results(self, predictions: list):\\n fig, ax = plt.subplots()\\n cm = confusion_matrix(self.test[1], predictions)\\n conf = confusion_matrix(self.test[1], predictions).ravel()\\n nbr_labels = len(set(self.test[1]))\\n cm = conf.reshape(nbr_labels, nbr_labels)\\n sns.heatmap(cm, annot=True, fmt=\\\"d\\\", cmap=\\\"Spectral\\\")\\n ax.set_xlabel(\\\"predicted label\\\")\\n ax.set_ylabel(\\\"true label\\\")\\n fig.savefig(\\\"confusion_matrix\\\")\\n\\n fig, ax = plt.subplots()\\n x = self.train[0] + self.test[0]\\n y = self.train[1] + self.test[1]\\n x = [i[0] for i in x]\\n y = [i for i in y]\\n results = pd.DataFrame({\\\"polarity strength\\\": x, \\\"true label\\\": y})\\n sns.boxplot(data=results, x=\\\"true label\\\", y=\\\"polarity strength\\\")\\n fig.savefig(\\\"boxplot\\\")\",\n \"def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_time):\\n ax.plot([y_true.min(), y_true.max()],\\n [y_true.min(), y_true.max()],\\n '--r', linewidth=2)\\n ax.scatter(y_true, y_pred, alpha=0.2)\\n\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.get_xaxis().tick_bottom()\\n ax.get_yaxis().tick_left()\\n ax.spines['left'].set_position(('outward', 10))\\n ax.spines['bottom'].set_position(('outward', 10))\\n ax.set_xlim([y_true.min(), y_true.max()])\\n ax.set_ylim([y_true.min(), y_true.max()])\\n ax.set_xlabel('Measured')\\n ax.set_ylabel('Predicted')\\n extra = plt.Rectangle((0, 0), 0, 0, fc=\\\"w\\\", fill=False,\\n edgecolor='none', linewidth=0)\\n ax.legend([extra], [scores], loc='upper left')\\n title = title + '\\\\n Evaluation in {:.2f} seconds'.format(elapsed_time)\\n ax.set_title(title)\",\n \"def plotPredictedError():\\n\\tglobal normalized\\n\\n\\twarmthPred = []\\n\\twarmthObserved = []\\n\\tcompPred = []\\n\\tcompObserved = []\\n\\tSStotalWarmth = 0\\n\\tSSresWarmth = 0\\n\\tSStotalComp = 0\\n\\tSSresComp = 0\\n\\tkeys = parser.getMappings(normalized)[0].keys()\\n\\tfor key in keys:\\n\\n\\t\\tif \\\"_\\\" in key:\\n\\t\\t\\twarmthAxis, compAxis = getPlotData(key)\\n\\t\\t\\twarmthPred.append(warmthAxis[3])\\n\\t\\t\\twarmthObserved.append(warmthAxis[2])\\n\\t\\t\\tcompPred.append(compAxis[3])\\n\\t\\t\\tcompObserved.append(compAxis[2])\\n\\n\\tmeanObservedWarmth = np.mean(warmthObserved)\\n\\tmeanObservedComp = np.mean(compObserved)\\n\\tfor i in range(0, len(warmthObserved)):\\n\\t\\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\\n\\t\\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\\n\\t\\tSStotalComp += (compObserved[i] - meanObservedComp)**2\\n\\t\\tSSresComp += (compObserved[i] - compPred[i])**2\\n\\n\\n\\tplt.axis([0, 100, 0, 100])\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.title(\\\"Observed vs Predicted Warmth\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(warmthObserved, warmthPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.axis([0, 100, 0, 100])\\n\\tplt.title(\\\"Observed vs Predicted Competence\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(compObserved, compPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\",\n \"def display_fit(x,y,p,func,fig=None):\\n if fig is None:\\n fig = plots.tac_figure('x','y','fitting')\\n fig.plot(x,np.log(y),label='data')\\n \\n \\n fig.plot(x,np.log(func(p,x)),'--x',label=func.__name__ + '('+\\n ','.join(['%.1e'%k for k in p])+ ')')\\n \\n return fig\",\n \"def validate_and_plot_one_class(normal,outliers):\\n print \\\"running a validation\\\"\\n \\n #classifier\\n \\n train_data = genfromtxt(normal, delimiter='\\\\t',skip_header=0)\\n test_data = genfromtxt(outliers, delimiter='\\\\t',skip_header=0)\\n\\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\\n outliers_proportion=0.01\\n\\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\\n #processing data without targets\\n X_train = clf.scale(train_data)\\n X_test = clf.scale(test_data)\\n\\n y_pred_train = clf.predict(X_train)\\n y_pred_test = clf.predict(X_test)\\n n_error_train = y_pred_train[y_pred_train == 1].size\\n n_error_test = y_pred_test[y_pred_test == -1].size\\n \\n X=np.vstack((X_train,X_test))\\n y_score = clf.predict(X)\\n\\n Y1=np.ones((X_train.shape[0],))\\n Y2=(np.ones((X_test.shape[0],))*-1)\\n y_true=np.concatenate((Y1,Y2))\\n \\n # Compute ROC curve and area the curve\\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\\n roc_auc = metrics.auc(fpr, tpr)\\n print \\\"Area under the ROC curve : %f\\\" % roc_auc\\n \\n # Plot ROC curve\\n\\n fig = matplotlib.pyplot.gcf()\\n fig.set_size_inches(6.5,6.5)\\n #font = {'family' : 'sans-serif',\\n # 'weight' : 'normal',\\n # 'size' : 18}\\n\\n #matplotlib.rc('font', **font)\\n pl.clf()\\n #modify plot area\\n #modify tick label font size\\n ax = pl.gca() # get the current axes\\n for l in ax.get_xticklabels() + ax.get_yticklabels():\\n l.set_fontsize('x-large')\\n\\n #color from html code table, linewidth x2.0\\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\\\"#00CC66\\\",linewidth=3.0)\\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#009900\\\",linewidth=3.0)\\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n #for more lines with different kernels\\n #default_kernel=\\\"sigmoid\\\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#00CC66\\\",linewidth=2.0)\\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n pl.plot([0, 1], [0, 1], 'k--')\\n #modify base font size\\n pl.xlim([0.0, 1.0])\\n pl.ylim([0.0, 1.0])\\n pl.xlabel('False positive rate',fontsize='xx-large')\\n pl.ylabel('True positive rate',fontsize='xx-large')\\n #pl.title('Receiver operating characteristic example')\\n pl.legend(loc=\\\"lower right\\\",prop={'size':18})\\n pl.show()\\n sys.exit(0)\\n ##the code here below was used to create the ROC curve for europar 13\",\n \"def fittingPlots(ax, loadFile, drug1, drug2, df):\\n # Read model from saved pickle file\\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=True)\\n\\n if drug1 == \\\"Erl\\\":\\n drug1 = \\\"Erlotinib\\\"\\n if drug2 == \\\"Erl\\\":\\n drug2 = \\\"Erlotinib\\\"\\n\\n df.iloc[:, :] = np.median(M.samples[\\\"conflResid\\\"], axis=0).reshape(df.shape)\\n\\n sns.heatmap(df, ax=ax[0], cmap=\\\"PiYG\\\", vmin=-0.5, vmax=0.5, cbar=False, square=True)\\n ax[0].set_title(\\\"Full Model\\\")\\n\\n df3 = pd.DataFrame({\\\"drug\\\": drug1, \\\"param\\\": \\\"Growth\\\", \\\"value\\\": M.samples[\\\"EmaxGrowthEffect\\\"][:, 0]})\\n df4 = pd.DataFrame({\\\"drug\\\": drug2, \\\"param\\\": \\\"Growth\\\", \\\"value\\\": M.samples[\\\"EmaxGrowthEffect\\\"][:, 1]})\\n df5 = pd.DataFrame({\\\"drug\\\": drug1, \\\"param\\\": \\\"Death\\\", \\\"value\\\": M.samples[\\\"EmaxDeath\\\"][:, 0]})\\n df6 = pd.DataFrame({\\\"drug\\\": drug2, \\\"param\\\": \\\"Death\\\", \\\"value\\\": M.samples[\\\"EmaxDeath\\\"][:, 1]})\\n\\n dfplot = pd.concat([df3, df4, df5, df6])\\n dfplot[\\\"value\\\"] = dfplot[\\\"value\\\"]\\n\\n # TODO: Report IC50 in the text.\\n sns.violinplot(x=\\\"param\\\", y=\\\"value\\\", hue=\\\"drug\\\", data=dfplot, ax=ax[1], linewidth=0.1)\\n ax[1].set_xticklabels(ax[1].get_xticklabels(), rotation=25, horizontalalignment=\\\"right\\\")\\n ax[1].set_ylabel(\\\"Emax [1/hr]\\\")\\n ax[1].set_ylim(bottom=0.0, top=0.10)\\n ax[1].set_xlabel(\\\"\\\")\\n\\n # Remove legend title\\n handles, labels = ax[1].get_legend_handles_labels()\\n ax[1].legend(handles=handles, labels=labels)\",\n \"def plot_brute_leastsquares_results(result, best_vals=True, varlabels=None,\\r\\n output=None, leastsq_fit_result=None):\\r\\n from matplotlib.colors import LogNorm\\r\\n import matplotlib.cm as cm\\r\\n \\r\\n npars = len(result.var_names)\\r\\n _fig, axes = plt.subplots(npars, npars)\\r\\n\\r\\n if not varlabels:\\r\\n varlabels = result.var_names\\r\\n if best_vals and isinstance(best_vals, bool):\\r\\n best_vals = result.params\\r\\n if leastsq_fit_result is not None:\\r\\n best_vals_leastsq = leastsq_fit_result.params\\r\\n\\r\\n for i, par1 in enumerate(result.var_names):\\r\\n for j, par2 in enumerate(result.var_names):\\r\\n\\r\\n # parameter vs chi2 in case of only one parameter\\r\\n if npars == 1:\\r\\n axes.plot(result.brute_grid, result.brute_Jout, 'o', ms=3)\\r\\n axes.set_ylabel(r'$\\\\chi^{2}$')\\r\\n axes.set_xlabel(varlabels[i])\\r\\n if best_vals:\\r\\n axes.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n axes.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n\\r\\n # parameter vs chi2 profile on top\\r\\n elif i == j and j < npars-1:\\r\\n if i == 0:\\r\\n axes[0, 0].axis('off')\\r\\n ax = axes[i, j+1]\\r\\n red_axis = tuple([a for a in range(npars) if a != i])\\r\\n ax.plot(np.unique(result.brute_grid[i]),\\r\\n np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n 'o', ms=3)\\r\\n ax.set_ylabel(r'$\\\\chi^{2}$')\\r\\n ax.yaxis.set_label_position(\\\"right\\\")\\r\\n ax.yaxis.set_ticks_position('right')\\r\\n ax.set_xticks([])\\r\\n if best_vals:\\r\\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n # parameter vs chi2 profile on the left\\r\\n elif j == 0 and i > 0:\\r\\n ax = axes[i, j]\\r\\n red_axis = tuple([a for a in range(npars) if a != i])\\r\\n ax.plot(np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n np.unique(result.brute_grid[i]), 'o', ms=3)\\r\\n ax.invert_xaxis()\\r\\n ax.set_ylabel(varlabels[i])\\r\\n if i != npars-1:\\r\\n ax.set_xticks([])\\r\\n else:\\r\\n ax.set_xlabel(r'$\\\\chi^{2}$')\\r\\n if best_vals:\\r\\n ax.axhline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n ax.axhline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n\\r\\n # contour plots for all combinations of two parameters\\r\\n elif j > i:\\r\\n ax = axes[j, i+1]\\r\\n red_axis = tuple([a for a in range(npars) if a not in (i, j)])\\r\\n X, Y = np.meshgrid(np.unique(result.brute_grid[i]),\\r\\n np.unique(result.brute_grid[j]))\\r\\n lvls1 = np.linspace(result.brute_Jout.min(),\\r\\n np.median(result.brute_Jout)/2.0, 20, dtype='int')\\r\\n lvls2 = np.linspace(np.median(result.brute_Jout)/2.0,\\r\\n np.median(result.brute_Jout), 20, dtype='int')\\r\\n \\r\\n lvls = np.unique(np.concatenate((lvls1, lvls2)))\\r\\n \\r\\n ax.contourf(X.T, Y.T, np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n lvls, norm=LogNorm(),\\r\\n cmap=cm.nipy_spectral)\\r\\n ax.set_yticks([])\\r\\n if best_vals:\\r\\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n ax.axhline(best_vals[par2].value, ls='dashed', color='b')\\r\\n ax.plot(best_vals[par1].value, best_vals[par2].value, 'bs', ms=3)\\r\\n if best_vals_leastsq:\\r\\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n ax.axhline(best_vals_leastsq[par2].value, ls='dashed', color='r')\\r\\n ax.plot(best_vals_leastsq[par1].value, best_vals_leastsq[par2].value, 'rs', ms=3)\\r\\n if j != npars-1:\\r\\n ax.set_xticks([])\\r\\n else:\\r\\n ax.set_xlabel(varlabels[i])\\r\\n if j - i >= 2:\\r\\n axes[i, j].axis('off')\\r\\n\\r\\n if output is not None:\\r\\n plt.savefig(output)\\r\\n else: \\r\\n plt.tight_layout()\\r\\n plt.show()\",\n \"def plot_ece(confidences, accuracies, label='', ax=None, **kwargs):\\n if not ax:\\n plt.figure()\\n ax = plt.gca()\\n # ax.figure.set_size_inches(6, 4)\\n ax.plot(confidences, accuracies, label=label, **kwargs)\\n xbins = [i / 10. for i in range(11)]\\n ax.plot(xbins, xbins, linestyle=':', color='black')\\n ax.set_xlabel('Model Confidence')\\n ax.set_ylabel('Model Accuracy')\\n # ax.set_title(\\n # f\\\"Reliability Diagram Trained on {train_name}, Evaluated on {ood_name}\\\")\\n # ax.set_title(f\\\"Reliability Diagram\\\")\\n ax.legend(loc=4, facecolor='white')\\n return ax\",\n \"def plot(self):\\n fig = plt.figure()\\n ax = plt.gca()\\n ax.errorbar(self.sample_bins, self.test_scores.mean(axis=1),\\n yerr=self.test_scores.std(axis=1), fmt='r.-',\\n label='test')\\n ax.errorbar(self.sample_bins, self.train_scores.mean(axis=1),\\n yerr=self.train_scores.std(axis=1), fmt='b.-',\\n label='train')\\n ax.legend(loc='upper right')\\n return ax\",\n \"def testNonLinearity():\\n vis = VISinformation()\\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\\n nonlin = CCDnonLinearityModel(data.copy())\\n\\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\\n\\n fig = plt.figure(frameon=False)\\n\\n left, width = 0.1, 0.8\\n rect1 = [left, 0.3, width, 0.65]\\n rect2 = [left, 0.1, width, 0.2]\\n\\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\\n\\n ax1.axhline(y=0, c='k', ls='--')\\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\\n\\n ax2.axhline(y=0, c='k', ls='--')\\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\\n\\n ax1.axvline(x=97, c='k', ls='--')\\n ax2.axvline(x=97, c='k', ls='--')\\n\\n ax1.set_xticklabels([])\\n ax2.set_xlabel('Real Charge [electrons]')\\n ax1.set_ylabel('(Output / Real - 1)*100')\\n ax2.set_ylabel('O - R [ADUs]')\\n\\n ax1.set_xlim(0, vis['fullwellcapacity'])\\n ax2.set_xlim(0, vis['fullwellcapacity'])\\n ax1.set_ylim(-.15, .2)\\n\\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\\n plt.savefig('NonlinearityModel.pdf')\\n\\n ax1.set_ylim(-.1, 8)\\n ax2.set_ylim(0, 2)\\n ax1.set_xlim(50, 800)\\n ax2.set_xlim(50, 800)\\n plt.savefig('NonlinearityModel2.pdf')\\n\\n plt.close()\",\n \"def nonlinear_fit(X, Y, fitfunction, initial_guess=None, dY=None, \\n showplot=True, plot_some_errors=(False, 20), \\n **kwargs):\\n \\n if not isinstance(X, np.ndarray):\\n raise TypeError(\\\"X should be a np.array\\\")\\n if not isinstance(Y, np.ndarray):\\n raise TypeError(\\\"Y should be a np.array\\\")\\n if not isinstance(dY, np.ndarray) and dY is not None:\\n raise TypeError(\\\"dY shouuld be a np.array\\\")\\n if len(X) != len(Y):\\n raise IndexError(\\\"X and Y must have same lenght\\\")\\n if dY is not None and len(dY) != len(Y):\\n raise IndexError(\\\"dY and Y must have same lenght\\\")\\n \\n if dY is None:\\n W = None\\n else:\\n W = 1/dY**2\\n \\n parameters, covariance = curve_fit(fitfunction, X, Y,\\n p0=initial_guess, sigma=W) \\n rsq = sum( (Y - fitfunction(X, *parameters))**2 )\\n rsq = rsq/sum( (Y - np.mean(Y))**2 )\\n rsq = 1 - rsq\\n\\n if showplot:\\n \\n plt.figure()\\n if dY is None:\\n plt.plot(X, Y, 'b.', zorder=0)\\n else:\\n if plot_some_errors[0] == False:\\n plt.errorbar(X, Y, yerr=dY, linestyle='b', marker='.',\\n ecolor='b', elinewidth=1.5, zorder=0)\\n else:\\n plt.errorbar(X, Y, yerr=dY, linestyle='-', marker='.',\\n color='b', ecolor='b', elinewidth=1.5,\\n errorevery=len(Y)/plot_some_errors[1], \\n zorder=0)\\n plt.plot(X, fitfunction(X, *parameters), 'r-', zorder=100) \\n plt.legend([\\\"Ajuste lineal ponderado\\\",\\\"Datos\\\"])\\n \\n n = len(parameters)\\n kwargs_list = ['text_position', 'par_units', 'par_string_scale', \\n 'par_error_digits', 'rsq_decimal_digits']\\n kwargs_default = [(.02,'up'), ['' for i in range(n)], \\n [False for i in range(n)], \\n [3 for i in range(n)], 3]\\n for key, value in zip(kwargs_list, kwargs_default):\\n try:\\n kwargs[key]\\n if key != 'text_position':\\n try:\\n if len(kwargs[key]) != n:\\n print(\\\"Wrong number of parameters\\\",\\n \\\"on '{}'\\\".format(key))\\n kwargs[key] = value\\n except TypeError:\\n kwargs[key] = [kwargs[key] for i in len(n)]\\n except KeyError:\\n kwargs[key] = value\\n \\n if kwargs['text_position'][1] == 'up':\\n vertical = [.9-i*.08 for i in range(n+1)]\\n elif kwargs['text_position'][1] == 'down':\\n vertical = [.05+i*.08 for i in range(n+1)]\\n else:\\n if kwargs['text_position'][1] <= .08:\\n fact = .08\\n else:\\n fact = -.08\\n vertical = [\\n kwargs['text_position'][1]+fact*i for i in range(n+1)]\\n \\n for i in range(n):\\n plt.annotate(\\n 'a{} = {}'.format(\\n i,\\n fst.error_value(\\n parameters[i], \\n sqrt(covariance[i,i]),\\n error_digits=kwargs['par_error_digits'][i],\\n units=kwargs['par_units'][i],\\n string_scale=kwargs['par_string_scale'][i],\\n one_point_scale=True,\\n legend=True)),\\n (kwargs['text_position'][0], vertical[i]),\\n xycoords='axes fraction')\\n rsqft = r'$R^2$ = {:.' + str(kwargs['rsq_decimal_digits'])+'f}'\\n plt.annotate(rsqft.format(rsq),\\n (kwargs['text_position'][0], vertical[-i]),\\n xycoords='axes fraction')\\n \\n plt.show()\\n \\n parameters_error = np.array(\\n [sqrt(covariance[i,i]) for i in range(n)])\\n parameters = list(zip(parameters, parameters_error))\\n \\n return rsq, parameters\",\n \"def plot_results(\\n predictor_names, validation_auc_values, is_forward_test,\\n axes_object=None, num_predictors_to_plot=None):\\n\\n if num_predictors_to_plot is None:\\n num_predictors_to_plot = len(predictor_names)\\n\\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\\n num_predictors_to_plot = min([\\n num_predictors_to_plot, len(predictor_names)\\n ])\\n\\n y_coords = numpy.linspace(\\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\\n )[::-1]\\n\\n if axes_object is None:\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n axes_object.barh(\\n y_coords, validation_auc_values[:num_predictors_to_plot],\\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\\n linewidth=BAR_EDGE_WIDTH\\n )\\n\\n axes_object.set_yticks([], [])\\n axes_object.set_xlabel('Validation AUC')\\n\\n if is_forward_test:\\n axes_object.set_ylabel('Predictor added')\\n else:\\n axes_object.set_ylabel('Predictor removed')\\n\\n axes_object.set_ylim(\\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\\n )\\n axes_object.set_xlim(\\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\\n )\\n\\n for j in range(num_predictors_to_plot):\\n axes_object.text(\\n 0., y_coords[j], ' ' + predictor_names[j],\\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\\n horizontalalignment='left', verticalalignment='center'\\n )\\n\\n return axes_object\",\n \"def plot_convergence_(OptimizeResult, fig_savepath, figsize=(5.51, 3.54), format='PNG', dpi=300): # (5.51,3.54)\\n fig = plt.figure(figsize=figsize)\\n ax0 = fig.add_subplot(111)\\n plot_convergence(OptimizeResult, ax=ax0, true_minimum=0.0, )\\n plt.title(\\\"\\\")\\n ax0.set_ylabel(r\\\"minimum MSE after $n$ calls\\\")\\n # plt.tight_layout()\\n plt.subplots_adjust(left=0.12, bottom=0.12, right=0.96, top=0.94, hspace=0.1, wspace=0.2)\\n plt.savefig(fig_savepath, format=format, dpi=dpi)\\n # plt.show()\",\n \"def plot_confusion_matrix(self):\\r\\n interp = ClassificationInterpretation.from_learner(self.learn)\\r\\n interp.plot_confusion_matrix()\",\n \"def display_comparison(self, X_val, y_val):\\n import matplotlib.pyplot as plt\\n x = []\\n y = []\\n for model_tuple in self.model_list:\\n x.append(model_tuple[1])\\n y.append(model_tuple[0].score(X_val, y_val))\\n plt.scatter(x, y)\\n plt.show()\",\n \"def problemOne(self):\\n self.hot_volt = self.data['calibration']['hot volt'].tolist()\\n self.pitot_vel = self.data['calibration']['pitot vel'].tolist()\\n # Create interpolation function of FFT data for finding coefficients\\n self.v_hot = np.poly1d(np.array(self.cal_coeffs))\\n # Create string to print coefficients on plot\\n print_coeffs = 'Curve Coefficients:'\\n coeff_index = [4, 3, 2, 1, 0]\\n for i in range(0, 5):\\n print_coeffs += f'\\\\n$a_{i}$ = {self.cal_coeffs[coeff_index[i]]}'\\n # Create curve fit data to plot\\n fit_plot_y = [self.v_hot(j) for j in self.hot_volt]\\n # Calculate difference and standard deviation b/w the interpolation curve and experimental data\\n difference = []\\n for i in self.hot_volt:\\n index = self.hot_volt.index(i)\\n difference.append(self.pitot_vel[index] - self.v_hot(i))\\n std_dev = statistics.stdev(difference)\\n print(f'prob one std dev = {std_dev}')\\n # Plot velocities vs voltage\\n plot_1 = plt.figure(figsize=(8, 8))\\n vv = plot_1.add_subplot(1, 1, 1)\\n props = dict(boxstyle='round', facecolor='white', alpha=0.2)\\n vv.set_xlabel('Hotwire $E_v$ [Volts]', fontsize=14)\\n vv.set_ylabel('Velocity [m/s]', fontsize=14)\\n vv.grid(linewidth=0.5, color='gray', linestyle='--')\\n vv.plot(self.hot_volt, fit_plot_y, color='k', linewidth=1, label='Hotwire Curve Fit')\\n vv.scatter(self.hot_volt, self.pitot_vel, color='r', s=15, label='Pitot Exp. Data', marker='o')\\n vv.text(0.02, 0.9, print_coeffs, transform=vv.transAxes, fontsize=11, verticalalignment='top', bbox=props)\\n vv.legend(loc='upper left')\\n plot_1.savefig(os.path.join(os.getcwd(), r'plots\\\\prob1'))\\n plt.draw()\",\n \"def find_best(results, show_plot=True):\\n max_point = max(results)\\n print(\\\"Maximum achieved at d={} and class prior={}. Accuracy of {}%.\\\".format(max_point[1],max_point[2],max_point[0]))\\n if show_plot:\\n import matplotlib.pyplot as plt\\n from matplotlib import cm\\n from mpl_toolkits.mplot3d import Axes3D\\n z,x,y = zip(*results)\\n fig = plt.figure()\\n ax = fig.gca(projection='3d')\\n ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)\\n ax.text(max_point[1],max_point[2],max_point[0]+2, \\\"MAX\\\")\\n plt.title('Parameter Tuning Results')\\n plt.xlabel('d value')\\n plt.ylabel('class prior')\\n ax.set_zlabel('Accuracy')\\n plt.show()\",\n \"def show_trap_results():\\n df_grid = pd.read_hdf('./temp_results.h5', '/optimize_grid')\\n print(df_grid)\\n \\n print('Minimum fwhm:')\\n print(df_grid[df_grid.fwhm_ovr_mean==df_grid.fwhm_ovr_mean.min()])\\n \\n plt.plot(df_grid.e_fit, df_grid.fwhm_ovr_mean, '.b')\\n plt.show()\",\n \"def get_accuracy_and_plot_confusion(y_correct, y_pred, classes, plot=True, title='Confusion matrix'):\\n if plot:\\n cm = confusion_matrix(y_correct, y_pred)\\n plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\\n plt.title(title)\\n plt.colorbar()\\n tick_marks = np.arange(len(classes))\\n plt.xticks(tick_marks, classes, rotation=45)\\n plt.yticks(tick_marks, classes)\\n\\n thresh = cm.max() / 2.\\n for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\\n plt.text(j, i, cm[i, j],\\n horizontalalignment=\\\"center\\\",\\n color=\\\"white\\\" if cm[i, j] > thresh else \\\"black\\\")\\n\\n plt.tight_layout()\\n plt.ylabel('True label')\\n plt.xlabel('Predicted label')\\n plt.show()\\n return accuracy_score(y_correct, y_pred)\",\n \"def plot_correction_in_fibre_p_fibre(fig_size,\\n wlm,\\n espectro_old,\\n espectro_fit_median,\\n espectro_new,\\n fibre_p,\\n clip_high, \\n show_plot=False):\\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\\n ax.plot(\\n wlm,\\n old_div(espectro_old, espectro_fit_median),\\n \\\"r\\\",\\n label=\\\"Uncorrected\\\",\\n alpha=0.5,\\n )\\n ax.plot(\\n wlm,\\n old_div(espectro_new, espectro_fit_median),\\n \\\"b\\\",\\n label=\\\"Corrected\\\",\\n alpha=0.5,\\n )\\n const = old_div((np.nanmax(espectro_new) - np.nanmin(espectro_new)), 2)\\n ax.plot(\\n wlm,\\n old_div((const + espectro_new - espectro_old), espectro_fit_median),\\n \\\"k\\\",\\n label=\\\"Dif + const\\\",\\n alpha=0.5,\\n )\\n ax.axhline(y=clip_high, color=\\\"k\\\", linestyle=\\\":\\\", alpha=0.5)\\n ax.set_ylabel(\\\"Flux / Continuum\\\")\\n\\n ax.set_xlabel(r\\\"Wavelength [$\\\\AA$]\\\")\\n ax.set_title(\\\"Checking correction in fibre {}\\\".format(str(fibre_p)))\\n ax.legend(frameon=False, loc=1, ncol=4)\\n\\n if show_plot:\\n plt.show()\\n return fig\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def make_accuracy_plot(ax,\\n groundtruth_boxes,\\n hpu_boxes,\\n cpu_boxes,\\n hpu_strategy,\\n label,\\n N=10,\\n num_graph_points=20,\\n match_mode=\\\"ellipse\\\",\\n):\\n print \\\"Making plot for\\\", repr(label)\\n print \\\"TODO: this should graph seconds per image\\\"\\n mix_fractions = np.linspace(0, 1.0, num_graph_points)\\n # Plot confidence intervals\\n min_ci = []\\n max_ci = []\\n mean_accs = []\\n stderr_accs = []\\n for mix_fraction in mix_fractions:\\n accuracies = [\\n maximum_F_score(\\n groundtruth_boxes,\\n hpu_strategy(hpu_boxes, cpu_boxes, mix_fraction),\\n match_mode=match_mode,\\n )\\n for _ in xrange(N)\\n ]\\n mean_accs.append(np.mean(accuracies))\\n stderr_accs.append(np.std(accuracies, ddof=1) / np.sqrt(N))\\n #print mix_fraction, np.mean(accuracies)\\n ax.errorbar(mix_fractions, mean_accs, stderr_accs, label=label)\\n ax.set_xlabel(\\\"Fraction of HPU-labeled images\\\")\\n ax.set_ylabel(\\\"Maximum F-score\\\")\",\n \"def quick_plot(solution):\\n plt.suptitle('GNLSE solution')\\n\\n plt.subplot(1, 2, 1)\\n plot_wavelength_vs_distance(solution)\\n\\n plt.subplot(1, 2, 2)\\n plot_delay_vs_distance(solution)\\n\\n plt.show()\",\n \"def show_fit(self):\\n self.fft_fit_plotter.plot(self.ax)\\n plt.draw()\",\n \"def plot_metrics(results, epsilon_pos, epsilon_neg):\\n ## Plot risk and fairness gaps as a function of sample size,\\n ## with true minimum risk and true fairness gaps for reference.\\n\\n metrics_Y0 = pd.concat(results['metrics_Y0_noisy'], keys=n_arr)\\n metrics_Y0 = metrics_Y0.reset_index().drop(columns='level_1').rename(\\n columns={'level_0': 'n'})\\n metrics_Y = pd.concat(results['metrics_Y_noisy'], keys=n_arr)\\n metrics_Y = metrics_Y.reset_index().drop(columns='level_1').rename(\\n columns={'level_0': 'n'})\\n metrics = pd.concat([metrics_Y0, metrics_Y])\\n\\n m = results['metrics_Y0_best']\\n risk = m.loc[m.Metric == 'Risk', 'Value'].values[0]\\n\\n g = sns.FacetGrid(metrics, row='Outcome', col='Metric',\\n col_order=['risk', 'gap_FPR', 'gap_FNR'])\\n g.map(sns.pointplot, 'n', 'value', order=n_arr)\\n g.set_xticklabels(rotation=45)\\n\\n g.axes[0, 0].hlines(risk, *g.axes[0, 0].get_xlim())\\n g.axes[1, 0].hlines(risk, *g.axes[1, 0].get_xlim())\\n\\n g.axes[0, 1].hlines(epsilon_pos, *g.axes[0, 1].get_xlim())\\n g.axes[1, 1].hlines(epsilon_pos, *g.axes[1, 1].get_xlim())\\n\\n g.axes[0, 2].hlines(epsilon_neg, *g.axes[0, 2].get_xlim())\\n g.axes[1, 2].hlines(epsilon_neg, *g.axes[1, 2].get_xlim())\",\n \"def report(self, X, y):\\n predict = self.model.predict(X)\\n\\n skplt.estimators.plot_feature_importances(\\n self.model, x_tick_rotation=90)\\n plt.show()\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=predict)\\n lims = [\\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\\n ]\\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\\n ax.set_aspect('equal')\\n ax.set_xlim(lims)\\n ax.set_ylim(lims)\\n ax.set_xlabel(\\\"Observed\\\")\\n ax.set_ylabel(\\\"Predict\\\")\\n ax.set_title(\\\"Predict vs. Observed\\\")\\n plt.show()\\n\\n residuals = y - predict\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=residuals)\\n plt.title(\\\"Residuals vs. Observed\\\")\\n plt.xlabel(\\\"Obserbed\\\")\\n plt.ylabel(\\\"Residuals\\\")\\n plt.show()\\n\\n plt.hist(residuals)\\n plt.title(\\\"Residuals distribution\\\")\\n plt.xlabel(\\\"Residuals value\\\")\\n plt.ylabel(\\\"Count\\\")\\n plt.show()\\n\\n display(\\n pd.DataFrame({\\n \\\"explained_variance_score\\\":\\n metrics.explained_variance_score(y, predict),\\n \\\"mean_absolute_error\\\":\\n metrics.mean_absolute_error(y, predict),\\n \\\"mean_squared_log_error\\\":\\n metrics.mean_squared_log_error(y, predict),\\n \\\"median_absolute_error\\\":\\n metrics.median_absolute_error(y, predict),\\n \\\"r2_score\\\":\\n metrics.r2_score(y, predict)\\n },\\n index=[0]))\",\n \"def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \\n plt.title(\\\"Polynomial function regression\\\")\\n plt.grid()\\n plt.plot(x_poly, y_poly, c='black', label='true function')\\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\\n plt.legend()\\n plt.show()\",\n \"def plot_diagram(probs, labels, y_axis='accuracy'):\\n probs_labels = [(prob, labels[i]) for i, prob in enumerate(probs)]\\n probs_labels = np.array(sorted(probs_labels, key=lambda x: x[0]))\\n window_len = int(len(labels)/100.)\\n calibration_errors = []\\n confidences = []\\n accuracies = []\\n # More interesting than length of the window (which is specific to this\\n # window) is average distance between datapoints. This normalizes by dividing\\n # by the window length.\\n distances = []\\n for i in range(len(probs_labels)-window_len):\\n distances.append((\\n probs_labels[i+window_len, 0] - probs_labels[i, 0])/float(window_len))\\n # It's pretty sketchy to look for the 100 datapoints around this one.\\n # They could be anywhere in the probability simplex. This introduces bias.\\n mean_confidences = mean(probs_labels[i:i + window_len, 0])\\n confidences.append(mean_confidences)\\n class_accuracies = mean(probs_labels[i:i + window_len, 1])\\n accuracies.append(class_accuracies)\\n calibration_error = class_accuracies-mean_confidences\\n calibration_errors.append(calibration_error)\\n\\n if y_axis == 'accuracy':\\n fig, ax = plt.subplots()\\n fig.set_size_inches(5, 5)\\n xbins = [i/10. for i in range(11)]\\n ax.plot(confidences, accuracies, color='green')\\n ax.plot(xbins, xbins, color='orange')\\n ax.set_xlabel('Model Confidence')\\n ax.set_ylabel('Model Accuracy')\\n elif y_axis == 'error':\\n fig, ax = plt.subplots()\\n fig.set_size_inches(5, 5)\\n xbins = [i/10. for i in range(11)]\\n ax.plot(confidences, calibration_errors, color='green')\\n ax.plot(xbins, xbins, color='orange')\\n ax.set_xlabel('Model Confidence')\\n ax.set_ylabel('Model Calibration Error')\\n ax.set_title('Reliability Diagram', fontsize=20)\\n return fig\",\n \"def calibrationPlot(predictions, truth, classes = None, label = \\\"Model\\\", newFigure = None, n_bins = 5):\\n predictions, truth = selection(predictions, truth, classes)\\n predictions, truth = flatten(predictions, truth)\\n predictions = ((predictions - predictions.min()) / (predictions.max() - predictions.min())).flatten()\\n fraction_of_positives, mean_predicted_value = calibration_curve(truth, predictions, n_bins = n_bins)\\n bins = np.linspace(0., 1. + 1e-8, n_bins + 1)\\n binids = np.digitize(predictions, bins) - 1\\n bin_sums = np.bincount(binids, minlength=len(bins))\\n bin_sums = bin_sums[bin_sums != 0] * 500 / np.sum(bin_sums)\\n\\n if newFigure is not None:\\n plt.figure(newFigure)\\n else:\\n plt.xlabel('Mean Predicted Value')\\n plt.ylabel('Fraction Positive')\\n plt.title('Calibration')\\n\\n p = plt.plot(mean_predicted_value, fraction_of_positives, alpha = 0.5, ls=':')\\n plt.scatter(mean_predicted_value, fraction_of_positives, s = bin_sums, label = label + \\\" ({:.2f})\\\".format(brier_score_loss(truth, predictions)), color = p[0].get_color(), alpha = 0.5)\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\\n train_x_pos = [0, 4, 8, 12]\\n cv_x_pos = [1, 5, 9, 13]\\n test_x_pos = [2, 6, 10, 14]\\n ticks = cv_x_pos\\n\\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\\n\\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\\n\\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\\n\\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\\n\\n fig, ax = plt.subplots()\\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\\n ax.set_ylabel('Accuracy')\\n ax.set_xticks(ticks)\\n ax.set_xticklabels(labels)\\n ax.set_title('Models')\\n ax.yaxis.grid(True)\\n ax.legend()\\n plt.tight_layout()\",\n \"def plot(self) -> Figure:\\n ax = self.setup_plot()\\n ax.errorbar(\\n self.doses,\\n self.means,\\n yerr=self.errorbars(),\\n label=\\\"Mean ± 95% CI\\\",\\n **plotting.DATASET_POINT_FORMAT,\\n )\\n ax.legend(**plotting.LEGEND_OPTS)\\n return ax.get_figure()\",\n \"def _plot_good_pred_whitout_reject(self, test: Set, title=None, fig_size=None):\\r\\n if fig_size is not None:\\r\\n fig = plt.figure(figsize=fig_size)\\r\\n else:\\r\\n fig = plt.figure()\\r\\n ax = fig.add_subplot(111)\\r\\n goodclassified_index = []\\r\\n for idx_preds in range(self.preds.shape[1]):\\r\\n new_good_index = []\\r\\n for idx in range(self.preds.shape[0]):\\r\\n if test.labels[idx] == self.preds[idx, idx_preds]:\\r\\n new_good_index.append(idx)\\r\\n if new_good_index:\\r\\n ax.scatter(test.features[new_good_index, 0], self.features[new_good_index, 1],\\r\\n label='Good classified top{0}'.format(int(idx_preds + 1)))\\r\\n goodclassified_index += new_good_index\\r\\n misclassified = [idx for idx in range(self.preds.shape[0]) if idx not in goodclassified_index]\\r\\n if misclassified:\\r\\n ax.scatter(test.features[misclassified, 0], test.features[misclassified, 1],\\r\\n label='Misclassified', marker='x', c='red')\\r\\n box = ax.get_position()\\r\\n ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\\r\\n # Put a legend to the right of the current axis\\r\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\\r\\n if title is not None:\\r\\n ax.set_title(title)\\r\\n plt.show()\",\n \"def plot(self, fit_result, axes, x, linewidth=None, alpha=None, color=None, normalize=None):\\n y = self.predict(fit_result, x)\\n if normalize is not None:\\n y = normalize(y)\\n result = axes.plot(x, y, color,\\n lw=linewidth, alpha=alpha,\\n scalex=False, scaley=False)\\n return result\",\n \"def plot_results(\\n data,\\n xparam,\\n yparam,\\n pxrange=None,\\n pyrange=None,\\n data_comp=None,\\n data_bohlin=None,\\n figsize=None,\\n alpha=0.25,\\n):\\n # set the plotting defaults\\n set_params(lw=2, fontsize=22)\\n\\n fig, ax = plt.subplots(figsize=figsize)\\n\\n if data_bohlin is not None:\\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\\n xcol = data_bohlin[xparam]\\n xcol_unc = get_unc(xparam, data_bohlin)\\n ycol = data_bohlin[yparam]\\n ycol_unc = get_unc(yparam, data_bohlin)\\n ax.errorbar(\\n xcol,\\n ycol,\\n xerr=xcol_unc,\\n yerr=ycol_unc,\\n fmt=\\\"ro\\\",\\n label=\\\"Bohlin (1978)\\\",\\n alpha=alpha,\\n )\\n if data_comp is not None:\\n xcol = data_comp[xparam]\\n xcol_unc = get_unc(xparam, data_comp)\\n ycol = data_comp[yparam]\\n ycol_unc = get_unc(yparam, data_comp)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"go\\\")\\n # plot the error bars as ellipses illustrating the covariance\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data_comp[\\\"AV\\\"].data,\\n cterm_unc=data_comp[\\\"AV_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"g\\\"\\n )\\n\\n xcol = data[xparam].data\\n xcol_unc = get_unc(xparam, data)\\n ycol = data[yparam].data\\n ycol_unc = get_unc(yparam, data)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"bo\\\")\\n\\n # plot the error bars as ellipses illustrating the covariance\\n if yparam[0:3] == \\\"CAV\\\":\\n cparam = \\\"AV\\\"\\n elif yparam[0:1] == \\\"C\\\":\\n cparam = \\\"EBV\\\"\\n else:\\n cparam = \\\"AV\\\"\\n\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data[cparam].data,\\n cterm_unc=data[cparam + \\\"_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"b\\\", pellipse=True\\n )\\n\\n ax.set_xlabel(format_colname(xparam))\\n ax.set_ylabel(format_colname(yparam))\\n\\n # fit a line\\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\\n # line_init = models.Polynomial1D(1)\\n line_init = models.Linear1D()\\n fit = fitting.LinearLSQFitter()\\n # fitter with outlier rejection\\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\\n\\n # fit the data w/o weights\\n fitted_model = fit(line_init, xcol, ycol)\\n print(fitted_model)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\\n\\n # print(\\\"linear fit params [slope, y-intercept]\\\")\\n # print(params)\\n xlim = ax.get_xlim()\\n x_mod = np.linspace(xlim[0], xlim[1])\\n # y_mod = params[1] + x_mod * params[0]\\n # ax.plot(x_mod, y_mod, \\\"k--\\\")\\n\\n ax.plot(x_mod, fitted_model(x_mod), \\\"k-\\\")\\n ax.plot(x_mod, fitted_model_weights(x_mod), \\\"k--\\\")\\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \\\"k.\\\")\\n\\n ax.plot(xcol, data_sc, 'ko')\\n print(data_sc)\\n\\n if pxrange is not None:\\n ax.set_xlim(pxrange)\\n if pyrange is not None:\\n ax.set_ylim(pyrange)\\n\\n return fig\",\n \"def check_fit(truth, prob):\\n fpr, tpr, _ = roc_curve(truth, prob) # drop_intermediate:(default=True)\\n roc_auc = auc(fpr, tpr) # calculate the AUC\\n plt.figure()\\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\\n plt.xlim([-0.1, 1.05])\\n plt.ylim([-0.1, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic example')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\\n print('results are RMSE, accuracy, ROC, loss function')\\n print(sqrt(mean_squared_error(truth, prob)), accuracy_score(truth, prob), roc_auc, zero_one_loss(truth, prob))\",\n \"def convergence():\\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n # point spread and point total subplots\\n subplots = [\\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\\n (True, [200.5], league.totals, 'probability total > 200.5'),\\n ]\\n\\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, values)\\n\\n line = lines[-1]\\n\\n for label2 in label2_list:\\n\\n # evaluation times and labels\\n times = np.arange(league.times.size)[::1000]\\n labels1 = times.size * [label1]\\n labels2 = times.size * [label2]\\n\\n # observed win probability\\n prob = melo.probability(times, labels1, labels2, lines=line)\\n ax.plot(times, prob)\\n\\n # true (analytic) win probability\\n if ax.is_first_row():\\n prob = skellam.sf(line, int(label1), int(label2))\\n ax.axhline(prob, color='k')\\n else:\\n prob = poisson.sf(line, int(label1) + int(label2))\\n ax.axhline(prob, color='k')\\n\\n # axes labels\\n if ax.is_last_row():\\n ax.set_xlabel('Iterations')\\n ax.set_ylabel(ylabel)\\n\\n set_tight(w_pad=.5)\",\n \"def plot(self, ylog=False, category=\\\"Accuracy\\\", figsize=(12, 5)):\\n if self.CV == False: # no Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n if self.CV == True: # has Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n\\n return fig, ax\",\n \"def visualize_cross_validation_results(cross_val_results, plots_filepath):\\n\\n pair_model_scores, pair_model_stds, \\\\\\n siamese_model_scores_2, siamese_model_stds_2, \\\\\\n siamese_model_scores_10, siamese_model_stds_10 = cross_val_results\\n param_names = (\\\"NBCH1\\\", \\\"NBCH2\\\", \\\"NBFCH\\\", \\\"BATCH_NORM\\\", \\\"SKIP_CON\\\", \\\"LR\\\")\\n\\n def aggregate_results(scores, stds):\\n \\\"\\\"\\\"\\n Helper function to aggregate score means and standard deviations for a model across parameter values\\n\\n :param scores: dictionary of score means {param_combo: score_mean}\\n :param stds: dictionary of score stds {param_combo: score_std}\\n\\n :returns: list of tuples of pandas.Dataframe objects containing aggregated mean and std data\\n \\\"\\\"\\\"\\n\\n scores = pd.DataFrame(scores.values(),\\n index=scores.keys(),\\n columns=[\\\"SCORE MEAN\\\", ])\\n stds = pd.DataFrame(stds.values(),\\n index=stds.keys(),\\n columns=[\\\"SCORE STD\\\", ])\\n scores.index.name = param_names\\n stds.index.name = param_names\\n data = []\\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\\n data.append((aggregate_scores, aggregate_stds))\\n return data\\n\\n pair_model_data = aggregate_results(pair_model_scores, pair_model_stds)\\n siamese_model_2_data = aggregate_results(siamese_model_scores_2, siamese_model_stds_2)\\n siamese_model_10_data = aggregate_results(siamese_model_scores_10, siamese_model_stds_10)\\n\\n # Group results for all models\\n model_names = (\\\"Pair\\\", \\\"Siamese 2\\\", \\\"Siamese 10\\\")\\n grouped_data = []\\n for pair_model_group_data, siamese_model_2_group_data, siamese_model_10_group_data in zip(pair_model_data,\\n siamese_model_2_data,\\n siamese_model_10_data):\\n score_means = (pair_model_group_data[0], siamese_model_2_group_data[0], siamese_model_10_group_data[0])\\n score_mean_data = pd.concat(score_means, axis=1)\\n score_mean_data.columns = model_names\\n\\n score_stds = (pair_model_group_data[1], siamese_model_2_group_data[1], siamese_model_10_group_data[1])\\n score_std_data = pd.concat(score_stds, axis=1)\\n score_std_data.columns = model_names\\n\\n grouped_data.append((score_mean_data, score_std_data))\\n\\n plots_param_names = (\\\"nbch1\\\", \\\"nbch2\\\", \\\"nbfch\\\", \\\"batch_norm+skip_con\\\", \\\"lr\\\")\\n for i, (plot_param_names, (score_mean_data, score_std_data)) in enumerate(zip(plots_param_names, grouped_data)):\\n plt.figure(figsize=(10, 5))\\n score_mean_data.plot(kind=\\\"line\\\" if plot_param_names == \\\"lr\\\" else \\\"bar\\\",\\n yerr=score_std_data,\\n capsize=5,\\n ylim=(0.4, 1.1),\\n colormap=colormap_brg_darker)\\n plt.title(\\\"Cross validation results for parameters:\\\\n{}\\\".format(plot_param_names), fontsize=18)\\n plt.xlabel(\\\"Parameter value\\\", fontsize=14)\\n plt.ylabel(\\\"Average accuracy\\\", fontsize=14)\\n plt.xticks(fontsize=12, rotation=30)\\n plt.yticks(fontsize=12)\\n plt.legend(title=\\\"Model\\\", title_fontsize=10)\\n plt.tight_layout()\\n plt.savefig(fname=plots_filepath + \\\"cross_validation_{}.eps\\\".format(plot_param_names),\\n dpi=\\\"figure\\\", format=\\\"eps\\\")\\n plt.close()\",\n \"def _th_plot(self, y_true, y_pred_proba, pos_label, pos_label_ind,\\n best_th_, q, tpr, fpr, th_, th_range, index, roc_auc_kwargs):\\n fig, axs = plt.subplots(nrows=2, ncols=1)\\n fig.set_size_inches(10, 10)\\n # Roc score.\\n y_type = sklearn.utils.multiclass.type_of_target(y_true)\\n if y_type == \\\"binary\\\":\\n roc_auc = sklearn.metrics.roc_auc_score(\\n y_true, y_pred_proba[:, pos_label_ind], **roc_auc_kwargs)\\n elif y_type == \\\"multiclass\\\":\\n roc_auc = sklearn.metrics.roc_auc_score(\\n y_true, y_pred_proba, **roc_auc_kwargs)\\n else:\\n assert False, f\\\"Unhandled y_type {y_type}\\\"\\n # Roc curve.\\n axs[0].plot(fpr, tpr, 'darkorange',\\n label=f\\\"ROC curve (AUC = {roc_auc:.3f}).\\\")\\n axs[0].scatter(fpr[index], tpr[index], c='b', marker=\\\"o\\\")\\n axs[0].plot([0, 1], [0, 1], color='navy', linestyle='--')\\n axs[0].set_xlabel('False Positive Rate')\\n axs[0].set_ylabel('True Positive Rate')\\n axs[0].set_title(f\\\"Receiver operating characteristic \\\"\\n f\\\"(label '{pos_label}')\\\")\\n axs[0].legend(loc=\\\"lower right\\\")\\n # Metric q.\\n axs[1].plot(th_, q, 'green')\\n axs[1].vlines(best_th_, np.min(q), np.max(q))\\n axs[1].vlines(th_range, np.min(q), np.max(q), colors='b',\\n linestyles=':')\\n axs[1].set_xlim([0.0, 1.0])\\n axs[1].set_xlabel('Threshold')\\n axs[1].set_ylabel('TPR/(TPR+FPR)')\\n axs[1].set_title('Selected th values objective maximum')\\n # plt.plot(th_, fpr, 'red')\\n plt.show()\",\n \"def residuals(y_true, y_pred, ax=None):\\n\\n _check_parameter_validity(y_true, y_pred)\\n\\n if ax is None:\\n ax = plt.gca()\\n\\n # horizontal line for residual=0\\n ax.axhline(y=0)\\n\\n ax.scatter(y_pred, y_true - y_pred)\\n\\n _set_ax_settings(ax, \\\"Predicted Value\\\", \\\"Residuals\\\", \\\"Residuals Plot\\\")\\n return ax\",\n \"def analyse_algorithms(R, u_t, inverse_transform, true_weight_vect, algo_list, equation, preconditioner):\\n\\n # Generate the model list for each sparse regression algorithm\\n algo_model_list_list = []\\n for algo_index, algo in enumerate(algo_list):\\n model_list = generate_models(R, u_t, inverse_transform, algo)\\n algo_model_list_list.append(model_list)\\n\\n # set up plot\\n symbol_list = ['v', 's', 'o', '+', '*', 'D']\\n color_list = [(162 / 256., 173 / 256., 0., 0.9), (156 / 256., 157 / 256., 159 / 256., 0.8),\\n (0., 101 / 256., 189 / 256., 1.), (227 / 256., 114 / 256., 34 / 256., 0.9)]\\n fig, ax = plt.subplots(figsize=(1.8 * 2.6, 1.8 * 1.95))\\n\\n # iterate all models of all algorithms and plot the summaries\\n for algo_index, algo in enumerate(algo_list):\\n model_list = algo_model_list_list[algo_index]\\n for i_model, model in enumerate(model_list):\\n set_model_correctness_and_error(model, true_weight_vect) # calculate absolute and relative error\\n # plot model properties\\n ax.semilogy(model.terms, model.mean_rel_err, marker=symbol_list[algo_index], markerfacecolor='none',\\n linestyle='None', color=color_list[algo_index], label=algo if i_model == 0 else \\\"\\\")\\n\\n # finish plot\\n ax.plot((-1., 10.), (1.5, 1.5), color='k')\\n # xlim needs to be adjusted with respect to the maximum number of correct term in the model\\n ax.set(ylim=[1.e-9, 75.], xlim=[0.5, 6.5], xlabel='Number of Terms', ylabel='MRE')\\n ax.legend(loc=4)\\n ax.set_yticks(ax.get_yticks()[:-3])\\n ax.set_xticks(np.arange(1, 7, 1))\\n plt.savefig('Regression_accuracy_comparison_' + str(equation) + '_' + preconditioner + '_test.png')\\n plt.savefig('Regression_accuracy_comparison_' + str(equation) + '_' + preconditioner + '_test.pgf')\",\n \"def PlotComparison(result_values, descrete, continuous, jitter=100):\\n df = result_values.copy()\\n np.random.seed(0)\\n df[continuous] = df[continuous] + np.random.randint(low=-jitter, high=jitter, size=len(df))\\n base = alt.Chart(df).transform_calculate(\\n ymin=\\\"datum.mean-2*datum.std\\\",\\n ymax=\\\"datum.mean+2*datum.std\\\",\\n ).properties(\\n title = '[Interactive] Accuracy by Params'\\n )\\n \\n points = base.mark_point(\\n filled=True,\\n size=10\\n ).encode(\\n x=continuous,\\n y=alt.Y('mean:Q'),#, scale=alt.Scale(domain=(0.55, 0.7))),\\n color=descrete,\\n tooltip=['mean','std']\\n )\\n\\n errorbars = base.mark_errorbar().encode(\\n x=continuous,\\n y=alt.Y(\\\"ymin:Q\\\",title='Accuracy'),\\n y2=\\\"ymax:Q\\\",\\n color=descrete,\\n )\\n\\n return(points + errorbars)\",\n \"def plotProfits(confidence, title=\\\"\\\"):\\r\\n profits = []\\r\\n ticks = range(5, 101)\\r\\n for i in ticks:\\r\\n p = profitComputation(i, confidence)\\r\\n profits.append(p)\\r\\n plt.plot(ticks, profits)\\r\\n plt.xticks(range(0, 101, 5))\\r\\n plt.xlabel(\\\"% of matches we bet on\\\")\\r\\n plt.ylabel(\\\"Return on investment (%)\\\")\\r\\n plt.suptitle(title)\",\n \"def compare_parameter_plots(result_file, result_file_eccentric, fitted_params, resultType, planet,\\n plotPublished = False, publishedDataFile = None, saveplot=True, foldext=''):\\n\\n # Check if we are wanting to compare the eccentric and circular resutls.\\n\\n inputData_circular = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\\n inputData_eccentric = np.genfromtxt(result_file_eccentric, dtype=None, delimiter=', ', comments='#', encoding = None)\\n\\n inputData = [inputData_circular, inputData_eccentric]\\n\\n # Find out the indices of the type of average and the error\\n if 't0' in str(inputData[0][0]):\\n values = [s for i, s in enumerate(inputData[0][0]) if 't0' in s]\\n indices = [i for i, s in enumerate(inputData[0][0]) if 't0' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t0_mu') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t0_med') + Nbefore\\n e = values.index('t0_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t0_lqs') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n elif 't_secondary' in str(inputData[0]):\\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t_secondary_mu') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t_secondary_med') + Nbefore\\n e = values.index('t_secondary_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t_secondary_lqs') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n else:\\n raise ValueError(\\\"Not implemented indices selection if we have not fit for t0\\\")\\n\\n # If we have some published values, create a table of the Nsigma difference\\n if plotPublished:\\n print \\\"\\\\nOpening file for writing nsigma from published...\\\"\\n f = open(\\\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFEccentricCircular.txt\\\".format(planet, foldext), 'w')\\n print >> f, (\\\"Param\\\\tAOR\\\\tChannel\\\\tMethod\\\\tCirc_val\\\\tCirc_err\\\\tEcc_val\\\\tEcc_err\\\\tSigma\\\\tNsigdiff\\\")\\n print >> f, (\\\"==============================================================================================\\\")\\n\\n for p in range(len(fitted_params)):\\n\\n # Figure out which parameter we are looking at\\n param = fitted_params[p]\\n\\n # Initialise plotting the parameters\\n fig = plt.figure(figsize=(8,5))\\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\\n ax1.set_title(r'Ch1 ($3.6\\\\mu m$)')\\n ax2.set_title(r'Ch2 ($4.5\\\\mu m$)')\\n ax1.set_ylabel(param)\\n\\n markers = ['o', '*']\\n offset = [0,0.01]\\n lab = [' cir',' ecc']\\n\\n # create lists to save the parameters to so that we can compare the circular and elliptical results\\n ch1polyMean_list, ch1PLDMean_list, ch1polyStds_list, ch1PLDStds_list = [],[],[],[]\\n ch2polyMean_list, ch2PLDMean_list, ch2polyStds_list, ch2PLDStds_list = [],[],[],[]\\n\\n for c in range(len(inputData)):\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\\n ch1polyAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'poly' in line]\\n ch1PLDAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'PLD' in line]\\n\\n if ch1polyAORs != ch1PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line]\\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line])\\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymetric errors\\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'poly' in line]).T\\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'PLD' in line]).T\\n\\n ch1polyMean_list.append(ch1polyMean)\\n ch1PLDMean_list.append(ch1PLDMean)\\n ch1polyStds_list.append(ch1polyStds)\\n ch1PLDStds_list.append(ch1PLDStds)\\n\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\\n ch2polyAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'poly' in line]\\n ch2PLDAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'PLD' in line]\\n\\n if ch2polyAORs != ch2PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line]\\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line])\\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymmetric errors\\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'poly' in line]).T\\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'PLD' in line]).T\\n\\n ch2polyMean_list.append(ch2polyMean)\\n ch2PLDMean_list.append(ch2PLDMean)\\n ch2polyStds_list.append(ch2polyStds)\\n ch2PLDStds_list.append(ch2PLDStds)\\n\\n # Calculate the weighted means...\\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean), np.array(ch1PLDStds))\\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\\n\\n # Channel 1\\n # polynomial\\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05+offset[c], ch1polyMean, yerr = ch1polyStds, marker = markers[c], linestyle='', color ='b', label = 'Poly' + lab[c])\\n # PLD\\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05+offset[c], ch1PLDMean, yerr = ch1PLDStds, marker = markers[c], linestyle='', color = 'r', label = 'PLD' + lab[c])\\n # labels\\n ax1.set_xticks(range(len(ch1PLDMean)))\\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\\n\\n\\n # Channel2\\n # polynomial\\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05+offset[c], ch2polyMean, yerr = ch2polyStds, marker = markers[c], linestyle='', color ='b')\\n # PLD\\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05+offset[c], ch2PLDMean, yerr = ch2PLDStds, marker = markers[c], linestyle='', color = 'r')\\n # labmarkers[c]\\n ax2.set_xticks(range(len(ch2PLDMean)))\\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\\n\\n # Plot the weighted means\\n if len(ch1polyMean) > 1.:\\n ax1.axhline(WMch1poly, color = 'b')\\n ax1.axhspan(WMch1poly - TSch1poly,\\n WMch1poly + TSch1poly,\\n alpha = 0.3, color='b',label='Weighted Mean')\\n ax1.axhline(WMch1PLD, color = 'r')\\n ax1.axhspan(WMch1PLD - TSch1PLD,\\n WMch1PLD + TSch1PLD,\\n alpha = 0.3, color='r',label='Weighted Mean')\\n\\n ax2.axhline(WMch2poly, color = 'b')\\n ax2.axhspan(WMch2poly - TSch2poly,\\n WMch2poly + TSch2poly,\\n alpha = 0.3, color='b')\\n ax2.axhline(WMch2PLD, color = 'r')\\n ax2.axhspan(WMch2PLD - TSch2PLD,\\n WMch2PLD + TSch2PLD,\\n alpha = 0.3, color='r')\\n\\n\\n if plotPublished:\\n # Plot the published values if they they are given\\n # and calculate Nsigma from published and save to a file\\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\\n\\n if param in data.T[0].tolist():\\n\\n pIdx = data.T[0].tolist().index(param)\\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\\n float(data[pIdx][1]) + float(data[pIdx][2]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\\n float(data[pIdx][3]) + float(data[pIdx][4]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n\\n # Save the number of sigma to a file\\n # This doesn't need to be in param loop because we want to do it for all the parameters\\n # regardless if we have published values.\\n # polynomial\\n for i in range(len(ch1polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1polyAORs[i], 'ch1', 'poly',\\n float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()), #channel 1\\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()),\\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[0].T[i].max()))))\\n\\n for i in range(len(ch2polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2polyAORs[i], 'ch2', 'poly',\\n float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()), #channel 1\\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()),\\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[0].T[i].max()))))\\n #PLD\\n for i in range(len(ch1PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1PLDAORs[i], 'ch1', 'PLD',\\n float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()), #channel 1\\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()),\\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[0].T[i].max()))))\\n\\n for i in range(len(ch2PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2PLDAORs[i], 'ch2', 'PLD',\\n float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()), #channel 1\\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()),\\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[0].T[i].max()))))\\n pass\\n\\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\\n axis1ylim = ax1.get_ylim()\\n axis2ylim = ax2.get_ylim()\\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\\n ymin = ax1.get_ylim()[0]\\n else:\\n ymin = ax2.get_ylim()[0]\\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\\n ymax = ax2.get_ylim()[1]\\n else:\\n ymax = ax1.get_ylim()[1]\\n ax1.set_ylim(ymin,ymax)\\n ax2.set_ylim(ax1.get_ylim())\\n ax2.get_yaxis().set_visible(False)\\n\\n ax1.legend(loc = 'best')\\n\\n\\n # Save if required\\n if saveplot:\\n plt.savefig(\\\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}_eccentricCircular.png\\\".format(planet,foldext,param, os.getenv('HOME')),bbox_inches='tight')\\n #plt.close()\\n if plotPublished:\\n f.close()\\n else:\\n pass\",\n \"def plot_fit_results(tool):\\n fig, ax = plt.subplots()\\n\\n model_meyer_ref = CrabSpectrum(\\\"meyer\\\").model\\n model_meyer_ref.plot(\\n [10 * u.GeV, 100 * u.TeV],\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=\\\":\\\",\\n lw=2.2,\\n color=\\\"#555555\\\",\\n label=\\\"Meyer et al. (2010)\\\",\\n )\\n\\n # where to take the results, configurations for the individual butterflies\\n instruments = [\\\"fermi\\\", \\\"magic\\\", \\\"veritas\\\", \\\"fact\\\", \\\"hess\\\", \\\"joint\\\"]\\n labels = [\\\"Fermi-LAT\\\", \\\"MAGIC\\\", \\\"VERITAS\\\", \\\"FACT\\\", \\\"H.E.S.S.\\\", \\\"joint fit\\\"]\\n lss = [\\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"-\\\"]\\n colors = COLORS\\n # with one loop we realize all the butterfly plots\\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\\n\\n path = (\\n config.repo_path\\n / f\\\"results/fit/{tool}/{instrument}/fit_results_logparabola.yaml\\\"\\n )\\n\\n if not path.exists():\\n log.warning(f\\\"Missing: {path} . Skipping.\\\")\\n continue\\n\\n results = load_yaml(path)\\n parameters = results[\\\"parameters\\\"]\\n\\n model_lp = LogParabola.from_log10(\\n amplitude=parameters[0][\\\"value\\\"] * u.Unit(parameters[0][\\\"unit\\\"]),\\n reference=parameters[1][\\\"value\\\"] * u.Unit(parameters[1][\\\"unit\\\"]),\\n alpha=parameters[2][\\\"value\\\"] * u.Unit(parameters[2][\\\"unit\\\"]),\\n beta=parameters[3][\\\"value\\\"] * u.Unit(parameters[3][\\\"unit\\\"]),\\n )\\n\\n # energy range for the plot\\n dataset = config.get_dataset(instrument)\\n energy_range = dataset.energy_range\\n\\n # just in case of the joint fit put a thicker line and a less transparent butterfly\\n if instrument == \\\"joint\\\":\\n model_lp.plot(\\n energy_range,\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=ls,\\n lw=3,\\n color=color,\\n label=label,\\n )\\n else:\\n model_lp.plot(\\n energy_range,\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=ls,\\n lw=2.2,\\n color=color,\\n label=label,\\n )\\n\\n # read the butterfly from the multivariate sampling results\\n table_path = Path(\\n f\\\"{config.repo_path}/results/figures/stat_err/{instrument}_flux_errorband.dat\\\"\\n )\\n log.info(f\\\"reading butterfly values from {table_path}\\\")\\n t = Table.read(table_path, format=\\\"ascii.ecsv\\\")\\n energies = t[\\\"energies\\\"].data * t[\\\"energies\\\"].unit\\n flux_lo = t[\\\"flux_lo\\\"].data * t[\\\"flux_lo\\\"].unit\\n flux_hi = t[\\\"flux_hi\\\"].data * t[\\\"flux_hi\\\"].unit\\n\\n if instrument == \\\"joint\\\":\\n alpha = 0.38\\n else:\\n alpha = 0.28\\n\\n plt.fill_between(\\n energies.to(\\\"TeV\\\"),\\n (energies ** 2 * flux_lo).to(\\\"erg cm-2 s-1\\\"),\\n (energies ** 2 * flux_hi).to(\\\"erg cm-2 s-1\\\"),\\n color=color,\\n alpha=alpha,\\n label=\\\"\\\",\\n )\\n\\n ax.legend(fontsize=FONTSIZE)\\n ax.set_ylim([1e-12, 2e-10])\\n\\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\\n # make axis thicker\\n for axis in [\\\"top\\\", \\\"bottom\\\", \\\"left\\\", \\\"right\\\"]:\\n ax.spines[axis].set_linewidth(1.6)\\n ax.tick_params(\\\"both\\\", length=7, width=1.6, which=\\\"major\\\", labelsize=FONTSIZE)\\n ax.tick_params(\\\"both\\\", length=4, width=1.6, which=\\\"minor\\\", labelsize=FONTSIZE)\\n\\n plt.tight_layout()\\n\\n filename = f\\\"results/figures/crab_sed_{tool}_fit.png\\\"\\n filename_pdf = f\\\"results/figures/crab_sed_{tool}_fit.pdf\\\"\\n log.info(f\\\"Writing {filename}\\\")\\n fig.savefig(filename)\\n fig.savefig(filename_pdf)\",\n \"def plotComparison2(x, nt, nx, c, phi, phiExact, methodName): \\n plt.plot(x, phiExact)\\n\\n plt.plot(x, phi, label=methodName)\\n plt.ylim([-0.2, 1.4])\",\n \"def plot(self):\\n # plot the data for checking\\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\\n 3,2, figsize=(10,8))\\n\\n # Relative height\\n self.board_reference.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\\n self.board_intervention.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\\n\\n # Landuse\\n self.board_reference.plot(\\n column='landuse', legend=True, ax=ax3, cmap='viridis',\\n scheme='equal_interval', k=11)\\n self.board_intervention.plot(\\n column='landuse', legend=True, ax=ax4, cmap='viridis',\\n scheme='equal_interval', k=11)\\n\\n index = np.arange(7)\\n xticks = self.PotTax_reference.index.values\\n bar_width = 0.3\\n\\n # plot the initial and new situation comparison\\n label = (\\\"reference: \\\" +\\n str(round(self.PotTax_reference.sum().TFI, 2)))\\n reference = ax5.bar(\\n index, self.PotTax_reference.values.flatten(), bar_width,\\n label=label, tick_label=xticks)\\n label = (\\\"intervention: \\\" +\\n str(round(self.PotTax_intervention.sum().TFI, 2)))\\n intervention = ax5.bar(\\n index+bar_width, self.PotTax_intervention.values.flatten(),\\n bar_width, label=label, tick_label=xticks)\\n ax5.set_ylabel(\\\"total value\\\")\\n ax5.legend(loc='best')\\n for tick in ax5.get_xticklabels():\\n tick.set_rotation(90)\\n\\n # plot the percentage increase/decrease between the initial and new\\n # situation\\n data = self.PotTax_percentage.values.flatten()\\n percentage = ax6.bar(\\n index, data, bar_width, label=\\\"percentage\\\", tick_label=xticks)\\n ax6.set_ylabel(\\\"increase (%)\\\")\\n minimum = min(data)\\n maximum = max(data)\\n size = len(str(int(round(maximum))))\\n maximum = int(str(maximum)[:1])\\n maximum = (maximum + 1) * (10**(size-1))\\n ax6.set_ylim([min(0, minimum), maximum])\\n for tick in ax6.get_xticklabels():\\n tick.set_rotation(90)\",\n \"def plot_corr_normalized(models,data,fit,**kwargs):\\n _fnNMod = len(models)\\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\\n ## -- objects to hold all plot data\\n ## - Dat/Fit refers to the correlator data or the fit function\\n ## - Central/Error are the central value and errors\\n _fnDatCentral = []\\n _fnDatError = []\\n _fnFitOnes = []\\n _fnFitError = []\\n #\\n ## -- other objects\\n _fnTDataNonZero = []\\n _fnTFitNonZero = []\\n _fnTData = []\\n _fnTFit = []\\n _fnTRem = [] # number of previous timeslices removed\\n fig,ax = plt.subplots(1)\\n #\\n ## -- setup plot function\\n def do_plot_normalized(idx,fig=fig):\\n fig.clear()\\n ax = fig.add_subplot(111)\\n key = models[idx[0]].datatag\\n\\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\\n ax.set_ylim(utp.get_option(\\\"y_limit\\\",[0.2,1.8],**kwargs[key]))\\n #\\n ## -- plot fit\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\\n color=utp.get_option(\\\"color2\\\",'b',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ## -- plot correlator data\\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\\n mfc=utp.get_option(\\\"markerfacecolor1\\\",'None',**kwargs[key]),\\n mec=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n color=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle1\\\",'None',**kwargs[key]),\\n marker=utp.get_option(\\\"marker1\\\",'o',**kwargs[key]),\\n ms=utp.get_option(\\\"markersize\\\",6,**kwargs[key]))\\n ax.scatter(_fnTFitNonZero[idx[0]],\\n [ _fnDatCentral[idx[0]][t] for t in\\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\\n color=utp.get_option(\\\"color1\\\",'r',**kwargs[key]),\\n marker=utp.get_option(\\\"marker\\\",'o',**kwargs[key]),\\n s=utp.get_option(\\\"markersize\\\",36,**kwargs[key]))\\n fig.suptitle(utp.get_option(\\\"plottitlefn\\\",str(idx[0])+\\\" default title \\\"+str(key),**kwargs[key]),\\n fontsize=utp.get_option(\\\"titlesize\\\",20,**kwargs[key]))\\n ## -- modify some options \\n ax.set_xlabel(r'$t$')\\n ax.set_ylabel(utp.get_option(\\\"yaxistitle\\\",r\\\"$C(t)/C_{fit}(t)$\\\",**kwargs[key]))\\n for item in ([ax.xaxis.label,ax.yaxis.label]):\\n # must be after setting label content (LaTeX ruins it)\\n item.set_fontsize(fontsize=utp.get_option(\\\"fontsize\\\",20,**kwargs[key]))\\n rect =fig.patch\\n rect.set_facecolor('white')\\n if utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".pdf\\\",**kwargs[key])\\n plt.savefig(save_dir+'/'+save_name)\\n if utp.get_option(\\\"to_terminal\\\",True,**kwargs[key]):\\n plt.draw()\\n pass\\n #\\n ## -- setup button press action function\\n def press_normalized(event,idx=_fnIdx):\\n #print('press_normalized', event.key)\\n try:\\n ## -- manually indicate index\\n idx[0] = int(event.key) + (idx[0])*10\\n except ValueError:\\n if event.key==' ': ## -- space\\n ## -- allows for replotting when changing index by typing number keys\\n idx[0] = idx[0] % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='left':\\n idx[0] = (idx[0] - 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='right':\\n idx[0] = (idx[0] + 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='backspace':\\n ## -- reset index so can manually flip through using number keys\\n idx[0] = 0\\n elif event.key=='d':\\n ## -- dump plots into ./plotdump directory\\n for ix,model in zip(range(len(models)),models):\\n key = model.datatag\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".png\\\",**kwargs[key])\\n do_plot_normalized([ix])\\n plt.savefig(save_dir+'/'+save_name)\\n do_plot_normalized(idx)\\n #\\n ## -- \\n fig.canvas.mpl_connect('key_press_event',press_normalized)\\n ## -- save plot data\\n for idx,model in zip(range(len(models)),models):\\n key = model.datatag\\n _fnTData.append(model.tdata)\\n _fnTFit.append(model.tfit)\\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\\n ## -- fit\\n _fnFitFunc = utp.create_fit_func(model,fit)\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\\n _fnTRem[-1] = \\\\\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\\n ## -- data\\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean)) )\\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean) )\\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\\n ## -- done saving data\\n \\n if not(utp.get_option(\\\"to_terminal\\\",True,**kwargs[key])) and\\\\\\n utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n for ix in range(len(models)):\\n ## -- loops and saves all without creating window\\n do_plot_normalized([ix])\\n else:\\n do_plot_normalized(_fnIdx)\",\n \"def plot_results(self):\\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))\",\n \"def display_results(experiment, norms, nus, filename):\\n # plot the results of the experiment\\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\\n\\n # plot large scale overview\\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\\n\\n # plot more detailed errors exluding OLS estimate\\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\\n\\n # add title and save\\n plt.savefig(filename, dpi=300)\",\n \"def plot(self):\\n\\t\\traw_labels = self.make_raw_data()[1]\\n\\t\\tbalanced_labels = self.get_extra()[1]\\n\\t\\tfig, ax1 = subplots()\\n\\t\\tax2 = ax1.twinx()\\n\\t\\tx = array(range(1, NCLASSES + 1))\\n\\t\\tl1 = ax1.bar(x - 0.3, self.prior_sizes, width = 0.25, color = 'b', align = 'center', label = 'train')\\n\\t\\tl2 = ax2.bar(x, bincount(raw_labels - 1), width = 0.25, color = 'r', align = 'center', label = 'confident')\\n\\t\\tl3 = ax2.bar(x + 0.3, bincount(balanced_labels - 1), width = 0.25, color = 'g', align = 'center', label = 'rebalanced')\\n\\t\\tconfident_frac = len(raw_labels) / float(self.predictions.shape[0])\\n\\t\\tusable_frac = len(balanced_labels) / float(self.predictions.shape[0])\\n\\t\\tax1.set_title('at >{0:.1f}%, {1:.1f}% reliable, {2:.1f}% usable'.format(self.confidence * 100, confident_frac * 100, usable_frac * 100))\\n\\t\\tax1.legend([l1, l2, l3], [l1.get_label(), l2.get_label(), l3.get_label()], loc = 'upper right')\\n\\t\\tax1.set_xticks(x)\",\n \"def plot(self, fname=None):\\n x = np.linspace(self.bounds[0], self.bounds[-1], 200)\\n y = [self.evaluate(xi) for xi in x]\\n plt.figure()\\n plt.plot(x, y, label='Class func')\\n plt.plot(self.bounds, self.gis, 'o', label='Algorithm')\\n plt.grid(color='0.7')\\n plt.xlabel('Dependent Variable')\\n plt.ylabel('PP Transformed Class Value')\\n if fname:\\n plt.savefig(fname)\\n else:\\n plt.show()\",\n \"def get_convergence_plot(self):\\n fig, ax = plt.subplots()\\n first_episode = self.get_convergence_episode()\\n\\n values = self.stats['return_stats']['episode_totals']\\n ax.plot(np.arange(len(values)), values, color='steelblue', lw=2, alpha=.9,\\n label='Return')\\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\\n ax.set_xlim(left=0, right=first_episode * 2)\\n\\n ax.set_title('Normalized regret = {:.3f}'.format(\\n self.get_normalized_regret()))\\n ax.legend()\\n ax.set_ylabel('Return')\\n ax.set_xlabel('Episode')\\n return fig\",\n \"def plot_ordination(res, choices=[1,2],\\n axis_names='PC', constrained_names=None,\\n samples_kw={}, species_kw={}, centroids_kw={}, biplot_kw={},\\n axline_kw={}):\\n choices = asarray(choices) -1\\n samples, species, centroids, biplot, evals = [asarray(res.get(k, None))\\n for k in ['samples', 'species', 'centroids', 'biplot', 'eigvals']]\\n if isinstance(axis_names, str):\\n axis_names = ['%s%i' % (axis_names, i+1) for i in range(len(evals))]\\n # draw the axis lines\\n axline_kw = dict({'color':'gray'}, **axline_kw)\\n pylab.axvline(**axline_kw)\\n pylab.axhline(**axline_kw)\\n # calc percentages from evals and label them\\n evals = asarray(evals)\\n evals[evals<0] = 0\\n percs = 100 * (evals / evals.sum())\\n pylab.xlabel('%s - %.2f%%' % (axis_names[choices[0]], percs[choices[0]]))\\n pylab.ylabel('%s - %.2f%%' % (axis_names[choices[1]], percs[choices[1]]))\\n #plot the speceies points in red +\\n if any(species):\\n species_kw = dict({'cml': 'r+', 'label_kw':{'size':'smaller'}},\\n **species_kw) #set default\\n plot_points(species[:, choices], **species_kw)\\n # scatter the sample points in black\\n default = {'c': 'k', 's': 50, 'alpha': 0.5, 'label_kw': {'size': 'medium'}}\\n scatter_points(samples[:, choices], **dict(default, **samples_kw))\\n # scatter the centroids\\n if any(centroids):\\n default = {'c':'b', 's':0, 'label': 'X', 'label_kw':{'size':'larger',\\n 'color':'b', 'ha':'center', 'va':'center'}}\\n scatter_points(centroids[:, choices], **dict(default, **centroids_kw))\\n # arrow the biplot points\\n if any(biplot):\\n default = {'c':'b', 'label_kw':{'size':'larger', 'color':'b'}}\\n arrows([[0,0]] * len(biplot), biplot[:, choices],\\n **dict(default, **biplot_kw))\\n # calc the constrained percentage and title it\\n if constrained_names:\\n if isinstance(constrained_names, str): #a prefix\\n constrained_names = [n for n in axis_names if\\n n.startswith(constrained_names)]\\n con_idxs = [i for i, n in enumerate(axis_names)\\n if n in constrained_names]\\n con_perc = percs[con_idxs].sum()\\n pylab.title('%.2f%% constrained' % con_perc)\",\n \"def plot_data(self, plot_input=True, plot_fitted=True,plotfile=None, show=None):\\n if not self.fitted:\\n raise RuntimeError(\\\"Please run fit() before attempting to plot the results\\\")\\n\\n fitted_data = self.data_summary(printout=False)\\n fitted_mean = fitted_data['mean'].to_numpy().reshape((self.npoints,self.ndim))\\n print(fitted_mean.shape)\\n fitted_sigma = fitted_data['sd'].to_numpy().reshape((self.npoints,self.ndim))\\n if self.ndim==np.int(2) and isinstance(self.ndim, int):\\n blue, _, red, *_ = sns.color_palette()\\n f, ax = plt.subplots(1, 1, figsize=(5, 4))#, gridspec_kw=dict(width_ratios=[4, 3]))\\n\\n sns.scatterplot(x=self.data[:,0], y=self.data[:,1])\\n if plot_input:\\n ax.errorbar(x=self.data[:,0], y=self.data[:,1],\\n xerr=self.sigma[:,0], yerr=self.sigma[:,1],fmt='o',label='input data')\\n \\n if plot_fitted:\\n ax.errorbar(x=fitted_mean[:,0], y=fitted_mean[:,1],\\n xerr=fitted_sigma[:,0], yerr=fitted_sigma[:,1],fmt='o',label='inferred data')\\n \\n mu_post = self.trace.posterior[\\\"mu\\\"].mean(axis=(0, 1)).data\\n \\n sigma_post = self.trace.posterior[\\\"cov\\\"].mean(axis=(0, 1)).data\\n \\n var_post, U_post = np.linalg.eig(sigma_post)\\n angle_post = 180.0 / np.pi * np.arccos(np.abs(U_post[0, 0]))\\n\\n e_post = Ellipse(\\n mu_post,\\n 2 * np.sqrt(5.991 * var_post[0]),\\n 2 * np.sqrt(5.991 * var_post[1]),\\n angle=angle_post,\\n )\\n e_post.set_alpha(0.5)\\n e_post.set_facecolor(blue)\\n e_post.set_zorder(10)\\n ax.add_artist(e_post)\\n rect_post = plt.Rectangle((0, 0), 1, 1, fc=blue, alpha=0.5)\\n ax.legend(\\n [rect_post],\\n [\\\"Estimated 95% density region\\\"],\\n loc=2,\\n )\\n #plt.show()\\n\\n elif self.ndim > 2 and isinstance(int, self.ndim) and np.isfinite(self.ndim):\\n #raise NotImplementedError(\\\"This routine doesn't support plotting correlations in more than 2 dimensions yet!\\\")\\n rows = self.ndim - 1\\n cols = self.ndim - 1\\n fig = plt.figure()\\n gs = fig.add_gridSpec(rows, cols,left=0.1, right=0.9, bottom=0.1, top=0.9,\\n wspace=0.05, hspace=0.05)\\n for i in range(self.ndim - 1):\\n for j in range(i+1,self.ndim - 1):\\n ax = fig.add_subplot(gs[i,j])\\n #plot the data points\\n sns.scatterplot(self.data[:,i], self.data[:,j], ax=ax)\\n if plot_input:\\n ax.errorbar(x=self.data[:,i], y=self.data[:,j],\\n xerr=self.sigma[:,i], yerr=self.sigma[:,j])\\n \\n if plot_fitted:\\n ax.errorbar(x=fitted_mean[:,i], y=fitted_mean[:,j],\\n xerr=fitted_sigma[:,i], yerr=fitted_sigma[:,j])\\n \\n mu_post = self.trace.posterior[\\\"mu\\\"].mean(axis=(i, j)).data\\n \\n sigma_post = self.trace.posterior[\\\"cov\\\"].mean(axis=(i, j)).data\\n \\n var_post, U_post = np.linalg.eig(sigma_post)\\n angle_post = 180.0 / np.pi * np.arccos(np.abs(U_post[0, 0]))\\n \\n e_post = Ellipse(\\n mu_post,\\n 2 * np.sqrt(5.991 * var_post[0]),\\n 2 * np.sqrt(5.991 * var_post[1]),\\n angle=angle_post,\\n )\\n e_post.set_alpha(0.5)\\n e_post.set_facecolor(blue)\\n e_post.set_zorder(10)\\n ax.add_artist(e_post)\\n \\n else:\\n raise ValueError(\\\"Ndim is either less than 2 or is not an integer!\\\")\\n \\n if isinstance(plotfile, str):\\n plt.save(plotfile)\\n elif not show:\\n raise TypeError(\\\"plotfile must be a string\\\")\\n if show:\\n plt.show()\\n elif plotfile is not None:\\n plt.close()\",\n \"def check_fit(data, data_fit, time_points):\\n plt.figure()\\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\\\"Cases\\\", \\\"Deaths\\\", \\\"Hospitalized\\\", \\\"ICU\\\"])):\\n if data[ii] is not None:\\n plt.plot(time_points, data[ii], c=f\\\"C{jj}\\\", label=lab)\\n plt.plot(time_points, data_fit[ii], '--', c=f\\\"C{jj}\\\", label=f\\\"{lab} fit\\\")\\n plt.yscale(\\\"log\\\")\\n plt.legend()\\n # plt.savefig(\\\"Test_fitting\\\", format=\\\"png\\\")\\n plt.show()\",\n \"def plot_rank_sensitivity(\\n dmd_train_error, dmd_test_error, optdmd_train_error, optdmd_test_error\\n):\\n\\n # Generate figure.\\n fig, axes = plt.subplots(\\n 1, 2, figsize=(fig_width, fig_width / 4), sharex=True, sharey=True\\n )\\n\\n # Misc.\\n rank = np.arange(1, dmd_test_error.shape[0] + 1)\\n\\n #####\\n # TRAINING ERROR\\n #####\\n\\n # Plot the vanilla DMD error.\\n axes[0].plot(rank, dmd_train_error)\\n # Plot the OptDMD error.\\n axes[0].plot(rank, optdmd_train_error, ls=\\\"--\\\")\\n # Add decorators.\\n axes[0].set(\\n xlabel=r\\\"Rank of the DMD model\\\",\\n ylabel=r\\\"Normalized error\\\",\\n title=r\\\"Training dataset\\\",\\n )\\n axes[0].grid(True)\\n\\n #####\\n # TESTING ERROR\\n #####\\n\\n # Plot the vanilla DMD error.\\n axes[1].plot(rank, np.mean(dmd_test_error, axis=1), label=r\\\"Regular DMD\\\")\\n axes[1].fill_between(\\n rank,\\n np.mean(dmd_test_error, axis=1) + np.std(dmd_test_error, axis=1),\\n np.mean(dmd_test_error, axis=1) - np.std(dmd_test_error, axis=1),\\n alpha=0.25,\\n )\\n # Plot the OptDMD error.\\n axes[1].plot(\\n rank, np.mean(optdmd_test_error, axis=1), ls=\\\"--\\\", label=r\\\"Optimal DMD\\\"\\n )\\n axes[1].fill_between(\\n rank,\\n np.mean(optdmd_test_error, axis=1) + np.std(optdmd_test_error, axis=1),\\n np.mean(optdmd_test_error, axis=1) - np.std(optdmd_test_error, axis=1),\\n alpha=0.25,\\n )\\n # Add decorators.\\n axes[1].set(\\n xlim=(0, rank.max()),\\n xlabel=r\\\"Rank of the DMD model\\\",\\n ylim=(0, 1),\\n title=r\\\"Testing dataset\\\",\\n )\\n axes[1].grid(True)\\n axes[1].legend(loc=0)\\n\\n return\",\n \"def visualize_best_model_params(df, model_name, model_params, score_names, is_higher_score_better, err_param_name,\\n title, x_log=False, y_log=False, max_n_cols=2):\\n dfs = [df_ for df_ in split_df_by_model(df) if re.match(model_name + r\\\"(?:|Clean) #\\\\d+\\\", df_.name)]\\n\\n for df_ in dfs:\\n n_rows, n_cols = get_n_rows_cols(len(score_names), max_n_cols)\\n fig, axs = plt.subplots(n_rows, n_cols, figsize=(n_cols * 5, n_rows * 4), squeeze=False,\\n constrained_layout=True)\\n for i, ax in enumerate(axs.ravel()):\\n for j, score_name in enumerate(score_names):\\n df_opt = filter_optimized_results(df_, err_param_name, score_name, is_higher_score_better[j])\\n if x_log and y_log:\\n ax.loglog(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\\n elif x_log:\\n ax.semilogx(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\\n elif y_log:\\n ax.semilogy(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\\n else:\\n ax.plot(df_opt[err_param_name], df_opt[model_params[i]], label=score_name)\\n ax.set_xlabel(err_param_name)\\n ax.set_ylabel(model_params[i])\\n ax.legend(fontsize=\\\"small\\\")\\n\\n fig.suptitle(title + \\\" (\\\" + df_.name + \\\")\\\", fontsize=10)\\n path_to_plot = generate_unique_path(\\\"out\\\", \\\"png\\\")\\n fig.savefig(path_to_plot)\",\n \"def plotModelResults(model, X_train=X_train, X_test=X_test, plot_intervals=False, plot_anomalies=False):\\n\\n prediction = model.predict(X_test)\\n\\n plt.figure(figsize=(15, 7))\\n\\n plt.plot(prediction, \\\"g\\\", label=\\\"prediction\\\", linewidth=2.0)\\n plt.plot(y_test.values, label=\\\"actual\\\", linewidth=2.0)\\n plt.draw()\\n if plot_intervals:\\n cv = cross_val_score(model, X_train, y_train,\\n cv=tscv,\\n scoring=\\\"neg_mean_absolute_error\\\")\\n mae = cv.mean() * (-1)\\n deviation = cv.std()\\n\\n scale = 1.96\\n lower = prediction - (mae + scale * deviation)\\n upper = prediction + (mae + scale * deviation)\\n\\n plt.plot(lower, \\\"r--\\\", label=\\\"upper bond / lower bond\\\", alpha=0.5)\\n plt.plot(upper, \\\"r--\\\", alpha=0.5)\\n plt.draw()\\n\\n if plot_anomalies:\\n anomalies = np.array([np.NaN]*len(y_test))\\n anomalies[y_test<lower] = y_test[y_test<lower]\\n anomalies[y_test>upper] = y_test[y_test>upper]\\n plt.plot(anomalies, \\\"o\\\", markersize=10, label = \\\"Anomalies\\\")\\n plt.draw()\\n def mean_absolute_percentage_error(y_true, y_pred):\\n return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\\n\\n error = mean_absolute_percentage_error(prediction, y_test)\\n plt.title(\\\"Mean absolute percentage error {0:.2f}%\\\".format(error))\\n plt.legend(loc=\\\"best\\\")\\n plt.tight_layout()\\n plt.grid(True)\\n plt.draw()\",\n \"def plot(self):\\r\\n \\r\\n\\r\\n print(\\\"Printing decision surfaces of decision trees\\\")\\r\\n plot_colors = \\\"rb\\\"\\r\\n plot_step = 0.02\\r\\n n_classes = 2\\r\\n for _ in range (self.n_estimators):\\r\\n plt.subplot(2, 3, _ + 1)\\r\\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\\r\\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\\r\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\\r\\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\\r\\n Z = self.clfs[_].predict(np.c_[xx.ravel(), yy.ravel()])\\r\\n Z = np.array(Z)\\r\\n Z = Z.reshape(xx.shape)\\r\\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\\r\\n for i, color in zip(range(n_classes), plot_colors):\\r\\n if i == 0:\\r\\n idx = np.where(self.y == -1)\\r\\n if i == 1:\\r\\n idx = np.where(self.y == 1)\\r\\n for i in range (len(idx[0])):\\r\\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\\r\\n plt.suptitle(\\\"Decision surface of a decision tree using paired features\\\")\\r\\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\\r\\n plt.axis(\\\"tight\\\")\\r\\n\\r\\n plt.show()\\r\\n fig1 = plt\\r\\n\\r\\n # Figure 2\\r\\n print(\\\"Printing decision surface by combining the individual estimators\\\")\\r\\n plot_colors = \\\"rb\\\"\\r\\n plot_step = 0.02\\r\\n n_classes = 2\\r\\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\\r\\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\\r\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\\r\\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\\r\\n Z = config.Classifier_AB.predict(np.c_[xx.ravel(), yy.ravel()])\\r\\n Z = np.array(Z)\\r\\n Z = Z.reshape(xx.shape)\\r\\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\\r\\n for i, color in zip(range(n_classes), plot_colors):\\r\\n if i == 0:\\r\\n idx = np.where(self.y == -1)\\r\\n if i == 1:\\r\\n idx = np.where(self.y == 1)\\r\\n for i in range (len(idx[0])):\\r\\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\\r\\n plt.suptitle(\\\"Decision surface by combining individual estimators\\\")\\r\\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\\r\\n plt.axis(\\\"tight\\\")\\r\\n\\r\\n plt.show()\\r\\n fig2 = plt\\r\\n\\r\\n return [fig1,fig2]\",\n \"def plot_mean(self, exact, exact_label='CCSD', axabs=None):\\n if axabs is None:\\n axabs = plt.gca()\\n axabs.plot(list(range(1, self.max_dets)), self.means[0], label='independent')\\n axabs.plot(list(range(1, self.max_dets)), self.means[1], label='correlated')\\n axabs.axhline(self.means[0, 0], linestyle='--', color='silver', label='reference')\\n if exact:\\n axabs.axhline(exact, linestyle='dashdot', color='green', label=exact_label)\\n axabs.set_xlabel('Number of determinants in estimator')\\n axabs.set_ylabel(r'$E_\\\\mathrm{corr}$ / ha')\\n axabs.legend()\\n return axabs\",\n \"def PlotEnsemblePredictions(self,ens, sampling_freq=10, fontSizeLabels=24, fontSizeLegend=20,rescale=1.,pow10first=False):\\n pylab.figure()\\n\\tpylab.axes([0.15,0.35,0.95-0.15,0.95-0.35])\\n\\tdata_experiments = self.data.experiments\\n for independentValues in data_experiments:\\n Xdata = self.data.X[independentValues]\\n Ydata = self.data.Y[independentValues]\\n\\t Xtheory = scipy.logspace(scipy.log10(min(Xdata)),scipy.log10(max(Xdata)),num=100)\\n\\t pointType = self.data.pointType[independentValues]\\n\\t errorBar = self.data.errorBar[independentValues]\\n\\t mean_theory = scipy.zeros(len(Xtheory))\\n\\t std_theory = scipy.zeros(len(Xtheory))\\n for i in range(0, num_to_count):\\n\\t\\t ens_theory = self.theory.Y(Xtheory,ens[i*sampling_freq],independentValues)\\n\\t\\t mean_theory += ens_theory\\n\\t\\t std_theory += (ens_theory)**2\\n\\t mean_theory = mean_theory/(1.0*num_to_count)\\n\\t std_theory = scipy.sqrt((std_theory-num_to_count*mean_theory**2)/(num_to_count-1.))\\n\\t pylab.loglog(Xdata,Ydata,pointType[1])\\n\\t lb = self.getLabel(self.theory.independentNames,independentValues,pow10first=pow10first)\\n\\t pylab.errorbar(Xdata,Ydata, yerr=errorBar, fmt=pointType,label=lb)\\n\\t pylab.loglog(Xtheory,mean_theory,pointType[0])\\n\\t axis_dep=self.getAxis(Xdata,Ydata)\\n\\t #upper_bound = mean_theory+std_theory\\n\\t #lower_bound = mean_theory-std_theory\\n\\t upper_bound = scipy.exp(scipy.log(mean_theory) + scipy.log(1.+std_theory/mean_theory)*rescale)\\n\\t lower_bound = scipy.exp(scipy.log(mean_theory)+scipy.log(1.-std_theory/mean_theory)*rescale)\\n\\t for i in range(0, len(lower_bound)):\\n\\t\\t if lower_bound[i]<=0:\\n\\t\\t\\t lower_bound[i]=10.**(-16)\\n\\t pylab.fill_between(Xtheory,lower_bound,y2=upper_bound,color=pointType[0],alpha=0.2)\\n\\n\\t for i, Ax in enumerate(axis_dep):\\n\\t\\t ax0[i] =i%2 and max(ax0[i],Ax) or min(ax0[i],Ax)\\n\\tpylab.axis(tuple(ax0))\\n\\tpylab.legend(loc=(-0.15,-0.52),ncol=3)\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def compute(self):\\n # update parameters with the values of widgets\\n initguess = str(self.ptext.toPlainText())\\n if not self.checkUserInput(initguess):\\n return\\n stguess = initguess.replace('\\\\n', ',')\\n # update self.parmVal\\n self.guessToParms(stguess)\\n try:\\n self.parent.app.setOverrideCursor(Qt.WaitCursor)\\n result = least_squares(self.residuals, self.parmVal, bounds=self.bounds,\\n args=(self.data[1], self.data[0]))\\n self.parent.app.restoreOverrideCursor()\\n except ValueError as err:\\n errmsg = \\\"Fitting process failure:\\\\n{0}\\\".format(err)\\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\\n return\\n RMSE = np.sqrt(np.sum(np.square(result.fun)) / len(self.data[1]))\\n msg = \\\"Initial guess : \\\\n{0}\\\\n\\\".format(initguess)\\n msg += \\\"Number of peaks = {0:d}\\\\n\\\".format(self.npeaks)\\n logmsg = msg + 'Fitting results:\\\\n'\\n res = np.reshape(result.x, (self.npeaks, self.maxparm))\\n strres = self.resToStr(res)\\n logmsg += '[xm, amp, fwhm, asym, m] = \\\\n{0}\\\\n'.format(strres)\\n rmsemsg = 'RMSE = {0:g}\\\\n\\\\n'.format(RMSE)\\n msg += rmsemsg\\n logmsg += rmsemsg\\n self.parmVal = result.x\\n\\n # Show results in log windows\\n self.log.setText(msg)\\n self.log.moveCursor(QtGui.QTextCursor.End)\\n self.saveToLogFile(logmsg)\\n self.data[2] = self.fitfunc(self.data[0], result.x)\\n self.data[3] = self.data[2] - self.data[1] - self.diffshift\\n\\n self.updatePlot()\\n self.updateParmsEdit()\",\n \"def cross_validation_visualization(lambds, score_tr, score_te):\\n plt.semilogx(lambds, score_tr, marker=\\\".\\\", color='b', label='train score');\\n plt.semilogx(lambds, score_te, marker=\\\".\\\", color='r', label='test score');\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"score\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_test\\\")\",\n \"def plot_spectrumxichange(self):\\n countgood = 0 ; countbad = 0\\n for idata in self.datarg:\\n if idata[-1, 0] == 1.: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'b') \\n countgood += 1\\n print countgood , 'good solution'\\n else: \\n self.fig.axes[0].plot(idata[0:,0], idata[0: ,1] ,'r') \\n print countbad, 'bad solution'\\n countbad += 1\\n print 'We found %g good solutions and %g tda startdistributions that broke down before xi = 1, we hope that\\\\'s what you expected' %(countgood,countbad)\\n #Create custom artistsr[goodline,badline],['solution','breakdown']\\n goodline = pl.Line2D((0,1),(0,0), color='b') \\n badline = pl.Line2D((0,1),(0,0), color='r')\\n self.layout(self.reader.depvar['depvar'] , r'energy spectrum (a.u.)' , tit = r'All tda start distributions $\\\\xi$' , legendhand = [goodline , badline] , legendlab = ['solution', 'breakdown'] )\\n self.savefig('xispec')\",\n \"def diagnose(self):\\n return self._diagnostic_plot()\",\n \"def residual_vs_actual(\\n y_true: ArrayLike | str,\\n y_pred: ArrayLike | str,\\n df: pd.DataFrame | None = None,\\n ax: plt.Axes | None = None,\\n xlabel: str = r\\\"Actual value\\\",\\n ylabel: str = r\\\"Residual ($y_\\\\mathrm{true} - y_\\\\mathrm{pred}$)\\\",\\n **kwargs: Any,\\n) -> plt.Axes:\\n y_true, y_pred = df_to_arrays(df, y_true, y_pred)\\n assert isinstance(y_true, np.ndarray)\\n assert isinstance(y_pred, np.ndarray)\\n ax = ax or plt.gca()\\n\\n y_err = y_true - y_pred\\n\\n ax.plot(y_true, y_err, \\\"o\\\", alpha=0.5, label=None, mew=1.2, ms=5.2, **kwargs)\\n ax.axline(\\n [1, 0], [2, 0], linestyle=\\\"dashed\\\", color=\\\"black\\\", alpha=0.5, label=\\\"ideal\\\"\\n )\\n\\n ax.set(xlabel=xlabel, ylabel=ylabel)\\n ax.legend(loc=\\\"lower right\\\")\\n\\n return ax\",\n \"def eval_classifier(clf, X, y_correct, classes, plot_cm=True):\\n y_pred = clf.predict(X)\\n return get_accuracy_and_plot_confusion(y_correct, list(y_pred), classes, plot=plot_cm)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64745706","0.608616","0.60614175","0.6035531","0.58973026","0.5857323","0.5814659","0.5783457","0.57566994","0.5703762","0.5695166","0.56862897","0.565359","0.5642672","0.563932","0.5626169","0.5618816","0.5592678","0.5582807","0.5553929","0.555223","0.55493087","0.5547401","0.55418694","0.5537556","0.5518902","0.5482982","0.54750395","0.54677445","0.545783","0.5441279","0.5440747","0.54380274","0.5437051","0.54288936","0.5411604","0.5406179","0.5402073","0.53926903","0.53886604","0.53094506","0.5301336","0.5296608","0.5292991","0.5278967","0.52770174","0.52759236","0.5263119","0.5255967","0.5255666","0.5246936","0.5233588","0.5231803","0.5228872","0.52276266","0.5225481","0.5224835","0.52156943","0.5212242","0.5212242","0.51986223","0.5192945","0.5186527","0.51814854","0.51684415","0.51663977","0.5166123","0.51630044","0.5151505","0.51488465","0.51481825","0.5143279","0.5142206","0.51352906","0.5133545","0.51329005","0.51228595","0.5114236","0.5105969","0.5101264","0.5100215","0.50971115","0.50922185","0.5081753","0.5072231","0.5072219","0.5068585","0.5059861","0.5059155","0.5058479","0.50565284","0.50538903","0.5050526","0.5050357","0.50475144","0.5043964","0.5043552","0.5043397","0.5039517","0.50393486"],"string":"[\n \"0.64745706\",\n \"0.608616\",\n \"0.60614175\",\n \"0.6035531\",\n \"0.58973026\",\n \"0.5857323\",\n \"0.5814659\",\n \"0.5783457\",\n \"0.57566994\",\n \"0.5703762\",\n \"0.5695166\",\n \"0.56862897\",\n \"0.565359\",\n \"0.5642672\",\n \"0.563932\",\n \"0.5626169\",\n \"0.5618816\",\n \"0.5592678\",\n \"0.5582807\",\n \"0.5553929\",\n \"0.555223\",\n \"0.55493087\",\n \"0.5547401\",\n \"0.55418694\",\n \"0.5537556\",\n \"0.5518902\",\n \"0.5482982\",\n \"0.54750395\",\n \"0.54677445\",\n \"0.545783\",\n \"0.5441279\",\n \"0.5440747\",\n \"0.54380274\",\n \"0.5437051\",\n \"0.54288936\",\n \"0.5411604\",\n \"0.5406179\",\n \"0.5402073\",\n \"0.53926903\",\n \"0.53886604\",\n \"0.53094506\",\n \"0.5301336\",\n \"0.5296608\",\n \"0.5292991\",\n \"0.5278967\",\n \"0.52770174\",\n \"0.52759236\",\n \"0.5263119\",\n \"0.5255967\",\n \"0.5255666\",\n \"0.5246936\",\n \"0.5233588\",\n \"0.5231803\",\n \"0.5228872\",\n \"0.52276266\",\n \"0.5225481\",\n \"0.5224835\",\n \"0.52156943\",\n \"0.5212242\",\n \"0.5212242\",\n \"0.51986223\",\n \"0.5192945\",\n \"0.5186527\",\n \"0.51814854\",\n \"0.51684415\",\n \"0.51663977\",\n \"0.5166123\",\n \"0.51630044\",\n \"0.5151505\",\n \"0.51488465\",\n \"0.51481825\",\n \"0.5143279\",\n \"0.5142206\",\n \"0.51352906\",\n \"0.5133545\",\n \"0.51329005\",\n \"0.51228595\",\n \"0.5114236\",\n \"0.5105969\",\n \"0.5101264\",\n \"0.5100215\",\n \"0.50971115\",\n \"0.50922185\",\n \"0.5081753\",\n \"0.5072231\",\n \"0.5072219\",\n \"0.5068585\",\n \"0.5059861\",\n \"0.5059155\",\n \"0.5058479\",\n \"0.50565284\",\n \"0.50538903\",\n \"0.5050526\",\n \"0.5050357\",\n \"0.50475144\",\n \"0.5043964\",\n \"0.5043552\",\n \"0.5043397\",\n \"0.5039517\",\n \"0.50393486\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5709493"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":20282,"cells":{"query":{"kind":"string","value":"Returns where the arm end effector should be at time t"},"document":{"kind":"string","value":"def target_position(self, time):\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0","def end_time(self) -> float:\r\n ...","def endTime(self):\n return self.params['tend']","def get_last(t_, w_):\n return t_ - tf.constant(1)","def end(self):\n return self._t0 + self.length","def getEndTime(self):\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)","def end_effectors_pos(self):\n def relative_pos_in_egocentric_frame(physics):\n end_effector = physics.bind(self._entity.end_effectors).xpos\n torso = physics.bind(self._entity.root_body).xpos\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\n return observable.Generic(relative_pos_in_egocentric_frame)","def est_am(t,y):\n ch=t>t_eq\n y1=y[ch]\n return y1[-1]-y1[0]","def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\n\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\n naturalLog = np.log(numeratorLN/denomLN)\n\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\n brackets = F - Fp + product1\n\n product2 = (1/Ks)*brackets\n time = tp + product2 - endingTime\n return time","def getEndTime(self):\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)","def find_exit_time(self):\n \n # check when last bead starts moving\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\n nonzero = np.flatnonzero( vel_last_bead )\n \n if nonzero.size == 0:\n warnings.warn('The wave did not exit the chain or it could not be determined.')\n return np.nan\n else:\n exit_index = np.min( nonzero )\n time = self.get_time()\n exit_time = time[exit_index]\n return exit_time","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)","def timeofflight(xhat0):\n\t\timport poincare\n\t\t#Find the point on the computed poincare section, closest to the x0\n\t\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\n\t\t#Take its time of flight as\n\t\tif imin < np.size(ps,0)-1: \n\t\t\tTapproximate = ps[imin+1,0]-ps[imin,0]\n\t\telse:\n\t\t\tTapproximate = ps[imin,0]-ps[imin-1,0]\n\t\tprint(\"Tapproximate:\")\n\t\tprint(Tapproximate)\n\t\t#Integrate for a little bit longer than the approximated integration time:\n\t\tstoptime = 1.2*Tapproximate\n\t\tnumpoints = int(stoptime/0.01)\n\t\t#Integration time array:\n\t\tt = np.linspace(0, stoptime, numpoints)\n\t\txhatphi0 = np.append(xhat0, np.array([0], float))\n\t\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\n\t\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\n\t\t#Compute Poincare section:\n\t\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\n\t\tprint(\"psreturn:\")\n\t\tprint(psreturn)\n\t\t#Take the time nearest to the approximated time. This is due to the\n\t\t#fact that the array ps sometimes includes the initial point and sometimes\n\t\t#does not, hence we are not always sure the position of the first return.\n\t\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\n\t\ttof = psreturn[itof,0]\n\t\treturn tof","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def get_delta_t(self):\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\n - self.gv.t_queue[self.gv.filter_min_bound]","def at(self, t):\n return self.start + (self.end - self.start) * t","def end_time(self):\n pass","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def end_time(self):\n # TODO: use pd.Timestamp instead\n return self.time[-1].to_pydatetime()","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def get_trace_abs(self, norm=True):\n if self.Et is not None:\n # Center peak in time\n ind = np.argmax(abs(self.Et))\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\n Et = np.abs(np.roll(self.Et, shift))\n if norm is True:\n Et /= Et.max()\n else:\n Et = None\n return Et","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def _dy(self, T):\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])","def end_point(self) -> Vec3:\n v = list(self.vertices([self.dxf.end_angle]))\n return v[0]","def _reached_temperature_end_point(self, T, Tend):\n if Tend is None:\n # End point not give\n return False\n\n if self._integration_direction == \"increasing\":\n if T > Tend:\n return True\n elif self._integration_direction == \"decreasing\":\n if T < Tend:\n return True\n return False","def end_time(self, t):\r\n # Increase temperature while silent.\r\n if np.count_nonzero(self.next_note) == 0:\r\n self.silent_time += 1\r\n if self.silent_time >= NOTES_PER_BAR:\r\n self.temperature += 0.1\r\n else:\r\n self.silent_time = 0\r\n self.temperature = self.default_temp\r\n \r\n self.notes_memory.append(self.next_note)\r\n # Consistent with dataset representation\r\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\r\n self.results.append(self.next_note)\r\n # Reset next note\r\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\r\n return self.results[-1]","def find_alert_time(self) -> None:\n \n # Also not clear from the paper how to doe this,\n # use the first 10 data points in the light curve to determine the magnitude\n # baseline\n\n mean_mag = np.mean(self.mags[:10])\n std_mag = np.std(self.mags[:10])\n\n num_above = 0 \n i = 9\n\n while num_above < 3 and i < len(self.times)-1:\n \n i += 1 \n\n if self.mags[i] < mean_mag - std_mag:\n num_above += 1\n else:\n num_above = 0.0\n\n if len(self.times) - 1 == i:\n print(\"Give me more training data, not alerted yet, this is probably going to fail\")\n \n return self.times[i-1]","def eval(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[:len(res)//2]","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def getEndTime(self):\n return _osgAnimation.Channel_getEndTime(self)","def line_segment(t, # Array of times for each position\n t_now # Current time (float)\n ):\n i = np.argwhere(t > t_now)\n if len(i) > 0:\n if i[0] != 0: # if the current time is not less than the starting time\n segment_starting_index = i[0][0] - 1\n else:\n segment_starting_index = 0\n\n segment_end_index = i[0][0]\n\n else: # if the current time is more than the last point (destination) time\n segment_starting_index = t.shape[0]\n segment_end_index = t.shape[0]\n\n return segment_starting_index, segment_end_index","def end_abs(self):\n if self.end == float('inf'):\n return self.track.duration\n else:\n return self.end","def time_step(self):\n\n rho_rel = np.abs(self.rho_dt / self.rho)\n rho_rel_max = np.max(rho_rel)\n e_rel = np.abs(self.e_dt / self.e)\n e_rel_max = np.max(e_rel)\n x_rel = np.abs(self.u / self.dx)\n x_rel_max = np.max(x_rel)\n y_rel = np.abs(self.w / self.dy)\n y_rel_max = np.max(y_rel)\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\n delta = np.max(np.abs(rel))\n\n if 0.1 <= delta <= 1e3:\n self.dt = self.p / delta\n else:\n self.dt = self.p","def end_time(self):\n return RPR.GetAudioAccessorEndTime(self.id)","def run_e(self, t):\n if t > self.n_t:\n raise IndexError('Maximum simulated timesteps exceeded in E step')\n if self.pf.t >= t:\n raise IndexError(\n 'Particle filter already run past given time point')\n while self.pf.t < t:\n self.pf.advance()\n self.pf.calculate_means_sdevs()\n\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))","def end_of_horizon_cost_rule(_m):\r\n\r\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\r\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\r","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def end(self):\r\n hours = self.length // 60\r\n minutes = self.length % 60\r\n return time(self.start.hour + hours, self.start.minute + minutes)","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def get_end(self):\n\n return self.end_cycle","def _get_end_time(self):\n return self.__end_time","def get_end(self):\n return self._start + self._duration","def diff(t, y):\n origin = root.vectorize()\n root.tensorize(y)\n self.time = t if not imaginary else None\n self.eom()\n ans = root.vectorize(use_aux=True)\n root.tensorize(origin)\n return ans","def inc_end(self):\n return self._exc_end - TIMERANGE_PRECISION","def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\n i,u = self.getSegment(t,endBehavior)\n if i<0: return self.milestones[0]\n elif i+1>=len(self.milestones): return self.milestones[-1]\n #linear interpolate between milestones[i] and milestones[i+1]\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])","def eval(self,t,endBehavior='halt'):\n self._skip_deriv = True\n res = Trajectory.eval_state(self,t,endBehavior)\n self._skip_deriv = False\n return res[:len(res)//2]","def timeEnd(self)->datetime:\n if self._scenario == LM_HardDate.Scenario.ValidSince:\n raise SdkError(\"timeEnd not defined for scenario 'ValidSince'\")\n\n return self._lic.params['timeEnd'].value","def evap(self, lai, tl, ta, qa):#average ta and tl!!\n\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\n\t\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \n\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\n\t return 0.\n\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\n\t return (self.tx*self.ZT*self.TAI*10**6/dt)\n\t else:\n\t return fsev","def get_end(self):\n return self.start + timedelta(minutes=self.duration)","def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to the array\n\t\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\n\t\tdUdt = dUdt + self.getHeatFlux(temperature)\n\t\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\n\t\treturn numpy.append(dNdt,dTdt)","def time_end(self):\n return self._time_end","def tLoss(self, dt, qt, tl, ta, qa):\n\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def after(self, time: float) -> 'Trajectory':\n return self.split(time)[1]","def lerp(self, t):\n pass","def set_T_lm(self):\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) )","def end_time(self):\n return from_ts(self.end_time_ms)","def elapsed_raw(self, start=\"__enter__\", end=\"__exit__\"):\n return self.laps[end] - self.laps[start]","def get_vehicle_end_index(self):\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def cal_end(self):\n return self.datetime_end","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def update(self, tfinal):\n t = 0; kk = 0\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\n self.omega = np.zeros((nstep,self.npts))\n self.theta = np.zeros((nstep,self.npts))\n\n while t <(tfinal+1e-10):\n self.return_map()\n self.omega[kk] = self.y[0]\n self.theta[kk] = self.y[1]\n\n self.y = RK4(self.y, self.dt, t, self.deri)\n kk += 1; t += self.dt\n\n return self","def get_terminating_ray(self):\n return self._terminating_ray","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def end_time(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"end_time\")","def get_current_ee_pose(self):\n #self.arm_endpoint = #magic tf call that I can add\n while True:\n try:\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\n break # once the transform is obtained move on\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\n continue # if it fails try again\n point = [translation[0], translation[1], translation[2]]\n self.arm_endpoint = np.array(point)\n # rospy.logerr(self.arm_endpoint)","def o(r, t):\n return r/t**0.5","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def roty(self, t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s],\n [0, 1, 0],\n [-s, 0, c]])","def getEnd(self) -> long:\n ...","def trapezoid(t, params):\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n\n envelope = tf.ones_like(t, dtype=tf.float64)\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\n return envelope","def _get_end(self):\n return self._end","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def ricker(dt, pt):\n nt = int(2 * pt / dt)\n c = np.zeros(nt)\n t0 = pt / dt\n a_ricker = 4 / pt\n\n for it in range(0, nt):\n t = ((it + 1) - t0) * dt\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\n\n return c","def end_time(self):\n return self.time_parser.end_time","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def horde_end(self):","def roty(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])","def out(self, t: any, dim=(None, None)) -> any:\n lB = self.interval[0] # Lower Boundary\n uB = self.interval[1] # Upper Boundary\n # Initialize random step vector each sampling period using comprehensive list.\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\n step_vector[0] = self.ss # keep the steady state value as first\n u = np.zeros(shape=dim) # Initialize step control input array u.\n j = 0\n\n ramp_Step = self.saw_time\n count = 1\n for i in range(len(t)): # Excluding the last point\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\n j += 1\n count = 1\n\n if self.ss is not None and j == 0:\n u[i, :] = self.ss\n else:\n if count != ramp_Step:\n\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\n count += 1\n else:\n u[i, :] = step_vector[j]\n return u","def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\n dT = self.deriv(t,endBehavior)\n return so3.deskew(dT[0])+dT[1]","def getETA():","def getETA():"],"string":"[\n \"def endTime(self) -> float:\\n try: return self.times[-1]\\n except IndexError: return 0.0\",\n \"def end_time(self) -> float:\\r\\n ...\",\n \"def endTime(self):\\n return self.params['tend']\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def end(self):\\n return self._t0 + self.length\",\n \"def getEndTime(self):\\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)\",\n \"def end_effectors_pos(self):\\n def relative_pos_in_egocentric_frame(physics):\\n end_effector = physics.bind(self._entity.end_effectors).xpos\\n torso = physics.bind(self._entity.root_body).xpos\\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\\n return observable.Generic(relative_pos_in_egocentric_frame)\",\n \"def est_am(t,y):\\n ch=t>t_eq\\n y1=y[ch]\\n return y1[-1]-y1[0]\",\n \"def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\\n\\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\\n naturalLog = np.log(numeratorLN/denomLN)\\n\\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\\n brackets = F - Fp + product1\\n\\n product2 = (1/Ks)*brackets\\n time = tp + product2 - endingTime\\n return time\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)\",\n \"def find_exit_time(self):\\n \\n # check when last bead starts moving\\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\\n nonzero = np.flatnonzero( vel_last_bead )\\n \\n if nonzero.size == 0:\\n warnings.warn('The wave did not exit the chain or it could not be determined.')\\n return np.nan\\n else:\\n exit_index = np.min( nonzero )\\n time = self.get_time()\\n exit_time = time[exit_index]\\n return exit_time\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)\",\n \"def timeofflight(xhat0):\\n\\t\\timport poincare\\n\\t\\t#Find the point on the computed poincare section, closest to the x0\\n\\t\\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\\n\\t\\t#Take its time of flight as\\n\\t\\tif imin < np.size(ps,0)-1: \\n\\t\\t\\tTapproximate = ps[imin+1,0]-ps[imin,0]\\n\\t\\telse:\\n\\t\\t\\tTapproximate = ps[imin,0]-ps[imin-1,0]\\n\\t\\tprint(\\\"Tapproximate:\\\")\\n\\t\\tprint(Tapproximate)\\n\\t\\t#Integrate for a little bit longer than the approximated integration time:\\n\\t\\tstoptime = 1.2*Tapproximate\\n\\t\\tnumpoints = int(stoptime/0.01)\\n\\t\\t#Integration time array:\\n\\t\\tt = np.linspace(0, stoptime, numpoints)\\n\\t\\txhatphi0 = np.append(xhat0, np.array([0], float))\\n\\t\\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\\n\\t\\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\\n\\t\\t#Compute Poincare section:\\n\\t\\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\\n\\t\\tprint(\\\"psreturn:\\\")\\n\\t\\tprint(psreturn)\\n\\t\\t#Take the time nearest to the approximated time. This is due to the\\n\\t\\t#fact that the array ps sometimes includes the initial point and sometimes\\n\\t\\t#does not, hence we are not always sure the position of the first return.\\n\\t\\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\\n\\t\\ttof = psreturn[itof,0]\\n\\t\\treturn tof\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def get_delta_t(self):\\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\\\\n - self.gv.t_queue[self.gv.filter_min_bound]\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def end_time(self):\\n pass\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def end_time(self):\\n # TODO: use pd.Timestamp instead\\n return self.time[-1].to_pydatetime()\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def get_trace_abs(self, norm=True):\\n if self.Et is not None:\\n # Center peak in time\\n ind = np.argmax(abs(self.Et))\\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\\n Et = np.abs(np.roll(self.Et, shift))\\n if norm is True:\\n Et /= Et.max()\\n else:\\n Et = None\\n return Et\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def _dy(self, T):\\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])\",\n \"def end_point(self) -> Vec3:\\n v = list(self.vertices([self.dxf.end_angle]))\\n return v[0]\",\n \"def _reached_temperature_end_point(self, T, Tend):\\n if Tend is None:\\n # End point not give\\n return False\\n\\n if self._integration_direction == \\\"increasing\\\":\\n if T > Tend:\\n return True\\n elif self._integration_direction == \\\"decreasing\\\":\\n if T < Tend:\\n return True\\n return False\",\n \"def end_time(self, t):\\r\\n # Increase temperature while silent.\\r\\n if np.count_nonzero(self.next_note) == 0:\\r\\n self.silent_time += 1\\r\\n if self.silent_time >= NOTES_PER_BAR:\\r\\n self.temperature += 0.1\\r\\n else:\\r\\n self.silent_time = 0\\r\\n self.temperature = self.default_temp\\r\\n \\r\\n self.notes_memory.append(self.next_note)\\r\\n # Consistent with dataset representation\\r\\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\\r\\n self.results.append(self.next_note)\\r\\n # Reset next note\\r\\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\\r\\n return self.results[-1]\",\n \"def find_alert_time(self) -> None:\\n \\n # Also not clear from the paper how to doe this,\\n # use the first 10 data points in the light curve to determine the magnitude\\n # baseline\\n\\n mean_mag = np.mean(self.mags[:10])\\n std_mag = np.std(self.mags[:10])\\n\\n num_above = 0 \\n i = 9\\n\\n while num_above < 3 and i < len(self.times)-1:\\n \\n i += 1 \\n\\n if self.mags[i] < mean_mag - std_mag:\\n num_above += 1\\n else:\\n num_above = 0.0\\n\\n if len(self.times) - 1 == i:\\n print(\\\"Give me more training data, not alerted yet, this is probably going to fail\\\")\\n \\n return self.times[i-1]\",\n \"def eval(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[:len(res)//2]\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def getEndTime(self):\\n return _osgAnimation.Channel_getEndTime(self)\",\n \"def line_segment(t, # Array of times for each position\\n t_now # Current time (float)\\n ):\\n i = np.argwhere(t > t_now)\\n if len(i) > 0:\\n if i[0] != 0: # if the current time is not less than the starting time\\n segment_starting_index = i[0][0] - 1\\n else:\\n segment_starting_index = 0\\n\\n segment_end_index = i[0][0]\\n\\n else: # if the current time is more than the last point (destination) time\\n segment_starting_index = t.shape[0]\\n segment_end_index = t.shape[0]\\n\\n return segment_starting_index, segment_end_index\",\n \"def end_abs(self):\\n if self.end == float('inf'):\\n return self.track.duration\\n else:\\n return self.end\",\n \"def time_step(self):\\n\\n rho_rel = np.abs(self.rho_dt / self.rho)\\n rho_rel_max = np.max(rho_rel)\\n e_rel = np.abs(self.e_dt / self.e)\\n e_rel_max = np.max(e_rel)\\n x_rel = np.abs(self.u / self.dx)\\n x_rel_max = np.max(x_rel)\\n y_rel = np.abs(self.w / self.dy)\\n y_rel_max = np.max(y_rel)\\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\\n delta = np.max(np.abs(rel))\\n\\n if 0.1 <= delta <= 1e3:\\n self.dt = self.p / delta\\n else:\\n self.dt = self.p\",\n \"def end_time(self):\\n return RPR.GetAudioAccessorEndTime(self.id)\",\n \"def run_e(self, t):\\n if t > self.n_t:\\n raise IndexError('Maximum simulated timesteps exceeded in E step')\\n if self.pf.t >= t:\\n raise IndexError(\\n 'Particle filter already run past given time point')\\n while self.pf.t < t:\\n self.pf.advance()\\n self.pf.calculate_means_sdevs()\\n\\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))\",\n \"def end_of_horizon_cost_rule(_m):\\r\\n\\r\\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\\r\\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\\r\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end(self):\\r\\n hours = self.length // 60\\r\\n minutes = self.length % 60\\r\\n return time(self.start.hour + hours, self.start.minute + minutes)\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def get_end(self):\\n\\n return self.end_cycle\",\n \"def _get_end_time(self):\\n return self.__end_time\",\n \"def get_end(self):\\n return self._start + self._duration\",\n \"def diff(t, y):\\n origin = root.vectorize()\\n root.tensorize(y)\\n self.time = t if not imaginary else None\\n self.eom()\\n ans = root.vectorize(use_aux=True)\\n root.tensorize(origin)\\n return ans\",\n \"def inc_end(self):\\n return self._exc_end - TIMERANGE_PRECISION\",\n \"def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\\n i,u = self.getSegment(t,endBehavior)\\n if i<0: return self.milestones[0]\\n elif i+1>=len(self.milestones): return self.milestones[-1]\\n #linear interpolate between milestones[i] and milestones[i+1]\\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\",\n \"def eval(self,t,endBehavior='halt'):\\n self._skip_deriv = True\\n res = Trajectory.eval_state(self,t,endBehavior)\\n self._skip_deriv = False\\n return res[:len(res)//2]\",\n \"def timeEnd(self)->datetime:\\n if self._scenario == LM_HardDate.Scenario.ValidSince:\\n raise SdkError(\\\"timeEnd not defined for scenario 'ValidSince'\\\")\\n\\n return self._lic.params['timeEnd'].value\",\n \"def evap(self, lai, tl, ta, qa):#average ta and tl!!\\n\\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\\n\\t\\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \\n\\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\\n\\t return 0.\\n\\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\\n\\t return (self.tx*self.ZT*self.TAI*10**6/dt)\\n\\t else:\\n\\t return fsev\",\n \"def get_end(self):\\n return self.start + timedelta(minutes=self.duration)\",\n \"def rightSideOfODE(self, Y, t):\\n\\t\\ttemperature = Y[-1]\\n\\t\\tamounts = Y[:-1]\\n\\t\\tself.amounts = amounts\\n\\t\\t# first get the species amount changes (as an array)\\n\\t\\tdNdt = -1 * self.getMolarFluxes(temperature)\\n\\t\\t# then get the temperature change, and append it to the array\\n\\t\\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\\n\\t\\tdUdt = dUdt + self.getHeatFlux(temperature)\\n\\t\\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\\n\\t\\treturn numpy.append(dNdt,dTdt)\",\n \"def time_end(self):\\n return self._time_end\",\n \"def tLoss(self, dt, qt, tl, ta, qa):\\n\\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def after(self, time: float) -> 'Trajectory':\\n return self.split(time)[1]\",\n \"def lerp(self, t):\\n pass\",\n \"def set_T_lm(self):\\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) )\",\n \"def end_time(self):\\n return from_ts(self.end_time_ms)\",\n \"def elapsed_raw(self, start=\\\"__enter__\\\", end=\\\"__exit__\\\"):\\n return self.laps[end] - self.laps[start]\",\n \"def get_vehicle_end_index(self):\\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def cal_end(self):\\n return self.datetime_end\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def update(self, tfinal):\\n t = 0; kk = 0\\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\\n self.omega = np.zeros((nstep,self.npts))\\n self.theta = np.zeros((nstep,self.npts))\\n\\n while t <(tfinal+1e-10):\\n self.return_map()\\n self.omega[kk] = self.y[0]\\n self.theta[kk] = self.y[1]\\n\\n self.y = RK4(self.y, self.dt, t, self.deri)\\n kk += 1; t += self.dt\\n\\n return self\",\n \"def get_terminating_ray(self):\\n return self._terminating_ray\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end_time(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def get_current_ee_pose(self):\\n #self.arm_endpoint = #magic tf call that I can add\\n while True:\\n try:\\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\\n break # once the transform is obtained move on\\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\\n continue # if it fails try again\\n point = [translation[0], translation[1], translation[2]]\\n self.arm_endpoint = np.array(point)\\n # rospy.logerr(self.arm_endpoint)\",\n \"def o(r, t):\\n return r/t**0.5\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def roty(self, t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s],\\n [0, 1, 0],\\n [-s, 0, c]])\",\n \"def getEnd(self) -> long:\\n ...\",\n \"def trapezoid(t, params):\\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n\\n envelope = tf.ones_like(t, dtype=tf.float64)\\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\\n return envelope\",\n \"def _get_end(self):\\n return self._end\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def ricker(dt, pt):\\n nt = int(2 * pt / dt)\\n c = np.zeros(nt)\\n t0 = pt / dt\\n a_ricker = 4 / pt\\n\\n for it in range(0, nt):\\n t = ((it + 1) - t0) * dt\\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\\n\\n return c\",\n \"def end_time(self):\\n return self.time_parser.end_time\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def horde_end(self):\",\n \"def roty(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])\",\n \"def out(self, t: any, dim=(None, None)) -> any:\\n lB = self.interval[0] # Lower Boundary\\n uB = self.interval[1] # Upper Boundary\\n # Initialize random step vector each sampling period using comprehensive list.\\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\\n step_vector[0] = self.ss # keep the steady state value as first\\n u = np.zeros(shape=dim) # Initialize step control input array u.\\n j = 0\\n\\n ramp_Step = self.saw_time\\n count = 1\\n for i in range(len(t)): # Excluding the last point\\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\\n j += 1\\n count = 1\\n\\n if self.ss is not None and j == 0:\\n u[i, :] = self.ss\\n else:\\n if count != ramp_Step:\\n\\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\\n count += 1\\n else:\\n u[i, :] = step_vector[j]\\n return u\",\n \"def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\\n dT = self.deriv(t,endBehavior)\\n return so3.deskew(dT[0])+dT[1]\",\n \"def getETA():\",\n \"def getETA():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6262754","0.60054207","0.59560645","0.5919242","0.59007686","0.58521706","0.5844045","0.580404","0.5791151","0.5790337","0.5788008","0.57607013","0.57595277","0.57300097","0.57146317","0.5713964","0.56925106","0.56845766","0.56776744","0.56025434","0.5577776","0.5577258","0.5561718","0.5554804","0.5550632","0.55414397","0.5509652","0.5486134","0.54807806","0.5450397","0.5448296","0.5435491","0.5428117","0.5421442","0.5420882","0.5407447","0.53956217","0.5393599","0.53911644","0.5388739","0.53826755","0.538183","0.53771454","0.5370922","0.5366723","0.53657544","0.53590137","0.5338765","0.53361785","0.5324579","0.5317156","0.5305034","0.5301146","0.52967286","0.529175","0.5290008","0.52892494","0.5269293","0.5254921","0.5254921","0.524881","0.5248734","0.52469486","0.52455217","0.5238649","0.5232238","0.5228608","0.5228394","0.52274954","0.52269995","0.52246207","0.52191484","0.5211364","0.5211364","0.52056676","0.5203241","0.52024585","0.5195268","0.5193534","0.51899034","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5184724","0.5183763","0.51775163","0.5172201","0.51709485","0.5164134","0.5155358","0.51551783","0.5154484","0.5141973","0.5139901","0.5139446","0.51381594","0.51364684","0.51364684"],"string":"[\n \"0.6262754\",\n \"0.60054207\",\n \"0.59560645\",\n \"0.5919242\",\n \"0.59007686\",\n \"0.58521706\",\n \"0.5844045\",\n \"0.580404\",\n \"0.5791151\",\n \"0.5790337\",\n \"0.5788008\",\n \"0.57607013\",\n \"0.57595277\",\n \"0.57300097\",\n \"0.57146317\",\n \"0.5713964\",\n \"0.56925106\",\n \"0.56845766\",\n \"0.56776744\",\n \"0.56025434\",\n \"0.5577776\",\n \"0.5577258\",\n \"0.5561718\",\n \"0.5554804\",\n \"0.5550632\",\n \"0.55414397\",\n \"0.5509652\",\n \"0.5486134\",\n \"0.54807806\",\n \"0.5450397\",\n \"0.5448296\",\n \"0.5435491\",\n \"0.5428117\",\n \"0.5421442\",\n \"0.5420882\",\n \"0.5407447\",\n \"0.53956217\",\n \"0.5393599\",\n \"0.53911644\",\n \"0.5388739\",\n \"0.53826755\",\n \"0.538183\",\n \"0.53771454\",\n \"0.5370922\",\n \"0.5366723\",\n \"0.53657544\",\n \"0.53590137\",\n \"0.5338765\",\n \"0.53361785\",\n \"0.5324579\",\n \"0.5317156\",\n \"0.5305034\",\n \"0.5301146\",\n \"0.52967286\",\n \"0.529175\",\n \"0.5290008\",\n \"0.52892494\",\n \"0.5269293\",\n \"0.5254921\",\n \"0.5254921\",\n \"0.524881\",\n \"0.5248734\",\n \"0.52469486\",\n \"0.52455217\",\n \"0.5238649\",\n \"0.5232238\",\n \"0.5228608\",\n \"0.5228394\",\n \"0.52274954\",\n \"0.52269995\",\n \"0.52246207\",\n \"0.52191484\",\n \"0.5211364\",\n \"0.5211364\",\n \"0.52056676\",\n \"0.5203241\",\n \"0.52024585\",\n \"0.5195268\",\n \"0.5193534\",\n \"0.51899034\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5184724\",\n \"0.5183763\",\n \"0.51775163\",\n \"0.5172201\",\n \"0.51709485\",\n \"0.5164134\",\n \"0.5155358\",\n \"0.51551783\",\n \"0.5154484\",\n \"0.5141973\",\n \"0.5139901\",\n \"0.5139446\",\n \"0.51381594\",\n \"0.51364684\",\n \"0.51364684\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20283,"cells":{"query":{"kind":"string","value":"Returns the arm's desired x,y,z velocity in workspace coordinates at time t"},"document":{"kind":"string","value":"def target_velocity(self, time):\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def get_position(self, t0):\n my_pos_x=np.random.uniform(-20, 20)\n my_pos_y=np.random.uniform(-20, 20)\n r=np.array([my_pos_x, my_pos_y])\n x_y=np.zeros(shape=(self.no_planets-1, 2))\n tol=1e-5\n diff=np.zeros(self.no_planets-1)\n for k in range(self.no_planets-1):\n r1=np.linalg.norm(r)\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\n x1=0\n y1=0\n x2=self.positionFunction(t0)[0,k]\n y2=self.positionFunction(t0)[1,k]\n x3=self.positionFunction(t0)[0,k+1]\n y3=self.positionFunction(t0)[1, k+1]\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\n x_y[k, 0]=x\n x_y[k, 1]=y\n diff[k]=difference\n if (diff > tol).any():\n print diff.max()\n print \"Oh no, one failed :(\"\n sys.exit(1)\n print \"My pos x:\", my_pos_x\n print \"My pos y:\", my_pos_y\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def _compute_solar_torque(self):\n pass","def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def get_angular_velocity(r, T):\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\n # velocity = 2(pi)r/T\n return (2*math.pi*r)/T","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def get_vsolar(self):\n return self.read_register(4098, 1, 3)","def eval_2pts(self, vector, t):\n if t < 0 or t > 1:\n raise Exception(\"Cannot Eval \", e, \" with t=\", t, \": t Should Satisfy 0<=t<=1.\")\n else:\n return Vector((1-t)*self.x + t*vector.x, (1-t)*self.y + t*vector.y, (1-t)*self.z + t*vector.z)","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def test_velocity(self):\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\n # r must contain 2 elements, otherwise the density and pressure are nan\n r = np.array([0.7, 0.8])\n t = 6.25e-6\n solrt = sol(r, t)\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)","def getVelocity(self):\n return self.v","def CalculatePosition(radius,velocity,time,dt):\n \n # Initial conditions\n theta = 0\n xini = radius * np.cos(theta)\n yini = radius * np.sin(theta)\n t = 0\n \n # Store positions and time\n xposition = [xini]\n yposition = [yini]\n storedtime = [t]\n \n # Calculate positions\n while t < time:\n t += dt\n x = radius * np.cos((velocity/radius)*t)\n y = radius * np.sin((velocity/radius)*t)\n \n xposition.append(x)\n yposition.append(y)\n storedtime.append(t)\n \n # Make an array\n xposition = np.array(xposition)\n yposition = np.array(yposition)\n storedtime = np.array(storedtime)\n \n return xposition,yposition,storedtime","def u_exact(self, t):\n\n # some abbreviations\n wE = self.params.omega_E\n wB = self.params.omega_B\n N = self.params.nparts\n u0 = self.params.u0\n\n if N != 1:\n raise ProblemError('u_exact is only valid for a single particle')\n\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\n\n wbar = np.sqrt(2) * wE\n\n # position and velocity in z direction is easy to compute\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\n\n # define temp. variables to compute complex position\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\n Rp = u0[0][0] - Rm\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\n Ip = u0[0][1] - Im\n\n # compute position in complex notation\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n # compute velocity as time derivative of the position\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n\n # get the appropriate real and imaginary parts\n u.pos[0, 0] = w.real\n u.vel[0, 0] = dw.real\n u.pos[1, 0] = w.imag\n u.vel[1, 0] = dw.imag\n\n return u","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def rhs(states, t, parameters, values=None):\n # Imports\n import numpy as np\n import math\n\n # Assign states\n assert(len(states) == 6)\n vlv, vrv, v1s, v2s, v1p, v2p = states\n\n # Assign parameters\n assert(len(parameters) == 38)\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\n twitchperiod=parameters[37]\n\n # Init return args\n if values is None:\n values = np.zeros((6,), dtype=np.float_)\n else:\n assert isinstance(values, np.ndarray) and values.shape == (6,)\n\n # Expressions for the Time varying elastance component\n t_lv = math.fmod(t, bcl)\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\n twitchperiod else 0)\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\n plv = p_epi + (-restVlv + vlv)*Elv\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\n prv = p_epi + (-restVrv + vrv)*Erv\n\n # Expressions for the Pressures and flows component\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\n rest_v1s/c1s)\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\n rest_v2s/c2s)\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\n rest_v1p/c1p)\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\n rest_v2p/c2p)\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\n q1_s = (-p2s + p1s)/R1_s\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\n q1_p = (-p2p + p1p)/R1_p\n\n # Expressions for the Ventricular volumes component\n values[0] = -qart_s + q_mit\n values[1] = -qart_p + q_tric\n\n # Expressions for the Systemic volumes component\n values[2] = -q1_s + qart_s\n values[3] = -q_tric + q1_s\n\n # Expressions for the Pulmonary volumes component\n values[4] = -q1_p + qart_p\n values[5] = -q_mit + q1_p\n\n # Return results\n return values","def target_velocity(self, s):\n # YOUR CODE HERE\n if s > self.total_length:\n s = self.total_length\n angular = np.array([0, 0 ,0])\n else:\n angular = np.array([0,0,self.targ_angular])\n\n theta = s/self.total_length*self.angle\n v_x = np.cos(theta)*self.targ_speed\n if self.left_turn:\n v_y = np.sin(theta)*self.targ_speed\n else:\n v_y = -np.sin(theta)*self.targ_speed\n \n linear = np.array([v_x, v_y, 0])\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\n \n toRet = [linear, angular]\n \n return toRet","def to_cart(self, t):\n # mean motion:\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\n # mean anomaly at t:\n M = n * (t - self.t0) + self.M0\n # print(np.fmod(M, 2*np.pi))\n # solve Kepler equation, get eccentric anomaly:\n E = self.kepler(self.e, M)\n cosE = np.cos(E)\n sinE = np.sin(E)\n # get true anomaly and distance from focus:\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\n # r = self.a*(1 - self.e*cosE)\n #\n sinw = np.sin(self.w)\n cosw = np.cos(self.w)\n sinu = sinw * cosv + cosw * sinv\n cosu = cosw * cosv - sinw * sinv\n # position\n cosNode = np.cos(self.Node)\n sinNode = np.sin(self.Node)\n cosi = np.cos(self.i)\n sini = np.sin(self.i)\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\n z = r * sinu * sini\n # velocity\n p = self.a * (1.0 - self.e ** 2)\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\n vz = z * V_1 / r + cosu * sini * V_2\n\n state = np.array([x, y, z, vx, vy, vz])\n state = np.reshape(np.asarray(state), (3, 2), 'F')\n\n return state","def robot_arm_pos(self):\n return self.sim.data.qpos[self.arm_index]","def verlet(self,t,dt,r0,r1):\r\n r2 = np.zeros([2,self.particles.size])\r\n\r\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\r\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\r\n dx = MXT - MX\r\n dx = dx\r\n\r\n dy = MYT - MY\r\n dy = dy\r\n\r\n r2 = np.square(dx)+np.square(dy)\r\n\r\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\r\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\r\n\r\n r2 = (2*r1 - r0 + np.transpose(fv(r1[0,:],r1[1,:],dx,dy,r2,t/self.dt,True,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2)) * (dt**2))\r\n #The transpose is necessary because I messed up the shapes when I did the fv function.\r\n\r\n #JV: this needs to change if we want to include particles with mass diferent than 1 (in reduced units),\r\n # in other words, diferent particles than the Argon gas\r\n\r\n return r2[0,:],r2[1,:]","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def acceleration(v,u,t):\n return ((v-u)/t)","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def target_velocity(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_velocity(path_time)","def rcm(t):\n x0 = 0 # initial position\n return np.array([\n 0,\n 0,\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\n ])","def get_acceleration(self,v,el,T_s,T_i):\n\n rad = radiation.Radiation()\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n g = rad.getGravity(el)\n\n\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\n\n Cd = .5 # Drag Coefficient\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\n\n if F_d > 0:\n F_d = F_d * self.Upsilon\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\n\n return accel","def f_2(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n # velocity equation for the ball after the bounce\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\n\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\n pyswice.furnsh_c(bskPath + ephemerisPath)\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\n position = positionVelocity[0:3] * 1000\n velocity = positionVelocity[3:6] * 1000\n pyswice.unload_c(bskPath + ephemerisPath)\n\n return position, velocity # [m], [m/s]","def slant_time(sx, sy, sz, rx, ry, rz, v):\n d = np.sqrt((rx - sx) ** 2 + (ry - sy) ** 2)\n h = rz - sz\n r = np.sqrt(d ** 2 + h ** 2)\n return r / v","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def f(r, t=np.nan):\n x, y, vx, vy = r\n rcubed = np.sqrt(x**2 + y**2)**3\n\n fx = vx #return 1st parameter\n fy = vy #return 2nd parameter\n fvx = -G*M*x/rcubed #return 3rd parameter\n fvy = -G*M*y/rcubed #return last parameter\n \n return np.array([fx, fy, fvx, fvy])","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def initial_vel(T,N,masses,dim):\r\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\r\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\r\n rand_v = rand_v - sum_v #Subtract cm-Motion\r\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\r\n T_act = 2/3*K/sc.k/N #Temperature\r\n R_scale = T/T_act #Scaling factor\r\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\r\n return v","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def move(self, t):\n if self.visible == True:\n self.x += self.vx * t\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\n\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\n self.phi = t * v_norm / self.radius\n\n glPushMatrix()\n glLoadIdentity()\n\n if v_norm > 0.0:\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\n glMultMatrixd(self.matrix)\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\n\n glPopMatrix()\n\n # Friction!!! Could do it as global parameter\n if v_norm > 0.0:\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\n\n if v_prime_norm < 0.0:\n v_prime_norm = 0.0\n\n self.vx *= v_prime_norm / v_norm\n self.vy *= v_prime_norm / v_norm\n\n return True\n # Add comment\n return False","def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\n rad = dia/2.\n tsr = rad*fabs(rot)/Vinf\n solidity = (chord*B)/rad\n\n # Translating the turbine position\n x0t = x0 - xt\n y0t = y0 - yt\n\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\n\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\n if param is None:\n loc1 = _parameterval(tsr,solidity,coef0)\n loc2 = _parameterval(tsr,solidity,coef1)\n loc3 = _parameterval(tsr,solidity,coef2)\n spr1 = _parameterval(tsr,solidity,coef3)\n spr2 = _parameterval(tsr,solidity,coef4)\n skw1 = _parameterval(tsr,solidity,coef5)\n skw2 = _parameterval(tsr,solidity,coef6)\n scl1 = _parameterval(tsr,solidity,coef7)\n scl2 = _parameterval(tsr,solidity,coef8)\n scl3 = _parameterval(tsr,solidity,coef9)\n\n else:\n # Reading in EMG distribution parameters\n loc1 = param[0]\n loc2 = param[1]\n loc3 = param[2]\n spr1 = param[3]\n spr2 = param[4]\n skw1 = param[5]\n skw2 = param[6]\n scl1 = param[7]\n scl2 = param[8]\n scl3 = param[9]\n\n ###################################\n if veltype == 'vort':\n # VORTICITY CALCULATION (NO INTEGRATION)\n if x0t < 0.:\n vel = 0.\n else:\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\n ###################################\n else:\n # Integration of the vorticity profile to calculate velocity\n if integration == 'simp':\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\n inte = 1 # Simpson's Rule\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\n\n if param is not None:\n print \"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\"\n\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\n\n if veltype == 'all':\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs*Vinf + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])\n ###################################\n elif integration == 'gskr':\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\n xbound = (scl3+5.)*dia\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\n\n if veltype == 'all':\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys/Vinf\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])/Vinf\n ###################################\n\n return vel","def shoot(self):\n e = self.energy()\n y = self.rap()\n sqrt_pt2_m2 = e / math.cosh(y)\n pz = sqrt_pt2_m2 * math.sinh(y)\n m = self.mass()\n pt = math.sqrt( sqrt_pt2_m2**2 - m**2 )\n phi = self.phi()\n px = pt * math.cos(phi);\n py = pt * math.sin(phi);\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def shoot(self):\n pt = self.pt()\n assert pt >= 0\n m = self.mass()\n assert m >= 0\n sqrt_pt2_m2 = math.sqrt( pt**2 + m**2 )\n y = self.rap()\n e = sqrt_pt2_m2 * math.cosh(y)\n pz = sqrt_pt2_m2 * math.sinh(y)\n phi = self.phi()\n px = pt * math.cos(phi);\n py = pt * math.sin(phi);\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def model(self, t):\n flux = np.zeros_like(t)\n dt = np.abs(self.timefrommidtransit(t))\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\n depth = self.traits['D']\n\n i = dt <= start\n flux[i] = depth\n i = (dt <= finish) * (dt > start)\n flux[i] = (finish - dt[i]) / (finish - start) * depth\n\n return flux","def shoot(self):\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n theta = self.theta()\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def obtain_vor_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VorticityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VorticityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VorticityZ\"][\" data\"][:, :, :])]), 0, 1)","def update(self, t, dt):\n # update boundary values\n self._apply_boundary_conditions(t,dt)\n #update current empirical wind velocity\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\n # initialise wind speed derivative arrays\n du_dt = scipy.zeros((self.nx, self.ny))\n dv_dt = scipy.zeros((self.nx, self.ny))\n # approximate spatial first derivatives with centred finite difference\n # equations for both components of wind field\n du_dx, du_dy = self._centred_first_derivs(self._u)\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\n # second derivatives with second order finite difference equations\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\n # = [sf_x-2f(x,y)] / (dx*dx)\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\n # = [sf_y-2f(x,y)] / (dy*dy)\n # second finite differences are not computed in full as the common\n # f(x,y) term in both expressions can be extracted out to reduce\n # the number of +/- operations required\n su_x, su_y = self._centred_first_sums(self._u)\n sv_x, sv_y = self._centred_first_sums(self._v)\n # use finite difference method to approximate time derivatives across\n # simulation region interior from defining PDEs\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\n self._Bx * su_x + self._By * su_y -\n self._C * self._u_int)\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\n self._Bx * sv_x + self._By * sv_y -\n self._C * self._v_int)\n # perform update with Euler integration\n self._u_int += du_dt * dt\n self._v_int += dv_dt * dt\n # update spline interpolators\n self._set_interpolators()","def vect_from_lspe_to_earth (self, vector, time):\n\n position_coord = self.lspe_coordinates (time)\n # The following code has been optimized:\n # position_vector = coord_to_pointing (position_coord)\n # angle = np.arccos (np.dot (self.spin_axis_lspe (time), position_vector))\n # and is therefore a one-line assignment: \n angle = np.pi * 0.5 - position_coord[0]\n rot_axis = np.array ([-np.sin (position_coord[1]),\n np.cos (position_coord[1]),\n 0])\n\n return rotate (vector, angle, rot_axis)","def solver_parachute(T, dt, v0, tp, Cd, rho, A, m):\n \n # Mesh initialization\n v = []; v.append(v0); t=[]; t.append(0);\n x = []; x.append(3000.)\n \n def X(t):\n return -9.81\n def Y(t):\n return Cd*rho*A/(2.*m)\n \n # Simulate the same way as solver() untill time tp\n while t[-1]<=tp:\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Y))\n x.append(x[-1] + dt*v[-1])\n t.append(t[-1] + dt)\n \n # Z is the same as the function Y, but with different values\n def Z(t):\n return 1.8*1.0*44./(2.*m)\n \n # Continue the simulation untill the skydiver hits the ground\n while x[-1] > 0:\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Z))\n x.append(x[-1] + dt*v[-1])\n t.append(t[-1] + dt)\n return v, t, x","def execute(self, state, dt):\n \n # The goal:\n theta_g = state.goal*math.pi/180\n \n # The robot:\n \n x_r, y_r, theta = state.pose\n # print(\"current Robot pose: ({}, {}, {})\".format(x_r, y_r, theta), file=sys.stderr)\n \n # 1. Calculate simple proportional error\n error = (theta_g - theta + math.pi)%(2*math.pi) - math.pi\n # print(\"current err: ({})\".format(error), file=sys.stderr)\n \n # 2. Calculate desired omega\n w_ = self.kp*error\n \n # 3. The linear velocity is given to us:\n v_ = state.velocity\n # print(\"current v, w: ({}, {})\".format(v_, w_), file=sys.stderr)\n \n\n return [v_, w_]","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def get_velocity(self):\n return self.momentum/self.mass","def compute_observation(self):\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\n robotEuler = p.getEulerFromQuaternion(robotOrn)\n linear, angular = p.getBaseVelocity(self.botId)\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))","def update_rk3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n try:\n\n kap1 = (self.vel, self.force(self.pos,\n self.vel,\n self.time))\n\n pos = self.pos+0.5*delta_t*kap1[0]\n vel = self.vel+0.5*delta_t*kap1[1]\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n 0.5*delta_t, drag=False)\n\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\n\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\n\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n except Collision.CollisionException as col:\n col.vel = self.vel+col.delta_t*kap1[0]\n raise col\n\n self.time += self.delta_t","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def parameters(self, t):\n if self.fixed_params:\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\n self.Qs[:, :, 0], self.Rs[:, :, 0])\n\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])","def vector_3D(pt1, pt2, t):\n x1, y1, z1 = pt1\n x2, y2, z2 = pt2\n \n modulus = np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2 + (z1 - z2) ** 2)\n \n x = x1 + (x2 - x1) / modulus * t\n y = y1 + (y2 - y1) / modulus * t\n z = z1 + (z2 - z1) / modulus * t\n \n return [x, y, z]","def driftRHS(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.linalg.norm(f)\n f = f/fs\n return -f*drift_velocity(fs)","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def solver(T, dt, v0, Cd, rho, A, m, Source=None):\n a = Cd*rho*A/(2*m) # Set up the constant a for compact code\n v = zeros(int(T/dt) + 1) # Create the velocity mesh\n v[0] = v0; g = 9.81;#Initial velocity and the value of gravity acceleration\n \n # Description of the functions X(t) and Y(t) is given in the PDF file\n def X(t): \n if(Source == None):\n return -g\n else:\n return -g + Source(t+dt/2.)/m\n \n def Y(t):\n return a\n \n #Calculate the velocity at each meshpoint\n for i in range(1,len(v)):\n v[i] = skydiving_iterate(v[i-1], dt*(i-1), dt, X, Y)\n return v, linspace(0, T, T/dt +1)","def get_trajectory(h, launch_speed, launch_angle):\n\n v0 = launch_speed\n theta = mp.radians(launch_angle)\n\n N = 100000\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\n tr = np.empty((N,2))\n v = np.empty((N,2))\n # Initial rocket position, velocity and acceleration\n tr[0] = 0, R + h\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\n a = calc_a(tr[0])\n\n for i, t in enumerate(tgrid[1:]):\n # Calculate the rocket's next position based on its instantaneous velocity.\n \n r = tr[i] + v[i] * dt \n \n if np.hypot(*r) < R:\n # Our rocket crashed.\n break\n # Update the rocket's position, velocity and acceleration.\n tr[i+1] = r\n v[i+1] = v[i] + a*dt\n a = calc_a(tr[i+1])\n return tr[:i+1]","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def _position_and_velocity(self, jd):\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\n self.elevation.au, jd.gast)\n pos = einsum('ij...,j...->i...', jd.MT, pos)\n vel = einsum('ij...,j...->i...', jd.MT, vel)\n return pos, vel","def verlet_next_pos(pos_t,vel_t,accel_t,dt):\n pos_t_plus_dt = pos_t.copy()\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \n\n return pos_t_plus_dt","def LeapFrog(self,r,v,dt):\n\n rhalf = r + np.asarray(v)*(dt/2) #Taking a half step forward with positional vector\n # predict the final velocity at the next timestep using the acceleration field at the rhalf position \n vnew = v + self.M31Accel(rhalf)*dt\n # predict the final position using the average of the current velocity and the final velocity\n rnew = r + 0.5*(v+vnew)*dt\n \n return rnew,vnew","def shoot(self):\n theta = self.theta()\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def get_camera_observation(self, t):\n if not self.enable_cameras:\n warnings.warn(\n \"Cameras are not enabled, so images in the camera observation\"\n \" are not initialized. Create `TriFingerPlatform` with\"\n \" `enable_cameras=True` to get rendered camera images.\"\n )\n\n current_t = self.simfinger._t\n\n if t < 0:\n raise ValueError(\"Cannot access time index less than zero.\")\n elif t == current_t:\n return self._camera_observation_t\n elif t == current_t + 1:\n return self._get_current_camera_observation(t)\n else:\n raise ValueError(\n \"Given time index t has to match with index of the current\"\n \" step or the next one.\"\n )","def get_velocity_vortex(strength, xv, yv, X, Y):\r\n u = +strength / (2 * math.pi) * (Y - yv) / ((X - xv)**2 + (Y - yv)**2)\r\n v = -strength / (2 * math.pi) * (X - xv) / ((X - xv)**2 + (Y - yv)**2)\r\n \r\n return u, v","def state(self, t):\n return self.mus[:, :, t + 1], self.Vs[:, :, t + 1]","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def compute_vel(self, state, goal):\n\n \"\"\"\n Unicycle model control law:\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\n v = commanded linear velocity of robot\n w = commanded rotational velcoity of robot\n kp = gain parameter where kp > 0\n ka = gain parameter where ka - kp > 0\n kb = gain parameter where kb < 0\n p = distance from robot to goal\n a = angle between current robot heading and heading to goal\n b = error between current heading to goal and target end heading\n \"\"\"\n \n #print('state,goal,v,w')\n #print(state)\n #print(goal)\n\n xr = state[0][0] # m in world frame\n yr = state[1][0] # m in world frame\n thetar = state[2][0] #rads\n\n xg = goal[0] # m in world frame\n yg = goal[1] # m in world frame\n\n dy = yg - yr\n dx = xg - xr\n\n #print('')\n #print(state)\n #print(goal)\n \n # Calculate a\n a = -1*thetar + math.atan2(dy,dx)\n\n #print(a)\n\n if a > math.pi:\n a = a - 2*math.pi\n\n if a < -1*math.pi:\n a = a + 2*math.pi\n\n #print(a)\n\n # Set omega according to control law\n omega = self.ka*a\n if math.fabs(omega) > self.MAX_OMEGA:\n if omega > 0:\n omega = self.MAX_OMEGA\n else:\n omega = -1*self.MAX_OMEGA\n\n # Calculate P\n p = math.sqrt(dy*dy + dx*dx)\n\n # Set v \n v = self.kp*p\n if v > self.MAX_SPEED:\n v = self.MAX_SPEED\n\n # set the done value\n done = (p <= self.done_distance)\n\n #print(v)\n #print(omega)\n\n out_tuple = (v, omega, done)\n \n return out_tuple","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def __init__(self, mass, radius, position, velocity):\n self.mass = mass\n self.radius = radius\n self.position = position\n self.velocity = velocity\n print(self.velocity)\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\n self.delete = False","def position(t):\n return c + tangent_vec * 7 * t ** 2","def target_velocity(self, s):\n if s > self.total_length:\n linear = np.array([0,0,0])\n else:\n linear = np.array([self.sign*self.targ_speed, 0, 0])\n \n angular = np.array([0,0,0])\n toRet = [linear, angular]\n\n return toRet","def derivative(r, t, G=6.67e-11, AU=1.496e+11,\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n if G < 0:\n print(f\"The gravitational constant is negative\")\n\n if AU < 0:\n print(f\"The Astronomical unit is negative\")\n\n if m1 < 0:\n print(f\"The mass of the first body is negative\")\n\n if m2 < 0:\n print(f\"The mass of the second body is negative\")\n\n if m3 < 0:\n print(f\"The mass of the third body is negative\")\n\n if a1 < 0:\n print(f\"The distance of body 1 from the body center is negative\")\n\n if a2 < 0:\n print(f\"The distance of body 2 from the body center is negative\")\n\n x1 = r[0]\n y1 = r[1]\n v_x1 = r[2]\n v_y1 = r[3]\n\n x2 = r[4]\n y2 = r[5]\n v_x2 = r[6]\n v_y2 = r[7]\n\n x3 = r[8]\n y3 = r[9]\n v_x3 = r[10]\n v_y3 = r[11]\n\n z1 = r[12]\n z2 = r[13]\n z3 = r[14]\n\n v_z1 = r[15]\n v_z2 = r[16]\n v_z3 = r[17]\n\n r1 = np.array([x1, y1, z1])\n r2 = np.array([x2, y2, z2])\n r3 = np.array([x3, y3, z3])\n\n dr1 = v_x1\n dr2 = v_y1\n\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\n\n dr5 = v_x2\n dr6 = v_y2\n\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\n\n dr9 = v_x3\n dr10 = v_y3\n\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\n\n dr13 = v_z1\n dr14 = v_z2\n dr15 = v_z3\n\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\n\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\n dr7, dr8, dr9, dr10, dr11, dr12,\n dr13, dr14, dr15, dr16, dr17, dr18])\n\n return dr","def vel(z, c = cp.cc.c_light_cm_s/1e5):\n # return z*c/(1+z)\n return c*((1+z)**2-1)/((1+z)**2+1)","def position(self, l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n pos = x + v * t + (1/2.0) * g * t**2\n \n if squeeze:\n pos = np.squeeze(pos, axis=0)\n return pos","def evol_dt(self, psi, t, dt):\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))","def VerletHope2(r, v, beta,dt,R_dust,M_dust):\n # Deceptively simple (read about Velocity Verlet on wikipedia)\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\n \n return (r_new, v_new)"],"string":"[\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def get_position(self, t0):\\n my_pos_x=np.random.uniform(-20, 20)\\n my_pos_y=np.random.uniform(-20, 20)\\n r=np.array([my_pos_x, my_pos_y])\\n x_y=np.zeros(shape=(self.no_planets-1, 2))\\n tol=1e-5\\n diff=np.zeros(self.no_planets-1)\\n for k in range(self.no_planets-1):\\n r1=np.linalg.norm(r)\\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\\n x1=0\\n y1=0\\n x2=self.positionFunction(t0)[0,k]\\n y2=self.positionFunction(t0)[1,k]\\n x3=self.positionFunction(t0)[0,k+1]\\n y3=self.positionFunction(t0)[1, k+1]\\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\\n x_y[k, 0]=x\\n x_y[k, 1]=y\\n diff[k]=difference\\n if (diff > tol).any():\\n print diff.max()\\n print \\\"Oh no, one failed :(\\\"\\n sys.exit(1)\\n print \\\"My pos x:\\\", my_pos_x\\n print \\\"My pos y:\\\", my_pos_y\\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def target_acceleration(self, time):\\n x_a = -self.w**2*self.r*sin(self.w*time)\\n y_a = -self.w**2*self.r*cos(self.w*time)\\n z_a = 0\\n # raise NotImplementedError\\n return np.array([x_a,y_a,z_a])\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def get_angular_velocity(r, T):\\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\\n # velocity = 2(pi)r/T\\n return (2*math.pi*r)/T\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def get_vsolar(self):\\n return self.read_register(4098, 1, 3)\",\n \"def eval_2pts(self, vector, t):\\n if t < 0 or t > 1:\\n raise Exception(\\\"Cannot Eval \\\", e, \\\" with t=\\\", t, \\\": t Should Satisfy 0<=t<=1.\\\")\\n else:\\n return Vector((1-t)*self.x + t*vector.x, (1-t)*self.y + t*vector.y, (1-t)*self.z + t*vector.z)\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def test_velocity(self):\\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\\n # r must contain 2 elements, otherwise the density and pressure are nan\\n r = np.array([0.7, 0.8])\\n t = 6.25e-6\\n solrt = sol(r, t)\\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)\",\n \"def getVelocity(self):\\n return self.v\",\n \"def CalculatePosition(radius,velocity,time,dt):\\n \\n # Initial conditions\\n theta = 0\\n xini = radius * np.cos(theta)\\n yini = radius * np.sin(theta)\\n t = 0\\n \\n # Store positions and time\\n xposition = [xini]\\n yposition = [yini]\\n storedtime = [t]\\n \\n # Calculate positions\\n while t < time:\\n t += dt\\n x = radius * np.cos((velocity/radius)*t)\\n y = radius * np.sin((velocity/radius)*t)\\n \\n xposition.append(x)\\n yposition.append(y)\\n storedtime.append(t)\\n \\n # Make an array\\n xposition = np.array(xposition)\\n yposition = np.array(yposition)\\n storedtime = np.array(storedtime)\\n \\n return xposition,yposition,storedtime\",\n \"def u_exact(self, t):\\n\\n # some abbreviations\\n wE = self.params.omega_E\\n wB = self.params.omega_B\\n N = self.params.nparts\\n u0 = self.params.u0\\n\\n if N != 1:\\n raise ProblemError('u_exact is only valid for a single particle')\\n\\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\\n\\n wbar = np.sqrt(2) * wE\\n\\n # position and velocity in z direction is easy to compute\\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\\n\\n # define temp. variables to compute complex position\\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\\n Rp = u0[0][0] - Rm\\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\\n Ip = u0[0][1] - Im\\n\\n # compute position in complex notation\\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n # compute velocity as time derivative of the position\\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n\\n # get the appropriate real and imaginary parts\\n u.pos[0, 0] = w.real\\n u.vel[0, 0] = dw.real\\n u.pos[1, 0] = w.imag\\n u.vel[1, 0] = dw.imag\\n\\n return u\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def rhs(states, t, parameters, values=None):\\n # Imports\\n import numpy as np\\n import math\\n\\n # Assign states\\n assert(len(states) == 6)\\n vlv, vrv, v1s, v2s, v1p, v2p = states\\n\\n # Assign parameters\\n assert(len(parameters) == 38)\\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\\\\n twitchperiod=parameters[37]\\n\\n # Init return args\\n if values is None:\\n values = np.zeros((6,), dtype=np.float_)\\n else:\\n assert isinstance(values, np.ndarray) and values.shape == (6,)\\n\\n # Expressions for the Time varying elastance component\\n t_lv = math.fmod(t, bcl)\\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\\\\n twitchperiod else 0)\\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\\n plv = p_epi + (-restVlv + vlv)*Elv\\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\\n prv = p_epi + (-restVrv + vrv)*Erv\\n\\n # Expressions for the Pressures and flows component\\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\\\\n rest_v1s/c1s)\\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\\\\n rest_v2s/c2s)\\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\\\\n rest_v1p/c1p)\\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\\\\n rest_v2p/c2p)\\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\\n q1_s = (-p2s + p1s)/R1_s\\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\\n q1_p = (-p2p + p1p)/R1_p\\n\\n # Expressions for the Ventricular volumes component\\n values[0] = -qart_s + q_mit\\n values[1] = -qart_p + q_tric\\n\\n # Expressions for the Systemic volumes component\\n values[2] = -q1_s + qart_s\\n values[3] = -q_tric + q1_s\\n\\n # Expressions for the Pulmonary volumes component\\n values[4] = -q1_p + qart_p\\n values[5] = -q_mit + q1_p\\n\\n # Return results\\n return values\",\n \"def target_velocity(self, s):\\n # YOUR CODE HERE\\n if s > self.total_length:\\n s = self.total_length\\n angular = np.array([0, 0 ,0])\\n else:\\n angular = np.array([0,0,self.targ_angular])\\n\\n theta = s/self.total_length*self.angle\\n v_x = np.cos(theta)*self.targ_speed\\n if self.left_turn:\\n v_y = np.sin(theta)*self.targ_speed\\n else:\\n v_y = -np.sin(theta)*self.targ_speed\\n \\n linear = np.array([v_x, v_y, 0])\\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\\n \\n toRet = [linear, angular]\\n \\n return toRet\",\n \"def to_cart(self, t):\\n # mean motion:\\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\\n # mean anomaly at t:\\n M = n * (t - self.t0) + self.M0\\n # print(np.fmod(M, 2*np.pi))\\n # solve Kepler equation, get eccentric anomaly:\\n E = self.kepler(self.e, M)\\n cosE = np.cos(E)\\n sinE = np.sin(E)\\n # get true anomaly and distance from focus:\\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\\n # r = self.a*(1 - self.e*cosE)\\n #\\n sinw = np.sin(self.w)\\n cosw = np.cos(self.w)\\n sinu = sinw * cosv + cosw * sinv\\n cosu = cosw * cosv - sinw * sinv\\n # position\\n cosNode = np.cos(self.Node)\\n sinNode = np.sin(self.Node)\\n cosi = np.cos(self.i)\\n sini = np.sin(self.i)\\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\\n z = r * sinu * sini\\n # velocity\\n p = self.a * (1.0 - self.e ** 2)\\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\\n vz = z * V_1 / r + cosu * sini * V_2\\n\\n state = np.array([x, y, z, vx, vy, vz])\\n state = np.reshape(np.asarray(state), (3, 2), 'F')\\n\\n return state\",\n \"def robot_arm_pos(self):\\n return self.sim.data.qpos[self.arm_index]\",\n \"def verlet(self,t,dt,r0,r1):\\r\\n r2 = np.zeros([2,self.particles.size])\\r\\n\\r\\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\\r\\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\\r\\n dx = MXT - MX\\r\\n dx = dx\\r\\n\\r\\n dy = MYT - MY\\r\\n dy = dy\\r\\n\\r\\n r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\\r\\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\\r\\n\\r\\n r2 = (2*r1 - r0 + np.transpose(fv(r1[0,:],r1[1,:],dx,dy,r2,t/self.dt,True,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2)) * (dt**2))\\r\\n #The transpose is necessary because I messed up the shapes when I did the fv function.\\r\\n\\r\\n #JV: this needs to change if we want to include particles with mass diferent than 1 (in reduced units),\\r\\n # in other words, diferent particles than the Argon gas\\r\\n\\r\\n return r2[0,:],r2[1,:]\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def target_velocity(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_velocity(path_time)\",\n \"def rcm(t):\\n x0 = 0 # initial position\\n return np.array([\\n 0,\\n 0,\\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\\n ])\",\n \"def get_acceleration(self,v,el,T_s,T_i):\\n\\n rad = radiation.Radiation()\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n g = rad.getGravity(el)\\n\\n\\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\\n\\n Cd = .5 # Drag Coefficient\\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\\n\\n if F_d > 0:\\n F_d = F_d * self.Upsilon\\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\\n\\n return accel\",\n \"def f_2(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n # velocity equation for the ball after the bounce\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\\n\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\\n pyswice.furnsh_c(bskPath + ephemerisPath)\\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\\n position = positionVelocity[0:3] * 1000\\n velocity = positionVelocity[3:6] * 1000\\n pyswice.unload_c(bskPath + ephemerisPath)\\n\\n return position, velocity # [m], [m/s]\",\n \"def slant_time(sx, sy, sz, rx, ry, rz, v):\\n d = np.sqrt((rx - sx) ** 2 + (ry - sy) ** 2)\\n h = rz - sz\\n r = np.sqrt(d ** 2 + h ** 2)\\n return r / v\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def f(r, t=np.nan):\\n x, y, vx, vy = r\\n rcubed = np.sqrt(x**2 + y**2)**3\\n\\n fx = vx #return 1st parameter\\n fy = vy #return 2nd parameter\\n fvx = -G*M*x/rcubed #return 3rd parameter\\n fvy = -G*M*y/rcubed #return last parameter\\n \\n return np.array([fx, fy, fvx, fvy])\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def initial_vel(T,N,masses,dim):\\r\\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\\r\\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\\r\\n rand_v = rand_v - sum_v #Subtract cm-Motion\\r\\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\\r\\n T_act = 2/3*K/sc.k/N #Temperature\\r\\n R_scale = T/T_act #Scaling factor\\r\\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\\r\\n return v\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def move(self, t):\\n if self.visible == True:\\n self.x += self.vx * t\\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\\n\\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\\n self.phi = t * v_norm / self.radius\\n\\n glPushMatrix()\\n glLoadIdentity()\\n\\n if v_norm > 0.0:\\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\\n glMultMatrixd(self.matrix)\\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n\\n glPopMatrix()\\n\\n # Friction!!! Could do it as global parameter\\n if v_norm > 0.0:\\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\\n\\n if v_prime_norm < 0.0:\\n v_prime_norm = 0.0\\n\\n self.vx *= v_prime_norm / v_norm\\n self.vy *= v_prime_norm / v_norm\\n\\n return True\\n # Add comment\\n return False\",\n \"def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\\n rad = dia/2.\\n tsr = rad*fabs(rot)/Vinf\\n solidity = (chord*B)/rad\\n\\n # Translating the turbine position\\n x0t = x0 - xt\\n y0t = y0 - yt\\n\\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\\n\\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\\n if param is None:\\n loc1 = _parameterval(tsr,solidity,coef0)\\n loc2 = _parameterval(tsr,solidity,coef1)\\n loc3 = _parameterval(tsr,solidity,coef2)\\n spr1 = _parameterval(tsr,solidity,coef3)\\n spr2 = _parameterval(tsr,solidity,coef4)\\n skw1 = _parameterval(tsr,solidity,coef5)\\n skw2 = _parameterval(tsr,solidity,coef6)\\n scl1 = _parameterval(tsr,solidity,coef7)\\n scl2 = _parameterval(tsr,solidity,coef8)\\n scl3 = _parameterval(tsr,solidity,coef9)\\n\\n else:\\n # Reading in EMG distribution parameters\\n loc1 = param[0]\\n loc2 = param[1]\\n loc3 = param[2]\\n spr1 = param[3]\\n spr2 = param[4]\\n skw1 = param[5]\\n skw2 = param[6]\\n scl1 = param[7]\\n scl2 = param[8]\\n scl3 = param[9]\\n\\n ###################################\\n if veltype == 'vort':\\n # VORTICITY CALCULATION (NO INTEGRATION)\\n if x0t < 0.:\\n vel = 0.\\n else:\\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\\n ###################################\\n else:\\n # Integration of the vorticity profile to calculate velocity\\n if integration == 'simp':\\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\\n inte = 1 # Simpson's Rule\\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\\n\\n if param is not None:\\n print \\\"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\\\"\\n\\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs*Vinf + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])\\n ###################################\\n elif integration == 'gskr':\\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\\n xbound = (scl3+5.)*dia\\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys/Vinf\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])/Vinf\\n ###################################\\n\\n return vel\",\n \"def shoot(self):\\n e = self.energy()\\n y = self.rap()\\n sqrt_pt2_m2 = e / math.cosh(y)\\n pz = sqrt_pt2_m2 * math.sinh(y)\\n m = self.mass()\\n pt = math.sqrt( sqrt_pt2_m2**2 - m**2 )\\n phi = self.phi()\\n px = pt * math.cos(phi);\\n py = pt * math.sin(phi);\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def shoot(self):\\n pt = self.pt()\\n assert pt >= 0\\n m = self.mass()\\n assert m >= 0\\n sqrt_pt2_m2 = math.sqrt( pt**2 + m**2 )\\n y = self.rap()\\n e = sqrt_pt2_m2 * math.cosh(y)\\n pz = sqrt_pt2_m2 * math.sinh(y)\\n phi = self.phi()\\n px = pt * math.cos(phi);\\n py = pt * math.sin(phi);\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def model(self, t):\\n flux = np.zeros_like(t)\\n dt = np.abs(self.timefrommidtransit(t))\\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\\n depth = self.traits['D']\\n\\n i = dt <= start\\n flux[i] = depth\\n i = (dt <= finish) * (dt > start)\\n flux[i] = (finish - dt[i]) / (finish - start) * depth\\n\\n return flux\",\n \"def shoot(self):\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n theta = self.theta()\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def obtain_vor_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VorticityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VorticityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VorticityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def update(self, t, dt):\\n # update boundary values\\n self._apply_boundary_conditions(t,dt)\\n #update current empirical wind velocity\\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\\n # initialise wind speed derivative arrays\\n du_dt = scipy.zeros((self.nx, self.ny))\\n dv_dt = scipy.zeros((self.nx, self.ny))\\n # approximate spatial first derivatives with centred finite difference\\n # equations for both components of wind field\\n du_dx, du_dy = self._centred_first_derivs(self._u)\\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\\n # second derivatives with second order finite difference equations\\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\\n # = [sf_x-2f(x,y)] / (dx*dx)\\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\\n # = [sf_y-2f(x,y)] / (dy*dy)\\n # second finite differences are not computed in full as the common\\n # f(x,y) term in both expressions can be extracted out to reduce\\n # the number of +/- operations required\\n su_x, su_y = self._centred_first_sums(self._u)\\n sv_x, sv_y = self._centred_first_sums(self._v)\\n # use finite difference method to approximate time derivatives across\\n # simulation region interior from defining PDEs\\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\\n self._Bx * su_x + self._By * su_y -\\n self._C * self._u_int)\\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\\n self._Bx * sv_x + self._By * sv_y -\\n self._C * self._v_int)\\n # perform update with Euler integration\\n self._u_int += du_dt * dt\\n self._v_int += dv_dt * dt\\n # update spline interpolators\\n self._set_interpolators()\",\n \"def vect_from_lspe_to_earth (self, vector, time):\\n\\n position_coord = self.lspe_coordinates (time)\\n # The following code has been optimized:\\n # position_vector = coord_to_pointing (position_coord)\\n # angle = np.arccos (np.dot (self.spin_axis_lspe (time), position_vector))\\n # and is therefore a one-line assignment: \\n angle = np.pi * 0.5 - position_coord[0]\\n rot_axis = np.array ([-np.sin (position_coord[1]),\\n np.cos (position_coord[1]),\\n 0])\\n\\n return rotate (vector, angle, rot_axis)\",\n \"def solver_parachute(T, dt, v0, tp, Cd, rho, A, m):\\n \\n # Mesh initialization\\n v = []; v.append(v0); t=[]; t.append(0);\\n x = []; x.append(3000.)\\n \\n def X(t):\\n return -9.81\\n def Y(t):\\n return Cd*rho*A/(2.*m)\\n \\n # Simulate the same way as solver() untill time tp\\n while t[-1]<=tp:\\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Y))\\n x.append(x[-1] + dt*v[-1])\\n t.append(t[-1] + dt)\\n \\n # Z is the same as the function Y, but with different values\\n def Z(t):\\n return 1.8*1.0*44./(2.*m)\\n \\n # Continue the simulation untill the skydiver hits the ground\\n while x[-1] > 0:\\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Z))\\n x.append(x[-1] + dt*v[-1])\\n t.append(t[-1] + dt)\\n return v, t, x\",\n \"def execute(self, state, dt):\\n \\n # The goal:\\n theta_g = state.goal*math.pi/180\\n \\n # The robot:\\n \\n x_r, y_r, theta = state.pose\\n # print(\\\"current Robot pose: ({}, {}, {})\\\".format(x_r, y_r, theta), file=sys.stderr)\\n \\n # 1. Calculate simple proportional error\\n error = (theta_g - theta + math.pi)%(2*math.pi) - math.pi\\n # print(\\\"current err: ({})\\\".format(error), file=sys.stderr)\\n \\n # 2. Calculate desired omega\\n w_ = self.kp*error\\n \\n # 3. The linear velocity is given to us:\\n v_ = state.velocity\\n # print(\\\"current v, w: ({}, {})\\\".format(v_, w_), file=sys.stderr)\\n \\n\\n return [v_, w_]\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def get_velocity(self):\\n return self.momentum/self.mass\",\n \"def compute_observation(self):\\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\\n robotEuler = p.getEulerFromQuaternion(robotOrn)\\n linear, angular = p.getBaseVelocity(self.botId)\\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))\",\n \"def update_rk3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n try:\\n\\n kap1 = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time))\\n\\n pos = self.pos+0.5*delta_t*kap1[0]\\n vel = self.vel+0.5*delta_t*kap1[1]\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n 0.5*delta_t, drag=False)\\n\\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\\n\\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\\n\\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n except Collision.CollisionException as col:\\n col.vel = self.vel+col.delta_t*kap1[0]\\n raise col\\n\\n self.time += self.delta_t\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def parameters(self, t):\\n if self.fixed_params:\\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\\n self.Qs[:, :, 0], self.Rs[:, :, 0])\\n\\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])\",\n \"def vector_3D(pt1, pt2, t):\\n x1, y1, z1 = pt1\\n x2, y2, z2 = pt2\\n \\n modulus = np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2 + (z1 - z2) ** 2)\\n \\n x = x1 + (x2 - x1) / modulus * t\\n y = y1 + (y2 - y1) / modulus * t\\n z = z1 + (z2 - z1) / modulus * t\\n \\n return [x, y, z]\",\n \"def driftRHS(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.linalg.norm(f)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def solver(T, dt, v0, Cd, rho, A, m, Source=None):\\n a = Cd*rho*A/(2*m) # Set up the constant a for compact code\\n v = zeros(int(T/dt) + 1) # Create the velocity mesh\\n v[0] = v0; g = 9.81;#Initial velocity and the value of gravity acceleration\\n \\n # Description of the functions X(t) and Y(t) is given in the PDF file\\n def X(t): \\n if(Source == None):\\n return -g\\n else:\\n return -g + Source(t+dt/2.)/m\\n \\n def Y(t):\\n return a\\n \\n #Calculate the velocity at each meshpoint\\n for i in range(1,len(v)):\\n v[i] = skydiving_iterate(v[i-1], dt*(i-1), dt, X, Y)\\n return v, linspace(0, T, T/dt +1)\",\n \"def get_trajectory(h, launch_speed, launch_angle):\\n\\n v0 = launch_speed\\n theta = mp.radians(launch_angle)\\n\\n N = 100000\\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\\n tr = np.empty((N,2))\\n v = np.empty((N,2))\\n # Initial rocket position, velocity and acceleration\\n tr[0] = 0, R + h\\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\\n a = calc_a(tr[0])\\n\\n for i, t in enumerate(tgrid[1:]):\\n # Calculate the rocket's next position based on its instantaneous velocity.\\n \\n r = tr[i] + v[i] * dt \\n \\n if np.hypot(*r) < R:\\n # Our rocket crashed.\\n break\\n # Update the rocket's position, velocity and acceleration.\\n tr[i+1] = r\\n v[i+1] = v[i] + a*dt\\n a = calc_a(tr[i+1])\\n return tr[:i+1]\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def _position_and_velocity(self, jd):\\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\\n self.elevation.au, jd.gast)\\n pos = einsum('ij...,j...->i...', jd.MT, pos)\\n vel = einsum('ij...,j...->i...', jd.MT, vel)\\n return pos, vel\",\n \"def verlet_next_pos(pos_t,vel_t,accel_t,dt):\\n pos_t_plus_dt = pos_t.copy()\\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \\n\\n return pos_t_plus_dt\",\n \"def LeapFrog(self,r,v,dt):\\n\\n rhalf = r + np.asarray(v)*(dt/2) #Taking a half step forward with positional vector\\n # predict the final velocity at the next timestep using the acceleration field at the rhalf position \\n vnew = v + self.M31Accel(rhalf)*dt\\n # predict the final position using the average of the current velocity and the final velocity\\n rnew = r + 0.5*(v+vnew)*dt\\n \\n return rnew,vnew\",\n \"def shoot(self):\\n theta = self.theta()\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def get_camera_observation(self, t):\\n if not self.enable_cameras:\\n warnings.warn(\\n \\\"Cameras are not enabled, so images in the camera observation\\\"\\n \\\" are not initialized. Create `TriFingerPlatform` with\\\"\\n \\\" `enable_cameras=True` to get rendered camera images.\\\"\\n )\\n\\n current_t = self.simfinger._t\\n\\n if t < 0:\\n raise ValueError(\\\"Cannot access time index less than zero.\\\")\\n elif t == current_t:\\n return self._camera_observation_t\\n elif t == current_t + 1:\\n return self._get_current_camera_observation(t)\\n else:\\n raise ValueError(\\n \\\"Given time index t has to match with index of the current\\\"\\n \\\" step or the next one.\\\"\\n )\",\n \"def get_velocity_vortex(strength, xv, yv, X, Y):\\r\\n u = +strength / (2 * math.pi) * (Y - yv) / ((X - xv)**2 + (Y - yv)**2)\\r\\n v = -strength / (2 * math.pi) * (X - xv) / ((X - xv)**2 + (Y - yv)**2)\\r\\n \\r\\n return u, v\",\n \"def state(self, t):\\n return self.mus[:, :, t + 1], self.Vs[:, :, t + 1]\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def compute_vel(self, state, goal):\\n\\n \\\"\\\"\\\"\\n Unicycle model control law:\\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\\n v = commanded linear velocity of robot\\n w = commanded rotational velcoity of robot\\n kp = gain parameter where kp > 0\\n ka = gain parameter where ka - kp > 0\\n kb = gain parameter where kb < 0\\n p = distance from robot to goal\\n a = angle between current robot heading and heading to goal\\n b = error between current heading to goal and target end heading\\n \\\"\\\"\\\"\\n \\n #print('state,goal,v,w')\\n #print(state)\\n #print(goal)\\n\\n xr = state[0][0] # m in world frame\\n yr = state[1][0] # m in world frame\\n thetar = state[2][0] #rads\\n\\n xg = goal[0] # m in world frame\\n yg = goal[1] # m in world frame\\n\\n dy = yg - yr\\n dx = xg - xr\\n\\n #print('')\\n #print(state)\\n #print(goal)\\n \\n # Calculate a\\n a = -1*thetar + math.atan2(dy,dx)\\n\\n #print(a)\\n\\n if a > math.pi:\\n a = a - 2*math.pi\\n\\n if a < -1*math.pi:\\n a = a + 2*math.pi\\n\\n #print(a)\\n\\n # Set omega according to control law\\n omega = self.ka*a\\n if math.fabs(omega) > self.MAX_OMEGA:\\n if omega > 0:\\n omega = self.MAX_OMEGA\\n else:\\n omega = -1*self.MAX_OMEGA\\n\\n # Calculate P\\n p = math.sqrt(dy*dy + dx*dx)\\n\\n # Set v \\n v = self.kp*p\\n if v > self.MAX_SPEED:\\n v = self.MAX_SPEED\\n\\n # set the done value\\n done = (p <= self.done_distance)\\n\\n #print(v)\\n #print(omega)\\n\\n out_tuple = (v, omega, done)\\n \\n return out_tuple\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def __init__(self, mass, radius, position, velocity):\\n self.mass = mass\\n self.radius = radius\\n self.position = position\\n self.velocity = velocity\\n print(self.velocity)\\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\\n self.delete = False\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def target_velocity(self, s):\\n if s > self.total_length:\\n linear = np.array([0,0,0])\\n else:\\n linear = np.array([self.sign*self.targ_speed, 0, 0])\\n \\n angular = np.array([0,0,0])\\n toRet = [linear, angular]\\n\\n return toRet\",\n \"def derivative(r, t, G=6.67e-11, AU=1.496e+11,\\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n if G < 0:\\n print(f\\\"The gravitational constant is negative\\\")\\n\\n if AU < 0:\\n print(f\\\"The Astronomical unit is negative\\\")\\n\\n if m1 < 0:\\n print(f\\\"The mass of the first body is negative\\\")\\n\\n if m2 < 0:\\n print(f\\\"The mass of the second body is negative\\\")\\n\\n if m3 < 0:\\n print(f\\\"The mass of the third body is negative\\\")\\n\\n if a1 < 0:\\n print(f\\\"The distance of body 1 from the body center is negative\\\")\\n\\n if a2 < 0:\\n print(f\\\"The distance of body 2 from the body center is negative\\\")\\n\\n x1 = r[0]\\n y1 = r[1]\\n v_x1 = r[2]\\n v_y1 = r[3]\\n\\n x2 = r[4]\\n y2 = r[5]\\n v_x2 = r[6]\\n v_y2 = r[7]\\n\\n x3 = r[8]\\n y3 = r[9]\\n v_x3 = r[10]\\n v_y3 = r[11]\\n\\n z1 = r[12]\\n z2 = r[13]\\n z3 = r[14]\\n\\n v_z1 = r[15]\\n v_z2 = r[16]\\n v_z3 = r[17]\\n\\n r1 = np.array([x1, y1, z1])\\n r2 = np.array([x2, y2, z2])\\n r3 = np.array([x3, y3, z3])\\n\\n dr1 = v_x1\\n dr2 = v_y1\\n\\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\\n\\n dr5 = v_x2\\n dr6 = v_y2\\n\\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\\n\\n dr9 = v_x3\\n dr10 = v_y3\\n\\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\\n\\n dr13 = v_z1\\n dr14 = v_z2\\n dr15 = v_z3\\n\\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\\n\\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\\n dr7, dr8, dr9, dr10, dr11, dr12,\\n dr13, dr14, dr15, dr16, dr17, dr18])\\n\\n return dr\",\n \"def vel(z, c = cp.cc.c_light_cm_s/1e5):\\n # return z*c/(1+z)\\n return c*((1+z)**2-1)/((1+z)**2+1)\",\n \"def position(self, l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n pos = x + v * t + (1/2.0) * g * t**2\\n \\n if squeeze:\\n pos = np.squeeze(pos, axis=0)\\n return pos\",\n \"def evol_dt(self, psi, t, dt):\\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \\n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))\",\n \"def VerletHope2(r, v, beta,dt,R_dust,M_dust):\\n # Deceptively simple (read about Velocity Verlet on wikipedia)\\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\\n \\n return (r_new, v_new)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6969122","0.67800456","0.65503675","0.6356482","0.6308465","0.630399","0.62948024","0.6286732","0.6198997","0.6128271","0.6115166","0.61008614","0.6078042","0.60758245","0.60072464","0.60019296","0.5946289","0.5930369","0.5901788","0.5872708","0.5855203","0.58523273","0.58491814","0.5849086","0.58163893","0.579883","0.57857317","0.5784836","0.5768581","0.57647824","0.5758543","0.5746092","0.57059747","0.5702502","0.56942767","0.5673562","0.56722385","0.5667243","0.56511366","0.56511366","0.5630674","0.5629474","0.56257075","0.56064296","0.5602463","0.5590452","0.5586714","0.55822533","0.5578318","0.5561385","0.55546415","0.55357075","0.5527219","0.55208564","0.55126905","0.5511763","0.55116713","0.5510358","0.55097157","0.55086154","0.55076605","0.55056196","0.550365","0.5500862","0.54954726","0.5490422","0.54893035","0.54885536","0.54882413","0.5488079","0.548359","0.547968","0.5477916","0.54747605","0.54652023","0.54608077","0.54604274","0.54495037","0.5438212","0.5429591","0.5427741","0.5427163","0.5426773","0.5425422","0.54208475","0.5416765","0.5415749","0.5414816","0.5404449","0.53989375","0.5391704","0.5386797","0.538015","0.5378102","0.5374643","0.5358867","0.5351797","0.5346971","0.5331315"],"string":"[\n \"0.6969122\",\n \"0.67800456\",\n \"0.65503675\",\n \"0.6356482\",\n \"0.6308465\",\n \"0.630399\",\n \"0.62948024\",\n \"0.6286732\",\n \"0.6198997\",\n \"0.6128271\",\n \"0.6115166\",\n \"0.61008614\",\n \"0.6078042\",\n \"0.60758245\",\n \"0.60072464\",\n \"0.60019296\",\n \"0.5946289\",\n \"0.5930369\",\n \"0.5901788\",\n \"0.5872708\",\n \"0.5855203\",\n \"0.58523273\",\n \"0.58491814\",\n \"0.5849086\",\n \"0.58163893\",\n \"0.579883\",\n \"0.57857317\",\n \"0.5784836\",\n \"0.5768581\",\n \"0.57647824\",\n \"0.5758543\",\n \"0.5746092\",\n \"0.57059747\",\n \"0.5702502\",\n \"0.56942767\",\n \"0.5673562\",\n \"0.56722385\",\n \"0.5667243\",\n \"0.56511366\",\n \"0.56511366\",\n \"0.5630674\",\n \"0.5629474\",\n \"0.56257075\",\n \"0.56064296\",\n \"0.5602463\",\n \"0.5590452\",\n \"0.5586714\",\n \"0.55822533\",\n \"0.5578318\",\n \"0.5561385\",\n \"0.55546415\",\n \"0.55357075\",\n \"0.5527219\",\n \"0.55208564\",\n \"0.55126905\",\n \"0.5511763\",\n \"0.55116713\",\n \"0.5510358\",\n \"0.55097157\",\n \"0.55086154\",\n \"0.55076605\",\n \"0.55056196\",\n \"0.550365\",\n \"0.5500862\",\n \"0.54954726\",\n \"0.5490422\",\n \"0.54893035\",\n \"0.54885536\",\n \"0.54882413\",\n \"0.5488079\",\n \"0.548359\",\n \"0.547968\",\n \"0.5477916\",\n \"0.54747605\",\n \"0.54652023\",\n \"0.54608077\",\n \"0.54604274\",\n \"0.54495037\",\n \"0.5438212\",\n \"0.5429591\",\n \"0.5427741\",\n \"0.5427163\",\n \"0.5426773\",\n \"0.5425422\",\n \"0.54208475\",\n \"0.5416765\",\n \"0.5415749\",\n \"0.5414816\",\n \"0.5404449\",\n \"0.53989375\",\n \"0.5391704\",\n \"0.5386797\",\n \"0.538015\",\n \"0.5378102\",\n \"0.5374643\",\n \"0.5358867\",\n \"0.5351797\",\n \"0.5346971\",\n \"0.5331315\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55071664"},"document_rank":{"kind":"string","value":"62"}}},{"rowIdx":20284,"cells":{"query":{"kind":"string","value":"Returns the arm's desired x,y,z acceleration in workspace coordinates at time t"},"document":{"kind":"string","value":"def target_acceleration(self, time):\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def acceleration(v,u,t):\n return ((v-u)/t)","def get_acceleration(self,v,el,T_s,T_i):\n\n rad = radiation.Radiation()\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n g = rad.getGravity(el)\n\n\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\n\n Cd = .5 # Drag Coefficient\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\n\n if F_d > 0:\n F_d = F_d * self.Upsilon\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\n\n return accel","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def acceleration(self):\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n \n ax = self._obj['u']*ux + self._obj['v']*uy\n ay = self._obj['u']*vx + self._obj['v']*vy\n\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\n\n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'{vel_units}^2')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\n\n\n return self._obj","def to_cart(self, t):\n # mean motion:\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\n # mean anomaly at t:\n M = n * (t - self.t0) + self.M0\n # print(np.fmod(M, 2*np.pi))\n # solve Kepler equation, get eccentric anomaly:\n E = self.kepler(self.e, M)\n cosE = np.cos(E)\n sinE = np.sin(E)\n # get true anomaly and distance from focus:\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\n # r = self.a*(1 - self.e*cosE)\n #\n sinw = np.sin(self.w)\n cosw = np.cos(self.w)\n sinu = sinw * cosv + cosw * sinv\n cosu = cosw * cosv - sinw * sinv\n # position\n cosNode = np.cos(self.Node)\n sinNode = np.sin(self.Node)\n cosi = np.cos(self.i)\n sini = np.sin(self.i)\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\n z = r * sinu * sini\n # velocity\n p = self.a * (1.0 - self.e ** 2)\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\n vz = z * V_1 / r + cosu * sini * V_2\n\n state = np.array([x, y, z, vx, vy, vz])\n state = np.reshape(np.asarray(state), (3, 2), 'F')\n\n return state","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def target_acceleration(self, time):\n #return np.array([0, 0, 0])\n if time <= self.total_time/4:\n return self.path1.target_acceleration(time)\n elif time <= self.total_time/2:\n return self.path2.target_acceleration(time)\n elif time <= self.total_time/4*3:\n return self.path3.target_acceleration(time)\n else:\n return self.path4.target_acceleration(time)","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def target_acceleration(self, time):\n return np.array([0, 0, 0])","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def target_acceleration(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_acceleration(path_time)","def a(self, x, t0):\n dummy = 0.0 * t0\n x_1 = x[0]\n x_2 = x[1]\n x_3 = x[2]\n x_4 = x[3]\n x_5 = x[4]\n x_6 = x[5]\n x_7 = x[6]\n # Load parameters.\n e_1_tilde = self.e_1_tilde\n e_2_tilde = self.e_2_tilde\n r = self.rr\n z_1 = self.z_1\n z_1_tilde = self.z_1_tilde\n z_2_tilde = self.z_2_tilde\n alpha_1 = self.alpha_1\n alpha_2 = self.alpha_2\n alpha_2_tilde = self.alpha_2_tilde\n alpha_11_tilde = self.alpha_11_tilde\n alpha_12_tilde = self.alpha_12_tilde\n mu_H_tilde = self.mu_H_tilde\n mu_1_tilde = self.mu_1_tilde\n mu_2_tilde = self.mu_2_tilde\n sigma_H = self.sigma_H\n sigma_1_tilde = self.sigma_1_tilde\n sigma_2_tilde = self.sigma_2_tilde\n sigma_11 = self.sigma_11\n sigma_12 = self.sigma_12\n #\n # Right hand side of model.\n #\n f_1 = z_1 * alpha_1 * x_3 * (1.0 - x_1) - mu_H_tilde * x_1\n f_2 = (1.0 - x_2) * (\n x_3 * (z_1_tilde * alpha_11_tilde + z_2_tilde * alpha_12_tilde)\n + z_1_tilde * alpha_2_tilde * x_6) - mu_1_tilde * x_2\n f_3 = (z_1 * sigma_H * x_1 +\n (z_1_tilde * sigma_11 + z_2_tilde * sigma_12) * x_2) \\\n * (x_4 - x_3) - (e_1_tilde + x_4) * x_3\n f_4 = x_4 * (1 - x_4)\n f_5 = z_2_tilde * alpha_2 * x_6 * (1.0 - x_5) - mu_2_tilde * x_5\n f_6 = (z_1_tilde * sigma_1_tilde * x_2\n + z_2_tilde * sigma_2_tilde * x_5) * (x_7 - x_6) \\\n - (e_2_tilde + r * x_7) * x_6\n f_7 = r * x_7 * (1.0 - x_7)\n r = np.array([f_1, f_2, f_3, f_4, f_5, f_6, f_7])\n return r","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def get_position(self, t0):\n my_pos_x=np.random.uniform(-20, 20)\n my_pos_y=np.random.uniform(-20, 20)\n r=np.array([my_pos_x, my_pos_y])\n x_y=np.zeros(shape=(self.no_planets-1, 2))\n tol=1e-5\n diff=np.zeros(self.no_planets-1)\n for k in range(self.no_planets-1):\n r1=np.linalg.norm(r)\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\n x1=0\n y1=0\n x2=self.positionFunction(t0)[0,k]\n y2=self.positionFunction(t0)[1,k]\n x3=self.positionFunction(t0)[0,k+1]\n y3=self.positionFunction(t0)[1, k+1]\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\n x_y[k, 0]=x\n x_y[k, 1]=y\n diff[k]=difference\n if (diff > tol).any():\n print diff.max()\n print \"Oh no, one failed :(\"\n sys.exit(1)\n print \"My pos x:\", my_pos_x\n print \"My pos y:\", my_pos_y\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def thetas (self,lag):\n tanthetas = [0,0,0]\n for k in range(3,self.n):\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\n tanthetas.append(tantheta_k)\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles","def compute_acceleration(self, x, y):\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\n return np.array([a_x, a_y])","def get_D_C3H8_air(self, T):\n\n self.set_TempPres_dependents(T)\n\n self.D_C3H8_air = (\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\n )\n\n return self.D_C3H8_air","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def tidal_acc(self, xyz):\r\n assert(xyz.shape[1] == 3)\r\n\r\n # create solar mass variable, if not already extant\r\n try:\r\n self.M\r\n except AttributeError:\r\n self.M = Constant(2e33) # solar mass in g\r\n\r\n # get the vector of x-values\r\n x = xyz[:, 0]\r\n\r\n # create an all-zero force vector\r\n acc = np.zeros_like(xyz)\r\n\r\n # get the heliocentric distance at the current time\r\n dist = self.trajectory(self.t)\r\n\r\n # get the acceleration as the difference between the acceleration at\r\n # the points and the acceleration at the c.o.m.\r\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\r\n return(acc)","def get_trajectory(h, launch_speed, launch_angle):\n\n v0 = launch_speed\n theta = mp.radians(launch_angle)\n\n N = 100000\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\n tr = np.empty((N,2))\n v = np.empty((N,2))\n # Initial rocket position, velocity and acceleration\n tr[0] = 0, R + h\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\n a = calc_a(tr[0])\n\n for i, t in enumerate(tgrid[1:]):\n # Calculate the rocket's next position based on its instantaneous velocity.\n \n r = tr[i] + v[i] * dt \n \n if np.hypot(*r) < R:\n # Our rocket crashed.\n break\n # Update the rocket's position, velocity and acceleration.\n tr[i+1] = r\n v[i+1] = v[i] + a*dt\n a = calc_a(tr[i+1])\n return tr[:i+1]","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def acceleration(self):\n return self.__accel","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def predict(self, t : float) -> vector :\n '''@ Zstar : vector'''\n '''@ dt : float'''\n '''@ dtau : float'''\n '''@ F : array'''\n dt = t - self.t\n dtau = self._normalizeDeltaTime(dt)\n F = self.stateTransitionMatrix(self.order+1, dtau)\n Zstar = F @ self.Z;\n return Zstar;","def update_ab3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 2:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.set_old(kap, 2)\n\n self.time += delta_t\n\n else:\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\n\n try:\n tmp = [self.get_old(0)]\n except IndexError:\n tmp = []\n kap = update_ab2(self)\n if tmp:\n self._old = self._old + tmp\n\n return kap","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def rcm(t):\n x0 = 0 # initial position\n return np.array([\n 0,\n 0,\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\n ])","def _compute_solar_torque(self):\n pass","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])","def acc(x: float, v: float, t: float) -> float:\n return -k*v - np.sin(x) + c*np.cos(omega*t)","def update_rk3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n try:\n\n kap1 = (self.vel, self.force(self.pos,\n self.vel,\n self.time))\n\n pos = self.pos+0.5*delta_t*kap1[0]\n vel = self.vel+0.5*delta_t*kap1[1]\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n 0.5*delta_t, drag=False)\n\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\n\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\n\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n except Collision.CollisionException as col:\n col.vel = self.vel+col.delta_t*kap1[0]\n raise col\n\n self.time += self.delta_t","def _get_alpha(self, m_t, v_t):\n return max(0, ((-m_t * self._psi \n + math.sqrt((m_t ** 2 * self._phi ** 4) \n / 4 + v_t * self._phi ** 2 * self._xi)) \n / (v_t * self._xi)))","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def get_actual_air_conditioned_temperature(\n hc_period: np.ndarray,\n theta_ac: np.ndarray, v_supply: np.ndarray, theta_supply_h: np.ndarray, theta_supply_c: np.ndarray,\n l_d_h: np.ndarray, l_d_cs: np.ndarray,\n u_prt: float, a_prt: np.ndarray, a_hcz: np.ndarray, q: float) -> np.ndarray:\n\n rho = get_air_density()\n c = get_specific_heat()\n\n a_prt = a_prt.reshape(1, 5).T\n a_hcz = a_hcz[0:5].reshape(1, 5).T\n\n theta_ac_act_h = np.maximum(theta_ac + (c * rho * v_supply * (theta_supply_h - theta_ac) - l_d_h * 10 ** 6)\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\n\n theta_ac_act_c = np.minimum(theta_ac - (c * rho * v_supply * (theta_ac - theta_supply_c) - l_d_cs * 10 ** 6)\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\n\n return theta_ac_act_h * (hc_period == 'h') + theta_ac_act_c * (hc_period == 'c') + theta_ac * (hc_period == 'm')","def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\n \n error_x = goal_x - curr_x\n error_y = goal_y - curr_y\n error_z = goal_z - curr_z\n error_rot_z = goal_rot_z - curr_rot_z\n\n self.output_x = 0.0\n self.output_y = 0.0\n self.output_z = 0.0\n self.output_rot_z = 0.0\n\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\n # self.current_time = time.time()\n self.current_time = rospy.get_time()\n delta_time = self.current_time - self.last_time\n delta_error_x = error_x - self.last_error_x\n delta_error_y = error_y - self.last_error_y\n delta_error_z = error_z - self.last_error_z\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\n\n # print(\"delta_time:\", delta_time)\n\n if (delta_time >= self.sample_time):\n self.PTerm_x = self.Kp_x * error_x\n self.PTerm_y = self.Kp_y * error_y\n self.PTerm_z = self.Kp_z * error_z\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\n\n self.ITerm_x += error_x * delta_time\n self.ITerm_y += error_y * delta_time\n self.ITerm_z += error_z * delta_time\n self.ITerm_rot_z += error_rot_z * delta_time\n\n if (self.ITerm_x < -self.windup_guard):\n self.ITerm_x = -self.windup_guard\n elif (self.ITerm_x > self.windup_guard):\n self.ITerm_x = self.windup_guard\n \n if (self.ITerm_y < -self.windup_guard):\n self.ITerm_y = -self.windup_guard\n elif (self.ITerm_y > self.windup_guard):\n self.ITerm_y = self.windup_guard\n\n if (self.ITerm_z < -self.windup_guard):\n self.ITerm_z = -self.windup_guard\n elif (self.ITerm_z > self.windup_guard):\n self.ITerm_z = self.windup_guard\n \n if (self.ITerm_rot_z < -self.windup_guard):\n self.ITerm_rot_z = -self.windup_guard\n elif (self.ITerm_rot_z > self.windup_guard):\n self.ITerm_rot_z = self.windup_guard\n\n self.DTerm_x = 0.0\n self.DTerm_y = 0.0\n self.DTerm_z = 0.0\n self.DTerm_rot_z = 0.0\n if delta_time > 0:\n self.DTerm_x = delta_error_x / delta_time\n self.DTerm_y = delta_error_y / delta_time\n self.DTerm_z = delta_error_z / delta_time\n self.DTerm_rot_z = delta_error_rot_z / delta_time\n\n\n # Remember last time and last error for next calculation\n self.last_time = self.current_time\n self.last_error_x = error_x\n self.last_error_y = error_y\n self.last_error_z = error_z\n self.last_error_rot_z = error_rot_z\n\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\n \n return self.output_x, self.output_y, self.output_z, self.output_rot_z","def acceleration(data_array, time=1):\n speed = DataOperation.speed(data_array)\n acc_values = np.zeros(speed.size)\n count = 1\n acc_values[0] = 0\n for d in speed[1:]:\n acc_values[count] = (d - speed[count-1])/3.6/time\n count += 1\n return acc_values","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def thetacm(t):\n return np.array([\n 0,\n 0,\n self.wz * t\n ])","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def _acceleration(data):\n\n # intermediate values\n sumcube_resids = ((data.mean() - data)**3).sum()\n\n # dodge the ZeroDivision error\n sumsqr_resids = max(((data.mean() - data)**2).sum(), 1e-12)\n\n # compute and return the acceleration\n return sumcube_resids / (6 * sumsqr_resids**1.5)","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def derivative(r, t, G=6.67e-11, AU=1.496e+11,\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n if G < 0:\n print(f\"The gravitational constant is negative\")\n\n if AU < 0:\n print(f\"The Astronomical unit is negative\")\n\n if m1 < 0:\n print(f\"The mass of the first body is negative\")\n\n if m2 < 0:\n print(f\"The mass of the second body is negative\")\n\n if m3 < 0:\n print(f\"The mass of the third body is negative\")\n\n if a1 < 0:\n print(f\"The distance of body 1 from the body center is negative\")\n\n if a2 < 0:\n print(f\"The distance of body 2 from the body center is negative\")\n\n x1 = r[0]\n y1 = r[1]\n v_x1 = r[2]\n v_y1 = r[3]\n\n x2 = r[4]\n y2 = r[5]\n v_x2 = r[6]\n v_y2 = r[7]\n\n x3 = r[8]\n y3 = r[9]\n v_x3 = r[10]\n v_y3 = r[11]\n\n z1 = r[12]\n z2 = r[13]\n z3 = r[14]\n\n v_z1 = r[15]\n v_z2 = r[16]\n v_z3 = r[17]\n\n r1 = np.array([x1, y1, z1])\n r2 = np.array([x2, y2, z2])\n r3 = np.array([x3, y3, z3])\n\n dr1 = v_x1\n dr2 = v_y1\n\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\n\n dr5 = v_x2\n dr6 = v_y2\n\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\n\n dr9 = v_x3\n dr10 = v_y3\n\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\n\n dr13 = v_z1\n dr14 = v_z2\n dr15 = v_z3\n\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\n\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\n dr7, dr8, dr9, dr10, dr11, dr12,\n dr13, dr14, dr15, dr16, dr17, dr18])\n\n return dr","def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation","def r_3a(t9, rho = 1, sc = 1):\n # q = 7.275 MeV\n t9m1 = 1 / t9\n t9log = np.log(t9)\n t913 = np.exp(t9log * (1 / 3))\n t9m13 = 1 / t913\n t953 = t9 * t913**2\n t93 = cube(t9)\n rho2 = rho**2\n ra3 = (\n + np.exp(\n -9.710520e-01\n -3.706000e+01 * t9m13\n +2.934930e+01 * t913\n -1.155070e+02 * t9\n -1.000000e+01 * t953\n -1.333330e+00 * t9log)\n + np.exp(\n -2.435050e+01\n -4.126560e+00 * t9m1\n -1.349000e+01 * t9m13\n +2.142590e+01 * t913\n -1.347690e+00 * t9\n +8.798160e-02 * t953\n -1.316530e+01 * t9log)\n + np.exp(\n -1.178840e+01\n -1.024460e+00 * t9m1\n -2.357000e+01 * t9m13\n +2.048860e+01 * t913\n -1.298820e+01 * t9\n -2.000000e+01 * t953\n -2.166670e+00 * t9log))\n f = ra3 * rho2 * (sc / 6)\n rev = 2.00e20 * t93 * np.exp(-84.424 * t9m1)\n r = rev * ra3\n return f, r","def euler_cromer_approx(theta_0, omega_0, dt, T_i):\n theta=np.zeros(samples)\n omega=np.zeros(samples)\n t=np.zeros(samples)\n theta[0]=theta_0\n omega[0]=omega_0\n t[0]=T_i\n\n for n in range(1,samples):\n \"\"\"\n calculates new value for omega using old value of theta and omega\n \"\"\"\n omega[n]=omega[n-1]-g/l*theta[n-1]*dt\n \n \"\"\"\n Calculates new theta using new omega and old theta\n \"\"\"\n theta[n]=theta[n-1]+omega[n]*dt\n \n \"\"\"\n Time array in same dimension for ploting\n \"\"\"\n t[n]=t[n-1]+dt\n \n \n \"\"\"\n theta: array with values of angular displacement\n w: array with values of angular velocity\n t: array with time-values\n \"\"\"\n return theta,omega,t","def get_z_from_t(t):\n\n\n global z_from_t_interp\n\n if z_from_t_interp is None: initialize()\n\n return z_from_t_interp(t)","def advanceVelocity(self,time,acceleration):\n if not isinstance(acceleration,Cartesian3DVector):\n raise CoordinateException(\"Advancing particle momentum with the incorrect acceleration type.\")\n return self.v + time*acceleration","def spaceship_acceleration_x(dt, rotation):\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))","def getorbit(sat, tfinal, tstep, trec):\n ntimes = (int)(tfinal/tstep)\n n_tvals = (int)(tfinal/trec)\n state_arr = np.zeros((6, n_tvals))\n orbelem_arr = np.zeros((6, n_tvals))\n s_major_arr = np.zeros(n_tvals)\n count = 0\n for i in range(ntimes):\n sat.rk4_step_sat(tstep)\n if i % (trec/tstep) == 0:\n state_arr[:, count] = sat.getstate()\n orbelem_arr[:, count] = sat.orb_elem()\n s_major_arr[count] = sat.get_a()\n tether = sat.get_tether()\n tether.setlamda_a(sat)\n tether.set_iv(sat)\n print state_arr[0, count]\n print count\n count += 1\n return (state_arr, orbelem_arr, s_major_arr)","def acceleration(self):\n # speed is by formula: x axis speed: by cos of the heading and y\n # axis by sine of the heading\n self.x_speed += math.cos(math.radians(self.degrees))\n self.y_speed += math.sin(math.radians(self.degrees))","def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\r\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\r\n * c)) ** 2) - 1.0)\r\n self.xa_track.append(x)\r\n p = qe * self.t[i]\r\n self.pa.append(p)\r\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\r\n jv = self.t[i] * qe / (m * c)\r\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\r\n self.va.append(v)\r\n print 'Analytical solution of the differential equation of motion'","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def eval_model(t,lat,lon,head,pitch,tide=0,temp=None,press=None):\n #get the sun positions for each timestamp, at our known lat,lon\n #sun_head, sun_zen = sunpos_mag(t,lat,lon,tide,temp,press,radians=True)\n sun_head = sunpos_mag(t, lat, lon, tide, temp, press, radians=True)\n sun_zen = sun_head[...,1]\n sun_head = sun_head[...,0]\n\n #TODO: input and output argument mismatch\n #get the ocean model aop values for each camera position\n aop = oceanaop(sun_head,sun_zen,head,pitch,1.33)\n return sun_zen,sun_head,aop","def get_action(self):\n # Actual q and dq\n contacts = np.array(\n [(leg_state in (gait_generator_lib.LegState.STANCE,\n gait_generator_lib.LegState.EARLY_CONTACT))\n for leg_state in self._gait_generator.desired_leg_state],\n dtype=np.float64)\n foot_positions = self._robot.GetFootPositionsInBaseFrame()\n\n robot_com_height = self._estimate_robot_height(contacts, foot_positions)\n robot_com_velocity = self._state_estimator.com_velocity_body_frame\n robot_com_roll_pitch_yaw = np.array(self._robot.GetBaseRollPitchYaw())\n robot_com_roll_pitch_yaw[2] = 0. # To prevent yaw drifting\n robot_com_roll_pitch_yaw_rate = self._robot.GetBaseRollPitchYawRate()\n robot_q = np.hstack(([0., 0., robot_com_height], robot_com_roll_pitch_yaw))\n robot_dq = np.hstack((robot_com_velocity, robot_com_roll_pitch_yaw_rate))\n # Desired q and dq\n desired_com_position = np.array((0., 0., self._desired_body_height),\n dtype=np.float64)\n desired_com_velocity = np.array(\n (self.desired_speed[0], self.desired_speed[1], 0.), dtype=np.float64)\n desired_com_roll_pitch_yaw = np.array((0., 0., 0.), dtype=np.float64)\n desired_com_angular_velocity = np.array(\n (0., 0., self.desired_twisting_speed), dtype=np.float64)\n desired_q = np.hstack((desired_com_position, desired_com_roll_pitch_yaw))\n desired_dq = np.hstack(\n (desired_com_velocity, desired_com_angular_velocity))\n # Desired ddq\n desired_ddq = KP * (desired_q - robot_q) + KD * (desired_dq - robot_dq)\n desired_ddq = np.clip(desired_ddq, MIN_DDQ, MAX_DDQ)\n contact_forces = self._qp_torque_optimizer.compute_contact_force(\n foot_positions, desired_ddq, contacts=contacts)\n\n action = {}\n for leg_id, force in enumerate(contact_forces):\n # While \"Lose Contact\" is useful in simulation, in real environment it's\n # susceptible to sensor noise. Disabling for now.\n # if self._gait_generator.leg_state[\n # leg_id] == gait_generator_lib.LegState.LOSE_CONTACT:\n # force = (0, 0, 0)\n motor_torques = self._robot.MapContactForceToJointTorques(leg_id, force)\n for joint_id, torque in motor_torques.items():\n action[joint_id] = (0, 0, 0, 0, torque)\n return action, contact_forces","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def get_current_thrust_direction(self,\n time: float) -> np.array:\n # Interpolate with time\n angle = self.thrust_angle_interpolator.interpolate(time)\n # Set thrust in vertical frame and transpose it\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\n # Update flight conditions (this is needed to let tudat know to update all variables)\n self.vehicle_body.flight_conditions.update_conditions(time)\n # Get aerodynamic angle calculator\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\n frames.AerodynamicsReferenceFrames.vertical_frame,\n frames.AerodynamicsReferenceFrames.inertial_frame)\n # Compute the thrust in the inertial frame\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\n thrust_direction_vertical_frame)\n return thrust_inertial_frame","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n theta_t = self.get_ik(self.target_position(t))\n # print(self.target_position(t))\n #theta_t = np.array(theta_t)\n # print(theta_t)\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here? cause you're mean\n\n point.positions = theta_t\n point.velocities = (theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def get_control_input(self, dt):\n \n desired_z = 3.0\n actual_z = self.internal_state.transform.translation.z\n \n # Convert to quaternion object for use by euler_from_quaternion()\n quaternion = np.array([self.internal_state.transform.rotation.x,\n self.internal_state.transform.rotation.y,\n self.internal_state.transform.rotation.z,\n self.internal_state.transform.rotation.w])\n \n # Determine the euler angles\n euler = euler_from_quaternion(quaternion)\n roll = euler[0]\n pitch = euler[1]\n yaw = euler[2]\n \n # Corrections for yaw wrap around\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \n np.abs(np.abs(yaw) - np.pi) < 0.2):\n # Add or subtract 2 pi depending on crossing direction\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \n \n \n # Determine current yaw rate for yaw rate controller\n yaw_rate = (yaw - self.yaw_old) / dt\n \n # After use, update the old yaw value with the current yaw\n self.yaw_old = yaw\n \n # Determine current climb rate\n climb_rate = (actual_z - self.z_old) / dt\n \n # After use, update the old altitude with the current altitude\n self.z_old = actual_z\n \n # Find the errors between desired and actual signals\n err_roll = self.desired_roll - roll\n err_pitch = self.desired_pitch - pitch\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\n err_climb_rate = self.desired_climb_rate - climb_rate\n \n # Set the hover motor speed\n motor_control = self.hover_speed * self.unit_hover_cmd\n \n # Roll controller\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\n \n # Pitch controller\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\n \n # Yaw rate controller (assuming small angles)\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\n \n # Climb rate controller\n motor_control += ((self.climb_Pgain * err_climb_rate +\n self.climb_Igain * self.internal_climb_error +\n self.climb_Dgain / dt * (err_climb_rate - \n self.internal_old_climb_rate_error)) * \n self.unit_hover_cmd)\n \n # Update the cumulative errors for integration\n self.internal_roll_error += err_roll * dt\n self.internal_pitch_error += err_pitch * dt\n self.internal_yaw_error += err_yaw_rate * dt\n self.internal_climb_error += err_climb_rate * dt\n \n # Update old error with current errors for differentiation\n self.internal_old_roll_error = err_roll\n self.internal_old_pitch_error = err_pitch\n self.internal_old_yaw_rate_error = err_yaw_rate\n self.internal_old_climb_rate_error = err_climb_rate\n \n \n # Return the minimum of the \n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def dynamics(x,Earth):\r\n\r\n # precompute a few terms to reduce number of operations\r\n r = norm(x[0:3])\r\n Re_r_sqr = 1.5*Earth.J2*(Earth.R/r)**2\r\n five_z_sqr = 5*x[2]**2/(r**2)\r\n\r\n # two body and J2 acceleration together\r\n accel = (-Earth.mu/(r**3))*np.array([x[0]*(1 - Re_r_sqr*(five_z_sqr - 1)),\r\n x[1]*(1 - Re_r_sqr*(five_z_sqr - 1)),\r\n x[2]*(1 - Re_r_sqr*(five_z_sqr - 3))])\r\n\r\n return np.array([x[3],x[4],x[5],accel[0],accel[1],accel[2]])","def model(self, t):\n flux = np.zeros_like(t)\n dt = np.abs(self.timefrommidtransit(t))\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\n depth = self.traits['D']\n\n i = dt <= start\n flux[i] = depth\n i = (dt <= finish) * (dt > start)\n flux[i] = (finish - dt[i]) / (finish - start) * depth\n\n return flux","def parameters(self, t):\n if self.fixed_params:\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\n self.Qs[:, :, 0], self.Rs[:, :, 0])\n\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])","def path(e,a,q,i,period, timediff, offset):\n b = a*np.sqrt(1-e**2)\n c=np.sqrt(a**2-b**2)\n #t = ((timediff*np.pi*b)/period)\n #t1 = ((timediff)*np.pi*b)/period\n #print(t1-t)\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\n #print(t)\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\n theta=0 #need a real theta value \n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\n \n \n return xcoord, ycoord, zcoord","def OrbitIntegration(self, t0, dt, tmax):\n\n # initialize the time to the input starting time\n t = t0\n \n # initialize an empty array of size\n orbit = np.zeros((int(tmax/dt)+2,7))\n orbit[0] = t0, *tuple(self.r0), *tuple(self.v0)\n \n # initialize a counter for the orbit. \n i = 1 \n \n # start the integration \n while (t<tmax): \n # **** advance the time by one timestep, dt\n t += dt\n orbit[i-1,0] = t\n \n # ***** advance the position and velocity using the LeapFrog scheme\n r = [orbit[i-1,1], orbit[i-1,2], orbit[i-1,3]]\n v = [orbit[i-1,4], orbit[i-1,5], orbit[i-1,6]]\n rnew, vnew = self.LeapFrog(r,v,dt)\n # **** store the new position vector into the columns with indexes 1,2,3 of the ith row of orbit\n orbit[i] = t, * tuple(rnew), *tuple(vnew)\n # **** update counter i\n i += 1\n \n # write the data to a file\n np.savetxt(self.filename, orbit, fmt = \"%11.3f\"*7, comments='#', \n header=\"{:>10s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}\"\\\n .format('t', 'x', 'y', 'z', 'vx', 'vy', 'vz'))","def AccPlanet (self):\n\n for planet_a in self.planets: #This 'for' loop choses a body from self.planets and calls it 'planet_a'\n\n totalAcceleration = np.array([0, 0, 0],dtype=float) #'totalAcceleration' is defined as an array the values of which can be updated, similarly to position and velocity in the Particle class.\n for planet_b in self.planets: #This 'for' loop choses a body from self.planets and calls it 'planet_b'\n if planet_a == planet_b: #This is a condition to avoid to loop over the same planet finding the acceleration on itself, a physical nonsense\"\n continue\n G=6.67408e-11 #gravitational constant\n acceleration = planet_b.mass * (-G) * ((planet_a.position-planet_b.position))/(np.linalg.norm((planet_a.position-planet_b.position)))**3\n totalAcceleration += acceleration # this sums all the accelerations acting on planet_a.\n planet_a.acceleration = totalAcceleration #Each body's resulting acceleration is updated to the body's information defined in the Particle class.\n \n \"\"\" \n 'acceleration' defines the acceleration between the two bodies chosen by the loops;\n 'totalAcceleration' defines the acceleration of all bodies on planet_a,\n it is in fact he sum of all accelerations calculated with the 'acceleration' equation.\n 'planet_a.acceleration' updates 'totalAcceleration' to the planet considered for every deltaT time step.\n deltaT is introduced indirectly in this method through the variables 'position' and 'velocity', necessary to compute 'acceleration'\n \"\"\"","def position(t):\n return c + tangent_vec * 7 * t ** 2","def M31Accel(self,r):\n\n ### Call the previous functions for the halo, bulge and disk\n halo_acc = self.HernquistAccel(self.Mhalo,self.rhalo,r) #Calculating halo acceleration\n bulge_acc = self.HernquistAccel(self.Mbulge,self.rbulge,r) #\"\"\" bulge \"\"\"\n disk_acc = self.MiyamotoNagaiAccel(self.Mdisk,self.rdisk,r)#\"\"\" disk \"\"\"\n sum1 = np.add(halo_acc,bulge_acc) #summing halo and bulge first\n acc_sum = np.add(sum1,disk_acc) #then adding disk acceleration\n\n return acc_sum","def acceleration_sensor(axis):\n\n\tsensor_name = \"baseBoard\"\n\treg_addr = 24\n\tdata_len = 56\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t#get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Imu', Imu, 2)\n\tacceleration = data.linear_acceleration\n\tif axis == \"x\":\n\t\tresult = acceleration.x\n\telif axis == \"y\":\n\t\tresult = acceleration.y\n\telse:\n\t\tresult = acceleration.z\n\n\tdelete_sensor(sensor_name)\n\treturn result","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def get_camera_observation(self, t):\n if not self.enable_cameras:\n warnings.warn(\n \"Cameras are not enabled, so images in the camera observation\"\n \" are not initialized. Create `TriFingerPlatform` with\"\n \" `enable_cameras=True` to get rendered camera images.\"\n )\n\n current_t = self.simfinger._t\n\n if t < 0:\n raise ValueError(\"Cannot access time index less than zero.\")\n elif t == current_t:\n return self._camera_observation_t\n elif t == current_t + 1:\n return self._get_current_camera_observation(t)\n else:\n raise ValueError(\n \"Given time index t has to match with index of the current\"\n \" step or the next one.\"\n )","def update_apc23(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 1:\n\n\n try:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = 0.5*self.delta_t/(self.time-self.get_old(0, 2))\n\n pos = self.pos+delta_t*((1+beta)*self.vel-beta*self.get_old(0, 0))\n vel = self.vel+delta_t*((1+beta)*kap[1]-beta*self.get_old(0, 1))\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n beta1 = (3.0*(self.time-self.get_old(0,2))+delta_t)/(6.0*self.time-self.get_old(0,2))\n beta2 = -delta_t**2/(6.0*(self.time+delta_t-self.get_old(0,2))*(self.time-self.get_old(0,2)))\n\n print self.force(pos, vel, self.time+delta_t), kap[1], self.get_old(0,1)\n\n pos = self.pos+delta_t*((1.0-beta1-beta2)*vel+beta1*self.vel+beta2*self.get_old(0, 0))\n vel = self.vel+delta_t*((1.0-beta1-beta2)*self.force(pos, vel, self.time+delta_t,\n drag=False)+beta1*kap[1]+beta2*self.get_old(0,1))\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = 0.5*col.delta_t/(self.time-self.get_old(0, 2))\n vel = self.vel+col.delta_t*(1+beta)*kap[1]-beta*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.time += delta_t\n\n else:\n ## reduced to using the Adams first order method for the first timestep:\n\n kap = update_apc1(self)\n\n self.set_old(kap, 1)\n\n return kap","def update_apc11(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n pos = self.pos+delta_t*self.vel\n vel = self.vel+delta_t*kap[1]\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n force = self.force(pos,\n vel,\n self.time+delta_t, drag=False)\n\n pos = self.pos+delta_t*vel\n vel = self.vel+delta_t*force\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n vel = self.vel+col.delta_t*kap[1]\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest = True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n \n self.time += delta_t\n\n return (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)","def analytic(env, t, cfg):\n if t==0:\n action = (-1, -1, 1, 1)\n #action = (-1, -1, 1, np.pi/4)\n elif t==1:\n action = (1, 1, -1, -1)\n elif t==2:\n action = (0, 0, 1, 0)\n elif t==3:\n action = (1, 0, -1, 0)\n else:\n action = env.get_random_action()\n f = 1\n action = (action[0], action[1], action[2]/f, action[3]/f)\n return action"],"string":"[\n \"def target_acceleration(self, time):\\n x_a = -self.w**2*self.r*sin(self.w*time)\\n y_a = -self.w**2*self.r*cos(self.w*time)\\n z_a = 0\\n # raise NotImplementedError\\n return np.array([x_a,y_a,z_a])\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def get_acceleration(self,v,el,T_s,T_i):\\n\\n rad = radiation.Radiation()\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n g = rad.getGravity(el)\\n\\n\\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\\n\\n Cd = .5 # Drag Coefficient\\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\\n\\n if F_d > 0:\\n F_d = F_d * self.Upsilon\\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\\n\\n return accel\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def acceleration(self):\\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n \\n ax = self._obj['u']*ux + self._obj['v']*uy\\n ay = self._obj['u']*vx + self._obj['v']*vy\\n\\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\\n\\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'{vel_units}^2')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\\n\\n\\n return self._obj\",\n \"def to_cart(self, t):\\n # mean motion:\\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\\n # mean anomaly at t:\\n M = n * (t - self.t0) + self.M0\\n # print(np.fmod(M, 2*np.pi))\\n # solve Kepler equation, get eccentric anomaly:\\n E = self.kepler(self.e, M)\\n cosE = np.cos(E)\\n sinE = np.sin(E)\\n # get true anomaly and distance from focus:\\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\\n # r = self.a*(1 - self.e*cosE)\\n #\\n sinw = np.sin(self.w)\\n cosw = np.cos(self.w)\\n sinu = sinw * cosv + cosw * sinv\\n cosu = cosw * cosv - sinw * sinv\\n # position\\n cosNode = np.cos(self.Node)\\n sinNode = np.sin(self.Node)\\n cosi = np.cos(self.i)\\n sini = np.sin(self.i)\\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\\n z = r * sinu * sini\\n # velocity\\n p = self.a * (1.0 - self.e ** 2)\\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\\n vz = z * V_1 / r + cosu * sini * V_2\\n\\n state = np.array([x, y, z, vx, vy, vz])\\n state = np.reshape(np.asarray(state), (3, 2), 'F')\\n\\n return state\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def target_acceleration(self, time):\\n #return np.array([0, 0, 0])\\n if time <= self.total_time/4:\\n return self.path1.target_acceleration(time)\\n elif time <= self.total_time/2:\\n return self.path2.target_acceleration(time)\\n elif time <= self.total_time/4*3:\\n return self.path3.target_acceleration(time)\\n else:\\n return self.path4.target_acceleration(time)\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def target_acceleration(self, time):\\n return np.array([0, 0, 0])\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def target_acceleration(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_acceleration(path_time)\",\n \"def a(self, x, t0):\\n dummy = 0.0 * t0\\n x_1 = x[0]\\n x_2 = x[1]\\n x_3 = x[2]\\n x_4 = x[3]\\n x_5 = x[4]\\n x_6 = x[5]\\n x_7 = x[6]\\n # Load parameters.\\n e_1_tilde = self.e_1_tilde\\n e_2_tilde = self.e_2_tilde\\n r = self.rr\\n z_1 = self.z_1\\n z_1_tilde = self.z_1_tilde\\n z_2_tilde = self.z_2_tilde\\n alpha_1 = self.alpha_1\\n alpha_2 = self.alpha_2\\n alpha_2_tilde = self.alpha_2_tilde\\n alpha_11_tilde = self.alpha_11_tilde\\n alpha_12_tilde = self.alpha_12_tilde\\n mu_H_tilde = self.mu_H_tilde\\n mu_1_tilde = self.mu_1_tilde\\n mu_2_tilde = self.mu_2_tilde\\n sigma_H = self.sigma_H\\n sigma_1_tilde = self.sigma_1_tilde\\n sigma_2_tilde = self.sigma_2_tilde\\n sigma_11 = self.sigma_11\\n sigma_12 = self.sigma_12\\n #\\n # Right hand side of model.\\n #\\n f_1 = z_1 * alpha_1 * x_3 * (1.0 - x_1) - mu_H_tilde * x_1\\n f_2 = (1.0 - x_2) * (\\n x_3 * (z_1_tilde * alpha_11_tilde + z_2_tilde * alpha_12_tilde)\\n + z_1_tilde * alpha_2_tilde * x_6) - mu_1_tilde * x_2\\n f_3 = (z_1 * sigma_H * x_1 +\\n (z_1_tilde * sigma_11 + z_2_tilde * sigma_12) * x_2) \\\\\\n * (x_4 - x_3) - (e_1_tilde + x_4) * x_3\\n f_4 = x_4 * (1 - x_4)\\n f_5 = z_2_tilde * alpha_2 * x_6 * (1.0 - x_5) - mu_2_tilde * x_5\\n f_6 = (z_1_tilde * sigma_1_tilde * x_2\\n + z_2_tilde * sigma_2_tilde * x_5) * (x_7 - x_6) \\\\\\n - (e_2_tilde + r * x_7) * x_6\\n f_7 = r * x_7 * (1.0 - x_7)\\n r = np.array([f_1, f_2, f_3, f_4, f_5, f_6, f_7])\\n return r\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def get_position(self, t0):\\n my_pos_x=np.random.uniform(-20, 20)\\n my_pos_y=np.random.uniform(-20, 20)\\n r=np.array([my_pos_x, my_pos_y])\\n x_y=np.zeros(shape=(self.no_planets-1, 2))\\n tol=1e-5\\n diff=np.zeros(self.no_planets-1)\\n for k in range(self.no_planets-1):\\n r1=np.linalg.norm(r)\\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\\n x1=0\\n y1=0\\n x2=self.positionFunction(t0)[0,k]\\n y2=self.positionFunction(t0)[1,k]\\n x3=self.positionFunction(t0)[0,k+1]\\n y3=self.positionFunction(t0)[1, k+1]\\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\\n x_y[k, 0]=x\\n x_y[k, 1]=y\\n diff[k]=difference\\n if (diff > tol).any():\\n print diff.max()\\n print \\\"Oh no, one failed :(\\\"\\n sys.exit(1)\\n print \\\"My pos x:\\\", my_pos_x\\n print \\\"My pos y:\\\", my_pos_y\\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def thetas (self,lag):\\n tanthetas = [0,0,0]\\n for k in range(3,self.n):\\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\\n tanthetas.append(tantheta_k)\\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles\",\n \"def compute_acceleration(self, x, y):\\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\\n return np.array([a_x, a_y])\",\n \"def get_D_C3H8_air(self, T):\\n\\n self.set_TempPres_dependents(T)\\n\\n self.D_C3H8_air = (\\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\\n )\\n\\n return self.D_C3H8_air\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def tidal_acc(self, xyz):\\r\\n assert(xyz.shape[1] == 3)\\r\\n\\r\\n # create solar mass variable, if not already extant\\r\\n try:\\r\\n self.M\\r\\n except AttributeError:\\r\\n self.M = Constant(2e33) # solar mass in g\\r\\n\\r\\n # get the vector of x-values\\r\\n x = xyz[:, 0]\\r\\n\\r\\n # create an all-zero force vector\\r\\n acc = np.zeros_like(xyz)\\r\\n\\r\\n # get the heliocentric distance at the current time\\r\\n dist = self.trajectory(self.t)\\r\\n\\r\\n # get the acceleration as the difference between the acceleration at\\r\\n # the points and the acceleration at the c.o.m.\\r\\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\\r\\n return(acc)\",\n \"def get_trajectory(h, launch_speed, launch_angle):\\n\\n v0 = launch_speed\\n theta = mp.radians(launch_angle)\\n\\n N = 100000\\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\\n tr = np.empty((N,2))\\n v = np.empty((N,2))\\n # Initial rocket position, velocity and acceleration\\n tr[0] = 0, R + h\\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\\n a = calc_a(tr[0])\\n\\n for i, t in enumerate(tgrid[1:]):\\n # Calculate the rocket's next position based on its instantaneous velocity.\\n \\n r = tr[i] + v[i] * dt \\n \\n if np.hypot(*r) < R:\\n # Our rocket crashed.\\n break\\n # Update the rocket's position, velocity and acceleration.\\n tr[i+1] = r\\n v[i+1] = v[i] + a*dt\\n a = calc_a(tr[i+1])\\n return tr[:i+1]\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def acceleration(self):\\n return self.__accel\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def predict(self, t : float) -> vector :\\n '''@ Zstar : vector'''\\n '''@ dt : float'''\\n '''@ dtau : float'''\\n '''@ F : array'''\\n dt = t - self.t\\n dtau = self._normalizeDeltaTime(dt)\\n F = self.stateTransitionMatrix(self.order+1, dtau)\\n Zstar = F @ self.Z;\\n return Zstar;\",\n \"def update_ab3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 2:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n\\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.set_old(kap, 2)\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\\n\\n try:\\n tmp = [self.get_old(0)]\\n except IndexError:\\n tmp = []\\n kap = update_ab2(self)\\n if tmp:\\n self._old = self._old + tmp\\n\\n return kap\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def rcm(t):\\n x0 = 0 # initial position\\n return np.array([\\n 0,\\n 0,\\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\\n ])\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])\",\n \"def acc(x: float, v: float, t: float) -> float:\\n return -k*v - np.sin(x) + c*np.cos(omega*t)\",\n \"def update_rk3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n try:\\n\\n kap1 = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time))\\n\\n pos = self.pos+0.5*delta_t*kap1[0]\\n vel = self.vel+0.5*delta_t*kap1[1]\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n 0.5*delta_t, drag=False)\\n\\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\\n\\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\\n\\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n except Collision.CollisionException as col:\\n col.vel = self.vel+col.delta_t*kap1[0]\\n raise col\\n\\n self.time += self.delta_t\",\n \"def _get_alpha(self, m_t, v_t):\\n return max(0, ((-m_t * self._psi \\n + math.sqrt((m_t ** 2 * self._phi ** 4) \\n / 4 + v_t * self._phi ** 2 * self._xi)) \\n / (v_t * self._xi)))\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def get_actual_air_conditioned_temperature(\\n hc_period: np.ndarray,\\n theta_ac: np.ndarray, v_supply: np.ndarray, theta_supply_h: np.ndarray, theta_supply_c: np.ndarray,\\n l_d_h: np.ndarray, l_d_cs: np.ndarray,\\n u_prt: float, a_prt: np.ndarray, a_hcz: np.ndarray, q: float) -> np.ndarray:\\n\\n rho = get_air_density()\\n c = get_specific_heat()\\n\\n a_prt = a_prt.reshape(1, 5).T\\n a_hcz = a_hcz[0:5].reshape(1, 5).T\\n\\n theta_ac_act_h = np.maximum(theta_ac + (c * rho * v_supply * (theta_supply_h - theta_ac) - l_d_h * 10 ** 6)\\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\\n\\n theta_ac_act_c = np.minimum(theta_ac - (c * rho * v_supply * (theta_ac - theta_supply_c) - l_d_cs * 10 ** 6)\\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\\n\\n return theta_ac_act_h * (hc_period == 'h') + theta_ac_act_c * (hc_period == 'c') + theta_ac * (hc_period == 'm')\",\n \"def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\\n \\n error_x = goal_x - curr_x\\n error_y = goal_y - curr_y\\n error_z = goal_z - curr_z\\n error_rot_z = goal_rot_z - curr_rot_z\\n\\n self.output_x = 0.0\\n self.output_y = 0.0\\n self.output_z = 0.0\\n self.output_rot_z = 0.0\\n\\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\\n # self.current_time = time.time()\\n self.current_time = rospy.get_time()\\n delta_time = self.current_time - self.last_time\\n delta_error_x = error_x - self.last_error_x\\n delta_error_y = error_y - self.last_error_y\\n delta_error_z = error_z - self.last_error_z\\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\\n\\n # print(\\\"delta_time:\\\", delta_time)\\n\\n if (delta_time >= self.sample_time):\\n self.PTerm_x = self.Kp_x * error_x\\n self.PTerm_y = self.Kp_y * error_y\\n self.PTerm_z = self.Kp_z * error_z\\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\\n\\n self.ITerm_x += error_x * delta_time\\n self.ITerm_y += error_y * delta_time\\n self.ITerm_z += error_z * delta_time\\n self.ITerm_rot_z += error_rot_z * delta_time\\n\\n if (self.ITerm_x < -self.windup_guard):\\n self.ITerm_x = -self.windup_guard\\n elif (self.ITerm_x > self.windup_guard):\\n self.ITerm_x = self.windup_guard\\n \\n if (self.ITerm_y < -self.windup_guard):\\n self.ITerm_y = -self.windup_guard\\n elif (self.ITerm_y > self.windup_guard):\\n self.ITerm_y = self.windup_guard\\n\\n if (self.ITerm_z < -self.windup_guard):\\n self.ITerm_z = -self.windup_guard\\n elif (self.ITerm_z > self.windup_guard):\\n self.ITerm_z = self.windup_guard\\n \\n if (self.ITerm_rot_z < -self.windup_guard):\\n self.ITerm_rot_z = -self.windup_guard\\n elif (self.ITerm_rot_z > self.windup_guard):\\n self.ITerm_rot_z = self.windup_guard\\n\\n self.DTerm_x = 0.0\\n self.DTerm_y = 0.0\\n self.DTerm_z = 0.0\\n self.DTerm_rot_z = 0.0\\n if delta_time > 0:\\n self.DTerm_x = delta_error_x / delta_time\\n self.DTerm_y = delta_error_y / delta_time\\n self.DTerm_z = delta_error_z / delta_time\\n self.DTerm_rot_z = delta_error_rot_z / delta_time\\n\\n\\n # Remember last time and last error for next calculation\\n self.last_time = self.current_time\\n self.last_error_x = error_x\\n self.last_error_y = error_y\\n self.last_error_z = error_z\\n self.last_error_rot_z = error_rot_z\\n\\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\\n \\n return self.output_x, self.output_y, self.output_z, self.output_rot_z\",\n \"def acceleration(data_array, time=1):\\n speed = DataOperation.speed(data_array)\\n acc_values = np.zeros(speed.size)\\n count = 1\\n acc_values[0] = 0\\n for d in speed[1:]:\\n acc_values[count] = (d - speed[count-1])/3.6/time\\n count += 1\\n return acc_values\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def thetacm(t):\\n return np.array([\\n 0,\\n 0,\\n self.wz * t\\n ])\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def _acceleration(data):\\n\\n # intermediate values\\n sumcube_resids = ((data.mean() - data)**3).sum()\\n\\n # dodge the ZeroDivision error\\n sumsqr_resids = max(((data.mean() - data)**2).sum(), 1e-12)\\n\\n # compute and return the acceleration\\n return sumcube_resids / (6 * sumsqr_resids**1.5)\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def derivative(r, t, G=6.67e-11, AU=1.496e+11,\\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n if G < 0:\\n print(f\\\"The gravitational constant is negative\\\")\\n\\n if AU < 0:\\n print(f\\\"The Astronomical unit is negative\\\")\\n\\n if m1 < 0:\\n print(f\\\"The mass of the first body is negative\\\")\\n\\n if m2 < 0:\\n print(f\\\"The mass of the second body is negative\\\")\\n\\n if m3 < 0:\\n print(f\\\"The mass of the third body is negative\\\")\\n\\n if a1 < 0:\\n print(f\\\"The distance of body 1 from the body center is negative\\\")\\n\\n if a2 < 0:\\n print(f\\\"The distance of body 2 from the body center is negative\\\")\\n\\n x1 = r[0]\\n y1 = r[1]\\n v_x1 = r[2]\\n v_y1 = r[3]\\n\\n x2 = r[4]\\n y2 = r[5]\\n v_x2 = r[6]\\n v_y2 = r[7]\\n\\n x3 = r[8]\\n y3 = r[9]\\n v_x3 = r[10]\\n v_y3 = r[11]\\n\\n z1 = r[12]\\n z2 = r[13]\\n z3 = r[14]\\n\\n v_z1 = r[15]\\n v_z2 = r[16]\\n v_z3 = r[17]\\n\\n r1 = np.array([x1, y1, z1])\\n r2 = np.array([x2, y2, z2])\\n r3 = np.array([x3, y3, z3])\\n\\n dr1 = v_x1\\n dr2 = v_y1\\n\\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\\n\\n dr5 = v_x2\\n dr6 = v_y2\\n\\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\\n\\n dr9 = v_x3\\n dr10 = v_y3\\n\\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\\n\\n dr13 = v_z1\\n dr14 = v_z2\\n dr15 = v_z3\\n\\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\\n\\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\\n dr7, dr8, dr9, dr10, dr11, dr12,\\n dr13, dr14, dr15, dr16, dr17, dr18])\\n\\n return dr\",\n \"def get_rotation(self) -> np.array:\\n axis = self.get_arms()[1]\\n force = [self.d_x, self.d_y] # \\\"Force applied on the arm\\\"\\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\\n if torque == 1: # Anti clockwise rotation\\n rotation = np.array([[0, -1], [1, 0]])\\n if torque == -1: # Clockwise rotation\\n rotation = np.array([[0, 1], [-1, 0]])\\n if torque == 0: # No rotation\\n rotation = np.array([[0, 0], [0, 0]])\\n return rotation\",\n \"def r_3a(t9, rho = 1, sc = 1):\\n # q = 7.275 MeV\\n t9m1 = 1 / t9\\n t9log = np.log(t9)\\n t913 = np.exp(t9log * (1 / 3))\\n t9m13 = 1 / t913\\n t953 = t9 * t913**2\\n t93 = cube(t9)\\n rho2 = rho**2\\n ra3 = (\\n + np.exp(\\n -9.710520e-01\\n -3.706000e+01 * t9m13\\n +2.934930e+01 * t913\\n -1.155070e+02 * t9\\n -1.000000e+01 * t953\\n -1.333330e+00 * t9log)\\n + np.exp(\\n -2.435050e+01\\n -4.126560e+00 * t9m1\\n -1.349000e+01 * t9m13\\n +2.142590e+01 * t913\\n -1.347690e+00 * t9\\n +8.798160e-02 * t953\\n -1.316530e+01 * t9log)\\n + np.exp(\\n -1.178840e+01\\n -1.024460e+00 * t9m1\\n -2.357000e+01 * t9m13\\n +2.048860e+01 * t913\\n -1.298820e+01 * t9\\n -2.000000e+01 * t953\\n -2.166670e+00 * t9log))\\n f = ra3 * rho2 * (sc / 6)\\n rev = 2.00e20 * t93 * np.exp(-84.424 * t9m1)\\n r = rev * ra3\\n return f, r\",\n \"def euler_cromer_approx(theta_0, omega_0, dt, T_i):\\n theta=np.zeros(samples)\\n omega=np.zeros(samples)\\n t=np.zeros(samples)\\n theta[0]=theta_0\\n omega[0]=omega_0\\n t[0]=T_i\\n\\n for n in range(1,samples):\\n \\\"\\\"\\\"\\n calculates new value for omega using old value of theta and omega\\n \\\"\\\"\\\"\\n omega[n]=omega[n-1]-g/l*theta[n-1]*dt\\n \\n \\\"\\\"\\\"\\n Calculates new theta using new omega and old theta\\n \\\"\\\"\\\"\\n theta[n]=theta[n-1]+omega[n]*dt\\n \\n \\\"\\\"\\\"\\n Time array in same dimension for ploting\\n \\\"\\\"\\\"\\n t[n]=t[n-1]+dt\\n \\n \\n \\\"\\\"\\\"\\n theta: array with values of angular displacement\\n w: array with values of angular velocity\\n t: array with time-values\\n \\\"\\\"\\\"\\n return theta,omega,t\",\n \"def get_z_from_t(t):\\n\\n\\n global z_from_t_interp\\n\\n if z_from_t_interp is None: initialize()\\n\\n return z_from_t_interp(t)\",\n \"def advanceVelocity(self,time,acceleration):\\n if not isinstance(acceleration,Cartesian3DVector):\\n raise CoordinateException(\\\"Advancing particle momentum with the incorrect acceleration type.\\\")\\n return self.v + time*acceleration\",\n \"def spaceship_acceleration_x(dt, rotation):\\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))\",\n \"def getorbit(sat, tfinal, tstep, trec):\\n ntimes = (int)(tfinal/tstep)\\n n_tvals = (int)(tfinal/trec)\\n state_arr = np.zeros((6, n_tvals))\\n orbelem_arr = np.zeros((6, n_tvals))\\n s_major_arr = np.zeros(n_tvals)\\n count = 0\\n for i in range(ntimes):\\n sat.rk4_step_sat(tstep)\\n if i % (trec/tstep) == 0:\\n state_arr[:, count] = sat.getstate()\\n orbelem_arr[:, count] = sat.orb_elem()\\n s_major_arr[count] = sat.get_a()\\n tether = sat.get_tether()\\n tether.setlamda_a(sat)\\n tether.set_iv(sat)\\n print state_arr[0, count]\\n print count\\n count += 1\\n return (state_arr, orbelem_arr, s_major_arr)\",\n \"def acceleration(self):\\n # speed is by formula: x axis speed: by cos of the heading and y\\n # axis by sine of the heading\\n self.x_speed += math.cos(math.radians(self.degrees))\\n self.y_speed += math.sin(math.radians(self.degrees))\",\n \"def anl_solution(self):\\r\\n\\r\\n m = float(self.mass) / self.nu_m\\r\\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\\\\r\\n / float(self.size_tick * self.size_tick)\\r\\n print 'qE=', qe\\r\\n c = self.light_vel\\r\\n for i in range(0, len(self.obs.obt_g)):\\r\\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\\r\\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\\r\\n * c)) ** 2) - 1.0)\\r\\n self.xa_track.append(x)\\r\\n p = qe * self.t[i]\\r\\n self.pa.append(p)\\r\\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\\r\\n jv = self.t[i] * qe / (m * c)\\r\\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\\r\\n self.va.append(v)\\r\\n print 'Analytical solution of the differential equation of motion'\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def eval_model(t,lat,lon,head,pitch,tide=0,temp=None,press=None):\\n #get the sun positions for each timestamp, at our known lat,lon\\n #sun_head, sun_zen = sunpos_mag(t,lat,lon,tide,temp,press,radians=True)\\n sun_head = sunpos_mag(t, lat, lon, tide, temp, press, radians=True)\\n sun_zen = sun_head[...,1]\\n sun_head = sun_head[...,0]\\n\\n #TODO: input and output argument mismatch\\n #get the ocean model aop values for each camera position\\n aop = oceanaop(sun_head,sun_zen,head,pitch,1.33)\\n return sun_zen,sun_head,aop\",\n \"def get_action(self):\\n # Actual q and dq\\n contacts = np.array(\\n [(leg_state in (gait_generator_lib.LegState.STANCE,\\n gait_generator_lib.LegState.EARLY_CONTACT))\\n for leg_state in self._gait_generator.desired_leg_state],\\n dtype=np.float64)\\n foot_positions = self._robot.GetFootPositionsInBaseFrame()\\n\\n robot_com_height = self._estimate_robot_height(contacts, foot_positions)\\n robot_com_velocity = self._state_estimator.com_velocity_body_frame\\n robot_com_roll_pitch_yaw = np.array(self._robot.GetBaseRollPitchYaw())\\n robot_com_roll_pitch_yaw[2] = 0. # To prevent yaw drifting\\n robot_com_roll_pitch_yaw_rate = self._robot.GetBaseRollPitchYawRate()\\n robot_q = np.hstack(([0., 0., robot_com_height], robot_com_roll_pitch_yaw))\\n robot_dq = np.hstack((robot_com_velocity, robot_com_roll_pitch_yaw_rate))\\n # Desired q and dq\\n desired_com_position = np.array((0., 0., self._desired_body_height),\\n dtype=np.float64)\\n desired_com_velocity = np.array(\\n (self.desired_speed[0], self.desired_speed[1], 0.), dtype=np.float64)\\n desired_com_roll_pitch_yaw = np.array((0., 0., 0.), dtype=np.float64)\\n desired_com_angular_velocity = np.array(\\n (0., 0., self.desired_twisting_speed), dtype=np.float64)\\n desired_q = np.hstack((desired_com_position, desired_com_roll_pitch_yaw))\\n desired_dq = np.hstack(\\n (desired_com_velocity, desired_com_angular_velocity))\\n # Desired ddq\\n desired_ddq = KP * (desired_q - robot_q) + KD * (desired_dq - robot_dq)\\n desired_ddq = np.clip(desired_ddq, MIN_DDQ, MAX_DDQ)\\n contact_forces = self._qp_torque_optimizer.compute_contact_force(\\n foot_positions, desired_ddq, contacts=contacts)\\n\\n action = {}\\n for leg_id, force in enumerate(contact_forces):\\n # While \\\"Lose Contact\\\" is useful in simulation, in real environment it's\\n # susceptible to sensor noise. Disabling for now.\\n # if self._gait_generator.leg_state[\\n # leg_id] == gait_generator_lib.LegState.LOSE_CONTACT:\\n # force = (0, 0, 0)\\n motor_torques = self._robot.MapContactForceToJointTorques(leg_id, force)\\n for joint_id, torque in motor_torques.items():\\n action[joint_id] = (0, 0, 0, 0, torque)\\n return action, contact_forces\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def get_current_thrust_direction(self,\\n time: float) -> np.array:\\n # Interpolate with time\\n angle = self.thrust_angle_interpolator.interpolate(time)\\n # Set thrust in vertical frame and transpose it\\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\\n # Update flight conditions (this is needed to let tudat know to update all variables)\\n self.vehicle_body.flight_conditions.update_conditions(time)\\n # Get aerodynamic angle calculator\\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\\n frames.AerodynamicsReferenceFrames.vertical_frame,\\n frames.AerodynamicsReferenceFrames.inertial_frame)\\n # Compute the thrust in the inertial frame\\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\\n thrust_direction_vertical_frame)\\n return thrust_inertial_frame\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n theta_t = self.get_ik(self.target_position(t))\\n # print(self.target_position(t))\\n #theta_t = np.array(theta_t)\\n # print(theta_t)\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here? cause you're mean\\n\\n point.positions = theta_t\\n point.velocities = (theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def get_control_input(self, dt):\\n \\n desired_z = 3.0\\n actual_z = self.internal_state.transform.translation.z\\n \\n # Convert to quaternion object for use by euler_from_quaternion()\\n quaternion = np.array([self.internal_state.transform.rotation.x,\\n self.internal_state.transform.rotation.y,\\n self.internal_state.transform.rotation.z,\\n self.internal_state.transform.rotation.w])\\n \\n # Determine the euler angles\\n euler = euler_from_quaternion(quaternion)\\n roll = euler[0]\\n pitch = euler[1]\\n yaw = euler[2]\\n \\n # Corrections for yaw wrap around\\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \\n np.abs(np.abs(yaw) - np.pi) < 0.2):\\n # Add or subtract 2 pi depending on crossing direction\\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \\n \\n \\n # Determine current yaw rate for yaw rate controller\\n yaw_rate = (yaw - self.yaw_old) / dt\\n \\n # After use, update the old yaw value with the current yaw\\n self.yaw_old = yaw\\n \\n # Determine current climb rate\\n climb_rate = (actual_z - self.z_old) / dt\\n \\n # After use, update the old altitude with the current altitude\\n self.z_old = actual_z\\n \\n # Find the errors between desired and actual signals\\n err_roll = self.desired_roll - roll\\n err_pitch = self.desired_pitch - pitch\\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\\n err_climb_rate = self.desired_climb_rate - climb_rate\\n \\n # Set the hover motor speed\\n motor_control = self.hover_speed * self.unit_hover_cmd\\n \\n # Roll controller\\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\\n \\n # Pitch controller\\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\\n \\n # Yaw rate controller (assuming small angles)\\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\\n \\n # Climb rate controller\\n motor_control += ((self.climb_Pgain * err_climb_rate +\\n self.climb_Igain * self.internal_climb_error +\\n self.climb_Dgain / dt * (err_climb_rate - \\n self.internal_old_climb_rate_error)) * \\n self.unit_hover_cmd)\\n \\n # Update the cumulative errors for integration\\n self.internal_roll_error += err_roll * dt\\n self.internal_pitch_error += err_pitch * dt\\n self.internal_yaw_error += err_yaw_rate * dt\\n self.internal_climb_error += err_climb_rate * dt\\n \\n # Update old error with current errors for differentiation\\n self.internal_old_roll_error = err_roll\\n self.internal_old_pitch_error = err_pitch\\n self.internal_old_yaw_rate_error = err_yaw_rate\\n self.internal_old_climb_rate_error = err_climb_rate\\n \\n \\n # Return the minimum of the \\n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def dynamics(x,Earth):\\r\\n\\r\\n # precompute a few terms to reduce number of operations\\r\\n r = norm(x[0:3])\\r\\n Re_r_sqr = 1.5*Earth.J2*(Earth.R/r)**2\\r\\n five_z_sqr = 5*x[2]**2/(r**2)\\r\\n\\r\\n # two body and J2 acceleration together\\r\\n accel = (-Earth.mu/(r**3))*np.array([x[0]*(1 - Re_r_sqr*(five_z_sqr - 1)),\\r\\n x[1]*(1 - Re_r_sqr*(five_z_sqr - 1)),\\r\\n x[2]*(1 - Re_r_sqr*(five_z_sqr - 3))])\\r\\n\\r\\n return np.array([x[3],x[4],x[5],accel[0],accel[1],accel[2]])\",\n \"def model(self, t):\\n flux = np.zeros_like(t)\\n dt = np.abs(self.timefrommidtransit(t))\\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\\n depth = self.traits['D']\\n\\n i = dt <= start\\n flux[i] = depth\\n i = (dt <= finish) * (dt > start)\\n flux[i] = (finish - dt[i]) / (finish - start) * depth\\n\\n return flux\",\n \"def parameters(self, t):\\n if self.fixed_params:\\n return (self.As[:, :, 0], self.Bs[:, :, 0], self.Cs[:, :, 0], self.Ds[:, :, 0],\\n self.Qs[:, :, 0], self.Rs[:, :, 0])\\n\\n return (self.As[:, :, t + 1], self.Bs[:, :, t + 1], self.Cs[:, :, t + 1], self.Ds[:, :, t + 1],\\n self.Qs[:, :, t + 1], self.Rs[:, :, t + 1])\",\n \"def path(e,a,q,i,period, timediff, offset):\\n b = a*np.sqrt(1-e**2)\\n c=np.sqrt(a**2-b**2)\\n #t = ((timediff*np.pi*b)/period)\\n #t1 = ((timediff)*np.pi*b)/period\\n #print(t1-t)\\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\\n #print(t)\\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\\n theta=0 #need a real theta value \\n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\\n \\n \\n return xcoord, ycoord, zcoord\",\n \"def OrbitIntegration(self, t0, dt, tmax):\\n\\n # initialize the time to the input starting time\\n t = t0\\n \\n # initialize an empty array of size\\n orbit = np.zeros((int(tmax/dt)+2,7))\\n orbit[0] = t0, *tuple(self.r0), *tuple(self.v0)\\n \\n # initialize a counter for the orbit. \\n i = 1 \\n \\n # start the integration \\n while (t<tmax): \\n # **** advance the time by one timestep, dt\\n t += dt\\n orbit[i-1,0] = t\\n \\n # ***** advance the position and velocity using the LeapFrog scheme\\n r = [orbit[i-1,1], orbit[i-1,2], orbit[i-1,3]]\\n v = [orbit[i-1,4], orbit[i-1,5], orbit[i-1,6]]\\n rnew, vnew = self.LeapFrog(r,v,dt)\\n # **** store the new position vector into the columns with indexes 1,2,3 of the ith row of orbit\\n orbit[i] = t, * tuple(rnew), *tuple(vnew)\\n # **** update counter i\\n i += 1\\n \\n # write the data to a file\\n np.savetxt(self.filename, orbit, fmt = \\\"%11.3f\\\"*7, comments='#', \\n header=\\\"{:>10s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}\\\"\\\\\\n .format('t', 'x', 'y', 'z', 'vx', 'vy', 'vz'))\",\n \"def AccPlanet (self):\\n\\n for planet_a in self.planets: #This 'for' loop choses a body from self.planets and calls it 'planet_a'\\n\\n totalAcceleration = np.array([0, 0, 0],dtype=float) #'totalAcceleration' is defined as an array the values of which can be updated, similarly to position and velocity in the Particle class.\\n for planet_b in self.planets: #This 'for' loop choses a body from self.planets and calls it 'planet_b'\\n if planet_a == planet_b: #This is a condition to avoid to loop over the same planet finding the acceleration on itself, a physical nonsense\\\"\\n continue\\n G=6.67408e-11 #gravitational constant\\n acceleration = planet_b.mass * (-G) * ((planet_a.position-planet_b.position))/(np.linalg.norm((planet_a.position-planet_b.position)))**3\\n totalAcceleration += acceleration # this sums all the accelerations acting on planet_a.\\n planet_a.acceleration = totalAcceleration #Each body's resulting acceleration is updated to the body's information defined in the Particle class.\\n \\n \\\"\\\"\\\" \\n 'acceleration' defines the acceleration between the two bodies chosen by the loops;\\n 'totalAcceleration' defines the acceleration of all bodies on planet_a,\\n it is in fact he sum of all accelerations calculated with the 'acceleration' equation.\\n 'planet_a.acceleration' updates 'totalAcceleration' to the planet considered for every deltaT time step.\\n deltaT is introduced indirectly in this method through the variables 'position' and 'velocity', necessary to compute 'acceleration'\\n \\\"\\\"\\\"\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def M31Accel(self,r):\\n\\n ### Call the previous functions for the halo, bulge and disk\\n halo_acc = self.HernquistAccel(self.Mhalo,self.rhalo,r) #Calculating halo acceleration\\n bulge_acc = self.HernquistAccel(self.Mbulge,self.rbulge,r) #\\\"\\\"\\\" bulge \\\"\\\"\\\"\\n disk_acc = self.MiyamotoNagaiAccel(self.Mdisk,self.rdisk,r)#\\\"\\\"\\\" disk \\\"\\\"\\\"\\n sum1 = np.add(halo_acc,bulge_acc) #summing halo and bulge first\\n acc_sum = np.add(sum1,disk_acc) #then adding disk acceleration\\n\\n return acc_sum\",\n \"def acceleration_sensor(axis):\\n\\n\\tsensor_name = \\\"baseBoard\\\"\\n\\treg_addr = 24\\n\\tdata_len = 56\\n\\tregist_sensor(sensor_name, reg_addr, data_len)\\n\\n\\t#get sensor data\\n\\tdata = rospy.wait_for_message('MediumSize/SensorHub/Imu', Imu, 2)\\n\\tacceleration = data.linear_acceleration\\n\\tif axis == \\\"x\\\":\\n\\t\\tresult = acceleration.x\\n\\telif axis == \\\"y\\\":\\n\\t\\tresult = acceleration.y\\n\\telse:\\n\\t\\tresult = acceleration.z\\n\\n\\tdelete_sensor(sensor_name)\\n\\treturn result\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def get_camera_observation(self, t):\\n if not self.enable_cameras:\\n warnings.warn(\\n \\\"Cameras are not enabled, so images in the camera observation\\\"\\n \\\" are not initialized. Create `TriFingerPlatform` with\\\"\\n \\\" `enable_cameras=True` to get rendered camera images.\\\"\\n )\\n\\n current_t = self.simfinger._t\\n\\n if t < 0:\\n raise ValueError(\\\"Cannot access time index less than zero.\\\")\\n elif t == current_t:\\n return self._camera_observation_t\\n elif t == current_t + 1:\\n return self._get_current_camera_observation(t)\\n else:\\n raise ValueError(\\n \\\"Given time index t has to match with index of the current\\\"\\n \\\" step or the next one.\\\"\\n )\",\n \"def update_apc23(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 1:\\n\\n\\n try:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = 0.5*self.delta_t/(self.time-self.get_old(0, 2))\\n\\n pos = self.pos+delta_t*((1+beta)*self.vel-beta*self.get_old(0, 0))\\n vel = self.vel+delta_t*((1+beta)*kap[1]-beta*self.get_old(0, 1))\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n beta1 = (3.0*(self.time-self.get_old(0,2))+delta_t)/(6.0*self.time-self.get_old(0,2))\\n beta2 = -delta_t**2/(6.0*(self.time+delta_t-self.get_old(0,2))*(self.time-self.get_old(0,2)))\\n\\n print self.force(pos, vel, self.time+delta_t), kap[1], self.get_old(0,1)\\n\\n pos = self.pos+delta_t*((1.0-beta1-beta2)*vel+beta1*self.vel+beta2*self.get_old(0, 0))\\n vel = self.vel+delta_t*((1.0-beta1-beta2)*self.force(pos, vel, self.time+delta_t,\\n drag=False)+beta1*kap[1]+beta2*self.get_old(0,1))\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = 0.5*col.delta_t/(self.time-self.get_old(0, 2))\\n vel = self.vel+col.delta_t*(1+beta)*kap[1]-beta*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using the Adams first order method for the first timestep:\\n\\n kap = update_apc1(self)\\n\\n self.set_old(kap, 1)\\n\\n return kap\",\n \"def update_apc11(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n pos = self.pos+delta_t*self.vel\\n vel = self.vel+delta_t*kap[1]\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n force = self.force(pos,\\n vel,\\n self.time+delta_t, drag=False)\\n\\n pos = self.pos+delta_t*vel\\n vel = self.vel+delta_t*force\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n vel = self.vel+col.delta_t*kap[1]\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest = True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n \\n self.time += delta_t\\n\\n return (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\",\n \"def analytic(env, t, cfg):\\n if t==0:\\n action = (-1, -1, 1, 1)\\n #action = (-1, -1, 1, np.pi/4)\\n elif t==1:\\n action = (1, 1, -1, -1)\\n elif t==2:\\n action = (0, 0, 1, 0)\\n elif t==3:\\n action = (1, 0, -1, 0)\\n else:\\n action = env.get_random_action()\\n f = 1\\n action = (action[0], action[1], action[2]/f, action[3]/f)\\n return action\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70698804","0.6440076","0.64124155","0.63377005","0.62645674","0.61269134","0.6121389","0.60776174","0.6065293","0.60262007","0.5981195","0.5970287","0.5951348","0.5951348","0.5893698","0.5862199","0.57664055","0.57601243","0.5720025","0.57073057","0.5696521","0.5682907","0.56764853","0.56734544","0.5672561","0.56371707","0.56295097","0.5617812","0.5613888","0.5601065","0.5597692","0.557338","0.55523825","0.55523825","0.5547055","0.5546421","0.5544016","0.5536098","0.5534026","0.5532073","0.55296224","0.5519509","0.5517921","0.5515829","0.55152005","0.5498072","0.54821515","0.54818827","0.5481809","0.5480942","0.5479749","0.54784137","0.5444404","0.54428095","0.5435487","0.5427761","0.5425837","0.5417583","0.5411677","0.5397863","0.5377289","0.53748715","0.5368776","0.53679246","0.5367156","0.5362285","0.536108","0.5355139","0.5350787","0.5350787","0.5350787","0.5350787","0.5349034","0.53474396","0.53452605","0.53452605","0.53452605","0.53452605","0.53445673","0.5344528","0.5343483","0.5331999","0.5330547","0.53252137","0.5325062","0.53189725","0.53066766","0.5297289","0.5296676","0.52915806","0.5284984","0.5279963","0.5279426","0.527929","0.52746373","0.527245","0.5264864","0.5263693","0.52613246","0.5252417","0.52518463"],"string":"[\n \"0.70698804\",\n \"0.6440076\",\n \"0.64124155\",\n \"0.63377005\",\n \"0.62645674\",\n \"0.61269134\",\n \"0.6121389\",\n \"0.60776174\",\n \"0.6065293\",\n \"0.60262007\",\n \"0.5981195\",\n \"0.5970287\",\n \"0.5951348\",\n \"0.5951348\",\n \"0.5893698\",\n \"0.5862199\",\n \"0.57664055\",\n \"0.57601243\",\n \"0.5720025\",\n \"0.57073057\",\n \"0.5696521\",\n \"0.5682907\",\n \"0.56764853\",\n \"0.56734544\",\n \"0.5672561\",\n \"0.56371707\",\n \"0.56295097\",\n \"0.5617812\",\n \"0.5613888\",\n \"0.5601065\",\n \"0.5597692\",\n \"0.557338\",\n \"0.55523825\",\n \"0.55523825\",\n \"0.5547055\",\n \"0.5546421\",\n \"0.5544016\",\n \"0.5536098\",\n \"0.5534026\",\n \"0.5532073\",\n \"0.55296224\",\n \"0.5519509\",\n \"0.5517921\",\n \"0.5515829\",\n \"0.55152005\",\n \"0.5498072\",\n \"0.54821515\",\n \"0.54818827\",\n \"0.5481809\",\n \"0.5480942\",\n \"0.5479749\",\n \"0.54784137\",\n \"0.5444404\",\n \"0.54428095\",\n \"0.5435487\",\n \"0.5427761\",\n \"0.5425837\",\n \"0.5417583\",\n \"0.5411677\",\n \"0.5397863\",\n \"0.5377289\",\n \"0.53748715\",\n \"0.5368776\",\n \"0.53679246\",\n \"0.5367156\",\n \"0.5362285\",\n \"0.536108\",\n \"0.5355139\",\n \"0.5350787\",\n \"0.5350787\",\n \"0.5350787\",\n \"0.5350787\",\n \"0.5349034\",\n \"0.53474396\",\n \"0.53452605\",\n \"0.53452605\",\n \"0.53452605\",\n \"0.53452605\",\n \"0.53445673\",\n \"0.5344528\",\n \"0.5343483\",\n \"0.5331999\",\n \"0.5330547\",\n \"0.53252137\",\n \"0.5325062\",\n \"0.53189725\",\n \"0.53066766\",\n \"0.5297289\",\n \"0.5296676\",\n \"0.52915806\",\n \"0.5284984\",\n \"0.5279963\",\n \"0.5279426\",\n \"0.527929\",\n \"0.52746373\",\n \"0.527245\",\n \"0.5264864\",\n \"0.5263693\",\n \"0.52613246\",\n \"0.5252417\",\n \"0.52518463\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20285,"cells":{"query":{"kind":"string","value":"takes a discrete point in time, and puts the position, velocity, and acceleration into a ROS JointTrajectoryPoint() to be put into a RobotTrajectory."},"document":{"kind":"string","value":"def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n theta_t = self.get_ik(self.target_position(t))\n # print(self.target_position(t))\n #theta_t = np.array(theta_t)\n # print(theta_t)\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here? cause you're mean\n\n point.positions = theta_t\n point.velocities = (theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def look_at(self, point, connector):\n\n\n try:\n point_camera = self.tfBuffer.transform(point, 'head')\n except (tf2.LookupException, tf2.ConnectivityException, tf2.ExtrapolationException) as e:\n rospy.loginfo(\"Waiting for transform... ({})\".format(e))\n return\n\n # Calculate the head joint angles and clip them to the right range\n angle_pan, angle_tilt = connector.head.get_motor_goals_from_point(point_camera.point)\n angle_pan = np.clip(np.rad2deg(angle_pan), connector.head.min_pan, connector.head.max_pan)\n angle_tilt = np.clip(np.rad2deg(angle_tilt), connector.head.min_tilt, connector.head.max_tilt)\n\n current_pan_pos, current_tilt_pos = connector.head.get_current_head_pos()\n if (abs(current_pan_pos - angle_pan) < connector.head.delta and\n abs(current_tilt_pos - angle_tilt) < connector.head.delta):\n # We reached the position\n if rospy.get_time() - self.position_reached_time > connector.head.wait_time:\n # We waited long enough, go back\n return self.pop()\n else:\n # Represent remaining wait time\n self.publish_debug_data(\"remaining_wait_time\",connector.head.wait_time - (rospy.get_time() - self.position_reached_time))\n\n else:\n # We haven't reached it\n # Update when we should reach it\n self.position_reached_time = rospy.get_time()\n connector.head.send_motor_goals(angle_pan, 30.0, angle_tilt, 30.0)\n\n # Represent remaining tilt\n self.publish_debug_data(\"remaining_tilt\",abs(current_pan_pos - angle_pan))\n self.publish_debug_data(\"remaining_pan\",abs(current_tilt_pos - angle_tilt))","def getPointTrajectory(self, localPt: Vector3) -> Trajectory:\n return Trajectory(self.times,[so3.apply(m,localPt) for m in self.milestones])","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def trajectory_control(self,position_trajectory,\n yaw_trajectory,\n time_trajectory,\n current_time):\n ind_min = np.argmin(np.abs(np.array(time_trajectory)-current_time))\n time_ref = time_trajectory[ind_min]\n \n \n if current_time < time_ref:\n position0 = position_trajectory[ind_min-1]\n position1 = position_trajectory[ind_min]\n \n time0 = time_trajectory[ind_min-1]\n time1 = time_trajectory[ind_min]\n yaw_cmd = yaw_trajectory[ind_min-1]\n \n else:\n yaw_cmd = yaw_trajectory[ind_min]\n if ind_min >= len(position_trajectory)-1:\n position0 = position_trajectory[ind_min]\n position1 = position_trajectory[ind_min]\n \n time0 = 0.0\n time1 = 1.0\n else:\n\n position0 = position_trajectory[ind_min]\n position1 = position_trajectory[ind_min+1]\n time0 = time_trajectory[ind_min]\n time1 = time_trajectory[ind_min+1]\n \n position_cmd = (position1-position0)* \\\n (current_time-time0)/(time1-time0)+position0\n velocity_cmd = (position1-position0)/(time1-time0)\n \n \n return (position_cmd,velocity_cmd,yaw_cmd)","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def make_trajectory(self, NextwpPosition, NextwpOrientation):\n d = np.linalg.norm(self.CurrentPosition - NextwpPosition)\n inter_segment_distance = 1\n self.no_of_segments = 1+int(d//inter_segment_distance)\n \n\n # enter sequence of waypoints: no of points should be self.no_of_segments+1\n x_wp = np.linspace(self.CurrentPosition[0], NextwpPosition[0], self.no_of_segments+1)\n y_wp = np.linspace(self.CurrentPosition[1], NextwpPosition[1], self.no_of_segments+1)\n z_wp = np.linspace(self.CurrentPosition[2], NextwpPosition[2], self.no_of_segments+1)\n \n # add intial and final condiions vel, acc, jerk\n x_ic = np.array([0, 0, 0])\n x_fc = np.array([0, 0, 0])\n x0 = np.array([x_wp[0], x_ic[0], x_ic[1], x_ic[2]])\n xT = np.array([x_wp[-1], x_fc[0], x_fc[1], x_fc[2]])\n\n y_ic = np.array([0, 0, 0])\n y_fc = np.array([0, 0, 0])\n y0 = np.array([y_wp[0], y_ic[0], y_ic[1], y_ic[2]])\n yT = np.array([y_wp[-1], y_fc[0], y_fc[1], y_fc[2]])\n \n z_ic = np.array([0, 0, 0])\n z_fc = np.array([0, 0, 0])\n z0 = np.array([z_wp[0], z_ic[0], z_ic[1], z_ic[2]])\n zT = np.array([z_wp[-1], z_fc[0], z_fc[1], z_fc[2]])\n\n path = [np.sqrt((x_wp[i]-x_wp[i-1])**2 + (y_wp[i]-y_wp[i-1])**2 + (z_wp[i]-z_wp[i-1])**2) for i in range(1, self.no_of_segments+1, 1)]\n\n \n T = []; T.insert(0, 0)\n T.insert(1, T[-1] + path[0]/self.reduced_speed)\n for i in range(1, len(path)-1, 1):\n T.append(T[-1] + path[i]/self.average_speed)\n T.insert(len(T)+1, T[-1]+path[-1]/self.reduced_speed) \n\n\n\n\n #T = []; T.insert(0, 0) # insert 0 at 0 position\n #for i in range(self.no_of_segments): \n # T.append(T[-1]+path[i]/self.average_speed)\n\n r = self.r\n N = 1 + self.N # because number of terms in a polynomial = degree+1\n\n QQ = []; AA_inv = []\n\n for i in range(self.no_of_segments): \n q = self.construct_Q(N, r, T[i], T[i+1])\n a = self.construct_A(N, r, T[i], T[i+1])\n a_inv = scipy.linalg.pinv(a)\n QQ = block_diag(QQ, q)\n AA_inv = block_diag(AA_inv, a_inv)\n \n order = 2*r*self.no_of_segments\n R = np.dot(AA_inv.T, np.dot(QQ, AA_inv))\n \n bx = self.construct_b(x0, xT)\n by = self.construct_b(y0, yT)\n bz = self.construct_b(z0, zT)\n\n m = Model(\"qp\")\n order = 2*r*self.no_of_segments\n dx = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\"dx\")\n dy = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\"dy\") \n dz = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\"dz\") \n\n # making objective using quicksum, takes a lot of time \n #obj1 = quicksum(dx[i] * quicksum(R[i][j] * dx[j] for j in range(order)) for i in range(order))\n #obj2 = quicksum(dy[i] * quicksum(R[i][j] * dy[j] for j in range(order)) for i in range(order))\n #obj3 = quicksum(dz[i] * quicksum(R[i][j] * dz[j] for j in range(order)) for i in range(order))\n \n # using LinExpr for the second expression is significantly faster \n obj1 = quicksum(dx[i] * LinExpr([(R[i][j], dx[j]) for j in range(order)]) for i in range(order))\n obj2 = quicksum(dy[i] * LinExpr([(R[i][j], dy[j]) for j in range(order)]) for i in range(order))\n obj3 = quicksum(dz[i] * LinExpr([(R[i][j], dz[j]) for j in range(order)]) for i in range(order))\n obj = obj1 + obj2 + obj3\n j = 0\n for i in range(order): \n if i < r: \n m.addConstr(dx[i] == bx[i])\n m.addConstr(dy[i] == by[i])\n m.addConstr(dz[i] == bz[i])\n elif i >= order-r: \n m.addConstr(dx[i] == bx[r+j])\n m.addConstr(dy[i] == by[r+j])\n m.addConstr(dz[i] == bz[r+j])\n j += 1\n \n c = 1 # counter\n for i in range(r, order-2*r, 2*r): \n #m.addConstr(dx[i] == self.x_wp[c])\n #m.addConstr(dy[i] == self.y_wp[c])\n #m.addConstr(dz[i] == self.z_wp[c])\n m.addConstr(dx[i] <= x_wp[c] + 0.2)\n m.addConstr(dx[i] >= x_wp[c] - 0.2)\n m.addConstr(dy[i] <= y_wp[c] + 0.2)\n m.addConstr(dy[i] >= y_wp[c] - 0.2)\n m.addConstr(dz[i] <= z_wp[c] + 0.2)\n m.addConstr(dz[i] >= z_wp[c] - 0.2)\n c = c+1\n for j in range(r): \n m.addConstr(dx[i+j] == dx[i+j+r])\n m.addConstr(dy[i+j] == dy[i+j+r])\n m.addConstr(dz[i+j] == dz[i+j+r])\n #if j ==2: \n # m.addConstr(dx[i+j] == 2.0)\n\n m.setObjective(obj, GRB.MINIMIZE)\n #m.write('model.lp')\n m.setParam('OutputFlag', 0)\n m.setParam('PSDtol', 1e-1)\n m.optimize()\n\n\n runtime = m.Runtime\n\n\n x_coeff = [dx[i].X for i in range(order)]\n y_coeff = [dy[i].X for i in range(order)]\n z_coeff = [dz[i].X for i in range(order)]\n\n Dx = np.asarray(x_coeff)[np.newaxis].T\n Dy = np.asarray(y_coeff)[np.newaxis].T \n Dz = np.asarray(z_coeff)[np.newaxis].T \n pcx = np.dot(AA_inv, Dx); pcy = np.dot(AA_inv, Dy); pcz = np.dot(AA_inv, Dz)\n\n\n poly_coeff_x = pcx.T.ravel().tolist()\n poly_coeff_y = pcy.T.ravel().tolist()\n poly_coeff_z = pcz.T.ravel().tolist()\n\n return poly_coeff_x, poly_coeff_y, poly_coeff_z, T, time.time()\n #self.publish(poly_coeff_x, poly_coeff_y, poly_coeff_z)","def point_head(self, point: Tuple[int, int], image_timestamp: Time):\n self.running = False\n\n point = Looker.correct_point(point)\n\n self.looker.target.header.frame_id = '/xtion_rgb_optical_frame'\n self.looker.pointing_frame = '/xtion_rgb_optical_frame'\n\n self.looker.pointing_axis.x = 0.0\n self.looker.pointing_axis.y = 0.0\n self.looker.pointing_axis.z = 1.0\n self.looker.max_velocity = 0.2\n\n look_point = PointStamped()\n look_point.header.frame_id = '/xtion_rgb_optical_frame'\n look_point.point.x = (point[0] - self.camera_intrinsics[0, 2]) / (self.camera_intrinsics[0, 0])\n look_point.point.y = (point[1] - self.camera_intrinsics[1, 2]) / (self.camera_intrinsics[1, 1])\n look_point.point.z = 1.0\n look_point.header.stamp = image_timestamp\n\n self.looker.target = look_point\n self.point_head_goal.send_goal(self.looker)","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def transform_point(p,R,t):\r\n x = R[0][0]*p[0]+R[0][1]*p[1]+t[0]\r\n y = R[1][0]*p[0]+R[1][1]*p[1]+t[1]\r\n return [x,y]","def executeTrajectory():\n driveStraight(1, 0.6)\n rotate(0.25)\n driveStraight(1, .45)\n rotate(-0.25)","def create_joint_trajectory(start_position, end_position,\n duration_of_trajectory, frequency_of_trajectory):\n\n frequency_of_ros_messages = frequency_of_trajectory # in Hz.\n number_of_way_points = duration_of_trajectory * frequency_of_ros_messages\n number_of_joints = start_position.__len__()\n trajectory = np.zeros((number_of_joints, number_of_way_points))\n\n for i in xrange(number_of_joints):\n trajectory[i] = np.linspace(start_position[i], end_position[i],\n number_of_way_points)\n trajectory = trajectory.T.copy()\n vel_lims = np.diff(trajectory, axis=0)\n #Because this is discrete differentiation,\n # the last value is missing: len(vel_lims) = len(trajectory) - 1\n # so we just repeat the last calculated velocity.\n vel_lims = np.append(vel_lims, [[x for x in vel_lims[-1,:]]], axis = 0)\n vel_lims = vel_lims * frequency_of_trajectory\n vel_lims = np.absolute(vel_lims)\n\n if vel_lims.all() > 1.0:\n raise ValueError(\"One or more of the values in the specified velocities\"\n \"Exceed 1 rad / second. The robot won't like this.\"\n \"Adjust the trajectory so that each point can be \"\n \"reached without exceeding this limit.\")\n return trajectory, vel_lims","def move_base(self, x, y, z):\n # fill ROS message\n goal = control_msgs.msg.FollowJointTrajectoryGoal()\n traj = trajectory_msgs.msg.JointTrajectory()\n traj.joint_names = [\"odom_x\", \"odom_y\", \"odom_t\"]\n p = trajectory_msgs.msg.JointTrajectoryPoint()\n p.positions = [x, y, z]\n p.velocities = [0, 0, 0]\n p.time_from_start = rospy.Time(15)\n traj.points = [p]\n goal.trajectory = traj\n\n # send message to the action server\n self.cli.send_goal(goal)\n\n # wait for the action server to complete the order\n self.cli.wait_for_result()\n return self._running","def line_param(point_a, point_b, t):\n new_point = point_a - point_b\n return point_b + t*new_point","def interp_cubic(p0, p1, t_abs):\n\tT = (p1.time_from_start - p0.time_from_start).to_sec()\n\tt = t_abs - p0.time_from_start.to_sec()\n\tq = [0] * 6\n\tqdot = [0] * 6\n\tqddot = [0] * 6\n\tfor i in range(len(p0.positions)):\n\t\ta = p0.positions[i]\n\t\tb = p0.velocities[i]\n\t\tc = (-3 * p0.positions[i] + 3 * p1.positions[i] - 2 * T * p0.velocities[i] - T * p1.velocities[i]) / T**2\n\t\td = (2 * p0.positions[i] - 2 * p1.positions[i] + T * p0.velocities[i] + T * p1.velocities[i]) / T**3\n\n\t\tq[i] = a + b * t + c * t**2 + d * t**3\n\t\tqdot[i] = b + 2 * c * t + 3 * d * t**2\n\t\tqddot[i] = 2 * c + 6 * d * t\n\treturn JointTrajectoryPoint(positions=q, velocities=qdot, accelerations=qddot, time_from_start=rospy.Duration(t_abs))","def _trajectory_to_multi_dof_joint_trajectory(self, p, v, a, j, s, c):\n\n msg = tm.MultiDOFJointTrajectory()\n point = tm.MultiDOFJointTrajectoryPoint()\n msg.points.append(point)\n\n #print(p)\n\n transform = gm.Transform()\n transform.translation.x = p[0]\n transform.translation.y = p[1]\n transform.translation.z = p[2]\n quaternion = tft.quaternion_from_euler(0.0, 0.0, p[3])\n transform.rotation.x = quaternion[0]\n transform.rotation.y = quaternion[1]\n transform.rotation.z = quaternion[2]\n transform.rotation.w = quaternion[3]\n point.transforms.append(transform)\n\n velocity = gm.Twist()\n velocity.linear.x = v[0]\n velocity.linear.y = v[1]\n velocity.linear.z = v[2]\n velocity.angular.z = v[3]\n point.velocities.append(velocity)\n\n acceleration = gm.Twist()\n acceleration.linear.x = a[0]\n acceleration.linear.y = a[1]\n acceleration.linear.z = a[2]\n point.accelerations.append(acceleration)\n\n return msg","def getTrajectoryMessage(action, jointOrder, velocity):\n # Set up a trajectory message to publish.\n actionMsg = JointTrajectory()\n actionMsg.joint_names = jointOrder\n # Create a point to tell the robot to move to.\n target = JointTrajectoryPoint()\n actionFloat = [float(i) for i in action]\n target.positions = actionFloat\n target.velocities = [velocity]*action.size\n\n target.time_from_start.nanosec = 1000000\n\n actionMsg.points = [target]\n return actionMsg","def trajectory1(self):\r\n\r\n trackt = [] # particle trajectory,\r\n trackx = [] # particle trajectory\r\n an = [] # analitical s**2 + x**2 = t**2\r\n s1 = [] # s = 10; s = 0, light\r\n s2 = [] # s = 20;\r\n s3 = [] # s = 40;\r\n for i in range(0, len(self.dt.obs.obt_g)):\r\n trackt.append(float(i))\r\n trackx.append(self.dt.x[i])\r\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\r\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\r\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\r\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\r\n\r\n # plots:\r\n\r\n (fig, ax) = plt.subplots() # figsize=(7,5)\r\n\r\n # trajectory\r\n\r\n ax.plot(\r\n trackx,\r\n trackt,\r\n marker='+',\r\n linewidth=1,\r\n linestyle='-',\r\n color='green',\r\n label='treck',\r\n )\r\n\r\n # measurement t\r\n # ax.plot(self.dt.x, self.dt.t, marker=\"+\", linestyle=\" \", color=\"blue\", label=\"result of measurement\")\r\n\r\n ax.plot(\r\n self.dt.x,\r\n self.dt.t,\r\n marker='o',\r\n linestyle=' ',\r\n color='black',\r\n label='result of measurement',\r\n )\r\n\r\n # analitical t\r\n\r\n ax.plot(self.dt.x, an, linestyle='-', color='red',\r\n label='continuum')\r\n\r\n # light trajectory\r\n\r\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\r\n label='s=0 (light)')\r\n\r\n # s(x) curves\r\n\r\n ax.plot(\r\n trackx,\r\n s1,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=1.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s2,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=2.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s3,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=4.0',\r\n )\r\n\r\n # error of measurement t\r\n\r\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\r\n\r\n # signature on the horizontal x-axis\r\n\r\n ax.set_xlabel('x in metres')\r\n xm = -1.0\r\n for i in range(len(self.dt.x)):\r\n if self.dt.x[i] > xm:\r\n xm = self.dt.x[i]\r\n stepx = round(xm / float(len(self.dt.x)), 1)\r\n xm = round(xm + stepx, 1)\r\n ax.set_xlim([0.0, xm])\r\n\r\n # signature on vertical y axis\r\n\r\n ax.set_ylabel('t in metres of light time ')\r\n ym = -1.0\r\n for i in range(len(self.dt.t)):\r\n if self.dt.t[i] > ym:\r\n ym = self.dt.t[i]\r\n stepy = round(ym / float(len(self.dt.t)), 1)\r\n ym = round(ym + stepy, 1)\r\n ax.set_ylim([0.0, ym])\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\r\n\r\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.xaxis.set_major_locator(locatorx)\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\r\n\r\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.yaxis.set_major_locator(locatory)\r\n\r\n ax.grid()\r\n\r\n # show legend\r\n\r\n ax.legend(loc='upper left')\r\n\r\n # show drawing\r\n\r\n plt.show()","def update_position(self, event):\n\n # Create a copy of the most recent stored twist data to perform calculations\n with self.lock:\n velocity_data = copy.deepcopy(self.twist)\n\n # Time elapsed since last update position call\n if hasattr(event, 'last_real'):\n if event.last_real is None:\n time = rospy.Duration(0.05)\n else:\n time = event.current_real - event.last_real\n \n time = time.to_sec()\n\n # Calculate angle turned in the given time using omega = theta/time\n angle = velocity_data.angular.z*time\n\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\n distance = velocity_data.linear.x*time\n\n # Calculate yaw of the robot\n self.vehicle_yaw += angle\n\n # Calculate vehicle x, y, z position coordinates\n # TODO recalculate the position based on traveling in a circular arc.\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\n\n # Calculate z position using linear interpolation and create cloud array\n \n # 1. Create ranges to be used in interpolation function\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\n\n # 2. Create array of points to be converted to point cloud for vizualization\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\n terrain_x = terrain_mesh_x.ravel()\n terrain_y = terrain_mesh_y.ravel()\n terrain_z = self.gaussian_array.ravel()\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\n\n # 3. Create interpolation function based on the ranges and gaussian data\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\n\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\n # TODO compute z height based on footprint\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\n\n # Convert Euler Angles to Quarternion\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\n\n # Broadcast vehicle frame which is a child of the world frame\n br = tf.TransformBroadcaster()\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \n V_rotation, rospy.Time.now(),\"vehicle_frame\", \"map\")\n\n # Construct the homogenous transformation matrix for map to vehicle frame\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \n map_T_V[:3,3] = np.array(V_translation)\n\n # Create footprint of vehicle\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\n V_footprint_x = V_footprint_mesh_x.ravel()\n V_footprint_y = V_footprint_mesh_y.ravel()\n\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\n # and its interpolated z value. Add this point to a list of points for visualization.\n # TODO Flatten into a single matrix multiply to remove for loop\n V_viz_points = []\n for i in range(V_footprint_x.shape[0]):\n p = Point()\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\n p.x = V_footprint_point[0, 0]\n p.y = V_footprint_point[1, 0]\n p.z = V_footprint_point[2, 0]\n V_viz_points.append(p)\n\n #####################################################################################\n # Create a copy of the most recent stored JointState data to perform calculations\n with self.joint_lock:\n joint_data = copy.deepcopy(self.joint)\n\n # If the data is empty on first run, fill with 0.0\n if not joint_data.velocity:\n joint_data.velocity = [0.0,0.0]\n \n # Calculate angle based on velocity data and time\n angle = joint_data.velocity[0]*time\n angle2 = joint_data.velocity[1]*time\n\n self.joint1_pitch += angle\n self.joint2_pitch += angle2\n\n # Transformations from vehicle frame to Joint1 and Joint2\n \n # Static rotation about z-axis \n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\n translation = [0.0, 0.0, 0.0]\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\n V_T_SRz[:3,3] = np.array(translation)\n\n # Dynamic rotation about the y-axis of Joint 1\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\n [0.0, 1.0, 0.0],\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\n\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\n\n SRz_T_J1 = np.zeros((4,4))\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\n SRz_T_J1[:4,3] = trans_SRz_T_J1\n\n # Translation based on length of Joint 1 arm \n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\n translation = [self.joint1_length, 0.0, 0.0]\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\n J1_T_STx[:3,3] = np.array(translation)\n\n # Dynamic rotation about y-axis of Joint 2\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\n translation = [0.0, 0.0, 0.0]\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\n STx_T_J2[:3,3] = np.array(translation)\n\n # matrix multiplication to form the homogenous matrices\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\n\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\n\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\n ripper_tip_point_viz = Point()\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\n V_viz_points.append(ripper_tip_point_viz)\n\n # use the ripper's position as an index value to access the gaussian array\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\n\n # Create a range of index values surrounding index_x and y\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\n\n # First check if the index is within the gaussian array, if it is, then check if the tip of\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\n # it to the surrounding cells, provided those cells are also within the gaussian array\n # TODO Remove use of for loops and excess if statements\n\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\n for i in range(nearby_index_cells_x.shape[0]):\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\n \n\n # Publish all messages\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)","def goto_point(self,targetx,targety):\n #if point is 0,0, make 0.01,0.01 to avoid divide by 0\n if targetx == 0 and targety == 0:\n targetx = 0.01\n targety = 0.01\n self.targetdistance = math.sqrt((self.currentx-targetx)**2 + (self.currenty-targety)**2)\n self.targetangle = math.atan2(targety-self.currenty,targetx-self.currentx)\n self.angledifference = self.angle_diff(self.targetangle,self.orientation)\n if abs(self.angledifference) < .10:\n self.turnspeed = 0\n else:\n self.turnspeed = math.tanh(self.kturn*self.angledifference)\n self.speed = math.tanh(self.targetdistance*self.kspeed/self.angledifference)\n if self.speed < 0:\n self.speed = 0\n self.linearVector = Vector3(x=self.speed, y=0.0, z=0.0)\n self.angularVector = Vector3(x = 0.0, y = 0.0, z = self.turnspeed)\n # print \"currentx = \" + str(self.currentx)\n # print \"currenty = \" + str(self.currenty)\n # print \"orientation = \" + str(self.orientation)\n # print \"targetangle = \" + str(self.targetangle)\n # print \"angledifference = \" + str(self.angledifference)\n #print \"turnspeed = \" + str(self.turnspeed)\n #print \"speed = \" + str(self.speed)","def execute_tp(self):\n self.status_message = \"State: Execute TP- Executing Motion Plan with trajectory planner\"\n self.current_state = \"execute_tp\"\n self.next_state = \"idle\"\n collect_info = threading.Thread(\n target=self.write_joint_pos, args=(\"tp_wp\",))\n collect_info.start()\n for wp in self.waypoints:\n # Ensure the correct number of joint angles\n full_wp = [0.0] * self.rexarm.num_joints\n full_wp[0:len(wp)] = wp\n self.tp.set_initial_wp()\n self.tp.set_final_wp(full_wp)\n\n if self.next_state == \"estop\":\n break\n # TODO: Set the positions and break if estop is needed\n self.tp.go()\n # self.rexarm.set_positions(wp)\n # time.sleep(1.5)","def target(self, time, points, dt, num_way):\n start_index = min(int(time / dt), num_way - 1)\n end_index = min(start_index + 1, num_way - 1)\n start_point = points[start_index]\n end_point = points[end_index]\n fraction = float(time % dt) / dt\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)","def compute_trajectory():\n pass","def __init__(self, P, t):\n n = len(t)\n assert len(P) == n # same number of time and control points\n self.X, self.Y = _unzip(P) # points in X, Y components\n self._n = xrange(n) # time/control point iterator\n self.t = t","def move_trapezoid(point, uvw_func, dt):\n uvw_1 = uvw_func(point)\n first_step = move(point, uvw_1, dt)\n uvw_2 = uvw_func(first_step)\n uvw = ((uvw_1[0] + uvw_2[0]) / 2,\n (uvw_1[1] + uvw_2[1]) / 2,\n (uvw_1[2] + uvw_2[2]) / 2)\n return move(point, uvw, dt)","def moveTo(self, pt: Tuple[float, float]) -> None:\n raise NotImplementedError","def _generate_trajectory(self, current_pos, velocity, goal, dt, prediction_time):\n\n history = list(np.copy(self._reached_goals))\n\n\n\n\n out = []\n out.append(np.copy(current_pos))\n first_goal_idx = np.where(self._goals == goal)[0][0]\n selected_goal = goal\n reached_goal = False\n counter_in_goal = 0\n\n\n\n for _ in range(prediction_time):\n\n # Particle reached selected goal\n # This will continuously chose a next goal, if a particle already reached its predecessor goal\n\n if np.linalg.norm(current_pos - selected_goal) <= 0.1:\n reached_goal = True\n\n\n\n\n\n\n if counter_in_goal > self.curr_stay_duration_goals[self._is_human_in_range_of_goal(selected_goal)[1]] / dt:\n\n selected_goal_idx = np.where(self._goals == selected_goal)[0][0]\n\n if len(history) > 0:\n if not selected_goal_idx == history[-1]:\n history.append(selected_goal_idx)\n else:\n history.append(selected_goal_idx)\n #print \"history:\"\n #print history\n # Select next goal based on the pre-learned goal-change probabilities\n\n\n #print \"selected goal {}\".format(selected_goal_idx)\n probs,available_goals = self.compute_transition_probs_for_goal_from_history(history,selected_goal_idx)\n\n\n for p in probs:\n if p < self._belief_threshold:\n p = 0.0\n\n print \"probs sampling: \"\n print probs / np.sum(np.asarray(probs))\n selected_goal = self._goals[np.random.choice(available_goals, p=probs / np.sum(np.asarray(probs)))]\n\n counter_in_goal = 0.0\n\n #print(\"switching\")\n\n else:\n counter_in_goal += 1\n #print(\"incr counter\")\n\n\n\n\n\n if reached_goal:\n #print self.curr_stay_duration_goals\n #print self.curr_stay_duration_goals[ self._is_human_in_range_of_goal(selected_goal)[1] ]\n\n new_pos = self.transition_human(current_pos, velocity, selected_goal, dt)\n\n out.append(new_pos)\n current_pos = new_pos\n\n\n\n else:\n new_pos = self.transition_human(current_pos, velocity, selected_goal, dt)\n out.append(new_pos)\n current_pos = new_pos\n\n return np.asarray(out)","def verlet_next_pos(pos_t,vel_t,accel_t,dt):\n pos_t_plus_dt = pos_t.copy()\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \n\n return pos_t_plus_dt","def send_joint_trajectory(trajectory, velocities, frequency=250):\n pub = rospy.Publisher(\"/wam/jnt_pos_cmd\", RTJointPos, queue_size=10)\n #If wam_node is running, it will be connected to this publisher.\n #Mostly this loop is here because you want to make sure the publisher\n #gets set up before it starts sending information.\n while pub.get_num_connections() < 1:\n print \"Waiting on the publisher to go up.\"\n rospy.sleep(0.5)\n\n trajectory_length = trajectory.__len__()\n finished = False\n traj_row = 0\n message_for_service = RTJointPos()\n\n r = rospy.Rate(frequency)\n\n while not rospy.is_shutdown() and not finished:\n message_for_service.joints = trajectory[traj_row]\n message_for_service.rate_limits = velocities[traj_row]\n traj_row += 1\n pub.publish(message_for_service)\n if traj_row == trajectory_length - 1:\n finished = True\n r.sleep()","def _make_point(self, active_point):\n # --------------------------------\n # Create Random Parameters\n # --------------------------------\n for _ in range(self._k):\n # Defines radial distance from active_point.\n rho = np.random.uniform(self._radius, 2 * self._radius)\n # Defines angle from active_point. Requires multiple angles for higher dimensional planes.\n theta = [np.random.uniform(0, 2 * np.pi) for _ in range(self._dim - 1)]\n\n # --------------------------------\n # Create New Point\n # --------------------------------\n\n # Create a 2D point using first theta angle.\n new_point = [active_point[0] + rho * np.cos(theta[0]), active_point[1] + rho * np.sin(theta[0])]\n # Generate more components of the coordinate for higher dimensional planes.\n new_point.extend([active_point[i] + rho * np.sin(theta[i-1]) for i in range(2, active_point.shape[0])])\n new_point = np.array(new_point)\n\n # Confirm point is valid\n if self._valid_point(new_point):\n return new_point\n return None","def move(self, a1dot, a2dot, timestep):\n\n # body_v, inertial_v = self.get_v(a1dot, a2dot)\n #\n # # lambdafication\n # x_dot = lambda t: inertial_v[0][0]\n # y_dot = lambda t: inertial_v[1][0]\n # theta_dot = lambda t: inertial_v[2][0]\n # _a1dot = lambda t: a1dot\n # _a2dot = lambda t: a2dot\n #\n # # find the increments\n # # fix to include time intervals\n # dx, _ = integrate.quad(x_dot, 0, timestep)\n # dy, _ = integrate.quad(y_dot, 0, timestep)\n # dtheta, _ = integrate.quad(theta_dot, 0, timestep)\n # da1, _ = integrate.quad(_a1dot, 0, timestep)\n # da2, _ = integrate.quad(_a2dot, 0, timestep)\n\n action = (a1dot, a2dot)\n t = timestep * self.t_interval\n x, y, theta, a1, a2 = self.perform_integration(action, t)\n\n # testing\n # print('the increments: ')\n # print(dx, dy, dtheta, da1, da2)\n\n # update robot variables\n self.x = x\n self.y = y\n # self.theta = theta\n # self.a1 = a1\n # self.a2 = a2\n self.time += t\n self.a1dot = a1dot\n self.a2dot = a2dot\n # self.body_v = (body_v[0][0], body_v[1][0], body_v[2][0])\n # self.inertial_v = (inertial_v[0][0], inertial_v[1][0], inertial_v[2][0])\n # self.state = (self.theta, self.a1, self.a2)\n\n # discretize state variables\n # print('before: ' + str(self.state))\n self.theta = self.rnd(self.discretize(theta, self.a_interval))\n\n # prevent theta from going out of -pi to pi range\n self.enforce_theta_range()\n\n self.a1 = self.rnd(self.discretize(a1, self.a_interval))\n self.a2 = self.rnd(self.discretize(a2, self.a_interval))\n self.state = (self.theta, self.a1, self.a2)\n # print('after: ' + str(self.state))\n\n return self.state","def advanceVelocity(self,time,acceleration):\n if not isinstance(acceleration,Cartesian3DVector):\n raise CoordinateException(\"Advancing particle momentum with the incorrect acceleration type.\")\n return self.v + time*acceleration","def __init__(self, robot: SmartBot, dt):\n self._robot = robot\n self._target_position = None\n self._dt = dt\n\n self._pose = np.zeros(3)","def __init__(self, total_time, kin, limb, ar_tag_pos):\n # raise NotImplementedError\n self.r = .1 \n MotionPath.__init__(self, limb, kin, total_time)\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\n self.ar_tag_pos[2] = 0.282\n self.start_pos = [ar_tag_pos[0],ar_tag_pos[1]+self.r,ar_tag_pos[2]]\n self.w = 2*math.pi/self.total_time","def log_odometry(self, data):\n\n\t\tself.pose = data.pose.pose\n\t\tself.velocity = data.twist.twist\n\n\t\tprintable_pose = self.human_readable_pose2d(self.pose)\n\n\t\t# log robot's pose\n\t\trospy.loginfo_throttle(\n\t\tperiod=1, # log every 10 seconds\n\t\tmsg=self.name + ' (%.3f, %.3f, %.3f) ' % printable_pose # message\n\t\t)","def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\n\n #project forwards in time\n sim_interval = self.sim_interval\n sim_interval_sq = sim_interval*sim_interval\n cmd_vel = list(cmd_vel)\n current_speed = list(current_speed)\n\n max_acc_x = self.robot.max_acc_x\n max_acc_th = self.robot.max_acc_th\n max_decc_x = self.robot.max_dacc_x\n max_decc_th = self.robot.max_dacc_th\n\n\n code = \"\"\"\n double x, y, th;\n x = y = th = 0;\n\n double vx, vth;\n vx = current_speed[0];\n vth = current_speed[1];\n\n double cmd_x = cmd_vel[0];\n double cmd_th = cmd_vel[1];\n\n //are we accelerating or decelerating?\n double acc_x;\n double acc_th;\n\n bool b_ax = false;\n if (cmd_x > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = accs[2];\n acc_x = -1*acc_x;\n }\n\n bool b_ath = false;\n if (cmd_th > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1* (double) accs[3];\n\n }\n\n py::list traj;\n\n //delay at the beginning\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //application of the command\n for (double i=0; i<=time_applied; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //delay before decellerating\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //now we apply a stop\n b_ax = false;\n if (0 > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = -1 * (double) accs[2];\n }\n\n b_ath = false;\n if (0 > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1 * (double) accs[3];\n }\n\n for (double i=0; i<=time_decc; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx) < 1e-6) vx = 0;\n\n //check if we have exceeded our target\n if (b_ax && (vx > 0 )) vx = 0;\n if (!b_ax && (vx < 0 )) vx = 0;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth) < 1e-6) vth = 0;\n if (b_ath && (vth > 0 )) vth = 0;\n if (!b_ath && (vth < 0 )) vth = 0;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n\n\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\n if (stopped) break;\n\n }\n\n return_val = traj;\n \"\"\"\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\n 'time_decc'], type_converters=converters.blitz)\n\n return traj","def publish(self):\n msg = PolynomialTrajectory()\n\n if self.trajectory_constructed == True: \n t = time.time()-self.traj_t0\n\n if t <= self.seg_times[-1]: \n segment = map(lambda x:x > t, self.seg_times).index(True)\n else: \n segment = self.no_of_segments; t = self.seg_times[-1]\n \n rospy.loginfo('the value of t and segment is:%f, %d', t, segment)\n #rospy.loginfo('segment times are:%f, %f, %f, %f, %f, %f', self.segment_times[0], \\\n #self.segment_times[1], self.segment_times[2], self.segment_times[3], self.segment_times[4], self.segment_times[5])\n p1 = self.pc_x; p2 = self.pc_y; p3 = self.pc_z\n N = self.N+1\n p1 = [p1[i:i + N] for i in range(0, len(p1), N)]\n [i.reverse() for i in p1]\n \n p2 = [p2[i:i + N] for i in range(0, len(p2), N)]\n [i.reverse() for i in p2]\n \n p3 = [p3[i:i + N] for i in range(0, len(p3), N)]\n [i.reverse() for i in p3]\n xx = np.poly1d(p1[segment-1]); vx = np.polyder(xx, 1); ax = np.polyder(xx, 2)\n yy = np.poly1d(p2[segment-1]); vy = np.polyder(yy, 1); ay = np.polyder(yy, 2)\n zz = np.poly1d(p3[segment-1]); vz = np.polyder(zz, 1); az = np.polyder(zz, 2)\n \n msg.header.stamp = rospy.Time.now()\n msg.pdes.x = xx(t); msg.pdes.y = yy(t); msg.pdes.z = zz(t)\n msg.vdes.x = vx(t); msg.vdes.y = vy(t); msg.ades.z = vz(t)\n msg.ades.x = ax(t); msg.ades.y = ay(t); msg.ades.z = az(t)\n msg.ddes.x = 1; msg.ddes.y = 0; msg.ddes.z = 0\n msg.controller = 0\n \n self.pub.publish(msg)\n\n else: \n rospy.loginfo('no goal is published yet')","def waypoint_callback(self, wp):\n if self.trajectory_constructed == False: \n NextwpPosition = np.array([wp.position.x, wp.position.y, wp.position.z])\n NextwpOrientation = np.array([wp.orientation.x, wp.orientation.y, wp.orientation.z, wp.orientation.w])\n self.pc_x, self.pc_y, self.pc_z, self.seg_times, self.traj_t0 = self.make_trajectory(NextwpPosition, NextwpOrientation) \n self.trajectory_constructed = True","def calculate_trajectory(self, position, velocity, acceleration,\n deltaV, deltaD):\n # Initial/End conditions\n initS = (position[0], velocity[0], acceleration[0])\n initD = (position[1], velocity[1], acceleration[1])\n\n # TODO: find proper boundary condition for dS\n dS = ((2 * initS[1] + deltaV) / 2) * self.deltaT\n\n endS = (initS[0] + dS, initS[1] + deltaV, 0)\n endD = (initD[0] + deltaD, 0, 0)\n\n # Calculate coefficients\n coeff_S = self.calculate_coefficients(initS, endS)\n coeff_D = self.calculate_coefficients(initD, endD)\n\n # Calculate trajectory\n trajectory = self._get_trajectory(coeff_S, coeff_D)\n\n return trajectory","def move2cartesian(position=None, orientation=None, relative_pose=None, in_tip_frame=False, joint_angles=[],\n tip_name='right_hand', linear_speed=0.6, linear_accel=0.6, rotational_speed=1.57,\n rotational_accel=1.57, timeout=None, neutral=False):\n\n try:\n #rospy.init_node('go_to_cartesian_pose_py')\n limb = Limb()\n\n traj_options = TrajectoryOptions()\n traj_options.interpolation_type = TrajectoryOptions.CARTESIAN\n traj = MotionTrajectory(trajectory_options = traj_options, limb = limb)\n\n wpt_opts = MotionWaypointOptions(max_linear_speed=linear_speed,\n max_linear_accel=linear_accel,\n max_rotational_speed=rotational_speed,\n max_rotational_accel=rotational_accel,\n max_joint_speed_ratio=1.0)\n waypoint = MotionWaypoint(options = wpt_opts.to_msg(), limb = limb)\n\n joint_names = limb.joint_names()\n\n if joint_angles and len(joint_angles) != len(joint_names):\n rospy.logerr('len(joint_angles) does not match len(joint_names!)')\n return None\n\n if neutral == True:\n limb.move_to_neutral()\n else:\n if (position is None and orientation is None and relative_pose is None):\n if joint_angles:\n # does Forward Kinematics\n waypoint.set_joint_angles(joint_angles, tip_name, joint_names)\n else:\n rospy.loginfo(\"No Cartesian pose or joint angles given. Using default\")\n waypoint.set_joint_angles(joint_angles=None, active_endpoint=tip_name)\n else:\n endpoint_state = limb.tip_state(tip_name)\n if endpoint_state is None:\n rospy.logerr('Endpoint state not found with tip name %s', tip_name)\n return None\n pose = endpoint_state.pose\n\n if relative_pose is not None:\n if len(relative_pose) != 6:\n rospy.logerr('Relative pose needs to have 6 elements (x,y,z,roll,pitch,yaw)')\n return None\n # create kdl frame from relative pose\n rot = PyKDL.Rotation.RPY(relative_pose[3],\n relative_pose[4],\n relative_pose[5])\n trans = PyKDL.Vector(relative_pose[0],\n relative_pose[1],\n relative_pose[2])\n f2 = PyKDL.Frame(rot, trans)\n # and convert the result back to a pose message\n if in_tip_frame:\n # end effector frame\n pose = posemath.toMsg(posemath.fromMsg(pose) * f2)\n else:\n # base frame\n pose = posemath.toMsg(f2 * posemath.fromMsg(pose))\n else:\n if position is not None and len(position) == 3:\n pose.position.x = position[0]\n pose.position.y = position[1]\n pose.position.z = position[2]\n if orientation is not None and len(orientation) == 4:\n pose.orientation.x = orientation[0]\n pose.orientation.y = orientation[1]\n pose.orientation.z = orientation[2]\n pose.orientation.w = orientation[3]\n poseStamped = PoseStamped()\n poseStamped.pose = pose\n\n if not joint_angles:\n # using current joint angles for nullspace bais if not provided\n joint_angles = limb.joint_ordered_angles()\n waypoint.set_cartesian_pose(poseStamped, tip_name, joint_angles)\n else:\n waypoint.set_cartesian_pose(poseStamped, tip_name, joint_angles)\n\n rospy.loginfo('Sending waypoint: \\n%s', waypoint.to_string())\n\n traj.append_waypoint(waypoint.to_msg())\n\n result = traj.send_trajectory(timeout=timeout)\n if result is None:\n rospy.logerr('Trajectory FAILED to send')\n return\n\n if result.result:\n rospy.loginfo('Motion controller successfully finished the trajectory!')\n else:\n rospy.logerr('Motion controller failed to complete the trajectory with error %s',\n result.errorId)\n \n except rospy.ROSInterruptException:\n rospy.logerr('Keyboard interrupt detected from the user. Exiting before trajectory completion.')","def motion_model(particle_poses, speed_command, odom_pose, odom_pose_prev, dt):\n \n M = particle_poses.shape[0]\n \n # TODO. For each particle calculate its predicted pose plus some\n # additive error to represent the process noise. With this demo\n # code, the particles move in the -y direction with some Gaussian\n # additive noise in the x direction. Hint, to start with do not\n # add much noise.\n\n #time is in ns 1e-9\n dt = dt * 1e-9\n \n if dt ==0:\n return particle_poses\n\n for m in range(M):\n\n theta = particle_poses[m, 2]\n\n v = speed_command[0]\n omega = speed_command[1]\n \n if motion_model_velocity: #Velocity\n\n if omega == 0: #straight\n vel_dx = v * cos(theta) * dt\n vel_dy = v * sin(theta) * dt\n vel_dtheta = 0\n\n else:\n vel_dx = -v / omega * sin(theta) + v / omega * sin(theta + omega * dt)\n vel_dy = v / omega * cos(theta) - v / omega * cos(theta + omega * dt)\n vel_dtheta = omega * dt\n \n\n\n if motion_model_odom:\n odom_mov = rev_odm(odom_pose, odom_pose_prev)\n\n #particle_poses[m] = fwd_odm(particle_poses[m], odom_mov)\n\n #odom_dpose = fwd_odm2(particle_poses[m], odom_mov)\n (odom_dx, odom_dy, odom_dtheta) = fwd_odm2(particle_poses[m], odom_mov)\n\n\n\n\n #fusion\n w = motion_weighting\n dx = w * odom_dx + (1-w) * vel_dx\n dy = w * odom_dy + (1-w) * vel_dy\n dtheta = w * odom_dtheta + (1-w) * vel_dtheta\n \n \n\n \n \n #process noise\n if motion_model_noise:\n noise_x= np.random.normal(0, motion_sigma_x)\n noise_y= np.random.normal(0, motion_sigma_y)\n noise_theta= np.random.normal(0, motion_sigma_theta)\n \n #local noise\n if motion_model_noise_alt:\n localnoise_x = np.random.normal(0, motion_sigma_x)\n localnoise_y = np.random.normal(0, motion_sigma_y)\n\n noise_x = localnoise_x * cos(theta) - localnoise_y * sin(theta)\n noise_y = localnoise_y * sin(theta) + localnoise_y * cos(theta)\n noise_theta = np.random.normal(0, motion_sigma_theta)\n\n\n\n particle_poses[m, 0] += dx + noise_x\n particle_poses[m, 1] += dy + noise_y\n particle_poses[m, 2] = wraptopi(theta + dtheta + noise_theta)\n\n \n return particle_poses","def position(t, x, y):\n return x * exp(-t * y) * sin(2 * pi * t)","def add_ado(\n self,\n position: torch.Tensor,\n velocity: torch.Tensor = torch.zeros(2),\n history: torch.Tensor = None,\n **ado_kwargs\n ) -> mantrap.agents.IntegratorDTAgent:\n # When being queried with an agent's history length of one, the Trajectron will always predict standing\n # still instead of assuming a constant velocity (or likewise). However when the user inputs just one\n # position and one velocity, rather than a full state history, continuing on this path clearly is the\n # user's intention, therefore stack several copies of this input state (position, velocity, time) in order\n # to create a history the Trajectron is used to deal with, while giving the incentive to predict a simple\n # \"constant\" continuation of this state as most likely prediction.\n if history is None or history.shape[0] == 1:\n position, velocity = position.float(), velocity.float()\n history = torch.stack([torch.cat(\n (position + velocity * self.dt * t, velocity, torch.ones(1) * self.time + self.dt * t))\n for t in range(-mantrap.constants.TRAJECTRON_DEFAULT_HISTORY_LENGTH, 1)\n ])\n\n ado = super(Trajectron, self).add_ado(position, velocity=velocity, history=history, **ado_kwargs)\n # Add a ado to Trajectron neural network model using reference ghost.\n self._add_agent_to_graph(agent=ado)\n return ado","def main():\r\n PathGenerator = TrajectoryGenerator()\r\n \r\n ## coordinate \r\n # Y \r\n # ^ /\r\n # | /\r\n # | / <theta>\r\n # o -- -- -- >X\r\n\r\n x_0 = 0.0 # initial x position\r\n y_0 = 0.0 # initial y position\r\n theta_0 = 0.0 *np.pi/180 # initial heading angle of the vehicle \r\n kappa_0 = 0.0 *np.pi/180 # initial steering angle \r\n initial_state = [x_0, y_0, theta_0, kappa_0] \r\n \r\n x_f = 13.0 # final x position\r\n y_f = 8.0 # final y position\r\n theta_f = 0.0 *np.pi/180 # final heading angle of the vehicle \r\n kappa_f = 0.0 *np.pi/180 # final steering angle \r\n final_state = [x_f, y_f, theta_f, kappa_f] \r\n\r\n traject = PathGenerator.compute_spline(initial_state, final_state)\r\n point_array = np.asarray(traject)\r\n plt.plot(point_array[:,0], point_array[:,1],'o')\r\n \r\n sample_resolution = 0.5\r\n temp_goal_list = []\r\n for i in range(-2, 3):\r\n temp_final_state = np.copy(final_state)\r\n temp_final_state[1] = temp_final_state[1] + float(i)*sample_resolution\r\n temp_goal_list.append(temp_final_state)\r\n \r\n start = time.time()\r\n point_list = []\r\n for i in range(0, 5):\r\n temp_goal = temp_goal_list[i]\r\n traject = PathGenerator.compute_spline(initial_state, temp_goal)\r\n point_list.append(traject)\r\n end = time.time()\r\n print('Executed time is %f'%(end - start))\r\n \r\n # pdb.set_trace()\r\n for i in range(0,5):\r\n point_array = np.asarray(point_list[i])\r\n plt.plot(point_array[:,0], point_array[:,1],'o')\r\n \r\n plt.axis('equal')\r\n plt.show()","def move(self, xT):\n # Sample distance to collision\n Distance = -(1.0/xT)*math.log(random.random())\n\n # Move Particle\n x = self.position[0] + Distance*self.direction[0]\n y = self.position[1] + Distance*self.direction[1]\n z = self.position[2] + Distance*self.direction[2]\n self.position = (x,y,z)","def my_go_to_pose1(robot, x, y, angle_z):\n # Assuming positive y is to the robot's left and positive x is the direction the robot is already facing\n hypotenuse = numpy.sqrt(x*x + y*y)\n angle_offset_of_target_point = numpy.arcsin(y/hypotenuse)*180/math.pi\n my_turn_in_place(robot, angle_offset_of_target_point , 30)\n my_drive_straight(robot, hypotenuse, 50)\n my_turn_in_place(robot, angle_z-angle_offset_of_target_point, 30)\n time.sleep(1)","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def _get_pointing_pose(self, point_entity):\n # type: (Entity, Arm) -> FrameStamped\n # Compute the frame w.r.t. base link\n fs_robot = point_entity.pose.projectToFrame(self.robot.base_link_frame, self.robot.tf_buffer)\n\n # Set the orientation to unity\n fs_robot.frame.M = kdl.Rotation()\n\n return fs_robot","def joint_trajectory(theta_start, theta_end, Tf, N, method):\n\n N = int(N)\n timegap = Tf / (N - 1.0) # N points, N-1 line segments\n traj = np.zeros((len(theta_start), N)) # intitialize the trajectory matrix, 1D joint vars, 2D each time instance\n\n # for each line segment, from 0 to T, calculate the corresponding s value (0to1)\n for i in range(N):\n if method == 3:\n s = cubic_time_scaling(Tf, timegap * i)\n else:\n s = quintic_time_scaling(Tf, timegap * i)\n traj[:, i] = s * np.array(theta_end) + (1 - s) * np.array(theta_start) # xi = x_start + (0.whatever fraction s)(x_end-x_start)\n traj = np.array(traj).T\n return traj","def write_point_trajectory_file( filename, times, points ):\n\n plot = open( filename, \"w\")\n plot.write(\"\"\"# point trajectory file \n# Each line represents one Cartesian points for plotting the moving point, e.g.\n# the origin of a moving coordinate frame.\n# format: timestamp x, y, z\n# units: seconds, millimeters\n\"\"\")\n\n for i,pt in enumerate( points ):\n plot.write( \"%f \" % times[i] )\n plot.write( \"%f %f %f\\n\" % tuple( pt[0:3] ) )\n plot.close()\n return","def _on_pose(self, msg):\n if self._history_length == Dashboard.POSE_MAX_TIMESTEPS:\n self._pose_history[:, :-1] = self._pose_history[:, 1:]\n else:\n self._history_length += 1\n\n self._pose_history[:, self._history_length-1] = [\n rospy.Time.now().to_time() % 1000,\n msg.x,\n msg.y,\n msg.theta,\n msg.linear_velocity,\n msg.angular_velocity,\n ]","def makeSpline(self, waypointTrajectory: Trajectory, loop: bool=False) -> None:\n if loop and waypointTrajectory.milestones[-1] != waypointTrajectory.milestones[0]:\n print(waypointTrajectory.milestones[-1],\"!=\",waypointTrajectory.milestones[0])\n raise ValueError(\"Asking for a loop trajectory but the endpoints don't match up\")\n velocities = []\n t = waypointTrajectory\n d = len(t.milestones[0])\n third = 1.0/3.0\n if len(t.milestones)==1:\n velocities.append([0]*d)\n elif len(t.milestones)==2:\n if loop:\n v = [0.0]*d\n velocities = [v,v]\n else:\n s = (1.0/(t.times[1]-t.times[0]) if (t.times[1]-t.times[0]) != 0 else 0)\n v = vectorops.mul(self.geodesic.difference(t.milestones[1],t.milestones[0]),s) \n velocities.append(v)\n v2 = vectorops.mul(self.geodesic.difference(t.milestones[0],t.milestones[1]),-s) \n velocities.append(v2)\n else:\n N = len(waypointTrajectory.milestones)\n if loop:\n timeiter = zip([-2]+list(range(N-1)),range(0,N),list(range(1,N))+[1])\n else:\n timeiter = zip(range(0,N-2),range(1,N-1),range(2,N))\n for p,i,n in timeiter:\n if p < 0: dtp = t.times[-1] - t.times[-2]\n else: dtp = t.times[i] - t.times[p]\n if n <= i: dtn = t.times[1]-t.times[0]\n else: dtn = t.times[n]-t.times[i]\n assert dtp >= 0 and dtn >= 0\n s2 = (1.0/dtn if dtn != 0 else 0)\n v2 = vectorops.mul(self.geodesic.difference(t.milestones[n],t.milestones[i]),s2)\n s1 = (1.0/dtp if dtp != 0 else 0)\n v1 = vectorops.mul(self.geodesic.difference(t.milestones[p],t.milestones[i]),-s1)\n v = vectorops.mul(vectorops.add(v1,v2),0.5)\n velocities.append(v)\n if not loop:\n #start velocity as linear\n v0 = vectorops.mul(self.geodesic.difference(t.milestones[1],t.milestones[0]),1.0/(t.times[1]-t.times[0]))\n #terminal velocity as quadratic\n vn = vectorops.mul(self.geodesic.difference(t.milestones[-2],t.milestones[-1]),-1.0/(t.times[-1]-t.times[-2]))\n velocities = [v0]+velocities+[vn]\n else:\n assert len(velocities) == N\n GeodesicHermiteTrajectory.__init__(self,self.geodesic,waypointTrajectory.times[:],waypointTrajectory.milestones,velocities)","def position(self, l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n pos = x + v * t + (1/2.0) * g * t**2\n \n if squeeze:\n pos = np.squeeze(pos, axis=0)\n return pos","def goToPose(self,pose,speed=DEFAULT_SPEED):\n\n print(\"Moving to {}\".format(pose.description))\n gpio = pose.gpio\n if gpio != None:\n pin = gpio.get('pin',None)\n value = gpio.get('value',0)\n if pin != None:\n if type(pin) is str:\n self.robot.set_io({pin:value})\n elif pin != -1:\n GPIO.output(pin, {0:False,1:True}[value])\n self.waitFor(gpio.get('delay',2))\n return 'Set Io: '+str(pin)+' value: '+str(value)\n print(gpio)\n newSpeed = speed\n if pose.speed != None:\n newSpeed = pose.speed\n cmd = self.getMovementCommand(pose,speed=newSpeed)\n print(cmd)\n self.robot.play(cmd)\n self.waitForCompletion()\n print(\"Completed move\")","def trajectory(self):\n return Trajectory.createFromTuples(self.points)","def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):\n #raise NotImplementedError\n MotionPath.__init__(self, limb, kin, total_time)\n start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])\n\n\n #The ar tracking function was not working properly so we added the block below \n #to correct it.\n if start_pos[1]>start_pos[0]:\n a = start_pos[0]\n b = start_pos[1]\n start_pos[0] = b\n start_pos[1] = a\n print(\"### Modified start_pos ###\")\n\n\n ar_tag_pos = np.array([abs(ar_tag_pos[0]), abs(ar_tag_pos[1]), abs(ar_tag_pos[2])])\n if ar_tag_pos[1]>ar_tag_pos[0]:\n a = ar_tag_pos[0]\n b = ar_tag_pos[1]\n ar_tag_pos[0] = b\n ar_tag_pos[1] = a\n self.start_pos = start_pos\n\n print(\"!!!!!!!!!!!!!!!!start_pos!!!!!!!!!!!!!!!!\")\n print(start_pos)\n print(\"!!!!!!!!!ar_tag_pos in LinearPath!!!!!!!!!\")\n print(ar_tag_pos)\n ar_tag_pos[2] = start_pos[2]\n self.ar_tag_pos = ar_tag_pos\n self.points_generated = []","def my_go_to_pose1(robot, x, y, angle_z):\n\t# ####\n\t# TODO: Implement a function that makes the robot move to a desired pose\n\t# using the my_drive_straight and my_turn_in_place functions. This should\n\t# include a sequence of turning in place, moving straight, and then turning\n\t# again at the target to get to the desired rotation (Approach 1).\n\t# ####\n\tfirstRotationInRadians = (0 if y == 0 else 90) if x == 0 else math.atan(y/x)\n\tfirstRotation = firstRotationInRadians * 360.0/ (2.0 * math.pi)\n\tmy_turn_in_place(robot, firstRotation, 30)\n\trobot.stop_all_motors()\n\t# robot.drive_wheels(0, 0, duration=1)\n\t# time.sleep(1)\n\tmy_drive_straight(robot, math.sqrt(x*x + y*y), (-1 if x < 0 else 1) * 30)\n\trobot.stop_all_motors()\n\t# robot.drive_wheels(0, 0, duration=1)\n\t# time.sleep(1)\n\tmy_turn_in_place(robot, angle_z - firstRotation , 30)\n\ttime.sleep(1)","def compute_trajectory(\n traj_type: str,\n origin: Position,\n goal: Position,\n step: int,\n origin_qd: float = 0.002,\n goal_qd: float = 0.002,\n) -> rtb.tools.trajectory.Trajectory:\n # print(f\"{origin=}\\n{goal=}\\n\")\n\n trajs = []\n for origin_q, goal_q in zip(origin.xyzrpy, goal.xyzrpy):\n\n if traj_type == \"lspb\":\n traj_func = rtb.tools.trajectory.lspb\n args = [origin_q, goal_q, step]\n elif traj_type == \"tpoly\":\n traj_func = rtb.tools.trajectory.tpoly\n args = [origin_q, goal_q, step, origin_qd, goal_qd]\n\n if origin_q == goal_q:\n trajs.append(\n Trajectory(\n traj_type,\n step,\n [origin_q] * step,\n [0] * step,\n [0] * step,\n istime=False,\n )\n )\n else:\n trajs.append(traj_func(*args))\n\n x = trajs[0].t\n y = np.array([tg.s for tg in trajs]).T\n yd = np.array([tg.sd for tg in trajs]).T\n ydd = np.array([tg.sdd for tg in trajs]).T\n\n istime = trajs[0].istime\n\n return Trajectory(\"mtraj\", x, y, yd, ydd, istime)","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def line_to(self, point: Onion[Tuple[float, float], Point2D, Point3D, Point]):\n start_point = self.last_point\n end_point = _point_2d(point)\n self._segments.append(Line3D.create(start_point, end_point))","def get_trajectory_message(action, joint_order):\n # Set up a trajectory message to publish.\n action_msg = JointTrajectory()\n # action_msg.joint_names = self.environment['joint_order']\n action_msg.joint_names = joint_order\n # Create a point to tell the robot to move to.\n target = JointTrajectoryPoint()\n action_float = [float(i) for i in action]\n target.positions = action_float\n\n # Package the single point into a trajectory of points with length 1.\n action_msg.points = [target]\n return action_msg","def setDirectionTowardPoint(self, x, y, speed):\n currX = self.xcor()\n currY = self.ycor()\n # get actual vector from t to x,y\n dXactual = x - currX\n dYactual = y - currY\n\n # get the length of that vector. Can also use turtle.distance\n length = math.hypot(dXactual, dYactual)\n\n # now scale the vector\n try:\n self.dx = dXactual / length * speed\n self.dy = dYactual / length * speed\n except:\n self.dx = 0\n self.dy = 0","def waypts2setpts(P, params):\n\tV = params.drone_vel # [m/s]\n\tfreq = params.ViconRate; dt = 1./freq\n\tdx = V * dt\n\ttraj_global = np.array(P[-1])\n\tfor i in range(len(P)-1, 0, -1):\n\t\tA = P[i]\n\t\tB = P[i-1]\n\n\t\tn = (B-A) / norm(B-A)\n\t\tdelta = n * dx\n\t\tN = int( norm(B-A) / norm(delta) )\n\t\tsp = A\n\t\ttraj_global = np.vstack([traj_global, sp])\n\t\tfor i in range(N):\n\t\t\tsp += delta\n\t\t\ttraj_global = np.vstack([traj_global, sp])\n\t\tsp = B\n\t\ttraj_global = np.vstack([traj_global, sp])\n\n\treturn traj_global","def move2goal(self):\n vel_msg = Twist()\n\n # Linear velocity in the x-axis.\n vel_msg.linear.x = 0.4 # m/s\n vel_msg.linear.y = 0\n vel_msg.linear.z = 0\n\n # Angular velocity in the z-axis.\n vel_msg.angular.x = 0\n vel_msg.angular.y = 0\n vel_msg.angular.z = 1.5 # rad/s\n\n # Starting point reference\n goal_x = 1.0 \n goal_y = 1.0\n x_ref = 1.0\n y_ref = 1.0\n\n # Previous Reference\n x_prev_ref = 0.0\n y_prev_ref = 0.0\n theta_prev_ref = self.theta\n vrefA = 0.5\n wrefA = 0.0\n \n i = 0\n tPx, tPy, tPTheta = self.initiate_trajectory(\n x_ref, y_ref, vel_msg, \n x_prev_ref, y_prev_ref, \n theta_prev_ref, vrefA, wrefA\n )\n\n x_prev_ref = tPx[0]\n y_prev_ref = tPy[0]\n theta_prev_ref = tPTheta[0]\n\n print(f'X TRAJECTORY: {tPx}\\nY TRAJECTORY: {tPy}\\nTHETA TRAJ: {tPTheta}')\n print(f'ACTUAL THETA: {self.theta}')\n\n while not rospy.is_shutdown():\n \n if i >= 8:\n i = 0\n\n x_ref = goal_x\n y_ref = goal_y\n\n tPx, tPy, tPTheta = self.initiate_trajectory(\n x_ref, y_ref, vel_msg, \n x_prev_ref, y_prev_ref, \n theta_prev_ref, vrefA, wrefA\n )\n # inputRef = ControllerInput(\n # xref=x_ref,\n # yref=y_ref,\n # RstateX=self.x_position,\n # RstateY=self.y_position,\n # RstateTheta=self.theta,\n # RstateVelocity=vel_msg.linear.x,\n # RstateW=vel_msg.angular.z,\n # xrefA=x_prev_ref,\n # yrefA=y_prev_ref,\n # thetarefA=theta_prev_ref,\n # vrefA=vrefA,\n # wrefA=wrefA\n # )\n\n # rospy.loginfo(f'X: {self.x_position} \\tY: {self.y_position}\\t Theta: {self.theta} ')\n # nmpc = NMPC_Controller(inputRef)\n # tPx, tPy, tPTheta = nmpc.test_create_mini_path()\n\n # print(f'X TRAJECTORY: {tPx}\\nY TRAJECTORY: {tPy}\\nTHETA TRAJ: {tPTheta}')\n # print(f'ACTUAL THETA: {self.theta}')\n \n # new_v, new_w = nmpc.start_optmizer()\n # new_v = round(new_v, 4)\n # new_w = round(new_w, 4)\n\n # print(new_v, new_w)\n # rospy.loginfo(\n # f'X: {self.x_position}, Y: {self.y_position}, THETA: {self.theta}')\n \n # self.velocity_publisher.publish(vel_msg)\n # x_prev_ref = self.x_position\n # y_prev_ref = self.y_position\n # theta_prev_ref = self.theta\n # vrefA = vel_msg.linear.x\n # wrefA = vel_msg.angular.z\n \n\n # theta_prev_ref = self.theta\n # vel_msg.angular.z = 0.0\n\n\n '''Update the linear & angular velocity'''\n # vel_msg.linear.x = new_v\n # vel_msg.angular.z = new_w\n\n if i < 8:\n inputRef = ControllerInput(\n xref = tPx[i],\n yref = tPy[i],\n RstateX = self.x_position,\n RstateY = self.y_position,\n RstateTheta = self.theta,\n RstateVelocity = vel_msg.linear.x,\n RstateW = vel_msg.angular.z,\n xrefA = x_prev_ref,\n yrefA = y_prev_ref,\n thetarefA = theta_prev_ref,\n vrefA = vrefA,\n wrefA = wrefA\n )\n\n nmpc = NMPC_Controller(inputRef)\n new_v, new_w = nmpc.start_optmizer()\n new_v = round(new_v, 4)\n new_w = round(new_w, 4)\n\n print(f'(actual) X: {self.x_position}, Y: {self.x_position}, THETA: {self.theta}')\n print(f'(desired) X: {tPx[i]}, Y: {tPy[i]}')\n print(f'V: {vel_msg.linear.x}\\tW: {vel_msg.angular.z}')\n\n x_prev_ref = tPx[i-1]\n y_prev_ref = tPy[i-1]\n theta_prev_ref = tPTheta[i-1]\n vrefA = vel_msg.linear.x\n wrefA = vel_msg.angular.z\n\n vel_msg.linear.x = new_v\n vel_msg.angular.z = new_w\n # vel_msg.angular.z = 0.0\n\n print(f'index: {i}')\n\n distance = math.sqrt((self.x_position - tPx[i])**2 + (self.y_position - tPy[i])**2)\n if distance < 0.3:\n print(f'Distance: {distance}')\n i+=1\n\n\n self.velocity_publisher.publish(vel_msg)\n self.rate.sleep()\n\n rospy.spin()","def _evolve(\n self,\n x0_idx: int,\n ) -> np.ndarray:\n x0 = self.starting_points[x0_idx, :]\n if type(x0) != np.ndarray:\n x0 = x0.toarray()\n x0 = x0.flatten()\n # [T, Dims, (Position, Velocity)]\n trajectory = np.zeros(\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\n \n # for each timestep, update the position of the phase point\n # based on the velocity of nearest neighbors and obey any\n # boundary constraints\n x = x0\n for t in range(self.timesteps):\n trajectory[t, :, 0] = x # match x position to dv/dx\n v = self.v_fxn(x=x.reshape(-1),)\n # add white noise if desired to better emulate a stochastic process\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\n x_new = x + (v[:, 0] + noise)*self.step_scale\n # constrain to a set of pre-defined boundaries\n # defaults to an identity if not set explicitly\n x_new = self.boundary_constraint(x_new)\n trajectory[t, :, 1] = v[:, 0]\n trajectory[t, :, 2] = v[:, 1]\n x = x_new\n return trajectory","def my_go_to_pose2(robot, x, y, angle_z):\n\t# ####\n\t# TODO: Implement a function that makes the robot move to a desired pose\n\t# using the robot.drive_wheels() function to jointly move and rotate the \n\t# robot to reduce distance between current and desired pose (Approach 2).\n\t# ####\n\t\n\tabsoluteTargetPosition = (robot.pose.position.x + x, robot.pose.position.y + y, robot.pose.rotation.angle_z.degrees + angle_z)\n\t\n\twhile(math.sqrt(x*x + y*y) > 50.0):\n\t\t# print(\"(x, y, angle_z) = (%i,%i,%i)\" % (x, y, angle_z))\n\t\tfirstRotationInRadians = (0 if y == 0 else 90) if x == 0 else math.atan(y/x)\n\t\tleftMotor = 10 * (2 * x - angle_z * (2 * math.pi / 360.0) * get_distance_between_wheels() * math.cos(firstRotationInRadians)) / (2 * get_front_wheel_radius() * math.cos(firstRotationInRadians))\n\t\trightMotor = 10 * (2 * x + angle_z * (2 * math.pi / 360.0) * get_distance_between_wheels() * math.cos(firstRotationInRadians)) / (2 * get_front_wheel_radius() * math.cos(firstRotationInRadians))\n\t\t# print(\"(leftMotor, rightMotor) = (%i,%i)\" % (leftMotor, rightMotor))\n\t\tangle_delta = get_front_wheel_radius() * (rightMotor - leftMotor) / get_distance_between_wheels()\n\t\tx_delta = get_front_wheel_radius() * math.cos(angle_z * 2.0 * math.pi / 360.0) * (leftMotor + rightMotor) / 2.0\n\t\ty_delta = get_front_wheel_radius() * math.sin(angle_z * 2.0 * math.pi / 360.0) * (leftMotor + rightMotor) / 2.0\n\t\t# print(\"angle_delta %i\" % angle_delta)\n\t\t# x = x - get_front_wheel_radius() * math.cos(angle_delta) * (leftMotor + rightMotor) / 2.0\n\t\t# y = y - get_front_wheel_radius() * math.sin(angle_delta) * (leftMotor + rightMotor) / 2.0\n\t\t# print(\"(x, y, angle_z) = (%i,%i,%i)\" % (x, y, angle_z))\n\t\t# angle_z = angle_z + angle_delta * (360.0/(2 * math.pi))\n\t\t# print(\"(x, y, angle_z) = (%i,%i,%i)\" % (x, y, angle_z))\n\t\trobot.drive_wheels(leftMotor, rightMotor, duration = 1)\n\t\trobot.stop_all_motors()\n\t\t# time.sleep(1)\n\t\tx = absoluteTargetPosition[0] - robot.pose.position.x\n\t\ty = absoluteTargetPosition[1] - robot.pose.position.y\n\t\tangle_z = absoluteTargetPosition[2] - robot.pose.rotation.angle_z.degrees\n\t\t# print(\"(x, y, angle_z) = (%i,%i,%i)\" % (x, y, angle_z))\n\t\trobot.stop_all_motors()\n\t\t# robot.drive_wheels(0,0)","def get_grasp_joint_trajectory(self, start_joints, target_pose, n_steps=40, ignore_orientation=False, link_name=None):\n link_name = link_name if link_name is not None else self.tool_frame\n \n assert len(start_joints) == len(self.joint_indices)\n assert target_pose.frame.count('base_link') == 1\n self.sim.update()\n \n # set active manipulator and start joint positions\n self.robot.SetDOFValues(start_joints, self.joint_indices)\n \n # initialize trajopt inputs\n rave_pose = tfx.pose(self.sim.transform_from_to(target_pose.matrix, target_pose.frame, 'world'))\n quat = rave_pose.orientation\n xyz = rave_pose.position\n quat_target = [quat.w, quat.x, quat.y, quat.z]\n xyz_target = [xyz.x, xyz.y, xyz.z]\n rave_mat = rave.matrixFromPose(np.r_[quat_target, xyz_target])\n \n# init_joint_target = None\n init_joint_target = self.sim.ik_for_link(rave_pose.matrix, self.manip, link_name, 0)\n if init_joint_target is not None:\n init_joint_target = self._closer_joint_angles(init_joint_target, start_joints)\n \n init_traj = self.ik_point(start_joints, xyz, n_steps=n_steps, link_name=link_name)\n \n request = self._get_grasp_trajopt_request(xyz_target, quat_target, n_steps,\n ignore_orientation=ignore_orientation, link_name=link_name, init_traj=init_traj)\n \n # convert dictionary into json-formatted string\n s = json.dumps(request) \n # create object that stores optimization problem\n prob = trajoptpy.ConstructProblem(s, self.sim.env)\n \n # TODO: worth doing?\n# tool_link = self.robot.GetLink(link_name)\n# def point_at(x):\n# self.robot.SetDOFValues(x, self.joint_indices, False)\n# T = tool_link.GetTransform()\n# local_dir = xyz.array - T[:3,3]\n# return T[1:3,:3].dot(local_dir)\n# \n# for t in xrange(int(0.8*n_steps), n_steps-1):\n# #prob.AddConstraint(point_at, [(t,j) for j in xrange(len(self.joint_indices))], \"EQ\", \"POINT_AT_%i\"%t)\n# prob.AddErrorCost(point_at, [(t,j) for j in xrange(len(self.joint_indices))], \"ABS\", \"POINT_AT_%i\"%t)\n\n # do optimization\n result = trajoptpy.OptimizeProblem(prob)\n \n prob.SetRobotActiveDOFs() # set robot DOFs to DOFs in optimization problem\n #num_upsampled_collisions = len(traj_collisions(result.GetTraj(), self.robot, n=100))\n num_upsampled_collisions = self._num_collisions(result.GetTraj())\n print('Number of collisions: {0}'.format(num_upsampled_collisions))\n self.robot.SetDOFValues(start_joints, self.joint_indices)\n if num_upsampled_collisions > 2:\n #if not traj_is_safe(result.GetTraj()[:], self.robot): # Check that trajectory is collision free\n return None\n else:\n return result.GetTraj()","def move_robot(self, pose):\n # type: (Pose) -> None\n start_pos = ModelState()\n start_pos.model_name = 'turtlebot3'\n start_pos.pose = pose\n rospy.wait_for_service('/gazebo/set_model_state')\n try:\n set_state = rospy.ServiceProxy('/gazebo/set_model_state', SetModelState)\n resp = set_state(start_pos)\n\n except rospy.ServiceException:\n print(\"Move Robot to position failed\")\n\n pub = rospy.Publisher('/initialpose', PoseWithCovarianceStamped, queue_size = 10)\n rospy.sleep(3)\n start_pos = PoseWithCovarianceStamped()\n start_pos.header.frame_id = 'map'\n start_pos.pose.pose = pose \n pub.publish(start_pos)","def step(self, dt):\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)","def update_position(self, robot_pose):\n x = self.pose[0] + robot_pose[0]\n y = self.pose[1] + robot_pose[1]\n phi = (self.pose[2] + robot_pose[2]) % 360\n self.pose = (x, y, phi)","def sample_trajectory(trajectory, t):\n\t# First point\n\tif t <= 0.0:\n\t\treturn copy.deepcopy(trajectory.points[0])\n\t# Last point\n\tif t >= trajectory.points[-1].time_from_start.to_sec():\n\t\treturn copy.deepcopy(trajectory.points[-1])\n\t# Finds the (middle) segment containing t\n\ti = 0\n\twhile trajectory.points[i + 1].time_from_start.to_sec() < t:\n\t\ti += 1\n\n\treturn interp_cubic(trajectory.points[i], trajectory.points[i + 1], t)","def _get_trajectory(self, coeff_S, coeff_D):\n # Create trajectory\n trajectory = Trajectory(self.deltaT, self.dt, self.t_steps)\n coeff = np.array([coeff_S, coeff_D]).T\n p_array = self.helper_p.dot(coeff)\n v_array = self.helper_v.dot(coeff)\n a_array = self.helper_a.dot(coeff)\n\n # Truncate trajectory\n trajectory.s_coordinates = p_array[:self.t_steps, 0]\n trajectory.d_coordinates = p_array[:self.t_steps, 1]\n trajectory.s_velocity = v_array[:self.t_steps, 0]\n trajectory.d_velocity = v_array[:self.t_steps, 1]\n trajectory.s_acceleration = a_array[:self.t_steps, 0]\n trajectory.d_acceleration = a_array[:self.t_steps, 1]\n\n return trajectory","def plot_trajectories_XYZ(t_start,t_stop):\n \n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\n \n index_start = np.where(time == t_start)[0][0]\n index_end = np.where(time == t_stop)[0][0]\n \n time = time[index_start:index_end+1]\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\n \n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\n \n plt.figure('Trajectories')\n plt.subplot(311)\n plt.plot(time,ankle_l_trajectory[:,0])\n plt.plot(time,ankle_r_trajectory[:,0])\n #plt.title('Trajectory of the X component')\n plt.xlabel('Time [s]')\n plt.ylabel('X Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(312)\n plt.plot(time,ankle_l_trajectory[:,1])\n plt.plot(time,ankle_r_trajectory[:,1])\n #plt.title('Trajectory of the Y component')\n plt.xlabel('Time [s]')\n plt.ylabel('Y Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(313)\n plt.plot(time,ankle_l_trajectory[:,2])\n plt.plot(time,ankle_r_trajectory[:,2])\n #plt.title('Trajectory of the Z component')\n plt.xlabel('Time [s]')\n plt.ylabel('Z Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n# plt.suptitle('Decomposition of the trajectories of the hind feet')\n return","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def cartesian_trajectory(X_start, X_end, Tf, N, method):\n\n N = int(N)\n timegap = Tf / (N - 1.0)\n traj = [[None]] * N\n R_start, p_start = ch3.transf_matrix_to_Rp(X_start)\n R_end, p_end = ch3.transf_matrix_to_Rp(X_end)\n\n R_start_end = np.dot(np.array(R_start).T,R_end)\n for i in range(N):\n if method == 3:\n s = cubic_time_scaling(Tf, timegap * i)\n else:\n s = quintic_time_scaling(Tf, timegap * i)\n\n R_start_end_fractioned = ch3.so3_to_rotation_matrix(ch3.rotation_matrix_to_so3(R_start_end) * s)\n R_start_s = np.dot(R_start, R_start_end_fractioned)\n\n p_start_s = s * np.array(p_end) + (1 - s) * np.array(p_start) #p_start + s(p_end-p_start)\n traj[i] = np.r_[np.c_[R_start_s, p_start_s], \\\n [[ 0, 0, 0, 1]]]\n\n \n return traj","def target_position(self, time):\n \"\"\"\n start_pos = self.points[self.cur_start]\n seg_time = time - self.last_checkpoint_time\n\n #The arguement of target-velocity dosent matter\n cur_pos = self.target_velocity(time)*seg_time + start_pos\n\n \n # or time > (self.total_time / 4)*(self.cur_start + 1)\n cur_pos_norm = length(cur_pos - start_pos)\n\n next_corner = self.points[(self.cur_start + 1)%4]\n \n seg_norm = length(next_corner - start_pos)\n print(\"cur_pos : \", cur_pos, \"segment: \", self.cur_start, seg_norm - cur_pos_norm)\n\n if cur_pos_norm >= seg_norm:\n self.cur_start = (self.cur_start + 1) % 4\n self.last_checkpoint_time = time\n return cur_pos\n \"\"\"\n\n #Possibly use rospy.sleep()\n total_time = self.total_time\n\n\n if time < total_time/4:\n return self.path1.target_position(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time < total_time/2:\n return self.path2.target_position(time - (total_time/4 + 0.5))\n # return self.path2.target_position(time - (total_time/4 ))\n\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= total_time/4*3:\n return self.path3.target_position(time - (total_time/2 + 1))\n # return self.path3.target_position(time - (total_time/2))\n\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n else:\n return self.path4.target_position(time - (total_time/4*3 + 1.5))\n # return self.path4.target_position(time - (total_time/4*3))","def my_go_to_pose2(robot, x, y, angle_z):\n # ####\n # TODO: Implement a function that makes the robot move to a desired pose\n # using the robot.drive_wheels() function to jointly move and rotate the \n # robot to reduce distance between current and desired pose (Approach 2).\n # ####\n pass","def project_point(self, point: array_like) -> Point:\n # Vector from the point in space to the point on the plane.\n vector_to_plane = Vector.from_points(point, self.point)\n\n # Perpendicular vector from the point in space to the plane.\n vector_projected = self.normal.project_vector(vector_to_plane)\n\n return Point(point) + vector_projected","def capture_ordinate(p, increment, flow, factor, printIt):\n x0, y0 = p.pos0\n\n forbid_up, forbid_down = 1., -1.\n if not(forbid_down < y0 < forbid_up):\n exception_msg = 'The starting point of the particle is outside the ' \\\n + 'prescribed limits. Please try to start close to ' \\\n + 'the capture domain.'\n raise Exception(exception_msg)\n\n if p.captured:\n return p, increment\n\n else:\n print('Calculating the capture ordinate, starting from y0 = %e' % y0)\n\n is_up = particle_up(p)\n\n if (increment > 0 and is_up) or (increment < 0 and not(is_up)):\n\n print('Still going above the object... Repeat again.')\n\n new_pos0 = np.array([x0, y0 - increment])\n\n pNext = Particle(p.diameter, p.density, p.birth, p.lifetime,\n new_pos0, None)\n\n pNext.compute_trajectory(flow, factor, printIt)\n\n return capture_ordinate(pNext, increment, flow, factor, printIt)\n\n else:\n print('Now it\\'s going below the object!')\n\n new_pos0 = np.array([x0, y0 + 0.7*increment])\n\n pNext = Particle(p.diameter, p.density, p.birth, p.lifetime,\n new_pos0, None)\n\n pNext.compute_trajectory(flow, factor, printIt)\n\n return capture_ordinate(pNext, 0.3*increment, flow, factor, printIt)","def predict_trajectory(x_init, v, yaw_dot):\n x = np.array(x_init)\n trajectory = [x]\n time = 0\n while time <= Config.predict_time:\n x = motion(x, [v, yaw_dot], Config.dt)\n trajectory.append(x)\n time += Config.dt\n\n return np.array(trajectory)","def setPoint(self, point):\n self._point = point\n self._point = self.projectPoint(Point.origin(point.dimension))","def advancePosition(self,time):\n velocity = self.getVelocity()\n return self.x + time*velocity","def _setup_move(self, position):\n self.log.debug(\"%s.setpoint = %s\", self.name, position)\n self.setpoint.put(position, wait=True)\n if self.actuate is not None:\n self.log.debug(\"%s.actuate = %s\", self.name, self.actuate_value)\n self.actuate.put(self.actuate_value, wait=False)","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def point(source, type='cross', timeLimit=7, intTime=None, refant=None, \n stepTriangle=None, stepCross=None, nptsCross=5, antwait=-2, tol=0.1,\n clear=True, apply=True, fitfwhm=True, pntwait=2, waitCycles=3,\n file=True, antennas=None, tmo=500):\n # Set source information\n sourceInfo = dict()\n sourceInfo['lofreq'] = commands.freqSetup()[2]\n sourceInfo['name'] = source\n sourceInfo['flux'] = utils.getSourceFlux(source, freq=sourceInfo['lofreq'])\n if sourceInfo['flux'] == None or sourceInfo['flux'] <= 0.0: \n sourceInfo['flux'] = 1.0\n\n # Set integration time, if needed\n if intTime == None:\n intTime = 10.0\n if sourceInfo['flux'] > 5.0 and sourceInfo['lofreq'] < 150.0: intTime = 4\n\n # Make initial guess to parameters\n # Offsets are increments to the mount offsets\n p0 = [sourceInfo['flux'], 0.0, 0.0, 1.0]\n\n # Set parameters\n parbase={'value':0., 'fixed':0, 'limited':[0,0], 'limits':[0.,0.]}\n parinfo = []\n for i in range(len(p0)):\n parinfo.append(copy.deepcopy(parbase))\n for i in range(len(p0)):\n parinfo[i]['value'] = p0[i]\n\n # Before proceeding, make sure we are on source\n commands.wait(commands.TRACK, tmo=tmo, waiton=commands.ALL)\n\n # Initialize. The initial pointing offsets are grabbed as well.\n # Do not trust \"clear=True\" to actually set the pointing offsets\n # to zero. There is a delay.\n converged = [False] * len(antennas)\n niter = 0\n tstart = time.time()\n offsetsAz, offsetsEl = grabPointingOffsets(antennas,clear=clear)\n data = dict()\n\n # Observe\n continuePointing = True\n ncyclesWait = 0\n while continuePointing and not min(converged) and \\\n time.time() - tstart < timeLimit*60.0:\n # Increment\n niter += 1\n print 'Iteration %2d' % niter\n\n # Uncomment line below to prevent accumulate data from \n # one iteration to the next\n # data = dict()\n\n # Observe center position if fitting 4 parameters and doing a triangle\n center = (len(data) == 0 and type == 'triangle' and fitfwhm)\n\n # Observe\n print ' ... collecting the data'\n t1 = - time.time()\n takeData(data, type, antennas, sourceInfo, offsetsAz, offsetsEl, \n nptsCross=nptsCross, stepTriangle=stepTriangle, \n stepCross=stepCross, antwait=antwait, intTime=intTime,\n center=center, niter=niter)\n fa = {'data': data}\n t1 += time.time()\n print ' ... that took %.1f seconds' % t1\n\n # Calibrate data and return structure that contains data to be fitted\n cal = dict()\n calibrateData(data, cal, antennas, sourceInfo, file=file, niter=niter)\n\n # Compute new offsets\n new_az = np.zeros(len(antennas))\n new_el = np.zeros(len(antennas))\n d_az = np.zeros(len(antennas))\n d_el = np.zeros(len(antennas))\n fwhm = np.zeros(len(antennas))\n ndata = np.zeros(len(antennas))\n validFit = [False] * len(antennas)\n for itel, values in cal.items():\n # Set initialize guesses\n maxoffset = 0.5 * getFWHM(antennas[itel], sourceInfo['lofreq'])\n parinfo[1]['value'] = offsetsAz[itel]\n parinfo[2]['value'] = offsetsEl[itel]\n parinfo[3]['value'] = getFWHM(antennas[itel], sourceInfo['lofreq'])\n if not fitfwhm: parinfo[3]['fixed'] = 1\n parinfo[1]['limited'] = [1,1]\n parinfo[2]['limited'] = [1,1]\n parinfo[3]['limited'] = [1,0]\n parinfo[1]['limits'] = [-maxoffset+offsetsAz[itel], maxoffset+offsetsAz[itel]]\n parinfo[2]['limits'] = [-maxoffset+offsetsEl[itel], maxoffset+offsetsEl[itel]]\n parinfo[3]['limits'] = [0.001, 10.0 * parinfo[3]['value']]\n\n # Fit the data\n ndata[itel] = len(values) # May be modified below if antenna is now offline\n\n if len(values) >= len(parinfo):\n fa = {'data': values}\n m = mpfit.mpfit(myfunct, parinfo=parinfo, functkw=fa, quiet=1)\n if m.status <= 0:\n print 'error message = ', m.errmsg\n else:\n validFit[itel] = True\n # elif m.dof > 0:\n # validFit[itel] = True\n\n # Store results if valid fit\n if validFit[itel]:\n # Computed reduced chi-squared\n # redchisq = (myfunct(m.params, data=values)[1]**2).sum() / m.dof\n\n # print '\\nFitting for antenna %2d:' % antennas[itel]\n # for v in values:\n # print ' %8.3f %8.3f %8.3f' % (v['amp'], v['offaz'], v['offel'])\n # print 'Fit = %.2f %.2f' % (m.params[1], m.params[2])\n \n # Compute change\n new_az[itel] = m.params[1]\n new_el[itel] = m.params[2]\n fwhm[itel] = m.params[3]\n d_az[itel] = m.params[1] - offsetsAz[itel]\n d_el[itel] = m.params[2] - offsetsEl[itel]\n\n # Save new offsets\n offsetsAz[itel] = m.params[1]\n offsetsEl[itel] = m.params[2]\n\n # Check convergence\n print ' %4s %7s %7s %7s %7s %7s' % \\\n ('Ant', 'fit_az', 'fit_el', 'daz', 'del', 'FWHM')\n print ' %4s %7s %7s %7s %7s' % \\\n ('', 'arcmin', 'arcmin', 'arcsec', 'arcsec')\n antennasComplete = converged[:]\n for i in range(len(antennas)):\n # Is the antennas in the subarray?\n inSubarray = antennas[i] in commands.currentAntennaNumbers()\n\n # Check convergence\n beamSize = getFWHM(antennas[i], sourceInfo['lofreq'])\n deltaBeam = np.sqrt(d_az[i]**2 + d_el[i]**2) / beamSize\n deltaFwhm = abs(beamSize - abs(fwhm[i]))\n converged[i] = (deltaBeam <= tol and deltaFwhm < 0.3 * beamSize and \n validFit[i] and inSubarray)\n\n # Antenna is considered done if it is no longer in the subarray\n # I set ndata to -1 to distingsuish it \n if not inSubarray: ndata[i] = -1\n if not inSubarray or converged[i]: antennasComplete[i] = True\n\n # Print message\n s = ''\n if validFit[i] and converged[i]: \n s = '*** converged '\n elif not validFit[i]:\n s = '*** invalid fit '\n if not inSubarray and not converged[i]:\n s = '*** antenna removed from subarray'\n if validFit[i]:\n print ' %4d %7.2f %7.2f %7.2f %7.2f %7.2f %s' % \\\n (antennas[i], new_az[i], new_el[i], \n d_az[i]*60.0, d_el[i]*60.0, fwhm[i]/beamSize, s)\n else:\n print ' %4d %7.2f %7.2f %7s %7s %7s %s' % \\\n (antennas[i], new_az[i], new_el[i], \"\", \"\", \"\", s)\n\n # See if we are almost done\n if antennasComplete.count(False) <= pntwait:\n ncyclesWait += 1\n else:\n ncyclesWait = 0\n\n # Did we reach the time limit?\n if min(antennasComplete) == False and time.time() - tstart > timeLimit*60.0:\n print '\\n\\n*** Time limit reached on radio pointing ***'\n continuePointing = False\n elif min(antennasComplete) == False and len(np.nonzero(ndata == 0)[0]) == antennasComplete.count(False): \n print '\\n\\n*** Stopping pointing since some antennas do not have valid data ***'\n continuePointing = False\n elif ncyclesWait >= waitCycles:\n if antennasComplete.count(False) > 0:\n print '\\n\\n*** Last %d antennas are having trouble converging - will abort pointing. ***' % antennasComplete.count(False)\n continuePointing = False\n \n\n # Update the mount offsets in the system\n results = dict()\n mountOffsetAz, mountOffsetEl = grabMountOffsets(antennas)\n print ''\n sup = []\n snoup = []\n for i in range(len(antennas)):\n if converged[i]:\n sup.append(antennas[i])\n aznew = mountOffsetAz[i] + offsetsAz[i]\n elnew = mountOffsetEl[i] + offsetsEl[i]\n if apply and antennas[i] in commands.currentAntennaNumbers(): \n commands.s.mountOffset(aznew, elnew, antennas[i])\n results[antennas[i]] = [offsetsAz[i], offsetsEl[i], aznew, elnew]\n else:\n snoup.append(antennas[i])\n commands.offset(0, 0)\n print ''\n if not apply:\n print '*** Did not apply offsets since apply=False'\n else:\n if len(sup) > 0:\n print '*** Updated pointing on antennas ',str(sup)\n else:\n print '*** Pointing did not converge on any antennas'\n if len(snoup) > 0:\n print '*** Did not update pointing on antennas ',str(snoup)\n else:\n print '*** Pointing converged on all antennas.'\n\n # Record various results in files\n resultsTime = getTimeStamps()\n recordMountOffsetsSession(results, resultsTime, antennas)\n recordMountOffsetsHistory(results, resultsTime, sourceInfo)\n recordPointingOffsetsHistory(results, resultsTime, sourceInfo)\n\n # Return solution\n return results","def plotTrajectory(xydata, colordata = 'time', cmap = cm.jet, size = 20, ax = None, line = True):\n \n if isinstance(colordata, basestring) and colordata in ['time']:\n c = np.linspace(0, len(xydata[:,0]), len(xydata[:,0]));\n else:\n c = colordata;\n \n if ax is None:\n ax = plt.gca();\n s = ax.scatter(xydata[:,0], xydata[:,1], c = c, cmap = cmap, s = size, marker = 'o', lw = 0);\n if isinstance(line, basestring):\n ax.plot(xydata[:,0], xydata[:,1], color = line); \n \n ax.get_figure().colorbar(s, ax = ax);\n return ax","def setPoint(self, point):\n self.position = point.position","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def on_pointing_axis_tracking(telescopename, stnid, band, antmodel, obstimebeg,\n obsdur, obstimestp, pointingdir,\n do_parallactic_rot=True):\n # *Setup Source*\n srcfld = dreambeam.rime.jones.DualPolFieldPointSrc(pointingdir)\n\n # *Load moouted feed*\n stnfeed = load_mountedfeed(telescopename, stnid, band, antmodel)\n stnrot = stnfeed.stnRot\n\n # *Setup PJones*\n timespy = []\n nrTimSamps = int((obsdur.total_seconds()/obstimestp.seconds))+1\n for ti in range(0, nrTimSamps):\n timespy.append(obstimebeg+ti*obstimestp)\n pjones = dreambeam.rime.jones.PJones(timespy, np.transpose(stnrot),\n do_parallactic_rot=do_parallactic_rot)\n\n # *Setup EJones*\n ejones = stnfeed.getEJones(pointingdir)\n freqs = stnfeed.getfreqs()\n\n # *Setup MEq*\n pjonesOfSrc = pjones.op(srcfld)\n jonesobj = ejones.op(pjonesOfSrc)\n\n # Get the resulting Jones matrices\n # (structure is Jn[freqIdx, timeIdx, chanIdx, compIdx] )\n jones = jonesobj.getValue()\n if not do_parallactic_rot:\n basis_from = jonesobj.get_basis()\n basis_to = pjonesOfSrc.get_basis()\n btransmat2d = basis2basis_transf(basis_from, basis_to)[..., 1:, 1:]\n # Tranformation from IAU2C09 has to be (right) transformed back 1st\n transmat2d = np.matmul(C09toIAU[1:, 1:], btransmat2d)\n jones = np.matmul(jones, transmat2d)\n jonesobj.jones = jones\n return timespy, freqs, jones, jonesobj","def getPositionTrajectory(self, localPt: Optional[Vector3] = None) -> Trajectory:\n if localPt is None:\n return Trajectory(self.times,[m[9:] for m in self.milestones])\n else:\n return Trajectory(self.times,[se3.apply(self.to_se3(m),localPt) for m in self.milestones])","def trajectory(self, lon, lat, alt, utc=12.0, speed=None, total_time=None,\n dt=10.0, smooth=10, traj_smooth=50):\n self.initall()\n calc_utc = False\n if speed is not None and total_time is not None:\n raise ValueError(\"Can't specify speed _and_ total_time.\")\n if speed is not None or total_time is not None:\n calc_utc = True\n if not isinstance(utc, (float, int)):\n print(\"utc should just be starting time if given speed/total_time \"\n \"-- using first term\")\n utc = [utc[0]]\n else:\n utc = [utc]\n # Calculate waypoints\n self.waypt = Namespace(lon=lon, lat=lat, alt=alt, distance=[0.0], speed=[0.0])\n self.total_distance = 0.0\n Rearth = [observer.earth_radius(lat[0])]\n ca = [0.0]\n for i in range(1, len(lon)):\n lon1, lon2, dlon, lat1, lat2, dlat, dalt = _split(i, lon, lat, alt)\n _a = np.sin(dlat/2.0)**2 + np.cos(lat1)*np.cos(lat2)*np.sin(dlon/2.0)**2\n _rth = observer.earth_radius((lat1+lat2)/2.0)\n _ca = 2.0 * np.arctan2(np.sqrt(_a), np.sqrt(1.0 - _a))\n _D = np.sqrt((_rth*_ca)**2 + dalt**2)\n Rearth.append(_rth)\n ca.append(_ca)\n self.waypt.distance.append(_D)\n self.total_distance += _D\n print(\"Total distance is {:.1f} mi\".format(self.total_distance / 1609.344))\n if total_time is not None:\n speed = self.total_distance / total_time\n self.traj = Namespace(utc=np.array([]), lon=np.array([]),\n lat=np.array([]), alt=np.array([]))\n self.waypoint_indices = []\n for i in range(1, len(lon)):\n if calc_utc:\n dt_waypt = self.waypt.distance[i] / speed\n utc.append(utc[i-1] + dt_waypt/3600.0)\n else:\n dt_waypt = (utc[i] - utc[i-1]) * 3600.0\n speed = self.waypt.distance[i] / dt_waypt\n self.waypt.speed.append(speed)\n # Calculate waypoints into trajectory at dt\n lon1, lon2, dlon, lat1, lat2, dlat, dalt = _split(i, lon, lat, alt)\n _altinc = self.waypt.distance[i] * np.sin(np.arctan2(dalt, Rearth[i]*ca[i]))\n N_time = int(np.floor(dt_waypt / dt))\n if np.fabs(N_time) < 2.0:\n continue\n _f = np.linspace(0.0, 1.0-1.0/N_time, N_time)\n _ta, _tb = np.sin((1.0 - _f)*ca[i]) / np.sin(ca[i]), np.sin(_f*ca[i]) / np.sin(ca[i])\n _x = _ta*np.cos(lat1)*np.cos(lon1) + _tb*np.cos(lat2)*np.cos(lon2)\n _y = _ta*np.cos(lat1)*np.sin(lon1) + _tb*np.cos(lat2)*np.sin(lon2)\n _z = _ta*np.sin(lat1) + _tb*np.sin(lat2)\n self.traj.utc = np.append(self.traj.utc, utc[i-1] +\n (dt/3600.0) * np.linspace(0, N_time-1, N_time))\n self.traj.lat = np.append(self.traj.lat, np.arctan2(_z, np.sqrt(_x**2+_y**2)))\n self.traj.lon = np.append(self.traj.lon, np.arctan2(_y, _x))\n self.traj.alt = np.append(self.traj.alt, alt[i-1] + _f * _altinc)\n self.waypoint_indices.append(len(self.traj.utc)-1)\n self.waypt.utc = utc\n self.traj.lon = self.smooth_array(np.rad2deg(self.traj.lon), traj_smooth)\n self.traj.lat = self.smooth_array(np.rad2deg(self.traj.lat), traj_smooth)\n self.traj.loc = EarthLocation(lon=self.traj.lon*u.deg, lat=self.traj.lat*u.deg,\n height=self.traj.alt*u.m)\n delta_x = self.traj.loc.x - self.obs.loc.x\n delta_y = self.traj.loc.y - self.obs.loc.y\n delta_z = self.traj.loc.z - self.obs.loc.z\n cosang = ((self.traj.loc.x*self.obs.loc.x +\n self.traj.loc.y*self.obs.loc.y +\n self.traj.loc.z*self.obs.loc.z) /\n (np.sqrt(self.traj.loc.x**2 + self.traj.loc.y**2 + self.traj.loc.z**2) *\n np.sqrt(self.obs.loc.x**2 + self.obs.loc.y**2 + self.obs.loc.z**2)))\n rtraj = np.sqrt(self.traj.loc.x**2 + self.traj.loc.y**2 + self.traj.loc.z**2)\n robs = np.sqrt(self.obs.loc.x**2 + self.obs.loc.y**2 + self.obs.loc.z**2)\n self.D = np.sqrt(delta_x**2 + delta_y**2 + delta_z**2)\n self.el = np.arcsin((rtraj * cosang - robs)/self.D)\n self.utc = self.traj.utc\n self.dt = np.array([dt] * len(self.traj.utc)) * u.second\n self.dbydt('D', smooth, False)","def execute_trajectory(\n trajectory: Trajectory,\n controller: Union['SimRobotController','RobotInterfaceBase'],\n speed: float = 1.0,\n smoothing: Optional[_SMOOTHING_OPTIONS2] = None,\n activeDofs: Optional[List[Union[int,str]]] = None\n ):\n if len(trajectory.times)==0: return #be tolerant of empty paths?\n if speed <= 0: raise ValueError(\"Speed must be positive\")\n from ..control.robotinterface import RobotInterfaceBase\n from ..robotsim import SimRobotController\n if isinstance(controller,SimRobotController):\n robot_model = controller.model()\n q0 = controller.getCommandedConfig()\n elif isinstance(controller,RobotInterfaceBase):\n robot_model = controller.klamptModel()\n cq0 = controller.commandedPosition()\n if cq0[0] is None:\n cq0 = controller.sensedPosition()\n q0 = controller.configToKlampt(cq0)\n else:\n raise ValueError(\"Invalid type of controller, must be SimRobotController or RobotInterfaceBase\")\n if activeDofs is not None:\n indices = [robot_model.link(d).getIndex for d in activeDofs]\n liftedMilestones = []\n assert not isinstance(trajectory,HermiteTrajectory),\"TODO: hermite trajectory lifting\"\n for m in trajectory.milestones:\n assert(len(m)==len(indices))\n q = q0[:]\n for i,v in zip(indices,m):\n q[i] = v\n liftedMilestones.append(q)\n tfull = trajectory.constructor()(trajectory.times,liftedMilestones)\n return execute_trajectory(tfull,controller,speed,smoothing)\n\n if isinstance(trajectory,HermiteTrajectory):\n assert smoothing == None,\"Smoothing cannot be applied to hermite trajectories\"\n ts = trajectory.startTime()\n n = len(q0)\n if isinstance(controller,SimRobotController):\n controller.setMilestone(trajectory.eval(ts),vectorops.mul(trajectory.deriv(ts),speed))\n n = len(trajectory.milestones[0])//2\n for i in range(1,len(trajectory.times)):\n q,v = trajectory.milestones[i][:n],trajectory.milestones[i][n:]\n controller.addCubic(q,vectorops.mul(v,speed),(trajectory.times[i]-trajectory.times[i-1])/speed)\n else:\n cv0 = controller.commandedVelocity()\n if cv0[0] is None:\n cv0 = controller.sensedVelocity()\n times,positions,velocities = [0],[controller.configFromKlampt(q0)],[cv0]\n start = 1 if trajectory.times[0]==0 else 0\n for i in range(start,len(trajectory.milestones)):\n times.append(trajectory.times[i]/speed)\n positions.append(controller.configFromKlampt(trajectory.milestones[i][:n]))\n velocities.append(controller.velocityFromKlampt(trajectory.milestones[i][n:]))\n controller.setPiecewiseCubic(times,positions,velocities)\n else:\n if smoothing == None:\n ts = trajectory.startTime()\n if isinstance(controller,SimRobotController):\n controller.setMilestone(trajectory.eval(ts))\n for i in range(1,len(trajectory.times)):\n q = trajectory.milestones[i]\n controller.addLinear(q,(trajectory.times[i]-trajectory.times[i-1])/speed)\n else:\n #TODO: move to start?\n times,positions = [0],[controller.configFromKlampt(q0)]\n start = 1 if 0==trajectory.times[0] else 0\n for i in range(start,len(trajectory.milestones)):\n times.append(trajectory.times[i]/speed)\n positions.append(controller.configFromKlampt(trajectory.milestones[i]))\n controller.setPiecewiseLinear(times,positions)\n elif smoothing == 'spline':\n t = HermiteTrajectory()\n t.makeSpline(trajectory)\n return execute_trajectory(t,controller)\n elif smoothing == 'pause':\n if isinstance(controller,SimRobotController):\n ts = trajectory.startTime()\n controller.setMilestone(trajectory.eval(ts))\n zero = [0.0]*len(trajectory.milestones[0])\n for i in range(1,len(trajectory.times)):\n q = trajectory.milestones[i]\n controller.addCubic(q,zero,(trajectory.times[i]-trajectory.times[i-1])/speed)\n else:\n #TODO: move to start?\n zero = [.0]*len(q0)\n t = HermiteTrajectory(trajectory.times,trajectory.milestones,[zero]*len(trajectory.milestones))\n return execute_trajectory(t,controller)\n else:\n raise ValueError(\"Invalid smoothing method specified\")","def _pid_control(self, waypoint, vehicle_location, vehicle_rotation):\n ## Vehicle transform should be [x,y,z, roll, pitch, yaw]\n\n v_begin = np.array(vehicle_location)\n v_end = v_begin + np.array([math.cos(math.radians(vehicle_rotation)),\n math.sin(math.radians(vehicle_rotation)),0])\n # print(\"vbegin\"+str(v_begin)+\"vend\"+ str(v_end)+\"waypoint\"+str(waypoint))\n v_vec = np.array([v_end[0] - v_begin[0], v_end[1] - v_begin[1], 0.0])\n w_vec = np.array([waypoint[0] -\n v_begin[0], waypoint[1] -\n v_begin[1], 0.0])\n _dot = math.acos(np.clip(np.dot(w_vec, v_vec) /\n (np.linalg.norm(w_vec) * np.linalg.norm(v_vec)), -1.0, 1.0))\n\n _cross = np.cross(v_vec, w_vec)\n if _cross[2] < 0:\n _dot *= -1.0\n\n self._e_buffer.append(_dot)\n if len(self._e_buffer) >= 2:\n _de = (self._e_buffer[-1] - self._e_buffer[-2]) / self._dt\n _ie = sum(self._e_buffer) * self._dt\n else:\n _de = 0.0\n _ie = 0.0\n # print(\"dot\"+str(_dot)+\"de\"+str(_de)+\"ie\"+str(_ie))\n return np.clip((self._K_P * _dot) + (self._K_D * _de /\n self._dt) + (self._K_I * _ie * self._dt), -1.0, 1.0)","def send_pose(self, pPosn, pOrnt, baseFrame, trgtFrame, pTime):\n # Create message\n xform = TransformStamped()\n # Transform Header\n xform.header.stamp = pTime\n xform.header.frame_id = baseFrame\n xform.child_frame_id = trgtFrame\n # Position\n xform.transform.translation.x = pPosn[0]\n xform.transform.translation.y = pPosn[1]\n xform.transform.translation.z = pPosn[2]\n # Orientation\n xform.transform.rotation.x = pOrnt[0]\n xform.transform.rotation.y = pOrnt[1]\n xform.transform.rotation.z = pOrnt[2]\n xform.transform.rotation.w = pOrnt[3]\n # Send message\n self.moveOut.sendTransform(xform)","def projectPoint(self, point):\n vector = self.normal_vector\n angle = vector.angle\n line = Line(point, angle, correct=False)\n projection = self.crossLine(line)\n return projection","def setTimepoint(self, tp):\n\t\tpass","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def draw_trajectory_SDEsys(Oscillatior_Parametrs, q0 = np.array([.1,.1]), T = 10000, dt = 0.1):\n\n\n N=int(T*1000) # number of time steps\n n_samp = np.amax([int(dt/(T/N)),1]) # sampling interval (cannot be smaller than time step)\n\n\n k,beta,D = Oscillatior_Parametrs['k'],Oscillatior_Parametrs['beta'],Oscillatior_Parametrs['D']\n\n Dim = len(k)\n q_model = np.zeros((N+1,Dim))\n\n for j in range(0,Dim):\n MySys=Linear_Stochastic_Oscillator(k[j],beta[j],D[j])\n t4,X4=MySys.GenerateTrajectory(q0,T=T,N=N)\n q_model[:,j]=X4[0,:]\n\n # subsample and push out\n q_model,t_model =q_model[::n_samp,:],t4[::n_samp]\n\n return t_model,q_model","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def __init__(self, target_velocity, dt, model_type, robot_type):\n super(StraightEnv, self).__init__(\n target_velocity=target_velocity,\n dt=dt,\n model_type=model_type,\n robot_type=robot_type\n )\n\n # Reward function parameters\n self._lambda1 = 0.25\n\n # State in frame of target straight line. See get_initial_state()\n # function for info.\n self._current_state = np.zeros(6)\n\n # Target line to follow. See get_initial_state() function for info.\n self._target_y = 0\n self._target_yaw = 0\n\n # Initialize nodes and set up ROS topics\n rospy.init_node('rl_planner')\n self.publisher = rospy.Publisher('commands/keyboard',\n ackermann_msgs.msg.AckermannDriveStamped, queue_size=1)\n rospy.Subscriber('ekf_localization/odom', nav_msgs.msg.Odometry,\n self._odometry_callback)\n self._sensor_stamp = rospy.Time.now()\n\n # Wait this number of timesteps before computing another action (this\n # is similar to setting a larger dt during training)\n self._num_states_needed = 3\n self._num_states_received = 0"],"string":"[\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def look_at(self, point, connector):\\n\\n\\n try:\\n point_camera = self.tfBuffer.transform(point, 'head')\\n except (tf2.LookupException, tf2.ConnectivityException, tf2.ExtrapolationException) as e:\\n rospy.loginfo(\\\"Waiting for transform... ({})\\\".format(e))\\n return\\n\\n # Calculate the head joint angles and clip them to the right range\\n angle_pan, angle_tilt = connector.head.get_motor_goals_from_point(point_camera.point)\\n angle_pan = np.clip(np.rad2deg(angle_pan), connector.head.min_pan, connector.head.max_pan)\\n angle_tilt = np.clip(np.rad2deg(angle_tilt), connector.head.min_tilt, connector.head.max_tilt)\\n\\n current_pan_pos, current_tilt_pos = connector.head.get_current_head_pos()\\n if (abs(current_pan_pos - angle_pan) < connector.head.delta and\\n abs(current_tilt_pos - angle_tilt) < connector.head.delta):\\n # We reached the position\\n if rospy.get_time() - self.position_reached_time > connector.head.wait_time:\\n # We waited long enough, go back\\n return self.pop()\\n else:\\n # Represent remaining wait time\\n self.publish_debug_data(\\\"remaining_wait_time\\\",connector.head.wait_time - (rospy.get_time() - self.position_reached_time))\\n\\n else:\\n # We haven't reached it\\n # Update when we should reach it\\n self.position_reached_time = rospy.get_time()\\n connector.head.send_motor_goals(angle_pan, 30.0, angle_tilt, 30.0)\\n\\n # Represent remaining tilt\\n self.publish_debug_data(\\\"remaining_tilt\\\",abs(current_pan_pos - angle_pan))\\n self.publish_debug_data(\\\"remaining_pan\\\",abs(current_tilt_pos - angle_tilt))\",\n \"def getPointTrajectory(self, localPt: Vector3) -> Trajectory:\\n return Trajectory(self.times,[so3.apply(m,localPt) for m in self.milestones])\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def trajectory_control(self,position_trajectory,\\n yaw_trajectory,\\n time_trajectory,\\n current_time):\\n ind_min = np.argmin(np.abs(np.array(time_trajectory)-current_time))\\n time_ref = time_trajectory[ind_min]\\n \\n \\n if current_time < time_ref:\\n position0 = position_trajectory[ind_min-1]\\n position1 = position_trajectory[ind_min]\\n \\n time0 = time_trajectory[ind_min-1]\\n time1 = time_trajectory[ind_min]\\n yaw_cmd = yaw_trajectory[ind_min-1]\\n \\n else:\\n yaw_cmd = yaw_trajectory[ind_min]\\n if ind_min >= len(position_trajectory)-1:\\n position0 = position_trajectory[ind_min]\\n position1 = position_trajectory[ind_min]\\n \\n time0 = 0.0\\n time1 = 1.0\\n else:\\n\\n position0 = position_trajectory[ind_min]\\n position1 = position_trajectory[ind_min+1]\\n time0 = time_trajectory[ind_min]\\n time1 = time_trajectory[ind_min+1]\\n \\n position_cmd = (position1-position0)* \\\\\\n (current_time-time0)/(time1-time0)+position0\\n velocity_cmd = (position1-position0)/(time1-time0)\\n \\n \\n return (position_cmd,velocity_cmd,yaw_cmd)\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def make_trajectory(self, NextwpPosition, NextwpOrientation):\\n d = np.linalg.norm(self.CurrentPosition - NextwpPosition)\\n inter_segment_distance = 1\\n self.no_of_segments = 1+int(d//inter_segment_distance)\\n \\n\\n # enter sequence of waypoints: no of points should be self.no_of_segments+1\\n x_wp = np.linspace(self.CurrentPosition[0], NextwpPosition[0], self.no_of_segments+1)\\n y_wp = np.linspace(self.CurrentPosition[1], NextwpPosition[1], self.no_of_segments+1)\\n z_wp = np.linspace(self.CurrentPosition[2], NextwpPosition[2], self.no_of_segments+1)\\n \\n # add intial and final condiions vel, acc, jerk\\n x_ic = np.array([0, 0, 0])\\n x_fc = np.array([0, 0, 0])\\n x0 = np.array([x_wp[0], x_ic[0], x_ic[1], x_ic[2]])\\n xT = np.array([x_wp[-1], x_fc[0], x_fc[1], x_fc[2]])\\n\\n y_ic = np.array([0, 0, 0])\\n y_fc = np.array([0, 0, 0])\\n y0 = np.array([y_wp[0], y_ic[0], y_ic[1], y_ic[2]])\\n yT = np.array([y_wp[-1], y_fc[0], y_fc[1], y_fc[2]])\\n \\n z_ic = np.array([0, 0, 0])\\n z_fc = np.array([0, 0, 0])\\n z0 = np.array([z_wp[0], z_ic[0], z_ic[1], z_ic[2]])\\n zT = np.array([z_wp[-1], z_fc[0], z_fc[1], z_fc[2]])\\n\\n path = [np.sqrt((x_wp[i]-x_wp[i-1])**2 + (y_wp[i]-y_wp[i-1])**2 + (z_wp[i]-z_wp[i-1])**2) for i in range(1, self.no_of_segments+1, 1)]\\n\\n \\n T = []; T.insert(0, 0)\\n T.insert(1, T[-1] + path[0]/self.reduced_speed)\\n for i in range(1, len(path)-1, 1):\\n T.append(T[-1] + path[i]/self.average_speed)\\n T.insert(len(T)+1, T[-1]+path[-1]/self.reduced_speed) \\n\\n\\n\\n\\n #T = []; T.insert(0, 0) # insert 0 at 0 position\\n #for i in range(self.no_of_segments): \\n # T.append(T[-1]+path[i]/self.average_speed)\\n\\n r = self.r\\n N = 1 + self.N # because number of terms in a polynomial = degree+1\\n\\n QQ = []; AA_inv = []\\n\\n for i in range(self.no_of_segments): \\n q = self.construct_Q(N, r, T[i], T[i+1])\\n a = self.construct_A(N, r, T[i], T[i+1])\\n a_inv = scipy.linalg.pinv(a)\\n QQ = block_diag(QQ, q)\\n AA_inv = block_diag(AA_inv, a_inv)\\n \\n order = 2*r*self.no_of_segments\\n R = np.dot(AA_inv.T, np.dot(QQ, AA_inv))\\n \\n bx = self.construct_b(x0, xT)\\n by = self.construct_b(y0, yT)\\n bz = self.construct_b(z0, zT)\\n\\n m = Model(\\\"qp\\\")\\n order = 2*r*self.no_of_segments\\n dx = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\\\"dx\\\")\\n dy = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\\\"dy\\\") \\n dz = m.addVars(order, lb = -GRB.INFINITY, ub = GRB.INFINITY, vtype=GRB.CONTINUOUS, name=\\\"dz\\\") \\n\\n # making objective using quicksum, takes a lot of time \\n #obj1 = quicksum(dx[i] * quicksum(R[i][j] * dx[j] for j in range(order)) for i in range(order))\\n #obj2 = quicksum(dy[i] * quicksum(R[i][j] * dy[j] for j in range(order)) for i in range(order))\\n #obj3 = quicksum(dz[i] * quicksum(R[i][j] * dz[j] for j in range(order)) for i in range(order))\\n \\n # using LinExpr for the second expression is significantly faster \\n obj1 = quicksum(dx[i] * LinExpr([(R[i][j], dx[j]) for j in range(order)]) for i in range(order))\\n obj2 = quicksum(dy[i] * LinExpr([(R[i][j], dy[j]) for j in range(order)]) for i in range(order))\\n obj3 = quicksum(dz[i] * LinExpr([(R[i][j], dz[j]) for j in range(order)]) for i in range(order))\\n obj = obj1 + obj2 + obj3\\n j = 0\\n for i in range(order): \\n if i < r: \\n m.addConstr(dx[i] == bx[i])\\n m.addConstr(dy[i] == by[i])\\n m.addConstr(dz[i] == bz[i])\\n elif i >= order-r: \\n m.addConstr(dx[i] == bx[r+j])\\n m.addConstr(dy[i] == by[r+j])\\n m.addConstr(dz[i] == bz[r+j])\\n j += 1\\n \\n c = 1 # counter\\n for i in range(r, order-2*r, 2*r): \\n #m.addConstr(dx[i] == self.x_wp[c])\\n #m.addConstr(dy[i] == self.y_wp[c])\\n #m.addConstr(dz[i] == self.z_wp[c])\\n m.addConstr(dx[i] <= x_wp[c] + 0.2)\\n m.addConstr(dx[i] >= x_wp[c] - 0.2)\\n m.addConstr(dy[i] <= y_wp[c] + 0.2)\\n m.addConstr(dy[i] >= y_wp[c] - 0.2)\\n m.addConstr(dz[i] <= z_wp[c] + 0.2)\\n m.addConstr(dz[i] >= z_wp[c] - 0.2)\\n c = c+1\\n for j in range(r): \\n m.addConstr(dx[i+j] == dx[i+j+r])\\n m.addConstr(dy[i+j] == dy[i+j+r])\\n m.addConstr(dz[i+j] == dz[i+j+r])\\n #if j ==2: \\n # m.addConstr(dx[i+j] == 2.0)\\n\\n m.setObjective(obj, GRB.MINIMIZE)\\n #m.write('model.lp')\\n m.setParam('OutputFlag', 0)\\n m.setParam('PSDtol', 1e-1)\\n m.optimize()\\n\\n\\n runtime = m.Runtime\\n\\n\\n x_coeff = [dx[i].X for i in range(order)]\\n y_coeff = [dy[i].X for i in range(order)]\\n z_coeff = [dz[i].X for i in range(order)]\\n\\n Dx = np.asarray(x_coeff)[np.newaxis].T\\n Dy = np.asarray(y_coeff)[np.newaxis].T \\n Dz = np.asarray(z_coeff)[np.newaxis].T \\n pcx = np.dot(AA_inv, Dx); pcy = np.dot(AA_inv, Dy); pcz = np.dot(AA_inv, Dz)\\n\\n\\n poly_coeff_x = pcx.T.ravel().tolist()\\n poly_coeff_y = pcy.T.ravel().tolist()\\n poly_coeff_z = pcz.T.ravel().tolist()\\n\\n return poly_coeff_x, poly_coeff_y, poly_coeff_z, T, time.time()\\n #self.publish(poly_coeff_x, poly_coeff_y, poly_coeff_z)\",\n \"def point_head(self, point: Tuple[int, int], image_timestamp: Time):\\n self.running = False\\n\\n point = Looker.correct_point(point)\\n\\n self.looker.target.header.frame_id = '/xtion_rgb_optical_frame'\\n self.looker.pointing_frame = '/xtion_rgb_optical_frame'\\n\\n self.looker.pointing_axis.x = 0.0\\n self.looker.pointing_axis.y = 0.0\\n self.looker.pointing_axis.z = 1.0\\n self.looker.max_velocity = 0.2\\n\\n look_point = PointStamped()\\n look_point.header.frame_id = '/xtion_rgb_optical_frame'\\n look_point.point.x = (point[0] - self.camera_intrinsics[0, 2]) / (self.camera_intrinsics[0, 0])\\n look_point.point.y = (point[1] - self.camera_intrinsics[1, 2]) / (self.camera_intrinsics[1, 1])\\n look_point.point.z = 1.0\\n look_point.header.stamp = image_timestamp\\n\\n self.looker.target = look_point\\n self.point_head_goal.send_goal(self.looker)\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def transform_point(p,R,t):\\r\\n x = R[0][0]*p[0]+R[0][1]*p[1]+t[0]\\r\\n y = R[1][0]*p[0]+R[1][1]*p[1]+t[1]\\r\\n return [x,y]\",\n \"def executeTrajectory():\\n driveStraight(1, 0.6)\\n rotate(0.25)\\n driveStraight(1, .45)\\n rotate(-0.25)\",\n \"def create_joint_trajectory(start_position, end_position,\\n duration_of_trajectory, frequency_of_trajectory):\\n\\n frequency_of_ros_messages = frequency_of_trajectory # in Hz.\\n number_of_way_points = duration_of_trajectory * frequency_of_ros_messages\\n number_of_joints = start_position.__len__()\\n trajectory = np.zeros((number_of_joints, number_of_way_points))\\n\\n for i in xrange(number_of_joints):\\n trajectory[i] = np.linspace(start_position[i], end_position[i],\\n number_of_way_points)\\n trajectory = trajectory.T.copy()\\n vel_lims = np.diff(trajectory, axis=0)\\n #Because this is discrete differentiation,\\n # the last value is missing: len(vel_lims) = len(trajectory) - 1\\n # so we just repeat the last calculated velocity.\\n vel_lims = np.append(vel_lims, [[x for x in vel_lims[-1,:]]], axis = 0)\\n vel_lims = vel_lims * frequency_of_trajectory\\n vel_lims = np.absolute(vel_lims)\\n\\n if vel_lims.all() > 1.0:\\n raise ValueError(\\\"One or more of the values in the specified velocities\\\"\\n \\\"Exceed 1 rad / second. The robot won't like this.\\\"\\n \\\"Adjust the trajectory so that each point can be \\\"\\n \\\"reached without exceeding this limit.\\\")\\n return trajectory, vel_lims\",\n \"def move_base(self, x, y, z):\\n # fill ROS message\\n goal = control_msgs.msg.FollowJointTrajectoryGoal()\\n traj = trajectory_msgs.msg.JointTrajectory()\\n traj.joint_names = [\\\"odom_x\\\", \\\"odom_y\\\", \\\"odom_t\\\"]\\n p = trajectory_msgs.msg.JointTrajectoryPoint()\\n p.positions = [x, y, z]\\n p.velocities = [0, 0, 0]\\n p.time_from_start = rospy.Time(15)\\n traj.points = [p]\\n goal.trajectory = traj\\n\\n # send message to the action server\\n self.cli.send_goal(goal)\\n\\n # wait for the action server to complete the order\\n self.cli.wait_for_result()\\n return self._running\",\n \"def line_param(point_a, point_b, t):\\n new_point = point_a - point_b\\n return point_b + t*new_point\",\n \"def interp_cubic(p0, p1, t_abs):\\n\\tT = (p1.time_from_start - p0.time_from_start).to_sec()\\n\\tt = t_abs - p0.time_from_start.to_sec()\\n\\tq = [0] * 6\\n\\tqdot = [0] * 6\\n\\tqddot = [0] * 6\\n\\tfor i in range(len(p0.positions)):\\n\\t\\ta = p0.positions[i]\\n\\t\\tb = p0.velocities[i]\\n\\t\\tc = (-3 * p0.positions[i] + 3 * p1.positions[i] - 2 * T * p0.velocities[i] - T * p1.velocities[i]) / T**2\\n\\t\\td = (2 * p0.positions[i] - 2 * p1.positions[i] + T * p0.velocities[i] + T * p1.velocities[i]) / T**3\\n\\n\\t\\tq[i] = a + b * t + c * t**2 + d * t**3\\n\\t\\tqdot[i] = b + 2 * c * t + 3 * d * t**2\\n\\t\\tqddot[i] = 2 * c + 6 * d * t\\n\\treturn JointTrajectoryPoint(positions=q, velocities=qdot, accelerations=qddot, time_from_start=rospy.Duration(t_abs))\",\n \"def _trajectory_to_multi_dof_joint_trajectory(self, p, v, a, j, s, c):\\n\\n msg = tm.MultiDOFJointTrajectory()\\n point = tm.MultiDOFJointTrajectoryPoint()\\n msg.points.append(point)\\n\\n #print(p)\\n\\n transform = gm.Transform()\\n transform.translation.x = p[0]\\n transform.translation.y = p[1]\\n transform.translation.z = p[2]\\n quaternion = tft.quaternion_from_euler(0.0, 0.0, p[3])\\n transform.rotation.x = quaternion[0]\\n transform.rotation.y = quaternion[1]\\n transform.rotation.z = quaternion[2]\\n transform.rotation.w = quaternion[3]\\n point.transforms.append(transform)\\n\\n velocity = gm.Twist()\\n velocity.linear.x = v[0]\\n velocity.linear.y = v[1]\\n velocity.linear.z = v[2]\\n velocity.angular.z = v[3]\\n point.velocities.append(velocity)\\n\\n acceleration = gm.Twist()\\n acceleration.linear.x = a[0]\\n acceleration.linear.y = a[1]\\n acceleration.linear.z = a[2]\\n point.accelerations.append(acceleration)\\n\\n return msg\",\n \"def getTrajectoryMessage(action, jointOrder, velocity):\\n # Set up a trajectory message to publish.\\n actionMsg = JointTrajectory()\\n actionMsg.joint_names = jointOrder\\n # Create a point to tell the robot to move to.\\n target = JointTrajectoryPoint()\\n actionFloat = [float(i) for i in action]\\n target.positions = actionFloat\\n target.velocities = [velocity]*action.size\\n\\n target.time_from_start.nanosec = 1000000\\n\\n actionMsg.points = [target]\\n return actionMsg\",\n \"def trajectory1(self):\\r\\n\\r\\n trackt = [] # particle trajectory,\\r\\n trackx = [] # particle trajectory\\r\\n an = [] # analitical s**2 + x**2 = t**2\\r\\n s1 = [] # s = 10; s = 0, light\\r\\n s2 = [] # s = 20;\\r\\n s3 = [] # s = 40;\\r\\n for i in range(0, len(self.dt.obs.obt_g)):\\r\\n trackt.append(float(i))\\r\\n trackx.append(self.dt.x[i])\\r\\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\\r\\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\\r\\n\\r\\n # plots:\\r\\n\\r\\n (fig, ax) = plt.subplots() # figsize=(7,5)\\r\\n\\r\\n # trajectory\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n trackt,\\r\\n marker='+',\\r\\n linewidth=1,\\r\\n linestyle='-',\\r\\n color='green',\\r\\n label='treck',\\r\\n )\\r\\n\\r\\n # measurement t\\r\\n # ax.plot(self.dt.x, self.dt.t, marker=\\\"+\\\", linestyle=\\\" \\\", color=\\\"blue\\\", label=\\\"result of measurement\\\")\\r\\n\\r\\n ax.plot(\\r\\n self.dt.x,\\r\\n self.dt.t,\\r\\n marker='o',\\r\\n linestyle=' ',\\r\\n color='black',\\r\\n label='result of measurement',\\r\\n )\\r\\n\\r\\n # analitical t\\r\\n\\r\\n ax.plot(self.dt.x, an, linestyle='-', color='red',\\r\\n label='continuum')\\r\\n\\r\\n # light trajectory\\r\\n\\r\\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\\r\\n label='s=0 (light)')\\r\\n\\r\\n # s(x) curves\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n s1,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=1.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s2,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=2.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s3,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=4.0',\\r\\n )\\r\\n\\r\\n # error of measurement t\\r\\n\\r\\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\\r\\n\\r\\n # signature on the horizontal x-axis\\r\\n\\r\\n ax.set_xlabel('x in metres')\\r\\n xm = -1.0\\r\\n for i in range(len(self.dt.x)):\\r\\n if self.dt.x[i] > xm:\\r\\n xm = self.dt.x[i]\\r\\n stepx = round(xm / float(len(self.dt.x)), 1)\\r\\n xm = round(xm + stepx, 1)\\r\\n ax.set_xlim([0.0, xm])\\r\\n\\r\\n # signature on vertical y axis\\r\\n\\r\\n ax.set_ylabel('t in metres of light time ')\\r\\n ym = -1.0\\r\\n for i in range(len(self.dt.t)):\\r\\n if self.dt.t[i] > ym:\\r\\n ym = self.dt.t[i]\\r\\n stepy = round(ym / float(len(self.dt.t)), 1)\\r\\n ym = round(ym + stepy, 1)\\r\\n ax.set_ylim([0.0, ym])\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\\r\\n\\r\\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.xaxis.set_major_locator(locatorx)\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\\r\\n\\r\\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.yaxis.set_major_locator(locatory)\\r\\n\\r\\n ax.grid()\\r\\n\\r\\n # show legend\\r\\n\\r\\n ax.legend(loc='upper left')\\r\\n\\r\\n # show drawing\\r\\n\\r\\n plt.show()\",\n \"def update_position(self, event):\\n\\n # Create a copy of the most recent stored twist data to perform calculations\\n with self.lock:\\n velocity_data = copy.deepcopy(self.twist)\\n\\n # Time elapsed since last update position call\\n if hasattr(event, 'last_real'):\\n if event.last_real is None:\\n time = rospy.Duration(0.05)\\n else:\\n time = event.current_real - event.last_real\\n \\n time = time.to_sec()\\n\\n # Calculate angle turned in the given time using omega = theta/time\\n angle = velocity_data.angular.z*time\\n\\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\\n distance = velocity_data.linear.x*time\\n\\n # Calculate yaw of the robot\\n self.vehicle_yaw += angle\\n\\n # Calculate vehicle x, y, z position coordinates\\n # TODO recalculate the position based on traveling in a circular arc.\\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\\n\\n # Calculate z position using linear interpolation and create cloud array\\n \\n # 1. Create ranges to be used in interpolation function\\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\\n\\n # 2. Create array of points to be converted to point cloud for vizualization\\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\\n terrain_x = terrain_mesh_x.ravel()\\n terrain_y = terrain_mesh_y.ravel()\\n terrain_z = self.gaussian_array.ravel()\\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\\n\\n # 3. Create interpolation function based on the ranges and gaussian data\\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\\n\\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\\n # TODO compute z height based on footprint\\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\\n\\n # Convert Euler Angles to Quarternion\\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\\n\\n # Broadcast vehicle frame which is a child of the world frame\\n br = tf.TransformBroadcaster()\\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \\n V_rotation, rospy.Time.now(),\\\"vehicle_frame\\\", \\\"map\\\")\\n\\n # Construct the homogenous transformation matrix for map to vehicle frame\\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \\n map_T_V[:3,3] = np.array(V_translation)\\n\\n # Create footprint of vehicle\\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\\n V_footprint_x = V_footprint_mesh_x.ravel()\\n V_footprint_y = V_footprint_mesh_y.ravel()\\n\\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\\n # and its interpolated z value. Add this point to a list of points for visualization.\\n # TODO Flatten into a single matrix multiply to remove for loop\\n V_viz_points = []\\n for i in range(V_footprint_x.shape[0]):\\n p = Point()\\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\\n p.x = V_footprint_point[0, 0]\\n p.y = V_footprint_point[1, 0]\\n p.z = V_footprint_point[2, 0]\\n V_viz_points.append(p)\\n\\n #####################################################################################\\n # Create a copy of the most recent stored JointState data to perform calculations\\n with self.joint_lock:\\n joint_data = copy.deepcopy(self.joint)\\n\\n # If the data is empty on first run, fill with 0.0\\n if not joint_data.velocity:\\n joint_data.velocity = [0.0,0.0]\\n \\n # Calculate angle based on velocity data and time\\n angle = joint_data.velocity[0]*time\\n angle2 = joint_data.velocity[1]*time\\n\\n self.joint1_pitch += angle\\n self.joint2_pitch += angle2\\n\\n # Transformations from vehicle frame to Joint1 and Joint2\\n \\n # Static rotation about z-axis \\n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\\n translation = [0.0, 0.0, 0.0]\\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\\n V_T_SRz[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about the y-axis of Joint 1\\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\\n [0.0, 1.0, 0.0],\\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\\n\\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\\n\\n SRz_T_J1 = np.zeros((4,4))\\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\\n SRz_T_J1[:4,3] = trans_SRz_T_J1\\n\\n # Translation based on length of Joint 1 arm \\n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\\n translation = [self.joint1_length, 0.0, 0.0]\\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\\n J1_T_STx[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about y-axis of Joint 2\\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\\n translation = [0.0, 0.0, 0.0]\\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\\n STx_T_J2[:3,3] = np.array(translation)\\n\\n # matrix multiplication to form the homogenous matrices\\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\\n\\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\\n\\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\\n ripper_tip_point_viz = Point()\\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\\n V_viz_points.append(ripper_tip_point_viz)\\n\\n # use the ripper's position as an index value to access the gaussian array\\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\\n\\n # Create a range of index values surrounding index_x and y\\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\\n\\n # First check if the index is within the gaussian array, if it is, then check if the tip of\\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\\n # it to the surrounding cells, provided those cells are also within the gaussian array\\n # TODO Remove use of for loops and excess if statements\\n\\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\\n for i in range(nearby_index_cells_x.shape[0]):\\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\\n \\n\\n # Publish all messages\\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)\",\n \"def goto_point(self,targetx,targety):\\n #if point is 0,0, make 0.01,0.01 to avoid divide by 0\\n if targetx == 0 and targety == 0:\\n targetx = 0.01\\n targety = 0.01\\n self.targetdistance = math.sqrt((self.currentx-targetx)**2 + (self.currenty-targety)**2)\\n self.targetangle = math.atan2(targety-self.currenty,targetx-self.currentx)\\n self.angledifference = self.angle_diff(self.targetangle,self.orientation)\\n if abs(self.angledifference) < .10:\\n self.turnspeed = 0\\n else:\\n self.turnspeed = math.tanh(self.kturn*self.angledifference)\\n self.speed = math.tanh(self.targetdistance*self.kspeed/self.angledifference)\\n if self.speed < 0:\\n self.speed = 0\\n self.linearVector = Vector3(x=self.speed, y=0.0, z=0.0)\\n self.angularVector = Vector3(x = 0.0, y = 0.0, z = self.turnspeed)\\n # print \\\"currentx = \\\" + str(self.currentx)\\n # print \\\"currenty = \\\" + str(self.currenty)\\n # print \\\"orientation = \\\" + str(self.orientation)\\n # print \\\"targetangle = \\\" + str(self.targetangle)\\n # print \\\"angledifference = \\\" + str(self.angledifference)\\n #print \\\"turnspeed = \\\" + str(self.turnspeed)\\n #print \\\"speed = \\\" + str(self.speed)\",\n \"def execute_tp(self):\\n self.status_message = \\\"State: Execute TP- Executing Motion Plan with trajectory planner\\\"\\n self.current_state = \\\"execute_tp\\\"\\n self.next_state = \\\"idle\\\"\\n collect_info = threading.Thread(\\n target=self.write_joint_pos, args=(\\\"tp_wp\\\",))\\n collect_info.start()\\n for wp in self.waypoints:\\n # Ensure the correct number of joint angles\\n full_wp = [0.0] * self.rexarm.num_joints\\n full_wp[0:len(wp)] = wp\\n self.tp.set_initial_wp()\\n self.tp.set_final_wp(full_wp)\\n\\n if self.next_state == \\\"estop\\\":\\n break\\n # TODO: Set the positions and break if estop is needed\\n self.tp.go()\\n # self.rexarm.set_positions(wp)\\n # time.sleep(1.5)\",\n \"def target(self, time, points, dt, num_way):\\n start_index = min(int(time / dt), num_way - 1)\\n end_index = min(start_index + 1, num_way - 1)\\n start_point = points[start_index]\\n end_point = points[end_index]\\n fraction = float(time % dt) / dt\\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)\",\n \"def compute_trajectory():\\n pass\",\n \"def __init__(self, P, t):\\n n = len(t)\\n assert len(P) == n # same number of time and control points\\n self.X, self.Y = _unzip(P) # points in X, Y components\\n self._n = xrange(n) # time/control point iterator\\n self.t = t\",\n \"def move_trapezoid(point, uvw_func, dt):\\n uvw_1 = uvw_func(point)\\n first_step = move(point, uvw_1, dt)\\n uvw_2 = uvw_func(first_step)\\n uvw = ((uvw_1[0] + uvw_2[0]) / 2,\\n (uvw_1[1] + uvw_2[1]) / 2,\\n (uvw_1[2] + uvw_2[2]) / 2)\\n return move(point, uvw, dt)\",\n \"def moveTo(self, pt: Tuple[float, float]) -> None:\\n raise NotImplementedError\",\n \"def _generate_trajectory(self, current_pos, velocity, goal, dt, prediction_time):\\n\\n history = list(np.copy(self._reached_goals))\\n\\n\\n\\n\\n out = []\\n out.append(np.copy(current_pos))\\n first_goal_idx = np.where(self._goals == goal)[0][0]\\n selected_goal = goal\\n reached_goal = False\\n counter_in_goal = 0\\n\\n\\n\\n for _ in range(prediction_time):\\n\\n # Particle reached selected goal\\n # This will continuously chose a next goal, if a particle already reached its predecessor goal\\n\\n if np.linalg.norm(current_pos - selected_goal) <= 0.1:\\n reached_goal = True\\n\\n\\n\\n\\n\\n\\n if counter_in_goal > self.curr_stay_duration_goals[self._is_human_in_range_of_goal(selected_goal)[1]] / dt:\\n\\n selected_goal_idx = np.where(self._goals == selected_goal)[0][0]\\n\\n if len(history) > 0:\\n if not selected_goal_idx == history[-1]:\\n history.append(selected_goal_idx)\\n else:\\n history.append(selected_goal_idx)\\n #print \\\"history:\\\"\\n #print history\\n # Select next goal based on the pre-learned goal-change probabilities\\n\\n\\n #print \\\"selected goal {}\\\".format(selected_goal_idx)\\n probs,available_goals = self.compute_transition_probs_for_goal_from_history(history,selected_goal_idx)\\n\\n\\n for p in probs:\\n if p < self._belief_threshold:\\n p = 0.0\\n\\n print \\\"probs sampling: \\\"\\n print probs / np.sum(np.asarray(probs))\\n selected_goal = self._goals[np.random.choice(available_goals, p=probs / np.sum(np.asarray(probs)))]\\n\\n counter_in_goal = 0.0\\n\\n #print(\\\"switching\\\")\\n\\n else:\\n counter_in_goal += 1\\n #print(\\\"incr counter\\\")\\n\\n\\n\\n\\n\\n if reached_goal:\\n #print self.curr_stay_duration_goals\\n #print self.curr_stay_duration_goals[ self._is_human_in_range_of_goal(selected_goal)[1] ]\\n\\n new_pos = self.transition_human(current_pos, velocity, selected_goal, dt)\\n\\n out.append(new_pos)\\n current_pos = new_pos\\n\\n\\n\\n else:\\n new_pos = self.transition_human(current_pos, velocity, selected_goal, dt)\\n out.append(new_pos)\\n current_pos = new_pos\\n\\n return np.asarray(out)\",\n \"def verlet_next_pos(pos_t,vel_t,accel_t,dt):\\n pos_t_plus_dt = pos_t.copy()\\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \\n\\n return pos_t_plus_dt\",\n \"def send_joint_trajectory(trajectory, velocities, frequency=250):\\n pub = rospy.Publisher(\\\"/wam/jnt_pos_cmd\\\", RTJointPos, queue_size=10)\\n #If wam_node is running, it will be connected to this publisher.\\n #Mostly this loop is here because you want to make sure the publisher\\n #gets set up before it starts sending information.\\n while pub.get_num_connections() < 1:\\n print \\\"Waiting on the publisher to go up.\\\"\\n rospy.sleep(0.5)\\n\\n trajectory_length = trajectory.__len__()\\n finished = False\\n traj_row = 0\\n message_for_service = RTJointPos()\\n\\n r = rospy.Rate(frequency)\\n\\n while not rospy.is_shutdown() and not finished:\\n message_for_service.joints = trajectory[traj_row]\\n message_for_service.rate_limits = velocities[traj_row]\\n traj_row += 1\\n pub.publish(message_for_service)\\n if traj_row == trajectory_length - 1:\\n finished = True\\n r.sleep()\",\n \"def _make_point(self, active_point):\\n # --------------------------------\\n # Create Random Parameters\\n # --------------------------------\\n for _ in range(self._k):\\n # Defines radial distance from active_point.\\n rho = np.random.uniform(self._radius, 2 * self._radius)\\n # Defines angle from active_point. Requires multiple angles for higher dimensional planes.\\n theta = [np.random.uniform(0, 2 * np.pi) for _ in range(self._dim - 1)]\\n\\n # --------------------------------\\n # Create New Point\\n # --------------------------------\\n\\n # Create a 2D point using first theta angle.\\n new_point = [active_point[0] + rho * np.cos(theta[0]), active_point[1] + rho * np.sin(theta[0])]\\n # Generate more components of the coordinate for higher dimensional planes.\\n new_point.extend([active_point[i] + rho * np.sin(theta[i-1]) for i in range(2, active_point.shape[0])])\\n new_point = np.array(new_point)\\n\\n # Confirm point is valid\\n if self._valid_point(new_point):\\n return new_point\\n return None\",\n \"def move(self, a1dot, a2dot, timestep):\\n\\n # body_v, inertial_v = self.get_v(a1dot, a2dot)\\n #\\n # # lambdafication\\n # x_dot = lambda t: inertial_v[0][0]\\n # y_dot = lambda t: inertial_v[1][0]\\n # theta_dot = lambda t: inertial_v[2][0]\\n # _a1dot = lambda t: a1dot\\n # _a2dot = lambda t: a2dot\\n #\\n # # find the increments\\n # # fix to include time intervals\\n # dx, _ = integrate.quad(x_dot, 0, timestep)\\n # dy, _ = integrate.quad(y_dot, 0, timestep)\\n # dtheta, _ = integrate.quad(theta_dot, 0, timestep)\\n # da1, _ = integrate.quad(_a1dot, 0, timestep)\\n # da2, _ = integrate.quad(_a2dot, 0, timestep)\\n\\n action = (a1dot, a2dot)\\n t = timestep * self.t_interval\\n x, y, theta, a1, a2 = self.perform_integration(action, t)\\n\\n # testing\\n # print('the increments: ')\\n # print(dx, dy, dtheta, da1, da2)\\n\\n # update robot variables\\n self.x = x\\n self.y = y\\n # self.theta = theta\\n # self.a1 = a1\\n # self.a2 = a2\\n self.time += t\\n self.a1dot = a1dot\\n self.a2dot = a2dot\\n # self.body_v = (body_v[0][0], body_v[1][0], body_v[2][0])\\n # self.inertial_v = (inertial_v[0][0], inertial_v[1][0], inertial_v[2][0])\\n # self.state = (self.theta, self.a1, self.a2)\\n\\n # discretize state variables\\n # print('before: ' + str(self.state))\\n self.theta = self.rnd(self.discretize(theta, self.a_interval))\\n\\n # prevent theta from going out of -pi to pi range\\n self.enforce_theta_range()\\n\\n self.a1 = self.rnd(self.discretize(a1, self.a_interval))\\n self.a2 = self.rnd(self.discretize(a2, self.a_interval))\\n self.state = (self.theta, self.a1, self.a2)\\n # print('after: ' + str(self.state))\\n\\n return self.state\",\n \"def advanceVelocity(self,time,acceleration):\\n if not isinstance(acceleration,Cartesian3DVector):\\n raise CoordinateException(\\\"Advancing particle momentum with the incorrect acceleration type.\\\")\\n return self.v + time*acceleration\",\n \"def __init__(self, robot: SmartBot, dt):\\n self._robot = robot\\n self._target_position = None\\n self._dt = dt\\n\\n self._pose = np.zeros(3)\",\n \"def __init__(self, total_time, kin, limb, ar_tag_pos):\\n # raise NotImplementedError\\n self.r = .1 \\n MotionPath.__init__(self, limb, kin, total_time)\\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\\n self.ar_tag_pos[2] = 0.282\\n self.start_pos = [ar_tag_pos[0],ar_tag_pos[1]+self.r,ar_tag_pos[2]]\\n self.w = 2*math.pi/self.total_time\",\n \"def log_odometry(self, data):\\n\\n\\t\\tself.pose = data.pose.pose\\n\\t\\tself.velocity = data.twist.twist\\n\\n\\t\\tprintable_pose = self.human_readable_pose2d(self.pose)\\n\\n\\t\\t# log robot's pose\\n\\t\\trospy.loginfo_throttle(\\n\\t\\tperiod=1, # log every 10 seconds\\n\\t\\tmsg=self.name + ' (%.3f, %.3f, %.3f) ' % printable_pose # message\\n\\t\\t)\",\n \"def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\\n\\n #project forwards in time\\n sim_interval = self.sim_interval\\n sim_interval_sq = sim_interval*sim_interval\\n cmd_vel = list(cmd_vel)\\n current_speed = list(current_speed)\\n\\n max_acc_x = self.robot.max_acc_x\\n max_acc_th = self.robot.max_acc_th\\n max_decc_x = self.robot.max_dacc_x\\n max_decc_th = self.robot.max_dacc_th\\n\\n\\n code = \\\"\\\"\\\"\\n double x, y, th;\\n x = y = th = 0;\\n\\n double vx, vth;\\n vx = current_speed[0];\\n vth = current_speed[1];\\n\\n double cmd_x = cmd_vel[0];\\n double cmd_th = cmd_vel[1];\\n\\n //are we accelerating or decelerating?\\n double acc_x;\\n double acc_th;\\n\\n bool b_ax = false;\\n if (cmd_x > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = accs[2];\\n acc_x = -1*acc_x;\\n }\\n\\n bool b_ath = false;\\n if (cmd_th > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1* (double) accs[3];\\n\\n }\\n\\n py::list traj;\\n\\n //delay at the beginning\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //application of the command\\n for (double i=0; i<=time_applied; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //delay before decellerating\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //now we apply a stop\\n b_ax = false;\\n if (0 > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = -1 * (double) accs[2];\\n }\\n\\n b_ath = false;\\n if (0 > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1 * (double) accs[3];\\n }\\n\\n for (double i=0; i<=time_decc; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx) < 1e-6) vx = 0;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > 0 )) vx = 0;\\n if (!b_ax && (vx < 0 )) vx = 0;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth) < 1e-6) vth = 0;\\n if (b_ath && (vth > 0 )) vth = 0;\\n if (!b_ath && (vth < 0 )) vth = 0;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n\\n\\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\\n if (stopped) break;\\n\\n }\\n\\n return_val = traj;\\n \\\"\\\"\\\"\\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\\n 'time_decc'], type_converters=converters.blitz)\\n\\n return traj\",\n \"def publish(self):\\n msg = PolynomialTrajectory()\\n\\n if self.trajectory_constructed == True: \\n t = time.time()-self.traj_t0\\n\\n if t <= self.seg_times[-1]: \\n segment = map(lambda x:x > t, self.seg_times).index(True)\\n else: \\n segment = self.no_of_segments; t = self.seg_times[-1]\\n \\n rospy.loginfo('the value of t and segment is:%f, %d', t, segment)\\n #rospy.loginfo('segment times are:%f, %f, %f, %f, %f, %f', self.segment_times[0], \\\\\\n #self.segment_times[1], self.segment_times[2], self.segment_times[3], self.segment_times[4], self.segment_times[5])\\n p1 = self.pc_x; p2 = self.pc_y; p3 = self.pc_z\\n N = self.N+1\\n p1 = [p1[i:i + N] for i in range(0, len(p1), N)]\\n [i.reverse() for i in p1]\\n \\n p2 = [p2[i:i + N] for i in range(0, len(p2), N)]\\n [i.reverse() for i in p2]\\n \\n p3 = [p3[i:i + N] for i in range(0, len(p3), N)]\\n [i.reverse() for i in p3]\\n xx = np.poly1d(p1[segment-1]); vx = np.polyder(xx, 1); ax = np.polyder(xx, 2)\\n yy = np.poly1d(p2[segment-1]); vy = np.polyder(yy, 1); ay = np.polyder(yy, 2)\\n zz = np.poly1d(p3[segment-1]); vz = np.polyder(zz, 1); az = np.polyder(zz, 2)\\n \\n msg.header.stamp = rospy.Time.now()\\n msg.pdes.x = xx(t); msg.pdes.y = yy(t); msg.pdes.z = zz(t)\\n msg.vdes.x = vx(t); msg.vdes.y = vy(t); msg.ades.z = vz(t)\\n msg.ades.x = ax(t); msg.ades.y = ay(t); msg.ades.z = az(t)\\n msg.ddes.x = 1; msg.ddes.y = 0; msg.ddes.z = 0\\n msg.controller = 0\\n \\n self.pub.publish(msg)\\n\\n else: \\n rospy.loginfo('no goal is published yet')\",\n \"def waypoint_callback(self, wp):\\n if self.trajectory_constructed == False: \\n NextwpPosition = np.array([wp.position.x, wp.position.y, wp.position.z])\\n NextwpOrientation = np.array([wp.orientation.x, wp.orientation.y, wp.orientation.z, wp.orientation.w])\\n self.pc_x, self.pc_y, self.pc_z, self.seg_times, self.traj_t0 = self.make_trajectory(NextwpPosition, NextwpOrientation) \\n self.trajectory_constructed = True\",\n \"def calculate_trajectory(self, position, velocity, acceleration,\\n deltaV, deltaD):\\n # Initial/End conditions\\n initS = (position[0], velocity[0], acceleration[0])\\n initD = (position[1], velocity[1], acceleration[1])\\n\\n # TODO: find proper boundary condition for dS\\n dS = ((2 * initS[1] + deltaV) / 2) * self.deltaT\\n\\n endS = (initS[0] + dS, initS[1] + deltaV, 0)\\n endD = (initD[0] + deltaD, 0, 0)\\n\\n # Calculate coefficients\\n coeff_S = self.calculate_coefficients(initS, endS)\\n coeff_D = self.calculate_coefficients(initD, endD)\\n\\n # Calculate trajectory\\n trajectory = self._get_trajectory(coeff_S, coeff_D)\\n\\n return trajectory\",\n \"def move2cartesian(position=None, orientation=None, relative_pose=None, in_tip_frame=False, joint_angles=[],\\n tip_name='right_hand', linear_speed=0.6, linear_accel=0.6, rotational_speed=1.57,\\n rotational_accel=1.57, timeout=None, neutral=False):\\n\\n try:\\n #rospy.init_node('go_to_cartesian_pose_py')\\n limb = Limb()\\n\\n traj_options = TrajectoryOptions()\\n traj_options.interpolation_type = TrajectoryOptions.CARTESIAN\\n traj = MotionTrajectory(trajectory_options = traj_options, limb = limb)\\n\\n wpt_opts = MotionWaypointOptions(max_linear_speed=linear_speed,\\n max_linear_accel=linear_accel,\\n max_rotational_speed=rotational_speed,\\n max_rotational_accel=rotational_accel,\\n max_joint_speed_ratio=1.0)\\n waypoint = MotionWaypoint(options = wpt_opts.to_msg(), limb = limb)\\n\\n joint_names = limb.joint_names()\\n\\n if joint_angles and len(joint_angles) != len(joint_names):\\n rospy.logerr('len(joint_angles) does not match len(joint_names!)')\\n return None\\n\\n if neutral == True:\\n limb.move_to_neutral()\\n else:\\n if (position is None and orientation is None and relative_pose is None):\\n if joint_angles:\\n # does Forward Kinematics\\n waypoint.set_joint_angles(joint_angles, tip_name, joint_names)\\n else:\\n rospy.loginfo(\\\"No Cartesian pose or joint angles given. Using default\\\")\\n waypoint.set_joint_angles(joint_angles=None, active_endpoint=tip_name)\\n else:\\n endpoint_state = limb.tip_state(tip_name)\\n if endpoint_state is None:\\n rospy.logerr('Endpoint state not found with tip name %s', tip_name)\\n return None\\n pose = endpoint_state.pose\\n\\n if relative_pose is not None:\\n if len(relative_pose) != 6:\\n rospy.logerr('Relative pose needs to have 6 elements (x,y,z,roll,pitch,yaw)')\\n return None\\n # create kdl frame from relative pose\\n rot = PyKDL.Rotation.RPY(relative_pose[3],\\n relative_pose[4],\\n relative_pose[5])\\n trans = PyKDL.Vector(relative_pose[0],\\n relative_pose[1],\\n relative_pose[2])\\n f2 = PyKDL.Frame(rot, trans)\\n # and convert the result back to a pose message\\n if in_tip_frame:\\n # end effector frame\\n pose = posemath.toMsg(posemath.fromMsg(pose) * f2)\\n else:\\n # base frame\\n pose = posemath.toMsg(f2 * posemath.fromMsg(pose))\\n else:\\n if position is not None and len(position) == 3:\\n pose.position.x = position[0]\\n pose.position.y = position[1]\\n pose.position.z = position[2]\\n if orientation is not None and len(orientation) == 4:\\n pose.orientation.x = orientation[0]\\n pose.orientation.y = orientation[1]\\n pose.orientation.z = orientation[2]\\n pose.orientation.w = orientation[3]\\n poseStamped = PoseStamped()\\n poseStamped.pose = pose\\n\\n if not joint_angles:\\n # using current joint angles for nullspace bais if not provided\\n joint_angles = limb.joint_ordered_angles()\\n waypoint.set_cartesian_pose(poseStamped, tip_name, joint_angles)\\n else:\\n waypoint.set_cartesian_pose(poseStamped, tip_name, joint_angles)\\n\\n rospy.loginfo('Sending waypoint: \\\\n%s', waypoint.to_string())\\n\\n traj.append_waypoint(waypoint.to_msg())\\n\\n result = traj.send_trajectory(timeout=timeout)\\n if result is None:\\n rospy.logerr('Trajectory FAILED to send')\\n return\\n\\n if result.result:\\n rospy.loginfo('Motion controller successfully finished the trajectory!')\\n else:\\n rospy.logerr('Motion controller failed to complete the trajectory with error %s',\\n result.errorId)\\n \\n except rospy.ROSInterruptException:\\n rospy.logerr('Keyboard interrupt detected from the user. Exiting before trajectory completion.')\",\n \"def motion_model(particle_poses, speed_command, odom_pose, odom_pose_prev, dt):\\n \\n M = particle_poses.shape[0]\\n \\n # TODO. For each particle calculate its predicted pose plus some\\n # additive error to represent the process noise. With this demo\\n # code, the particles move in the -y direction with some Gaussian\\n # additive noise in the x direction. Hint, to start with do not\\n # add much noise.\\n\\n #time is in ns 1e-9\\n dt = dt * 1e-9\\n \\n if dt ==0:\\n return particle_poses\\n\\n for m in range(M):\\n\\n theta = particle_poses[m, 2]\\n\\n v = speed_command[0]\\n omega = speed_command[1]\\n \\n if motion_model_velocity: #Velocity\\n\\n if omega == 0: #straight\\n vel_dx = v * cos(theta) * dt\\n vel_dy = v * sin(theta) * dt\\n vel_dtheta = 0\\n\\n else:\\n vel_dx = -v / omega * sin(theta) + v / omega * sin(theta + omega * dt)\\n vel_dy = v / omega * cos(theta) - v / omega * cos(theta + omega * dt)\\n vel_dtheta = omega * dt\\n \\n\\n\\n if motion_model_odom:\\n odom_mov = rev_odm(odom_pose, odom_pose_prev)\\n\\n #particle_poses[m] = fwd_odm(particle_poses[m], odom_mov)\\n\\n #odom_dpose = fwd_odm2(particle_poses[m], odom_mov)\\n (odom_dx, odom_dy, odom_dtheta) = fwd_odm2(particle_poses[m], odom_mov)\\n\\n\\n\\n\\n #fusion\\n w = motion_weighting\\n dx = w * odom_dx + (1-w) * vel_dx\\n dy = w * odom_dy + (1-w) * vel_dy\\n dtheta = w * odom_dtheta + (1-w) * vel_dtheta\\n \\n \\n\\n \\n \\n #process noise\\n if motion_model_noise:\\n noise_x= np.random.normal(0, motion_sigma_x)\\n noise_y= np.random.normal(0, motion_sigma_y)\\n noise_theta= np.random.normal(0, motion_sigma_theta)\\n \\n #local noise\\n if motion_model_noise_alt:\\n localnoise_x = np.random.normal(0, motion_sigma_x)\\n localnoise_y = np.random.normal(0, motion_sigma_y)\\n\\n noise_x = localnoise_x * cos(theta) - localnoise_y * sin(theta)\\n noise_y = localnoise_y * sin(theta) + localnoise_y * cos(theta)\\n noise_theta = np.random.normal(0, motion_sigma_theta)\\n\\n\\n\\n particle_poses[m, 0] += dx + noise_x\\n particle_poses[m, 1] += dy + noise_y\\n particle_poses[m, 2] = wraptopi(theta + dtheta + noise_theta)\\n\\n \\n return particle_poses\",\n \"def position(t, x, y):\\n return x * exp(-t * y) * sin(2 * pi * t)\",\n \"def add_ado(\\n self,\\n position: torch.Tensor,\\n velocity: torch.Tensor = torch.zeros(2),\\n history: torch.Tensor = None,\\n **ado_kwargs\\n ) -> mantrap.agents.IntegratorDTAgent:\\n # When being queried with an agent's history length of one, the Trajectron will always predict standing\\n # still instead of assuming a constant velocity (or likewise). However when the user inputs just one\\n # position and one velocity, rather than a full state history, continuing on this path clearly is the\\n # user's intention, therefore stack several copies of this input state (position, velocity, time) in order\\n # to create a history the Trajectron is used to deal with, while giving the incentive to predict a simple\\n # \\\"constant\\\" continuation of this state as most likely prediction.\\n if history is None or history.shape[0] == 1:\\n position, velocity = position.float(), velocity.float()\\n history = torch.stack([torch.cat(\\n (position + velocity * self.dt * t, velocity, torch.ones(1) * self.time + self.dt * t))\\n for t in range(-mantrap.constants.TRAJECTRON_DEFAULT_HISTORY_LENGTH, 1)\\n ])\\n\\n ado = super(Trajectron, self).add_ado(position, velocity=velocity, history=history, **ado_kwargs)\\n # Add a ado to Trajectron neural network model using reference ghost.\\n self._add_agent_to_graph(agent=ado)\\n return ado\",\n \"def main():\\r\\n PathGenerator = TrajectoryGenerator()\\r\\n \\r\\n ## coordinate \\r\\n # Y \\r\\n # ^ /\\r\\n # | /\\r\\n # | / <theta>\\r\\n # o -- -- -- >X\\r\\n\\r\\n x_0 = 0.0 # initial x position\\r\\n y_0 = 0.0 # initial y position\\r\\n theta_0 = 0.0 *np.pi/180 # initial heading angle of the vehicle \\r\\n kappa_0 = 0.0 *np.pi/180 # initial steering angle \\r\\n initial_state = [x_0, y_0, theta_0, kappa_0] \\r\\n \\r\\n x_f = 13.0 # final x position\\r\\n y_f = 8.0 # final y position\\r\\n theta_f = 0.0 *np.pi/180 # final heading angle of the vehicle \\r\\n kappa_f = 0.0 *np.pi/180 # final steering angle \\r\\n final_state = [x_f, y_f, theta_f, kappa_f] \\r\\n\\r\\n traject = PathGenerator.compute_spline(initial_state, final_state)\\r\\n point_array = np.asarray(traject)\\r\\n plt.plot(point_array[:,0], point_array[:,1],'o')\\r\\n \\r\\n sample_resolution = 0.5\\r\\n temp_goal_list = []\\r\\n for i in range(-2, 3):\\r\\n temp_final_state = np.copy(final_state)\\r\\n temp_final_state[1] = temp_final_state[1] + float(i)*sample_resolution\\r\\n temp_goal_list.append(temp_final_state)\\r\\n \\r\\n start = time.time()\\r\\n point_list = []\\r\\n for i in range(0, 5):\\r\\n temp_goal = temp_goal_list[i]\\r\\n traject = PathGenerator.compute_spline(initial_state, temp_goal)\\r\\n point_list.append(traject)\\r\\n end = time.time()\\r\\n print('Executed time is %f'%(end - start))\\r\\n \\r\\n # pdb.set_trace()\\r\\n for i in range(0,5):\\r\\n point_array = np.asarray(point_list[i])\\r\\n plt.plot(point_array[:,0], point_array[:,1],'o')\\r\\n \\r\\n plt.axis('equal')\\r\\n plt.show()\",\n \"def move(self, xT):\\n # Sample distance to collision\\n Distance = -(1.0/xT)*math.log(random.random())\\n\\n # Move Particle\\n x = self.position[0] + Distance*self.direction[0]\\n y = self.position[1] + Distance*self.direction[1]\\n z = self.position[2] + Distance*self.direction[2]\\n self.position = (x,y,z)\",\n \"def my_go_to_pose1(robot, x, y, angle_z):\\n # Assuming positive y is to the robot's left and positive x is the direction the robot is already facing\\n hypotenuse = numpy.sqrt(x*x + y*y)\\n angle_offset_of_target_point = numpy.arcsin(y/hypotenuse)*180/math.pi\\n my_turn_in_place(robot, angle_offset_of_target_point , 30)\\n my_drive_straight(robot, hypotenuse, 50)\\n my_turn_in_place(robot, angle_z-angle_offset_of_target_point, 30)\\n time.sleep(1)\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def _get_pointing_pose(self, point_entity):\\n # type: (Entity, Arm) -> FrameStamped\\n # Compute the frame w.r.t. base link\\n fs_robot = point_entity.pose.projectToFrame(self.robot.base_link_frame, self.robot.tf_buffer)\\n\\n # Set the orientation to unity\\n fs_robot.frame.M = kdl.Rotation()\\n\\n return fs_robot\",\n \"def joint_trajectory(theta_start, theta_end, Tf, N, method):\\n\\n N = int(N)\\n timegap = Tf / (N - 1.0) # N points, N-1 line segments\\n traj = np.zeros((len(theta_start), N)) # intitialize the trajectory matrix, 1D joint vars, 2D each time instance\\n\\n # for each line segment, from 0 to T, calculate the corresponding s value (0to1)\\n for i in range(N):\\n if method == 3:\\n s = cubic_time_scaling(Tf, timegap * i)\\n else:\\n s = quintic_time_scaling(Tf, timegap * i)\\n traj[:, i] = s * np.array(theta_end) + (1 - s) * np.array(theta_start) # xi = x_start + (0.whatever fraction s)(x_end-x_start)\\n traj = np.array(traj).T\\n return traj\",\n \"def write_point_trajectory_file( filename, times, points ):\\n\\n plot = open( filename, \\\"w\\\")\\n plot.write(\\\"\\\"\\\"# point trajectory file \\n# Each line represents one Cartesian points for plotting the moving point, e.g.\\n# the origin of a moving coordinate frame.\\n# format: timestamp x, y, z\\n# units: seconds, millimeters\\n\\\"\\\"\\\")\\n\\n for i,pt in enumerate( points ):\\n plot.write( \\\"%f \\\" % times[i] )\\n plot.write( \\\"%f %f %f\\\\n\\\" % tuple( pt[0:3] ) )\\n plot.close()\\n return\",\n \"def _on_pose(self, msg):\\n if self._history_length == Dashboard.POSE_MAX_TIMESTEPS:\\n self._pose_history[:, :-1] = self._pose_history[:, 1:]\\n else:\\n self._history_length += 1\\n\\n self._pose_history[:, self._history_length-1] = [\\n rospy.Time.now().to_time() % 1000,\\n msg.x,\\n msg.y,\\n msg.theta,\\n msg.linear_velocity,\\n msg.angular_velocity,\\n ]\",\n \"def makeSpline(self, waypointTrajectory: Trajectory, loop: bool=False) -> None:\\n if loop and waypointTrajectory.milestones[-1] != waypointTrajectory.milestones[0]:\\n print(waypointTrajectory.milestones[-1],\\\"!=\\\",waypointTrajectory.milestones[0])\\n raise ValueError(\\\"Asking for a loop trajectory but the endpoints don't match up\\\")\\n velocities = []\\n t = waypointTrajectory\\n d = len(t.milestones[0])\\n third = 1.0/3.0\\n if len(t.milestones)==1:\\n velocities.append([0]*d)\\n elif len(t.milestones)==2:\\n if loop:\\n v = [0.0]*d\\n velocities = [v,v]\\n else:\\n s = (1.0/(t.times[1]-t.times[0]) if (t.times[1]-t.times[0]) != 0 else 0)\\n v = vectorops.mul(self.geodesic.difference(t.milestones[1],t.milestones[0]),s) \\n velocities.append(v)\\n v2 = vectorops.mul(self.geodesic.difference(t.milestones[0],t.milestones[1]),-s) \\n velocities.append(v2)\\n else:\\n N = len(waypointTrajectory.milestones)\\n if loop:\\n timeiter = zip([-2]+list(range(N-1)),range(0,N),list(range(1,N))+[1])\\n else:\\n timeiter = zip(range(0,N-2),range(1,N-1),range(2,N))\\n for p,i,n in timeiter:\\n if p < 0: dtp = t.times[-1] - t.times[-2]\\n else: dtp = t.times[i] - t.times[p]\\n if n <= i: dtn = t.times[1]-t.times[0]\\n else: dtn = t.times[n]-t.times[i]\\n assert dtp >= 0 and dtn >= 0\\n s2 = (1.0/dtn if dtn != 0 else 0)\\n v2 = vectorops.mul(self.geodesic.difference(t.milestones[n],t.milestones[i]),s2)\\n s1 = (1.0/dtp if dtp != 0 else 0)\\n v1 = vectorops.mul(self.geodesic.difference(t.milestones[p],t.milestones[i]),-s1)\\n v = vectorops.mul(vectorops.add(v1,v2),0.5)\\n velocities.append(v)\\n if not loop:\\n #start velocity as linear\\n v0 = vectorops.mul(self.geodesic.difference(t.milestones[1],t.milestones[0]),1.0/(t.times[1]-t.times[0]))\\n #terminal velocity as quadratic\\n vn = vectorops.mul(self.geodesic.difference(t.milestones[-2],t.milestones[-1]),-1.0/(t.times[-1]-t.times[-2]))\\n velocities = [v0]+velocities+[vn]\\n else:\\n assert len(velocities) == N\\n GeodesicHermiteTrajectory.__init__(self,self.geodesic,waypointTrajectory.times[:],waypointTrajectory.milestones,velocities)\",\n \"def position(self, l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n pos = x + v * t + (1/2.0) * g * t**2\\n \\n if squeeze:\\n pos = np.squeeze(pos, axis=0)\\n return pos\",\n \"def goToPose(self,pose,speed=DEFAULT_SPEED):\\n\\n print(\\\"Moving to {}\\\".format(pose.description))\\n gpio = pose.gpio\\n if gpio != None:\\n pin = gpio.get('pin',None)\\n value = gpio.get('value',0)\\n if pin != None:\\n if type(pin) is str:\\n self.robot.set_io({pin:value})\\n elif pin != -1:\\n GPIO.output(pin, {0:False,1:True}[value])\\n self.waitFor(gpio.get('delay',2))\\n return 'Set Io: '+str(pin)+' value: '+str(value)\\n print(gpio)\\n newSpeed = speed\\n if pose.speed != None:\\n newSpeed = pose.speed\\n cmd = self.getMovementCommand(pose,speed=newSpeed)\\n print(cmd)\\n self.robot.play(cmd)\\n self.waitForCompletion()\\n print(\\\"Completed move\\\")\",\n \"def trajectory(self):\\n return Trajectory.createFromTuples(self.points)\",\n \"def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):\\n #raise NotImplementedError\\n MotionPath.__init__(self, limb, kin, total_time)\\n start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])\\n\\n\\n #The ar tracking function was not working properly so we added the block below \\n #to correct it.\\n if start_pos[1]>start_pos[0]:\\n a = start_pos[0]\\n b = start_pos[1]\\n start_pos[0] = b\\n start_pos[1] = a\\n print(\\\"### Modified start_pos ###\\\")\\n\\n\\n ar_tag_pos = np.array([abs(ar_tag_pos[0]), abs(ar_tag_pos[1]), abs(ar_tag_pos[2])])\\n if ar_tag_pos[1]>ar_tag_pos[0]:\\n a = ar_tag_pos[0]\\n b = ar_tag_pos[1]\\n ar_tag_pos[0] = b\\n ar_tag_pos[1] = a\\n self.start_pos = start_pos\\n\\n print(\\\"!!!!!!!!!!!!!!!!start_pos!!!!!!!!!!!!!!!!\\\")\\n print(start_pos)\\n print(\\\"!!!!!!!!!ar_tag_pos in LinearPath!!!!!!!!!\\\")\\n print(ar_tag_pos)\\n ar_tag_pos[2] = start_pos[2]\\n self.ar_tag_pos = ar_tag_pos\\n self.points_generated = []\",\n \"def my_go_to_pose1(robot, x, y, angle_z):\\n\\t# ####\\n\\t# TODO: Implement a function that makes the robot move to a desired pose\\n\\t# using the my_drive_straight and my_turn_in_place functions. This should\\n\\t# include a sequence of turning in place, moving straight, and then turning\\n\\t# again at the target to get to the desired rotation (Approach 1).\\n\\t# ####\\n\\tfirstRotationInRadians = (0 if y == 0 else 90) if x == 0 else math.atan(y/x)\\n\\tfirstRotation = firstRotationInRadians * 360.0/ (2.0 * math.pi)\\n\\tmy_turn_in_place(robot, firstRotation, 30)\\n\\trobot.stop_all_motors()\\n\\t# robot.drive_wheels(0, 0, duration=1)\\n\\t# time.sleep(1)\\n\\tmy_drive_straight(robot, math.sqrt(x*x + y*y), (-1 if x < 0 else 1) * 30)\\n\\trobot.stop_all_motors()\\n\\t# robot.drive_wheels(0, 0, duration=1)\\n\\t# time.sleep(1)\\n\\tmy_turn_in_place(robot, angle_z - firstRotation , 30)\\n\\ttime.sleep(1)\",\n \"def compute_trajectory(\\n traj_type: str,\\n origin: Position,\\n goal: Position,\\n step: int,\\n origin_qd: float = 0.002,\\n goal_qd: float = 0.002,\\n) -> rtb.tools.trajectory.Trajectory:\\n # print(f\\\"{origin=}\\\\n{goal=}\\\\n\\\")\\n\\n trajs = []\\n for origin_q, goal_q in zip(origin.xyzrpy, goal.xyzrpy):\\n\\n if traj_type == \\\"lspb\\\":\\n traj_func = rtb.tools.trajectory.lspb\\n args = [origin_q, goal_q, step]\\n elif traj_type == \\\"tpoly\\\":\\n traj_func = rtb.tools.trajectory.tpoly\\n args = [origin_q, goal_q, step, origin_qd, goal_qd]\\n\\n if origin_q == goal_q:\\n trajs.append(\\n Trajectory(\\n traj_type,\\n step,\\n [origin_q] * step,\\n [0] * step,\\n [0] * step,\\n istime=False,\\n )\\n )\\n else:\\n trajs.append(traj_func(*args))\\n\\n x = trajs[0].t\\n y = np.array([tg.s for tg in trajs]).T\\n yd = np.array([tg.sd for tg in trajs]).T\\n ydd = np.array([tg.sdd for tg in trajs]).T\\n\\n istime = trajs[0].istime\\n\\n return Trajectory(\\\"mtraj\\\", x, y, yd, ydd, istime)\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def line_to(self, point: Onion[Tuple[float, float], Point2D, Point3D, Point]):\\n start_point = self.last_point\\n end_point = _point_2d(point)\\n self._segments.append(Line3D.create(start_point, end_point))\",\n \"def get_trajectory_message(action, joint_order):\\n # Set up a trajectory message to publish.\\n action_msg = JointTrajectory()\\n # action_msg.joint_names = self.environment['joint_order']\\n action_msg.joint_names = joint_order\\n # Create a point to tell the robot to move to.\\n target = JointTrajectoryPoint()\\n action_float = [float(i) for i in action]\\n target.positions = action_float\\n\\n # Package the single point into a trajectory of points with length 1.\\n action_msg.points = [target]\\n return action_msg\",\n \"def setDirectionTowardPoint(self, x, y, speed):\\n currX = self.xcor()\\n currY = self.ycor()\\n # get actual vector from t to x,y\\n dXactual = x - currX\\n dYactual = y - currY\\n\\n # get the length of that vector. Can also use turtle.distance\\n length = math.hypot(dXactual, dYactual)\\n\\n # now scale the vector\\n try:\\n self.dx = dXactual / length * speed\\n self.dy = dYactual / length * speed\\n except:\\n self.dx = 0\\n self.dy = 0\",\n \"def waypts2setpts(P, params):\\n\\tV = params.drone_vel # [m/s]\\n\\tfreq = params.ViconRate; dt = 1./freq\\n\\tdx = V * dt\\n\\ttraj_global = np.array(P[-1])\\n\\tfor i in range(len(P)-1, 0, -1):\\n\\t\\tA = P[i]\\n\\t\\tB = P[i-1]\\n\\n\\t\\tn = (B-A) / norm(B-A)\\n\\t\\tdelta = n * dx\\n\\t\\tN = int( norm(B-A) / norm(delta) )\\n\\t\\tsp = A\\n\\t\\ttraj_global = np.vstack([traj_global, sp])\\n\\t\\tfor i in range(N):\\n\\t\\t\\tsp += delta\\n\\t\\t\\ttraj_global = np.vstack([traj_global, sp])\\n\\t\\tsp = B\\n\\t\\ttraj_global = np.vstack([traj_global, sp])\\n\\n\\treturn traj_global\",\n \"def move2goal(self):\\n vel_msg = Twist()\\n\\n # Linear velocity in the x-axis.\\n vel_msg.linear.x = 0.4 # m/s\\n vel_msg.linear.y = 0\\n vel_msg.linear.z = 0\\n\\n # Angular velocity in the z-axis.\\n vel_msg.angular.x = 0\\n vel_msg.angular.y = 0\\n vel_msg.angular.z = 1.5 # rad/s\\n\\n # Starting point reference\\n goal_x = 1.0 \\n goal_y = 1.0\\n x_ref = 1.0\\n y_ref = 1.0\\n\\n # Previous Reference\\n x_prev_ref = 0.0\\n y_prev_ref = 0.0\\n theta_prev_ref = self.theta\\n vrefA = 0.5\\n wrefA = 0.0\\n \\n i = 0\\n tPx, tPy, tPTheta = self.initiate_trajectory(\\n x_ref, y_ref, vel_msg, \\n x_prev_ref, y_prev_ref, \\n theta_prev_ref, vrefA, wrefA\\n )\\n\\n x_prev_ref = tPx[0]\\n y_prev_ref = tPy[0]\\n theta_prev_ref = tPTheta[0]\\n\\n print(f'X TRAJECTORY: {tPx}\\\\nY TRAJECTORY: {tPy}\\\\nTHETA TRAJ: {tPTheta}')\\n print(f'ACTUAL THETA: {self.theta}')\\n\\n while not rospy.is_shutdown():\\n \\n if i >= 8:\\n i = 0\\n\\n x_ref = goal_x\\n y_ref = goal_y\\n\\n tPx, tPy, tPTheta = self.initiate_trajectory(\\n x_ref, y_ref, vel_msg, \\n x_prev_ref, y_prev_ref, \\n theta_prev_ref, vrefA, wrefA\\n )\\n # inputRef = ControllerInput(\\n # xref=x_ref,\\n # yref=y_ref,\\n # RstateX=self.x_position,\\n # RstateY=self.y_position,\\n # RstateTheta=self.theta,\\n # RstateVelocity=vel_msg.linear.x,\\n # RstateW=vel_msg.angular.z,\\n # xrefA=x_prev_ref,\\n # yrefA=y_prev_ref,\\n # thetarefA=theta_prev_ref,\\n # vrefA=vrefA,\\n # wrefA=wrefA\\n # )\\n\\n # rospy.loginfo(f'X: {self.x_position} \\\\tY: {self.y_position}\\\\t Theta: {self.theta} ')\\n # nmpc = NMPC_Controller(inputRef)\\n # tPx, tPy, tPTheta = nmpc.test_create_mini_path()\\n\\n # print(f'X TRAJECTORY: {tPx}\\\\nY TRAJECTORY: {tPy}\\\\nTHETA TRAJ: {tPTheta}')\\n # print(f'ACTUAL THETA: {self.theta}')\\n \\n # new_v, new_w = nmpc.start_optmizer()\\n # new_v = round(new_v, 4)\\n # new_w = round(new_w, 4)\\n\\n # print(new_v, new_w)\\n # rospy.loginfo(\\n # f'X: {self.x_position}, Y: {self.y_position}, THETA: {self.theta}')\\n \\n # self.velocity_publisher.publish(vel_msg)\\n # x_prev_ref = self.x_position\\n # y_prev_ref = self.y_position\\n # theta_prev_ref = self.theta\\n # vrefA = vel_msg.linear.x\\n # wrefA = vel_msg.angular.z\\n \\n\\n # theta_prev_ref = self.theta\\n # vel_msg.angular.z = 0.0\\n\\n\\n '''Update the linear & angular velocity'''\\n # vel_msg.linear.x = new_v\\n # vel_msg.angular.z = new_w\\n\\n if i < 8:\\n inputRef = ControllerInput(\\n xref = tPx[i],\\n yref = tPy[i],\\n RstateX = self.x_position,\\n RstateY = self.y_position,\\n RstateTheta = self.theta,\\n RstateVelocity = vel_msg.linear.x,\\n RstateW = vel_msg.angular.z,\\n xrefA = x_prev_ref,\\n yrefA = y_prev_ref,\\n thetarefA = theta_prev_ref,\\n vrefA = vrefA,\\n wrefA = wrefA\\n )\\n\\n nmpc = NMPC_Controller(inputRef)\\n new_v, new_w = nmpc.start_optmizer()\\n new_v = round(new_v, 4)\\n new_w = round(new_w, 4)\\n\\n print(f'(actual) X: {self.x_position}, Y: {self.x_position}, THETA: {self.theta}')\\n print(f'(desired) X: {tPx[i]}, Y: {tPy[i]}')\\n print(f'V: {vel_msg.linear.x}\\\\tW: {vel_msg.angular.z}')\\n\\n x_prev_ref = tPx[i-1]\\n y_prev_ref = tPy[i-1]\\n theta_prev_ref = tPTheta[i-1]\\n vrefA = vel_msg.linear.x\\n wrefA = vel_msg.angular.z\\n\\n vel_msg.linear.x = new_v\\n vel_msg.angular.z = new_w\\n # vel_msg.angular.z = 0.0\\n\\n print(f'index: {i}')\\n\\n distance = math.sqrt((self.x_position - tPx[i])**2 + (self.y_position - tPy[i])**2)\\n if distance < 0.3:\\n print(f'Distance: {distance}')\\n i+=1\\n\\n\\n self.velocity_publisher.publish(vel_msg)\\n self.rate.sleep()\\n\\n rospy.spin()\",\n \"def _evolve(\\n self,\\n x0_idx: int,\\n ) -> np.ndarray:\\n x0 = self.starting_points[x0_idx, :]\\n if type(x0) != np.ndarray:\\n x0 = x0.toarray()\\n x0 = x0.flatten()\\n # [T, Dims, (Position, Velocity)]\\n trajectory = np.zeros(\\n (self.timesteps, x0.shape[0], 3), dtype=np.float32)\\n \\n # for each timestep, update the position of the phase point\\n # based on the velocity of nearest neighbors and obey any\\n # boundary constraints\\n x = x0\\n for t in range(self.timesteps):\\n trajectory[t, :, 0] = x # match x position to dv/dx\\n v = self.v_fxn(x=x.reshape(-1),)\\n # add white noise if desired to better emulate a stochastic process\\n noise = v[:, 1] * np.random.randn(v.shape[0]) * self.noise_scale\\n x_new = x + (v[:, 0] + noise)*self.step_scale\\n # constrain to a set of pre-defined boundaries\\n # defaults to an identity if not set explicitly\\n x_new = self.boundary_constraint(x_new)\\n trajectory[t, :, 1] = v[:, 0]\\n trajectory[t, :, 2] = v[:, 1]\\n x = x_new\\n return trajectory\",\n \"def my_go_to_pose2(robot, x, y, angle_z):\\n\\t# ####\\n\\t# TODO: Implement a function that makes the robot move to a desired pose\\n\\t# using the robot.drive_wheels() function to jointly move and rotate the \\n\\t# robot to reduce distance between current and desired pose (Approach 2).\\n\\t# ####\\n\\t\\n\\tabsoluteTargetPosition = (robot.pose.position.x + x, robot.pose.position.y + y, robot.pose.rotation.angle_z.degrees + angle_z)\\n\\t\\n\\twhile(math.sqrt(x*x + y*y) > 50.0):\\n\\t\\t# print(\\\"(x, y, angle_z) = (%i,%i,%i)\\\" % (x, y, angle_z))\\n\\t\\tfirstRotationInRadians = (0 if y == 0 else 90) if x == 0 else math.atan(y/x)\\n\\t\\tleftMotor = 10 * (2 * x - angle_z * (2 * math.pi / 360.0) * get_distance_between_wheels() * math.cos(firstRotationInRadians)) / (2 * get_front_wheel_radius() * math.cos(firstRotationInRadians))\\n\\t\\trightMotor = 10 * (2 * x + angle_z * (2 * math.pi / 360.0) * get_distance_between_wheels() * math.cos(firstRotationInRadians)) / (2 * get_front_wheel_radius() * math.cos(firstRotationInRadians))\\n\\t\\t# print(\\\"(leftMotor, rightMotor) = (%i,%i)\\\" % (leftMotor, rightMotor))\\n\\t\\tangle_delta = get_front_wheel_radius() * (rightMotor - leftMotor) / get_distance_between_wheels()\\n\\t\\tx_delta = get_front_wheel_radius() * math.cos(angle_z * 2.0 * math.pi / 360.0) * (leftMotor + rightMotor) / 2.0\\n\\t\\ty_delta = get_front_wheel_radius() * math.sin(angle_z * 2.0 * math.pi / 360.0) * (leftMotor + rightMotor) / 2.0\\n\\t\\t# print(\\\"angle_delta %i\\\" % angle_delta)\\n\\t\\t# x = x - get_front_wheel_radius() * math.cos(angle_delta) * (leftMotor + rightMotor) / 2.0\\n\\t\\t# y = y - get_front_wheel_radius() * math.sin(angle_delta) * (leftMotor + rightMotor) / 2.0\\n\\t\\t# print(\\\"(x, y, angle_z) = (%i,%i,%i)\\\" % (x, y, angle_z))\\n\\t\\t# angle_z = angle_z + angle_delta * (360.0/(2 * math.pi))\\n\\t\\t# print(\\\"(x, y, angle_z) = (%i,%i,%i)\\\" % (x, y, angle_z))\\n\\t\\trobot.drive_wheels(leftMotor, rightMotor, duration = 1)\\n\\t\\trobot.stop_all_motors()\\n\\t\\t# time.sleep(1)\\n\\t\\tx = absoluteTargetPosition[0] - robot.pose.position.x\\n\\t\\ty = absoluteTargetPosition[1] - robot.pose.position.y\\n\\t\\tangle_z = absoluteTargetPosition[2] - robot.pose.rotation.angle_z.degrees\\n\\t\\t# print(\\\"(x, y, angle_z) = (%i,%i,%i)\\\" % (x, y, angle_z))\\n\\t\\trobot.stop_all_motors()\\n\\t\\t# robot.drive_wheels(0,0)\",\n \"def get_grasp_joint_trajectory(self, start_joints, target_pose, n_steps=40, ignore_orientation=False, link_name=None):\\n link_name = link_name if link_name is not None else self.tool_frame\\n \\n assert len(start_joints) == len(self.joint_indices)\\n assert target_pose.frame.count('base_link') == 1\\n self.sim.update()\\n \\n # set active manipulator and start joint positions\\n self.robot.SetDOFValues(start_joints, self.joint_indices)\\n \\n # initialize trajopt inputs\\n rave_pose = tfx.pose(self.sim.transform_from_to(target_pose.matrix, target_pose.frame, 'world'))\\n quat = rave_pose.orientation\\n xyz = rave_pose.position\\n quat_target = [quat.w, quat.x, quat.y, quat.z]\\n xyz_target = [xyz.x, xyz.y, xyz.z]\\n rave_mat = rave.matrixFromPose(np.r_[quat_target, xyz_target])\\n \\n# init_joint_target = None\\n init_joint_target = self.sim.ik_for_link(rave_pose.matrix, self.manip, link_name, 0)\\n if init_joint_target is not None:\\n init_joint_target = self._closer_joint_angles(init_joint_target, start_joints)\\n \\n init_traj = self.ik_point(start_joints, xyz, n_steps=n_steps, link_name=link_name)\\n \\n request = self._get_grasp_trajopt_request(xyz_target, quat_target, n_steps,\\n ignore_orientation=ignore_orientation, link_name=link_name, init_traj=init_traj)\\n \\n # convert dictionary into json-formatted string\\n s = json.dumps(request) \\n # create object that stores optimization problem\\n prob = trajoptpy.ConstructProblem(s, self.sim.env)\\n \\n # TODO: worth doing?\\n# tool_link = self.robot.GetLink(link_name)\\n# def point_at(x):\\n# self.robot.SetDOFValues(x, self.joint_indices, False)\\n# T = tool_link.GetTransform()\\n# local_dir = xyz.array - T[:3,3]\\n# return T[1:3,:3].dot(local_dir)\\n# \\n# for t in xrange(int(0.8*n_steps), n_steps-1):\\n# #prob.AddConstraint(point_at, [(t,j) for j in xrange(len(self.joint_indices))], \\\"EQ\\\", \\\"POINT_AT_%i\\\"%t)\\n# prob.AddErrorCost(point_at, [(t,j) for j in xrange(len(self.joint_indices))], \\\"ABS\\\", \\\"POINT_AT_%i\\\"%t)\\n\\n # do optimization\\n result = trajoptpy.OptimizeProblem(prob)\\n \\n prob.SetRobotActiveDOFs() # set robot DOFs to DOFs in optimization problem\\n #num_upsampled_collisions = len(traj_collisions(result.GetTraj(), self.robot, n=100))\\n num_upsampled_collisions = self._num_collisions(result.GetTraj())\\n print('Number of collisions: {0}'.format(num_upsampled_collisions))\\n self.robot.SetDOFValues(start_joints, self.joint_indices)\\n if num_upsampled_collisions > 2:\\n #if not traj_is_safe(result.GetTraj()[:], self.robot): # Check that trajectory is collision free\\n return None\\n else:\\n return result.GetTraj()\",\n \"def move_robot(self, pose):\\n # type: (Pose) -> None\\n start_pos = ModelState()\\n start_pos.model_name = 'turtlebot3'\\n start_pos.pose = pose\\n rospy.wait_for_service('/gazebo/set_model_state')\\n try:\\n set_state = rospy.ServiceProxy('/gazebo/set_model_state', SetModelState)\\n resp = set_state(start_pos)\\n\\n except rospy.ServiceException:\\n print(\\\"Move Robot to position failed\\\")\\n\\n pub = rospy.Publisher('/initialpose', PoseWithCovarianceStamped, queue_size = 10)\\n rospy.sleep(3)\\n start_pos = PoseWithCovarianceStamped()\\n start_pos.header.frame_id = 'map'\\n start_pos.pose.pose = pose \\n pub.publish(start_pos)\",\n \"def step(self, dt):\\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)\",\n \"def update_position(self, robot_pose):\\n x = self.pose[0] + robot_pose[0]\\n y = self.pose[1] + robot_pose[1]\\n phi = (self.pose[2] + robot_pose[2]) % 360\\n self.pose = (x, y, phi)\",\n \"def sample_trajectory(trajectory, t):\\n\\t# First point\\n\\tif t <= 0.0:\\n\\t\\treturn copy.deepcopy(trajectory.points[0])\\n\\t# Last point\\n\\tif t >= trajectory.points[-1].time_from_start.to_sec():\\n\\t\\treturn copy.deepcopy(trajectory.points[-1])\\n\\t# Finds the (middle) segment containing t\\n\\ti = 0\\n\\twhile trajectory.points[i + 1].time_from_start.to_sec() < t:\\n\\t\\ti += 1\\n\\n\\treturn interp_cubic(trajectory.points[i], trajectory.points[i + 1], t)\",\n \"def _get_trajectory(self, coeff_S, coeff_D):\\n # Create trajectory\\n trajectory = Trajectory(self.deltaT, self.dt, self.t_steps)\\n coeff = np.array([coeff_S, coeff_D]).T\\n p_array = self.helper_p.dot(coeff)\\n v_array = self.helper_v.dot(coeff)\\n a_array = self.helper_a.dot(coeff)\\n\\n # Truncate trajectory\\n trajectory.s_coordinates = p_array[:self.t_steps, 0]\\n trajectory.d_coordinates = p_array[:self.t_steps, 1]\\n trajectory.s_velocity = v_array[:self.t_steps, 0]\\n trajectory.d_velocity = v_array[:self.t_steps, 1]\\n trajectory.s_acceleration = a_array[:self.t_steps, 0]\\n trajectory.d_acceleration = a_array[:self.t_steps, 1]\\n\\n return trajectory\",\n \"def plot_trajectories_XYZ(t_start,t_stop):\\n \\n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\\n \\n index_start = np.where(time == t_start)[0][0]\\n index_end = np.where(time == t_stop)[0][0]\\n \\n time = time[index_start:index_end+1]\\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\\n \\n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\\n \\n plt.figure('Trajectories')\\n plt.subplot(311)\\n plt.plot(time,ankle_l_trajectory[:,0])\\n plt.plot(time,ankle_r_trajectory[:,0])\\n #plt.title('Trajectory of the X component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('X Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(312)\\n plt.plot(time,ankle_l_trajectory[:,1])\\n plt.plot(time,ankle_r_trajectory[:,1])\\n #plt.title('Trajectory of the Y component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Y Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(313)\\n plt.plot(time,ankle_l_trajectory[:,2])\\n plt.plot(time,ankle_r_trajectory[:,2])\\n #plt.title('Trajectory of the Z component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Z Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n# plt.suptitle('Decomposition of the trajectories of the hind feet')\\n return\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def cartesian_trajectory(X_start, X_end, Tf, N, method):\\n\\n N = int(N)\\n timegap = Tf / (N - 1.0)\\n traj = [[None]] * N\\n R_start, p_start = ch3.transf_matrix_to_Rp(X_start)\\n R_end, p_end = ch3.transf_matrix_to_Rp(X_end)\\n\\n R_start_end = np.dot(np.array(R_start).T,R_end)\\n for i in range(N):\\n if method == 3:\\n s = cubic_time_scaling(Tf, timegap * i)\\n else:\\n s = quintic_time_scaling(Tf, timegap * i)\\n\\n R_start_end_fractioned = ch3.so3_to_rotation_matrix(ch3.rotation_matrix_to_so3(R_start_end) * s)\\n R_start_s = np.dot(R_start, R_start_end_fractioned)\\n\\n p_start_s = s * np.array(p_end) + (1 - s) * np.array(p_start) #p_start + s(p_end-p_start)\\n traj[i] = np.r_[np.c_[R_start_s, p_start_s], \\\\\\n [[ 0, 0, 0, 1]]]\\n\\n \\n return traj\",\n \"def target_position(self, time):\\n \\\"\\\"\\\"\\n start_pos = self.points[self.cur_start]\\n seg_time = time - self.last_checkpoint_time\\n\\n #The arguement of target-velocity dosent matter\\n cur_pos = self.target_velocity(time)*seg_time + start_pos\\n\\n \\n # or time > (self.total_time / 4)*(self.cur_start + 1)\\n cur_pos_norm = length(cur_pos - start_pos)\\n\\n next_corner = self.points[(self.cur_start + 1)%4]\\n \\n seg_norm = length(next_corner - start_pos)\\n print(\\\"cur_pos : \\\", cur_pos, \\\"segment: \\\", self.cur_start, seg_norm - cur_pos_norm)\\n\\n if cur_pos_norm >= seg_norm:\\n self.cur_start = (self.cur_start + 1) % 4\\n self.last_checkpoint_time = time\\n return cur_pos\\n \\\"\\\"\\\"\\n\\n #Possibly use rospy.sleep()\\n total_time = self.total_time\\n\\n\\n if time < total_time/4:\\n return self.path1.target_position(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time < total_time/2:\\n return self.path2.target_position(time - (total_time/4 + 0.5))\\n # return self.path2.target_position(time - (total_time/4 ))\\n\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= total_time/4*3:\\n return self.path3.target_position(time - (total_time/2 + 1))\\n # return self.path3.target_position(time - (total_time/2))\\n\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n else:\\n return self.path4.target_position(time - (total_time/4*3 + 1.5))\\n # return self.path4.target_position(time - (total_time/4*3))\",\n \"def my_go_to_pose2(robot, x, y, angle_z):\\n # ####\\n # TODO: Implement a function that makes the robot move to a desired pose\\n # using the robot.drive_wheels() function to jointly move and rotate the \\n # robot to reduce distance between current and desired pose (Approach 2).\\n # ####\\n pass\",\n \"def project_point(self, point: array_like) -> Point:\\n # Vector from the point in space to the point on the plane.\\n vector_to_plane = Vector.from_points(point, self.point)\\n\\n # Perpendicular vector from the point in space to the plane.\\n vector_projected = self.normal.project_vector(vector_to_plane)\\n\\n return Point(point) + vector_projected\",\n \"def capture_ordinate(p, increment, flow, factor, printIt):\\n x0, y0 = p.pos0\\n\\n forbid_up, forbid_down = 1., -1.\\n if not(forbid_down < y0 < forbid_up):\\n exception_msg = 'The starting point of the particle is outside the ' \\\\\\n + 'prescribed limits. Please try to start close to ' \\\\\\n + 'the capture domain.'\\n raise Exception(exception_msg)\\n\\n if p.captured:\\n return p, increment\\n\\n else:\\n print('Calculating the capture ordinate, starting from y0 = %e' % y0)\\n\\n is_up = particle_up(p)\\n\\n if (increment > 0 and is_up) or (increment < 0 and not(is_up)):\\n\\n print('Still going above the object... Repeat again.')\\n\\n new_pos0 = np.array([x0, y0 - increment])\\n\\n pNext = Particle(p.diameter, p.density, p.birth, p.lifetime,\\n new_pos0, None)\\n\\n pNext.compute_trajectory(flow, factor, printIt)\\n\\n return capture_ordinate(pNext, increment, flow, factor, printIt)\\n\\n else:\\n print('Now it\\\\'s going below the object!')\\n\\n new_pos0 = np.array([x0, y0 + 0.7*increment])\\n\\n pNext = Particle(p.diameter, p.density, p.birth, p.lifetime,\\n new_pos0, None)\\n\\n pNext.compute_trajectory(flow, factor, printIt)\\n\\n return capture_ordinate(pNext, 0.3*increment, flow, factor, printIt)\",\n \"def predict_trajectory(x_init, v, yaw_dot):\\n x = np.array(x_init)\\n trajectory = [x]\\n time = 0\\n while time <= Config.predict_time:\\n x = motion(x, [v, yaw_dot], Config.dt)\\n trajectory.append(x)\\n time += Config.dt\\n\\n return np.array(trajectory)\",\n \"def setPoint(self, point):\\n self._point = point\\n self._point = self.projectPoint(Point.origin(point.dimension))\",\n \"def advancePosition(self,time):\\n velocity = self.getVelocity()\\n return self.x + time*velocity\",\n \"def _setup_move(self, position):\\n self.log.debug(\\\"%s.setpoint = %s\\\", self.name, position)\\n self.setpoint.put(position, wait=True)\\n if self.actuate is not None:\\n self.log.debug(\\\"%s.actuate = %s\\\", self.name, self.actuate_value)\\n self.actuate.put(self.actuate_value, wait=False)\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def point(source, type='cross', timeLimit=7, intTime=None, refant=None, \\n stepTriangle=None, stepCross=None, nptsCross=5, antwait=-2, tol=0.1,\\n clear=True, apply=True, fitfwhm=True, pntwait=2, waitCycles=3,\\n file=True, antennas=None, tmo=500):\\n # Set source information\\n sourceInfo = dict()\\n sourceInfo['lofreq'] = commands.freqSetup()[2]\\n sourceInfo['name'] = source\\n sourceInfo['flux'] = utils.getSourceFlux(source, freq=sourceInfo['lofreq'])\\n if sourceInfo['flux'] == None or sourceInfo['flux'] <= 0.0: \\n sourceInfo['flux'] = 1.0\\n\\n # Set integration time, if needed\\n if intTime == None:\\n intTime = 10.0\\n if sourceInfo['flux'] > 5.0 and sourceInfo['lofreq'] < 150.0: intTime = 4\\n\\n # Make initial guess to parameters\\n # Offsets are increments to the mount offsets\\n p0 = [sourceInfo['flux'], 0.0, 0.0, 1.0]\\n\\n # Set parameters\\n parbase={'value':0., 'fixed':0, 'limited':[0,0], 'limits':[0.,0.]}\\n parinfo = []\\n for i in range(len(p0)):\\n parinfo.append(copy.deepcopy(parbase))\\n for i in range(len(p0)):\\n parinfo[i]['value'] = p0[i]\\n\\n # Before proceeding, make sure we are on source\\n commands.wait(commands.TRACK, tmo=tmo, waiton=commands.ALL)\\n\\n # Initialize. The initial pointing offsets are grabbed as well.\\n # Do not trust \\\"clear=True\\\" to actually set the pointing offsets\\n # to zero. There is a delay.\\n converged = [False] * len(antennas)\\n niter = 0\\n tstart = time.time()\\n offsetsAz, offsetsEl = grabPointingOffsets(antennas,clear=clear)\\n data = dict()\\n\\n # Observe\\n continuePointing = True\\n ncyclesWait = 0\\n while continuePointing and not min(converged) and \\\\\\n time.time() - tstart < timeLimit*60.0:\\n # Increment\\n niter += 1\\n print 'Iteration %2d' % niter\\n\\n # Uncomment line below to prevent accumulate data from \\n # one iteration to the next\\n # data = dict()\\n\\n # Observe center position if fitting 4 parameters and doing a triangle\\n center = (len(data) == 0 and type == 'triangle' and fitfwhm)\\n\\n # Observe\\n print ' ... collecting the data'\\n t1 = - time.time()\\n takeData(data, type, antennas, sourceInfo, offsetsAz, offsetsEl, \\n nptsCross=nptsCross, stepTriangle=stepTriangle, \\n stepCross=stepCross, antwait=antwait, intTime=intTime,\\n center=center, niter=niter)\\n fa = {'data': data}\\n t1 += time.time()\\n print ' ... that took %.1f seconds' % t1\\n\\n # Calibrate data and return structure that contains data to be fitted\\n cal = dict()\\n calibrateData(data, cal, antennas, sourceInfo, file=file, niter=niter)\\n\\n # Compute new offsets\\n new_az = np.zeros(len(antennas))\\n new_el = np.zeros(len(antennas))\\n d_az = np.zeros(len(antennas))\\n d_el = np.zeros(len(antennas))\\n fwhm = np.zeros(len(antennas))\\n ndata = np.zeros(len(antennas))\\n validFit = [False] * len(antennas)\\n for itel, values in cal.items():\\n # Set initialize guesses\\n maxoffset = 0.5 * getFWHM(antennas[itel], sourceInfo['lofreq'])\\n parinfo[1]['value'] = offsetsAz[itel]\\n parinfo[2]['value'] = offsetsEl[itel]\\n parinfo[3]['value'] = getFWHM(antennas[itel], sourceInfo['lofreq'])\\n if not fitfwhm: parinfo[3]['fixed'] = 1\\n parinfo[1]['limited'] = [1,1]\\n parinfo[2]['limited'] = [1,1]\\n parinfo[3]['limited'] = [1,0]\\n parinfo[1]['limits'] = [-maxoffset+offsetsAz[itel], maxoffset+offsetsAz[itel]]\\n parinfo[2]['limits'] = [-maxoffset+offsetsEl[itel], maxoffset+offsetsEl[itel]]\\n parinfo[3]['limits'] = [0.001, 10.0 * parinfo[3]['value']]\\n\\n # Fit the data\\n ndata[itel] = len(values) # May be modified below if antenna is now offline\\n\\n if len(values) >= len(parinfo):\\n fa = {'data': values}\\n m = mpfit.mpfit(myfunct, parinfo=parinfo, functkw=fa, quiet=1)\\n if m.status <= 0:\\n print 'error message = ', m.errmsg\\n else:\\n validFit[itel] = True\\n # elif m.dof > 0:\\n # validFit[itel] = True\\n\\n # Store results if valid fit\\n if validFit[itel]:\\n # Computed reduced chi-squared\\n # redchisq = (myfunct(m.params, data=values)[1]**2).sum() / m.dof\\n\\n # print '\\\\nFitting for antenna %2d:' % antennas[itel]\\n # for v in values:\\n # print ' %8.3f %8.3f %8.3f' % (v['amp'], v['offaz'], v['offel'])\\n # print 'Fit = %.2f %.2f' % (m.params[1], m.params[2])\\n \\n # Compute change\\n new_az[itel] = m.params[1]\\n new_el[itel] = m.params[2]\\n fwhm[itel] = m.params[3]\\n d_az[itel] = m.params[1] - offsetsAz[itel]\\n d_el[itel] = m.params[2] - offsetsEl[itel]\\n\\n # Save new offsets\\n offsetsAz[itel] = m.params[1]\\n offsetsEl[itel] = m.params[2]\\n\\n # Check convergence\\n print ' %4s %7s %7s %7s %7s %7s' % \\\\\\n ('Ant', 'fit_az', 'fit_el', 'daz', 'del', 'FWHM')\\n print ' %4s %7s %7s %7s %7s' % \\\\\\n ('', 'arcmin', 'arcmin', 'arcsec', 'arcsec')\\n antennasComplete = converged[:]\\n for i in range(len(antennas)):\\n # Is the antennas in the subarray?\\n inSubarray = antennas[i] in commands.currentAntennaNumbers()\\n\\n # Check convergence\\n beamSize = getFWHM(antennas[i], sourceInfo['lofreq'])\\n deltaBeam = np.sqrt(d_az[i]**2 + d_el[i]**2) / beamSize\\n deltaFwhm = abs(beamSize - abs(fwhm[i]))\\n converged[i] = (deltaBeam <= tol and deltaFwhm < 0.3 * beamSize and \\n validFit[i] and inSubarray)\\n\\n # Antenna is considered done if it is no longer in the subarray\\n # I set ndata to -1 to distingsuish it \\n if not inSubarray: ndata[i] = -1\\n if not inSubarray or converged[i]: antennasComplete[i] = True\\n\\n # Print message\\n s = ''\\n if validFit[i] and converged[i]: \\n s = '*** converged '\\n elif not validFit[i]:\\n s = '*** invalid fit '\\n if not inSubarray and not converged[i]:\\n s = '*** antenna removed from subarray'\\n if validFit[i]:\\n print ' %4d %7.2f %7.2f %7.2f %7.2f %7.2f %s' % \\\\\\n (antennas[i], new_az[i], new_el[i], \\n d_az[i]*60.0, d_el[i]*60.0, fwhm[i]/beamSize, s)\\n else:\\n print ' %4d %7.2f %7.2f %7s %7s %7s %s' % \\\\\\n (antennas[i], new_az[i], new_el[i], \\\"\\\", \\\"\\\", \\\"\\\", s)\\n\\n # See if we are almost done\\n if antennasComplete.count(False) <= pntwait:\\n ncyclesWait += 1\\n else:\\n ncyclesWait = 0\\n\\n # Did we reach the time limit?\\n if min(antennasComplete) == False and time.time() - tstart > timeLimit*60.0:\\n print '\\\\n\\\\n*** Time limit reached on radio pointing ***'\\n continuePointing = False\\n elif min(antennasComplete) == False and len(np.nonzero(ndata == 0)[0]) == antennasComplete.count(False): \\n print '\\\\n\\\\n*** Stopping pointing since some antennas do not have valid data ***'\\n continuePointing = False\\n elif ncyclesWait >= waitCycles:\\n if antennasComplete.count(False) > 0:\\n print '\\\\n\\\\n*** Last %d antennas are having trouble converging - will abort pointing. ***' % antennasComplete.count(False)\\n continuePointing = False\\n \\n\\n # Update the mount offsets in the system\\n results = dict()\\n mountOffsetAz, mountOffsetEl = grabMountOffsets(antennas)\\n print ''\\n sup = []\\n snoup = []\\n for i in range(len(antennas)):\\n if converged[i]:\\n sup.append(antennas[i])\\n aznew = mountOffsetAz[i] + offsetsAz[i]\\n elnew = mountOffsetEl[i] + offsetsEl[i]\\n if apply and antennas[i] in commands.currentAntennaNumbers(): \\n commands.s.mountOffset(aznew, elnew, antennas[i])\\n results[antennas[i]] = [offsetsAz[i], offsetsEl[i], aznew, elnew]\\n else:\\n snoup.append(antennas[i])\\n commands.offset(0, 0)\\n print ''\\n if not apply:\\n print '*** Did not apply offsets since apply=False'\\n else:\\n if len(sup) > 0:\\n print '*** Updated pointing on antennas ',str(sup)\\n else:\\n print '*** Pointing did not converge on any antennas'\\n if len(snoup) > 0:\\n print '*** Did not update pointing on antennas ',str(snoup)\\n else:\\n print '*** Pointing converged on all antennas.'\\n\\n # Record various results in files\\n resultsTime = getTimeStamps()\\n recordMountOffsetsSession(results, resultsTime, antennas)\\n recordMountOffsetsHistory(results, resultsTime, sourceInfo)\\n recordPointingOffsetsHistory(results, resultsTime, sourceInfo)\\n\\n # Return solution\\n return results\",\n \"def plotTrajectory(xydata, colordata = 'time', cmap = cm.jet, size = 20, ax = None, line = True):\\n \\n if isinstance(colordata, basestring) and colordata in ['time']:\\n c = np.linspace(0, len(xydata[:,0]), len(xydata[:,0]));\\n else:\\n c = colordata;\\n \\n if ax is None:\\n ax = plt.gca();\\n s = ax.scatter(xydata[:,0], xydata[:,1], c = c, cmap = cmap, s = size, marker = 'o', lw = 0);\\n if isinstance(line, basestring):\\n ax.plot(xydata[:,0], xydata[:,1], color = line); \\n \\n ax.get_figure().colorbar(s, ax = ax);\\n return ax\",\n \"def setPoint(self, point):\\n self.position = point.position\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def on_pointing_axis_tracking(telescopename, stnid, band, antmodel, obstimebeg,\\n obsdur, obstimestp, pointingdir,\\n do_parallactic_rot=True):\\n # *Setup Source*\\n srcfld = dreambeam.rime.jones.DualPolFieldPointSrc(pointingdir)\\n\\n # *Load moouted feed*\\n stnfeed = load_mountedfeed(telescopename, stnid, band, antmodel)\\n stnrot = stnfeed.stnRot\\n\\n # *Setup PJones*\\n timespy = []\\n nrTimSamps = int((obsdur.total_seconds()/obstimestp.seconds))+1\\n for ti in range(0, nrTimSamps):\\n timespy.append(obstimebeg+ti*obstimestp)\\n pjones = dreambeam.rime.jones.PJones(timespy, np.transpose(stnrot),\\n do_parallactic_rot=do_parallactic_rot)\\n\\n # *Setup EJones*\\n ejones = stnfeed.getEJones(pointingdir)\\n freqs = stnfeed.getfreqs()\\n\\n # *Setup MEq*\\n pjonesOfSrc = pjones.op(srcfld)\\n jonesobj = ejones.op(pjonesOfSrc)\\n\\n # Get the resulting Jones matrices\\n # (structure is Jn[freqIdx, timeIdx, chanIdx, compIdx] )\\n jones = jonesobj.getValue()\\n if not do_parallactic_rot:\\n basis_from = jonesobj.get_basis()\\n basis_to = pjonesOfSrc.get_basis()\\n btransmat2d = basis2basis_transf(basis_from, basis_to)[..., 1:, 1:]\\n # Tranformation from IAU2C09 has to be (right) transformed back 1st\\n transmat2d = np.matmul(C09toIAU[1:, 1:], btransmat2d)\\n jones = np.matmul(jones, transmat2d)\\n jonesobj.jones = jones\\n return timespy, freqs, jones, jonesobj\",\n \"def getPositionTrajectory(self, localPt: Optional[Vector3] = None) -> Trajectory:\\n if localPt is None:\\n return Trajectory(self.times,[m[9:] for m in self.milestones])\\n else:\\n return Trajectory(self.times,[se3.apply(self.to_se3(m),localPt) for m in self.milestones])\",\n \"def trajectory(self, lon, lat, alt, utc=12.0, speed=None, total_time=None,\\n dt=10.0, smooth=10, traj_smooth=50):\\n self.initall()\\n calc_utc = False\\n if speed is not None and total_time is not None:\\n raise ValueError(\\\"Can't specify speed _and_ total_time.\\\")\\n if speed is not None or total_time is not None:\\n calc_utc = True\\n if not isinstance(utc, (float, int)):\\n print(\\\"utc should just be starting time if given speed/total_time \\\"\\n \\\"-- using first term\\\")\\n utc = [utc[0]]\\n else:\\n utc = [utc]\\n # Calculate waypoints\\n self.waypt = Namespace(lon=lon, lat=lat, alt=alt, distance=[0.0], speed=[0.0])\\n self.total_distance = 0.0\\n Rearth = [observer.earth_radius(lat[0])]\\n ca = [0.0]\\n for i in range(1, len(lon)):\\n lon1, lon2, dlon, lat1, lat2, dlat, dalt = _split(i, lon, lat, alt)\\n _a = np.sin(dlat/2.0)**2 + np.cos(lat1)*np.cos(lat2)*np.sin(dlon/2.0)**2\\n _rth = observer.earth_radius((lat1+lat2)/2.0)\\n _ca = 2.0 * np.arctan2(np.sqrt(_a), np.sqrt(1.0 - _a))\\n _D = np.sqrt((_rth*_ca)**2 + dalt**2)\\n Rearth.append(_rth)\\n ca.append(_ca)\\n self.waypt.distance.append(_D)\\n self.total_distance += _D\\n print(\\\"Total distance is {:.1f} mi\\\".format(self.total_distance / 1609.344))\\n if total_time is not None:\\n speed = self.total_distance / total_time\\n self.traj = Namespace(utc=np.array([]), lon=np.array([]),\\n lat=np.array([]), alt=np.array([]))\\n self.waypoint_indices = []\\n for i in range(1, len(lon)):\\n if calc_utc:\\n dt_waypt = self.waypt.distance[i] / speed\\n utc.append(utc[i-1] + dt_waypt/3600.0)\\n else:\\n dt_waypt = (utc[i] - utc[i-1]) * 3600.0\\n speed = self.waypt.distance[i] / dt_waypt\\n self.waypt.speed.append(speed)\\n # Calculate waypoints into trajectory at dt\\n lon1, lon2, dlon, lat1, lat2, dlat, dalt = _split(i, lon, lat, alt)\\n _altinc = self.waypt.distance[i] * np.sin(np.arctan2(dalt, Rearth[i]*ca[i]))\\n N_time = int(np.floor(dt_waypt / dt))\\n if np.fabs(N_time) < 2.0:\\n continue\\n _f = np.linspace(0.0, 1.0-1.0/N_time, N_time)\\n _ta, _tb = np.sin((1.0 - _f)*ca[i]) / np.sin(ca[i]), np.sin(_f*ca[i]) / np.sin(ca[i])\\n _x = _ta*np.cos(lat1)*np.cos(lon1) + _tb*np.cos(lat2)*np.cos(lon2)\\n _y = _ta*np.cos(lat1)*np.sin(lon1) + _tb*np.cos(lat2)*np.sin(lon2)\\n _z = _ta*np.sin(lat1) + _tb*np.sin(lat2)\\n self.traj.utc = np.append(self.traj.utc, utc[i-1] +\\n (dt/3600.0) * np.linspace(0, N_time-1, N_time))\\n self.traj.lat = np.append(self.traj.lat, np.arctan2(_z, np.sqrt(_x**2+_y**2)))\\n self.traj.lon = np.append(self.traj.lon, np.arctan2(_y, _x))\\n self.traj.alt = np.append(self.traj.alt, alt[i-1] + _f * _altinc)\\n self.waypoint_indices.append(len(self.traj.utc)-1)\\n self.waypt.utc = utc\\n self.traj.lon = self.smooth_array(np.rad2deg(self.traj.lon), traj_smooth)\\n self.traj.lat = self.smooth_array(np.rad2deg(self.traj.lat), traj_smooth)\\n self.traj.loc = EarthLocation(lon=self.traj.lon*u.deg, lat=self.traj.lat*u.deg,\\n height=self.traj.alt*u.m)\\n delta_x = self.traj.loc.x - self.obs.loc.x\\n delta_y = self.traj.loc.y - self.obs.loc.y\\n delta_z = self.traj.loc.z - self.obs.loc.z\\n cosang = ((self.traj.loc.x*self.obs.loc.x +\\n self.traj.loc.y*self.obs.loc.y +\\n self.traj.loc.z*self.obs.loc.z) /\\n (np.sqrt(self.traj.loc.x**2 + self.traj.loc.y**2 + self.traj.loc.z**2) *\\n np.sqrt(self.obs.loc.x**2 + self.obs.loc.y**2 + self.obs.loc.z**2)))\\n rtraj = np.sqrt(self.traj.loc.x**2 + self.traj.loc.y**2 + self.traj.loc.z**2)\\n robs = np.sqrt(self.obs.loc.x**2 + self.obs.loc.y**2 + self.obs.loc.z**2)\\n self.D = np.sqrt(delta_x**2 + delta_y**2 + delta_z**2)\\n self.el = np.arcsin((rtraj * cosang - robs)/self.D)\\n self.utc = self.traj.utc\\n self.dt = np.array([dt] * len(self.traj.utc)) * u.second\\n self.dbydt('D', smooth, False)\",\n \"def execute_trajectory(\\n trajectory: Trajectory,\\n controller: Union['SimRobotController','RobotInterfaceBase'],\\n speed: float = 1.0,\\n smoothing: Optional[_SMOOTHING_OPTIONS2] = None,\\n activeDofs: Optional[List[Union[int,str]]] = None\\n ):\\n if len(trajectory.times)==0: return #be tolerant of empty paths?\\n if speed <= 0: raise ValueError(\\\"Speed must be positive\\\")\\n from ..control.robotinterface import RobotInterfaceBase\\n from ..robotsim import SimRobotController\\n if isinstance(controller,SimRobotController):\\n robot_model = controller.model()\\n q0 = controller.getCommandedConfig()\\n elif isinstance(controller,RobotInterfaceBase):\\n robot_model = controller.klamptModel()\\n cq0 = controller.commandedPosition()\\n if cq0[0] is None:\\n cq0 = controller.sensedPosition()\\n q0 = controller.configToKlampt(cq0)\\n else:\\n raise ValueError(\\\"Invalid type of controller, must be SimRobotController or RobotInterfaceBase\\\")\\n if activeDofs is not None:\\n indices = [robot_model.link(d).getIndex for d in activeDofs]\\n liftedMilestones = []\\n assert not isinstance(trajectory,HermiteTrajectory),\\\"TODO: hermite trajectory lifting\\\"\\n for m in trajectory.milestones:\\n assert(len(m)==len(indices))\\n q = q0[:]\\n for i,v in zip(indices,m):\\n q[i] = v\\n liftedMilestones.append(q)\\n tfull = trajectory.constructor()(trajectory.times,liftedMilestones)\\n return execute_trajectory(tfull,controller,speed,smoothing)\\n\\n if isinstance(trajectory,HermiteTrajectory):\\n assert smoothing == None,\\\"Smoothing cannot be applied to hermite trajectories\\\"\\n ts = trajectory.startTime()\\n n = len(q0)\\n if isinstance(controller,SimRobotController):\\n controller.setMilestone(trajectory.eval(ts),vectorops.mul(trajectory.deriv(ts),speed))\\n n = len(trajectory.milestones[0])//2\\n for i in range(1,len(trajectory.times)):\\n q,v = trajectory.milestones[i][:n],trajectory.milestones[i][n:]\\n controller.addCubic(q,vectorops.mul(v,speed),(trajectory.times[i]-trajectory.times[i-1])/speed)\\n else:\\n cv0 = controller.commandedVelocity()\\n if cv0[0] is None:\\n cv0 = controller.sensedVelocity()\\n times,positions,velocities = [0],[controller.configFromKlampt(q0)],[cv0]\\n start = 1 if trajectory.times[0]==0 else 0\\n for i in range(start,len(trajectory.milestones)):\\n times.append(trajectory.times[i]/speed)\\n positions.append(controller.configFromKlampt(trajectory.milestones[i][:n]))\\n velocities.append(controller.velocityFromKlampt(trajectory.milestones[i][n:]))\\n controller.setPiecewiseCubic(times,positions,velocities)\\n else:\\n if smoothing == None:\\n ts = trajectory.startTime()\\n if isinstance(controller,SimRobotController):\\n controller.setMilestone(trajectory.eval(ts))\\n for i in range(1,len(trajectory.times)):\\n q = trajectory.milestones[i]\\n controller.addLinear(q,(trajectory.times[i]-trajectory.times[i-1])/speed)\\n else:\\n #TODO: move to start?\\n times,positions = [0],[controller.configFromKlampt(q0)]\\n start = 1 if 0==trajectory.times[0] else 0\\n for i in range(start,len(trajectory.milestones)):\\n times.append(trajectory.times[i]/speed)\\n positions.append(controller.configFromKlampt(trajectory.milestones[i]))\\n controller.setPiecewiseLinear(times,positions)\\n elif smoothing == 'spline':\\n t = HermiteTrajectory()\\n t.makeSpline(trajectory)\\n return execute_trajectory(t,controller)\\n elif smoothing == 'pause':\\n if isinstance(controller,SimRobotController):\\n ts = trajectory.startTime()\\n controller.setMilestone(trajectory.eval(ts))\\n zero = [0.0]*len(trajectory.milestones[0])\\n for i in range(1,len(trajectory.times)):\\n q = trajectory.milestones[i]\\n controller.addCubic(q,zero,(trajectory.times[i]-trajectory.times[i-1])/speed)\\n else:\\n #TODO: move to start?\\n zero = [.0]*len(q0)\\n t = HermiteTrajectory(trajectory.times,trajectory.milestones,[zero]*len(trajectory.milestones))\\n return execute_trajectory(t,controller)\\n else:\\n raise ValueError(\\\"Invalid smoothing method specified\\\")\",\n \"def _pid_control(self, waypoint, vehicle_location, vehicle_rotation):\\n ## Vehicle transform should be [x,y,z, roll, pitch, yaw]\\n\\n v_begin = np.array(vehicle_location)\\n v_end = v_begin + np.array([math.cos(math.radians(vehicle_rotation)),\\n math.sin(math.radians(vehicle_rotation)),0])\\n # print(\\\"vbegin\\\"+str(v_begin)+\\\"vend\\\"+ str(v_end)+\\\"waypoint\\\"+str(waypoint))\\n v_vec = np.array([v_end[0] - v_begin[0], v_end[1] - v_begin[1], 0.0])\\n w_vec = np.array([waypoint[0] -\\n v_begin[0], waypoint[1] -\\n v_begin[1], 0.0])\\n _dot = math.acos(np.clip(np.dot(w_vec, v_vec) /\\n (np.linalg.norm(w_vec) * np.linalg.norm(v_vec)), -1.0, 1.0))\\n\\n _cross = np.cross(v_vec, w_vec)\\n if _cross[2] < 0:\\n _dot *= -1.0\\n\\n self._e_buffer.append(_dot)\\n if len(self._e_buffer) >= 2:\\n _de = (self._e_buffer[-1] - self._e_buffer[-2]) / self._dt\\n _ie = sum(self._e_buffer) * self._dt\\n else:\\n _de = 0.0\\n _ie = 0.0\\n # print(\\\"dot\\\"+str(_dot)+\\\"de\\\"+str(_de)+\\\"ie\\\"+str(_ie))\\n return np.clip((self._K_P * _dot) + (self._K_D * _de /\\n self._dt) + (self._K_I * _ie * self._dt), -1.0, 1.0)\",\n \"def send_pose(self, pPosn, pOrnt, baseFrame, trgtFrame, pTime):\\n # Create message\\n xform = TransformStamped()\\n # Transform Header\\n xform.header.stamp = pTime\\n xform.header.frame_id = baseFrame\\n xform.child_frame_id = trgtFrame\\n # Position\\n xform.transform.translation.x = pPosn[0]\\n xform.transform.translation.y = pPosn[1]\\n xform.transform.translation.z = pPosn[2]\\n # Orientation\\n xform.transform.rotation.x = pOrnt[0]\\n xform.transform.rotation.y = pOrnt[1]\\n xform.transform.rotation.z = pOrnt[2]\\n xform.transform.rotation.w = pOrnt[3]\\n # Send message\\n self.moveOut.sendTransform(xform)\",\n \"def projectPoint(self, point):\\n vector = self.normal_vector\\n angle = vector.angle\\n line = Line(point, angle, correct=False)\\n projection = self.crossLine(line)\\n return projection\",\n \"def setTimepoint(self, tp):\\n\\t\\tpass\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def draw_trajectory_SDEsys(Oscillatior_Parametrs, q0 = np.array([.1,.1]), T = 10000, dt = 0.1):\\n\\n\\n N=int(T*1000) # number of time steps\\n n_samp = np.amax([int(dt/(T/N)),1]) # sampling interval (cannot be smaller than time step)\\n\\n\\n k,beta,D = Oscillatior_Parametrs['k'],Oscillatior_Parametrs['beta'],Oscillatior_Parametrs['D']\\n\\n Dim = len(k)\\n q_model = np.zeros((N+1,Dim))\\n\\n for j in range(0,Dim):\\n MySys=Linear_Stochastic_Oscillator(k[j],beta[j],D[j])\\n t4,X4=MySys.GenerateTrajectory(q0,T=T,N=N)\\n q_model[:,j]=X4[0,:]\\n\\n # subsample and push out\\n q_model,t_model =q_model[::n_samp,:],t4[::n_samp]\\n\\n return t_model,q_model\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def __init__(self, target_velocity, dt, model_type, robot_type):\\n super(StraightEnv, self).__init__(\\n target_velocity=target_velocity,\\n dt=dt,\\n model_type=model_type,\\n robot_type=robot_type\\n )\\n\\n # Reward function parameters\\n self._lambda1 = 0.25\\n\\n # State in frame of target straight line. See get_initial_state()\\n # function for info.\\n self._current_state = np.zeros(6)\\n\\n # Target line to follow. See get_initial_state() function for info.\\n self._target_y = 0\\n self._target_yaw = 0\\n\\n # Initialize nodes and set up ROS topics\\n rospy.init_node('rl_planner')\\n self.publisher = rospy.Publisher('commands/keyboard',\\n ackermann_msgs.msg.AckermannDriveStamped, queue_size=1)\\n rospy.Subscriber('ekf_localization/odom', nav_msgs.msg.Odometry,\\n self._odometry_callback)\\n self._sensor_stamp = rospy.Time.now()\\n\\n # Wait this number of timesteps before computing another action (this\\n # is similar to setting a larger dt during training)\\n self._num_states_needed = 3\\n self._num_states_received = 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7366635","0.6119101","0.6077254","0.59451604","0.5930126","0.5914397","0.5907721","0.58628654","0.58250636","0.58205104","0.57535905","0.5750186","0.5665363","0.566258","0.56621027","0.5604078","0.560013","0.5575069","0.5521112","0.55184346","0.5504239","0.54938686","0.5472923","0.5468082","0.5448964","0.5443295","0.5438601","0.54358786","0.54295266","0.5414734","0.5404579","0.53888875","0.5386565","0.536857","0.5365834","0.53610075","0.5360736","0.53556764","0.5355093","0.5342698","0.53330815","0.53167266","0.5310432","0.5308198","0.5304091","0.5303766","0.5289079","0.5287572","0.5285226","0.52806705","0.52724785","0.5270726","0.5266657","0.5258611","0.5255059","0.52504104","0.5250129","0.5231708","0.5229839","0.52294326","0.5223818","0.52013296","0.5193942","0.5186066","0.51852256","0.5185102","0.5184418","0.5176084","0.51668257","0.5161384","0.515675","0.5153629","0.51501054","0.5148976","0.514023","0.5127088","0.5125156","0.51192117","0.5118747","0.5105849","0.5099747","0.50839055","0.5081834","0.5078976","0.50775665","0.50760674","0.50756323","0.5070947","0.5070653","0.5070062","0.5065643","0.5054703","0.5053073","0.50506306","0.50372154","0.5036989","0.5033011","0.50246024","0.50243247","0.5018641"],"string":"[\n \"0.7366635\",\n \"0.6119101\",\n \"0.6077254\",\n \"0.59451604\",\n \"0.5930126\",\n \"0.5914397\",\n \"0.5907721\",\n \"0.58628654\",\n \"0.58250636\",\n \"0.58205104\",\n \"0.57535905\",\n \"0.5750186\",\n \"0.5665363\",\n \"0.566258\",\n \"0.56621027\",\n \"0.5604078\",\n \"0.560013\",\n \"0.5575069\",\n \"0.5521112\",\n \"0.55184346\",\n \"0.5504239\",\n \"0.54938686\",\n \"0.5472923\",\n \"0.5468082\",\n \"0.5448964\",\n \"0.5443295\",\n \"0.5438601\",\n \"0.54358786\",\n \"0.54295266\",\n \"0.5414734\",\n \"0.5404579\",\n \"0.53888875\",\n \"0.5386565\",\n \"0.536857\",\n \"0.5365834\",\n \"0.53610075\",\n \"0.5360736\",\n \"0.53556764\",\n \"0.5355093\",\n \"0.5342698\",\n \"0.53330815\",\n \"0.53167266\",\n \"0.5310432\",\n \"0.5308198\",\n \"0.5304091\",\n \"0.5303766\",\n \"0.5289079\",\n \"0.5287572\",\n \"0.5285226\",\n \"0.52806705\",\n \"0.52724785\",\n \"0.5270726\",\n \"0.5266657\",\n \"0.5258611\",\n \"0.5255059\",\n \"0.52504104\",\n \"0.5250129\",\n \"0.5231708\",\n \"0.5229839\",\n \"0.52294326\",\n \"0.5223818\",\n \"0.52013296\",\n \"0.5193942\",\n \"0.5186066\",\n \"0.51852256\",\n \"0.5185102\",\n \"0.5184418\",\n \"0.5176084\",\n \"0.51668257\",\n \"0.5161384\",\n \"0.515675\",\n \"0.5153629\",\n \"0.51501054\",\n \"0.5148976\",\n \"0.514023\",\n \"0.5127088\",\n \"0.5125156\",\n \"0.51192117\",\n \"0.5118747\",\n \"0.5105849\",\n \"0.5099747\",\n \"0.50839055\",\n \"0.5081834\",\n \"0.5078976\",\n \"0.50775665\",\n \"0.50760674\",\n \"0.50756323\",\n \"0.5070947\",\n \"0.5070653\",\n \"0.5070062\",\n \"0.5065643\",\n \"0.5054703\",\n \"0.5053073\",\n \"0.50506306\",\n \"0.50372154\",\n \"0.5036989\",\n \"0.5033011\",\n \"0.50246024\",\n \"0.50243247\",\n \"0.5018641\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7287572"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20286,"cells":{"query":{"kind":"string","value":"Remember to call the constructor of MotionPath (__init__)"},"document":{"kind":"string","value":"def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):\n #raise NotImplementedError\n MotionPath.__init__(self, limb, kin, total_time)\n start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])\n\n\n #The ar tracking function was not working properly so we added the block below \n #to correct it.\n if start_pos[1]>start_pos[0]:\n a = start_pos[0]\n b = start_pos[1]\n start_pos[0] = b\n start_pos[1] = a\n print(\"### Modified start_pos ###\")\n\n\n ar_tag_pos = np.array([abs(ar_tag_pos[0]), abs(ar_tag_pos[1]), abs(ar_tag_pos[2])])\n if ar_tag_pos[1]>ar_tag_pos[0]:\n a = ar_tag_pos[0]\n b = ar_tag_pos[1]\n ar_tag_pos[0] = b\n ar_tag_pos[1] = a\n self.start_pos = start_pos\n\n print(\"!!!!!!!!!!!!!!!!start_pos!!!!!!!!!!!!!!!!\")\n print(start_pos)\n print(\"!!!!!!!!!ar_tag_pos in LinearPath!!!!!!!!!\")\n print(ar_tag_pos)\n ar_tag_pos[2] = start_pos[2]\n self.ar_tag_pos = ar_tag_pos\n self.points_generated = []"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, total_time, kin, limb, ar_tag_pos):\n # raise NotImplementedError\n self.r = .1 \n MotionPath.__init__(self, limb, kin, total_time)\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\n self.ar_tag_pos[2] = 0.282\n self.start_pos = [ar_tag_pos[0],ar_tag_pos[1]+self.r,ar_tag_pos[2]]\n self.w = 2*math.pi/self.total_time","def __init__(self, limb, kin, total_time, center_pos, num_way, radius, z_height=0.1):\n MotionPath.__init__(self, limb, kin, total_time)\n self.center_pos = center_pos\n self.num_way = num_way\n self.radius = radius\n self.z_height = z_height\n self.base_frame = 'base'\n self.tool_frame = 'left_gripper'\n self.plan_path()\n self.plot_path()","def __init__(self, limb, kin, total_time, goal_pos, num_way, start_pos=None):\n MotionPath.__init__(self, limb, kin, total_time)\n self.start_pos = start_pos\n self.goal_pos = goal_pos\n self.num_way = num_way\n self.base_frame = 'base'\n self.tool_frame = 'left_hand_camera' # 'left_gripper'\n self.plan_path()\n # self.plot_path()","def __init__(self, start_x, start_y):\n self.x = start_x\n self.y = start_y\n\n self._dead_end_direction = [[]]\n self._moved = False\n self._junction_index = [1]\n\n self.path = [[start_x, start_y]]","def __init__(self,path=None, init_pos=None, wind_map_ang=None, \n wind_map_mag=None, inlet_ang=None, inlet_mag=None,\n ground_speed=10, ghost_delta=2.0, traj_res=0.1,\n sim_dt=0.1, mass=3.71, max_tilt_angle=35, \n air_speed=10, command_airspeed = False):\n self.ground_speed = ground_speed\n self.air_speed = air_speed\n self.command_airspeed = command_airspeed\n self.traj_res = traj_res\n self.sim_dt = sim_dt\n self.mass = mass\n self.max_tilt_angle = max_tilt_angle\n self.path = path\n self.payload = 0\n self.air_density = 1.1718938453052181\n if init_pos is None:\n init_x = 0\n init_y = 0\n init_z = 20\n else:\n init_x = init_pos[0]\n init_y = init_pos[1]\n init_z = init_pos[2]\n self.init_state = QuadState(pos=np.array([init_x,init_y,init_z]))\n self.states_hist = []\n self.append_states_hist(0, self.init_state)\n self.ghost_delta = ghost_delta #secs\n self.actual_path = [self.init_state]\n self.xy_path = [(init_x,init_y)]\n dryden_upsample = 10\n if command_airspeed:\n # print(\"commanding airspeed\")\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.air_speed)\n else:\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.ground_speed)\n\n if inlet_ang is not None and inlet_mag is not None:\n self.windField = WindField(wind_map_ang, wind_map_mag, \n inlet_ang, inlet_mag)\n else:\n self.windField = WindField(wind_map_ang, wind_map_mag)","def __init__(self):\n self.center = Point()\n self.velocity = Velocity()","def __init__(self, x, y):\n\n self.x = x\n self.y = y\n self.path_x = []\n self.path_y = []\n self.parent = None\n self.cost = 0.0","def __init__(self):\n self.positionx = 400\n self.positiony = 600\n # direction goes from [0,360)\n self.direction = (45)","def __init__(self):\n super().__init__()\n self.waypoint_vector = [-1, 10]","def __init__(self, coords, goal_coords, current_path_length) :\r\n\r\n self.coords = coords #The coordinates of the node\r\n\r\n #Calculating the g(n) value of node\r\n self.calculate_gn_value(current_path_length)\r\n\r\n #Calculating the h(n) value of node\r\n self.calculate_hn_value(goal_coords)\r\n\r\n #Calculating f(n) value of node\r\n self.calculate_fn_value()","def __init__(self):\r\n self.position=(0,0)\r\n self.direction = 0.\r\n self.speed = 0\r\n self.state = 0\r\n pass","def __init__(self, path):\r\n self.path = path\r\n # 0.75 deg per grid box latitudinally\r\n self.lat_unit = 360","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self._path = path","def __init__(self, newPath):\n self.newPath = newPath","def __init__(self, mass, x, y,px=0.0,py=0.0):\n self.mass = mass\n self.position = np.array([x,y])\n self.momentum = np.array([px,py])","def __init__(self, mass, radius, position, velocity):\n self.mass = mass\n self.radius = radius\n self.position = position\n self.velocity = velocity\n print(self.velocity)\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\n self.delete = False","def __init__(self,mass,time,**kwargs):\n self.setTime(time)\n ParticlePhaseCoordinates.__init__(self,mass,**kwargs)","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All motion starts at (0,0).\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, x_0, y_0, initX, initY,h=5):\n self.x_0=x_0\n self.y_0=y_0\n self.x_init=initX\n self.y_init=initY\n self.step=h","def __init__(self, x, y):\n # assigning the initial position\n self.x = x\n self.y = y","def __init__(self,x,y,width,height):\n self.x = x\n self.y = y\n self.width = width\n self.height = height\n self.velocity_x = 0.0","def __init__(self):\n self.position = Vector2()\n self.velocity = Vector2()\n self.update_parameters()\n self.mass = 0.18 # Mass of Sphero robot in kilograms","def __init__(self):\n raise NotImplementedError('cannot create independent arc')","def _init_anim(self):\n pass","def __init__(self):\n self.x = 0\n self.y = 0","def __init__(self):\n self.x = 0\n self.y = 0","def __init__(self, position, momentum, mass):\n self.position = position\n self.momentum = momentum\n self.mass = mass","def __init__(self, coords, direction):\n self.y, self.x = coords\n self.direction = direction","def __init__(self):\n\n self.X = None\n self.y = None","def __init__(self):\n\n self.X = None\n self.y = None","def __init__(self):\n self.x = 0.0\n self.y = 0.0\n self.theta = 0.0\n self.total_distance_covered = 0.0","def __init__(self, pos=(0,0), dire = 0):\r\n self.initX = self.x = pos[0]\r\n self.initY = self.y = pos[1]\r\n self.initDir = self.dir = math.radians(dire)","def __init__(self):\n self.position = 0","def __init__(self, Position, M):\n self.pos = Position # Sets x position\n self.m = M # Sets mass\n # Initial velocity and acceleration set to be zero\n self.vel = np.zeros((2,))\n self.acc = np.zeros((2,))","def __init__(self, x_coor, x_speed, y_coor, y_speed, direction):\n self.__x_coor = x_coor\n self.__x_speed = x_speed\n self.__y_coor = y_coor\n self.__y_speed = y_speed\n self.__direction = direction\n self.__radius = self.TORPEDO_RADIUS","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def __init__(self, direction=0, x=0, y=0):\n self.direction = direction\n self.x = x\n self.y = y","def __init__(self, pos):\r\n self.pos = pos\r\n self.vel = [0, 0]\r\n self.acc = [0, 0]\r\n self.heading = math.pi\r\n self.screen = [0, 0]","def __init__(self, path):\n # TODO: later matching stuff will need superclass attributes\n self.path = path\n #self.topbp = ZFSBlockPointer(topbp) TODO: later","def __init__(self, pos):\r\n self.pos = pos","def __init__(self, x_axis_p, y_axis_p, x_speed=0, y_speed=0, direction=0):\r\n self.__x_axis = x_axis_p\r\n self.__y_axis = y_axis_p\r\n self.__X_speed = x_speed\r\n self.__y_speed = y_speed\r\n self.__direction = direction\r\n self.__lives = 3","def __init__(self, path, ar_no):\n self.path = path\n self.ar_no = ar_no\n self.dt = pos_neg_detection()\n self.ts = ts_processing(self.path, self.ar_no)","def __init__(self, inPs, outPs):\n self.angle = 0.0\n self.speed = 16.5\n\n super(MovementControl,self).__init__(inPs, outPs)","def __init__(self, path=None):\n pass","def __init__(self, new_pt):\n self.x = float(new_pt[0])\n self.y = float(new_pt[1])\n self.next = None\n self.prev = None\n self.distance_to_next = 0\n self.angle = None","def __init__(self, initX, initY):\n self.x = initX\n self.y = initY","def __init__(self, initX, initY):\n self.x = initX\n self.y = initY","def __init__(self):\n super().__init__(ShowGraphABC._UNDIRECTED, \"path\")","def __init__(self, name, state):\n self.name = name\n self.state = state\n self.onSolnPath = False\n self.parent = None\n self.nextOnPath = None","def __init__(self, x=0, y=0, rotation=0):\n self.x, self.y = x, y\n self.rotation = rotation\n\n self.x_speed, self.y_speed = 0, 0","def __init__(self, location):\r\n self.y = location[1]\r\n self.x = location[0]\r\n self.yvel = 0.0\r\n self.xvel = 0.0","def __init__(self):\n self.Robot = Robot()\n self.Omega = matrix()\n # self.Omega.value[0][0] = 1.0\n # self.Omega.value[1][1] = 1.0\n self.Xi = matrix()\n # Xi.value[0][0] = 0.0\n # Xi.value[1][0] = 0.0\n self.measure = {}\n self.landMarkCount = 0\n self.init = False\n self.bearing = 0\n self.x = 0\n self.y = 0\n \n # TODO","def __init__(self, x, y):","def __init__(self, path_fun, disp_fun):\n \n if path_fun.nx != 1 or disp_fun.nx != 1:\n raise ValueError(\"path_fun and disp_fun must have 1 input variable\")\n \n # The number of output coordinates is defined by the\n # number of output functions of `path_fun`\n nQ = path_fun.nf\n \n # The number of input coordinates equals the number\n # of path-displacements plus 1.\n if disp_fun.nf % nQ != 0:\n raise ValueError('dispfun.nf must be a multiple of nQ')\n n = disp_fun.nf // nQ # The number of displacement coordinates \n \n nQp = n + 1 # The total number of input coordinates \n \n Qpstr = ['s'] + [f\"d{i:d}\" for i in range(n)]\n Qstr = [f\"Q{i:d}\" for i in range(nQ)]\n \n # The maxderiv is the minimum of either path_fun \n # or disp_fun \n maxderiv = dfun._merged_maxderiv(path_fun.maxderiv, disp_fun.maxderiv)\n \n # If the displace vectors have a finite zlevel, then the \n # zlevel for that term is just 1 more (from the linear dependence on \n # Q'). The total zlevel is then the merged zlevel of the path function\n # and the displacement term \n #\n if disp_fun.zlevel is None:\n disp_zlevel = None \n else: \n disp_zlevel = disp_fun.zlevel + 1 \n zlevel = dfun._merged_zlevel(path_fun.zlevel, disp_zlevel)\n \n super().__init__(self._pathtrans_fun, nQp = nQp, nQ = nQ,\n name = 'Path', Qpstr = Qpstr, Qstr = Qstr,\n maxderiv = maxderiv, zlevel = zlevel)\n \n self.path_fun = path_fun \n self.disp_fun = disp_fun","def __init__(self, path):\n assert isinstance(path, plumbum.LocalPath), path\n assert path.exists()\n self.path = path\n super().__init__(path.stem)","def __init__(self, path, position: (int, int, int, int), name_id):\n self._path = path\n self._position = position\n self._name = name_id","def __init__(self, **kwargs):\n self.motion_err = np.array(kwargs.pop('err', [0., 0.]), dtype=float)\n\n pose = np.array(kwargs.pop('pose', [0.,0.,0.]), dtype=float)\n super(XYPhiRobot, self).__init__(pose=pose)","def __init__(self, x_pos, y_pos, radius, colour, moving = False):\n\t\t\n\t\tself.x_pos = x_pos\n\t\tself.y_pos = y_pos\n\t\tself.radius = radius\n\t\tself.diameter = 2*radius\n\t\tself.colour = colour\n\t\tself.moving = moving\n\t\tself.x_vec = 0\n\t\tself.y_vec = 0","def __init__(self, path):\n self.path = path \n self.current_location = os.getcwd()\n self.rmsd = dict()\n self._get_rmsd_list()\n self._get_scores_list()\n self._get_running_time()\n self._get_step()","def __init__(self):\n self.mu = None\n self.type = None\n self.direction = None\n self.eq_points = None\n self.init_conds = None\n self.time = None\n self.trajectory = None\n self.initial_point = None\n self.contour_levels = []","def __init__(self, d):\n\t\tself._coords = [0] * d","def __init__(self, center, waypoints, firepoints):\n super().__init__(center, MallFighter.MALL_FIGHTER_SPEED, MallFighter.ANIMATION_DELAY, *MallFighter.FILE_PATH)\n self.fire_idx = 0\n self.way_idx = 0\n self.waypoints = waypoints\n self.firepoints = firepoints","def __init__(self, parent, path_length, previous_action, current_player) :\n self.parent = parent\n self.path_length = path_length\n self.previous_action = previous_action\n self.current_player = current_player","def __init__(self, timestep=1.0 * simtk.unit.femtoseconds):\n\n super(VelocityVerletIntegrator, self).__init__(timestep)\n\n self.addPerDofVariable(\"x1\", 0)\n\n self.addUpdateContextState()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m+(x-x1)/dt\")\n self.addConstrainVelocities()","def __init__(obj, x, y, dy):\r\n obj.dy = dy\r\n GameObject.__init__(obj, x, y, obj.dxdy)","def __init__(self, init_pose=None, init_velocities=None, \n init_angle_velocities=None, runtime=5., target_pos=None):\n \n # initial state\n self.state_scale = 1\n \n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\n self.init_pose[2] += 10\n self.init_velocities = np.array([0.,0.,0.])\n self.init_angle_velocities = np.array([0.,0.,0.])\n\n self.runtime = runtime\n \n # Simulation\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \n self.action_repeat = 1\n\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\n self.state_size = self.action_repeat * self.init_state.shape[0]\n \n self.action_low = 0 #-1\n self.action_high = 2*450 #1\n self.action_size = 4\n\n self.action_scale = 1 #450 # 1/2 max of the action \n #self.state_scale = 150 # 1/2 size of the state space\n \n # Goal\n self.target_pose = np.array([0.,0.,150.0])\n\n # The previous position\n self.prev_pose = self.init_pose","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All walks start at (0, 0)\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All walks start at (0, 0)\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, motion, **kwargs):\n super(ShiftWeight, self).__init__(motion)","def __init__(self):\n self.inches_moved = 0\n self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B)\n self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C)\n self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A)\n self.touch_sensor = ev3.TouchSensor()\n self.running = True\n self.ir_sensor = ev3.InfraredSensor()\n self.color_sensor = ev3.ColorSensor()\n assert self.color_sensor\n assert self.ir_sensor\n assert self.touch_sensor\n self.arm_motor.position = 0\n self.pixy = ev3.Sensor(driver_name=\"pixy-lego\")\n assert self.pixy\n\n self.right_motor_encoder = self.right_motor.position\n self.left_motor_encoder = self.left_motor.position","def __init__(self, X, y):\n pass","def __init__(self):\n self.t_height = 291\n self.t_left = 65\n self.t_right = 144\n self.points = Pix()","def __init__(self, motion, **kwargs):\n super(ShiftIn, self).__init__(motion)","def __init__(self):\n\n\t\tself.position = np.array([0, 0])","def __init__(self, coordinate, speed_vec, heading):\n self.__heading = heading\n super().__init__(coordinate, speed_vec, Ship.RADIUS)","def __init__(self, name: str):\n self._name = name\n self._yaw = Motion(\"yaw\")\n self._pitch = Motion(\"pitch\")\n self._roll = Motion(\"roll\")\n self._sway = Motion(\"sway\")\n self._surge = Motion(\"surge\")\n self._heave = Motion(\"heave\")","def __init__(self, pts=[]):\n self.set_points(pts)","def __init__(self, angle, x, y):\n pygame.sprite.Sprite.__init__(self)\n self.image = pygame.image.load(\"Image/Trafico.png\")\n self.rect = self.image.get_rect()\n self.image_orig = self.image\n self.speed = 2\n self.direction = angle\n self.steering = 90\n self.x = x\n self.y = y","def __init__(self, path=\"IdentityFunction\"):\n self.path = path\n self.heal = lambda X: X\n self.heal_tf = lambda X: X","def __init__(self, num_points = 5000):\n self.num_points = num_points\n\n #all walks start at 0.0\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, x, y):\n self.x, self.y = x, y","def __init__(self, update_interval = None, **kwds):\n super().__init__(**kwds)\n self.am_moving = False\n self.pos_dict = self.stage.position()\n\n # Pretend it takes 200ms to move, regardless of the actual distance.\n #\n self.move_timer = QtCore.QTimer()\n self.move_timer.setInterval(200)\n self.move_timer.setSingleShot(True)\n self.move_timer.timeout.connect(self.handleMoveTimer)\n \n # Each time this timer fires we'll 'query' the stage for it's\n # current position.\n #\n self.update_timer = QtCore.QTimer()\n self.update_timer.setInterval(update_interval)\n self.update_timer.timeout.connect(self.handleUpdateTimer)\n self.update_timer.start()\n\n # We use a 'relay' signal as the stage might return\n # stale information when it is moving. However the\n # HardwareWorker that is querying the stage might not\n # know that the stage is moving.\n #\n self.positionUpdate.connect(self.handlePositionUpdate)","def __init__(self, paths):\n self.paths = paths","def __init__(self, path):\n self.path = os.path.abspath(path)","def __init__(self, model: models.ModelWrapper, path_coords: Tensor, target_distances: Tensor = None):\n self.model = model\n self.path_coords = path_coords.clone()\n self.target_distances = target_distances\n self._check_device()\n\n # This will raise an exception if gradients are computed without adapt_to_config() being called\n self.spring_constant = -1\n self.weight_decay = -1","def __init__(self, x1, y1):\n self.x = x1\n self.y = y1","def __init__(self, x, y = 505):\n super(PlayerProjectile, self).__init__(image = PlayerProjectile.image,\n x = x, y = y,\n dy = PlayerProjectile.speed)","def __init__(self, pos, radius):\n super().__init__(pos, radius)","def __init__(self, x, y):\n self.x = x\n self.y = y","def __init__(self, x, y):\n self.x = x\n self.y = y","def __init__(self, x, y):\n self.x = x\n self.y = y","def __init__(self, x, y):\n self.x = x\n self.y = y","def __init__(self, x, y):\n self.x = x\n self.y = y"],"string":"[\n \"def __init__(self, total_time, kin, limb, ar_tag_pos):\\n # raise NotImplementedError\\n self.r = .1 \\n MotionPath.__init__(self, limb, kin, total_time)\\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\\n self.ar_tag_pos[2] = 0.282\\n self.start_pos = [ar_tag_pos[0],ar_tag_pos[1]+self.r,ar_tag_pos[2]]\\n self.w = 2*math.pi/self.total_time\",\n \"def __init__(self, limb, kin, total_time, center_pos, num_way, radius, z_height=0.1):\\n MotionPath.__init__(self, limb, kin, total_time)\\n self.center_pos = center_pos\\n self.num_way = num_way\\n self.radius = radius\\n self.z_height = z_height\\n self.base_frame = 'base'\\n self.tool_frame = 'left_gripper'\\n self.plan_path()\\n self.plot_path()\",\n \"def __init__(self, limb, kin, total_time, goal_pos, num_way, start_pos=None):\\n MotionPath.__init__(self, limb, kin, total_time)\\n self.start_pos = start_pos\\n self.goal_pos = goal_pos\\n self.num_way = num_way\\n self.base_frame = 'base'\\n self.tool_frame = 'left_hand_camera' # 'left_gripper'\\n self.plan_path()\\n # self.plot_path()\",\n \"def __init__(self, start_x, start_y):\\n self.x = start_x\\n self.y = start_y\\n\\n self._dead_end_direction = [[]]\\n self._moved = False\\n self._junction_index = [1]\\n\\n self.path = [[start_x, start_y]]\",\n \"def __init__(self,path=None, init_pos=None, wind_map_ang=None, \\n wind_map_mag=None, inlet_ang=None, inlet_mag=None,\\n ground_speed=10, ghost_delta=2.0, traj_res=0.1,\\n sim_dt=0.1, mass=3.71, max_tilt_angle=35, \\n air_speed=10, command_airspeed = False):\\n self.ground_speed = ground_speed\\n self.air_speed = air_speed\\n self.command_airspeed = command_airspeed\\n self.traj_res = traj_res\\n self.sim_dt = sim_dt\\n self.mass = mass\\n self.max_tilt_angle = max_tilt_angle\\n self.path = path\\n self.payload = 0\\n self.air_density = 1.1718938453052181\\n if init_pos is None:\\n init_x = 0\\n init_y = 0\\n init_z = 20\\n else:\\n init_x = init_pos[0]\\n init_y = init_pos[1]\\n init_z = init_pos[2]\\n self.init_state = QuadState(pos=np.array([init_x,init_y,init_z]))\\n self.states_hist = []\\n self.append_states_hist(0, self.init_state)\\n self.ghost_delta = ghost_delta #secs\\n self.actual_path = [self.init_state]\\n self.xy_path = [(init_x,init_y)]\\n dryden_upsample = 10\\n if command_airspeed:\\n # print(\\\"commanding airspeed\\\")\\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.air_speed)\\n else:\\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.ground_speed)\\n\\n if inlet_ang is not None and inlet_mag is not None:\\n self.windField = WindField(wind_map_ang, wind_map_mag, \\n inlet_ang, inlet_mag)\\n else:\\n self.windField = WindField(wind_map_ang, wind_map_mag)\",\n \"def __init__(self):\\n self.center = Point()\\n self.velocity = Velocity()\",\n \"def __init__(self, x, y):\\n\\n self.x = x\\n self.y = y\\n self.path_x = []\\n self.path_y = []\\n self.parent = None\\n self.cost = 0.0\",\n \"def __init__(self):\\n self.positionx = 400\\n self.positiony = 600\\n # direction goes from [0,360)\\n self.direction = (45)\",\n \"def __init__(self):\\n super().__init__()\\n self.waypoint_vector = [-1, 10]\",\n \"def __init__(self, coords, goal_coords, current_path_length) :\\r\\n\\r\\n self.coords = coords #The coordinates of the node\\r\\n\\r\\n #Calculating the g(n) value of node\\r\\n self.calculate_gn_value(current_path_length)\\r\\n\\r\\n #Calculating the h(n) value of node\\r\\n self.calculate_hn_value(goal_coords)\\r\\n\\r\\n #Calculating f(n) value of node\\r\\n self.calculate_fn_value()\",\n \"def __init__(self):\\r\\n self.position=(0,0)\\r\\n self.direction = 0.\\r\\n self.speed = 0\\r\\n self.state = 0\\r\\n pass\",\n \"def __init__(self, path):\\r\\n self.path = path\\r\\n # 0.75 deg per grid box latitudinally\\r\\n self.lat_unit = 360\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self._path = path\",\n \"def __init__(self, newPath):\\n self.newPath = newPath\",\n \"def __init__(self, mass, x, y,px=0.0,py=0.0):\\n self.mass = mass\\n self.position = np.array([x,y])\\n self.momentum = np.array([px,py])\",\n \"def __init__(self, mass, radius, position, velocity):\\n self.mass = mass\\n self.radius = radius\\n self.position = position\\n self.velocity = velocity\\n print(self.velocity)\\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\\n self.delete = False\",\n \"def __init__(self,mass,time,**kwargs):\\n self.setTime(time)\\n ParticlePhaseCoordinates.__init__(self,mass,**kwargs)\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All motion starts at (0,0).\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, x_0, y_0, initX, initY,h=5):\\n self.x_0=x_0\\n self.y_0=y_0\\n self.x_init=initX\\n self.y_init=initY\\n self.step=h\",\n \"def __init__(self, x, y):\\n # assigning the initial position\\n self.x = x\\n self.y = y\",\n \"def __init__(self,x,y,width,height):\\n self.x = x\\n self.y = y\\n self.width = width\\n self.height = height\\n self.velocity_x = 0.0\",\n \"def __init__(self):\\n self.position = Vector2()\\n self.velocity = Vector2()\\n self.update_parameters()\\n self.mass = 0.18 # Mass of Sphero robot in kilograms\",\n \"def __init__(self):\\n raise NotImplementedError('cannot create independent arc')\",\n \"def _init_anim(self):\\n pass\",\n \"def __init__(self):\\n self.x = 0\\n self.y = 0\",\n \"def __init__(self):\\n self.x = 0\\n self.y = 0\",\n \"def __init__(self, position, momentum, mass):\\n self.position = position\\n self.momentum = momentum\\n self.mass = mass\",\n \"def __init__(self, coords, direction):\\n self.y, self.x = coords\\n self.direction = direction\",\n \"def __init__(self):\\n\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.x = 0.0\\n self.y = 0.0\\n self.theta = 0.0\\n self.total_distance_covered = 0.0\",\n \"def __init__(self, pos=(0,0), dire = 0):\\r\\n self.initX = self.x = pos[0]\\r\\n self.initY = self.y = pos[1]\\r\\n self.initDir = self.dir = math.radians(dire)\",\n \"def __init__(self):\\n self.position = 0\",\n \"def __init__(self, Position, M):\\n self.pos = Position # Sets x position\\n self.m = M # Sets mass\\n # Initial velocity and acceleration set to be zero\\n self.vel = np.zeros((2,))\\n self.acc = np.zeros((2,))\",\n \"def __init__(self, x_coor, x_speed, y_coor, y_speed, direction):\\n self.__x_coor = x_coor\\n self.__x_speed = x_speed\\n self.__y_coor = y_coor\\n self.__y_speed = y_speed\\n self.__direction = direction\\n self.__radius = self.TORPEDO_RADIUS\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self, direction=0, x=0, y=0):\\n self.direction = direction\\n self.x = x\\n self.y = y\",\n \"def __init__(self, pos):\\r\\n self.pos = pos\\r\\n self.vel = [0, 0]\\r\\n self.acc = [0, 0]\\r\\n self.heading = math.pi\\r\\n self.screen = [0, 0]\",\n \"def __init__(self, path):\\n # TODO: later matching stuff will need superclass attributes\\n self.path = path\\n #self.topbp = ZFSBlockPointer(topbp) TODO: later\",\n \"def __init__(self, pos):\\r\\n self.pos = pos\",\n \"def __init__(self, x_axis_p, y_axis_p, x_speed=0, y_speed=0, direction=0):\\r\\n self.__x_axis = x_axis_p\\r\\n self.__y_axis = y_axis_p\\r\\n self.__X_speed = x_speed\\r\\n self.__y_speed = y_speed\\r\\n self.__direction = direction\\r\\n self.__lives = 3\",\n \"def __init__(self, path, ar_no):\\n self.path = path\\n self.ar_no = ar_no\\n self.dt = pos_neg_detection()\\n self.ts = ts_processing(self.path, self.ar_no)\",\n \"def __init__(self, inPs, outPs):\\n self.angle = 0.0\\n self.speed = 16.5\\n\\n super(MovementControl,self).__init__(inPs, outPs)\",\n \"def __init__(self, path=None):\\n pass\",\n \"def __init__(self, new_pt):\\n self.x = float(new_pt[0])\\n self.y = float(new_pt[1])\\n self.next = None\\n self.prev = None\\n self.distance_to_next = 0\\n self.angle = None\",\n \"def __init__(self, initX, initY):\\n self.x = initX\\n self.y = initY\",\n \"def __init__(self, initX, initY):\\n self.x = initX\\n self.y = initY\",\n \"def __init__(self):\\n super().__init__(ShowGraphABC._UNDIRECTED, \\\"path\\\")\",\n \"def __init__(self, name, state):\\n self.name = name\\n self.state = state\\n self.onSolnPath = False\\n self.parent = None\\n self.nextOnPath = None\",\n \"def __init__(self, x=0, y=0, rotation=0):\\n self.x, self.y = x, y\\n self.rotation = rotation\\n\\n self.x_speed, self.y_speed = 0, 0\",\n \"def __init__(self, location):\\r\\n self.y = location[1]\\r\\n self.x = location[0]\\r\\n self.yvel = 0.0\\r\\n self.xvel = 0.0\",\n \"def __init__(self):\\n self.Robot = Robot()\\n self.Omega = matrix()\\n # self.Omega.value[0][0] = 1.0\\n # self.Omega.value[1][1] = 1.0\\n self.Xi = matrix()\\n # Xi.value[0][0] = 0.0\\n # Xi.value[1][0] = 0.0\\n self.measure = {}\\n self.landMarkCount = 0\\n self.init = False\\n self.bearing = 0\\n self.x = 0\\n self.y = 0\\n \\n # TODO\",\n \"def __init__(self, x, y):\",\n \"def __init__(self, path_fun, disp_fun):\\n \\n if path_fun.nx != 1 or disp_fun.nx != 1:\\n raise ValueError(\\\"path_fun and disp_fun must have 1 input variable\\\")\\n \\n # The number of output coordinates is defined by the\\n # number of output functions of `path_fun`\\n nQ = path_fun.nf\\n \\n # The number of input coordinates equals the number\\n # of path-displacements plus 1.\\n if disp_fun.nf % nQ != 0:\\n raise ValueError('dispfun.nf must be a multiple of nQ')\\n n = disp_fun.nf // nQ # The number of displacement coordinates \\n \\n nQp = n + 1 # The total number of input coordinates \\n \\n Qpstr = ['s'] + [f\\\"d{i:d}\\\" for i in range(n)]\\n Qstr = [f\\\"Q{i:d}\\\" for i in range(nQ)]\\n \\n # The maxderiv is the minimum of either path_fun \\n # or disp_fun \\n maxderiv = dfun._merged_maxderiv(path_fun.maxderiv, disp_fun.maxderiv)\\n \\n # If the displace vectors have a finite zlevel, then the \\n # zlevel for that term is just 1 more (from the linear dependence on \\n # Q'). The total zlevel is then the merged zlevel of the path function\\n # and the displacement term \\n #\\n if disp_fun.zlevel is None:\\n disp_zlevel = None \\n else: \\n disp_zlevel = disp_fun.zlevel + 1 \\n zlevel = dfun._merged_zlevel(path_fun.zlevel, disp_zlevel)\\n \\n super().__init__(self._pathtrans_fun, nQp = nQp, nQ = nQ,\\n name = 'Path', Qpstr = Qpstr, Qstr = Qstr,\\n maxderiv = maxderiv, zlevel = zlevel)\\n \\n self.path_fun = path_fun \\n self.disp_fun = disp_fun\",\n \"def __init__(self, path):\\n assert isinstance(path, plumbum.LocalPath), path\\n assert path.exists()\\n self.path = path\\n super().__init__(path.stem)\",\n \"def __init__(self, path, position: (int, int, int, int), name_id):\\n self._path = path\\n self._position = position\\n self._name = name_id\",\n \"def __init__(self, **kwargs):\\n self.motion_err = np.array(kwargs.pop('err', [0., 0.]), dtype=float)\\n\\n pose = np.array(kwargs.pop('pose', [0.,0.,0.]), dtype=float)\\n super(XYPhiRobot, self).__init__(pose=pose)\",\n \"def __init__(self, x_pos, y_pos, radius, colour, moving = False):\\n\\t\\t\\n\\t\\tself.x_pos = x_pos\\n\\t\\tself.y_pos = y_pos\\n\\t\\tself.radius = radius\\n\\t\\tself.diameter = 2*radius\\n\\t\\tself.colour = colour\\n\\t\\tself.moving = moving\\n\\t\\tself.x_vec = 0\\n\\t\\tself.y_vec = 0\",\n \"def __init__(self, path):\\n self.path = path \\n self.current_location = os.getcwd()\\n self.rmsd = dict()\\n self._get_rmsd_list()\\n self._get_scores_list()\\n self._get_running_time()\\n self._get_step()\",\n \"def __init__(self):\\n self.mu = None\\n self.type = None\\n self.direction = None\\n self.eq_points = None\\n self.init_conds = None\\n self.time = None\\n self.trajectory = None\\n self.initial_point = None\\n self.contour_levels = []\",\n \"def __init__(self, d):\\n\\t\\tself._coords = [0] * d\",\n \"def __init__(self, center, waypoints, firepoints):\\n super().__init__(center, MallFighter.MALL_FIGHTER_SPEED, MallFighter.ANIMATION_DELAY, *MallFighter.FILE_PATH)\\n self.fire_idx = 0\\n self.way_idx = 0\\n self.waypoints = waypoints\\n self.firepoints = firepoints\",\n \"def __init__(self, parent, path_length, previous_action, current_player) :\\n self.parent = parent\\n self.path_length = path_length\\n self.previous_action = previous_action\\n self.current_player = current_player\",\n \"def __init__(self, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n super(VelocityVerletIntegrator, self).__init__(timestep)\\n\\n self.addPerDofVariable(\\\"x1\\\", 0)\\n\\n self.addUpdateContextState()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x+dt*v\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m+(x-x1)/dt\\\")\\n self.addConstrainVelocities()\",\n \"def __init__(obj, x, y, dy):\\r\\n obj.dy = dy\\r\\n GameObject.__init__(obj, x, y, obj.dxdy)\",\n \"def __init__(self, init_pose=None, init_velocities=None, \\n init_angle_velocities=None, runtime=5., target_pos=None):\\n \\n # initial state\\n self.state_scale = 1\\n \\n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\\n self.init_pose[2] += 10\\n self.init_velocities = np.array([0.,0.,0.])\\n self.init_angle_velocities = np.array([0.,0.,0.])\\n\\n self.runtime = runtime\\n \\n # Simulation\\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \\n self.action_repeat = 1\\n\\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\\n self.state_size = self.action_repeat * self.init_state.shape[0]\\n \\n self.action_low = 0 #-1\\n self.action_high = 2*450 #1\\n self.action_size = 4\\n\\n self.action_scale = 1 #450 # 1/2 max of the action \\n #self.state_scale = 150 # 1/2 size of the state space\\n \\n # Goal\\n self.target_pose = np.array([0.,0.,150.0])\\n\\n # The previous position\\n self.prev_pose = self.init_pose\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All walks start at (0, 0)\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All walks start at (0, 0)\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, motion, **kwargs):\\n super(ShiftWeight, self).__init__(motion)\",\n \"def __init__(self):\\n self.inches_moved = 0\\n self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B)\\n self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C)\\n self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A)\\n self.touch_sensor = ev3.TouchSensor()\\n self.running = True\\n self.ir_sensor = ev3.InfraredSensor()\\n self.color_sensor = ev3.ColorSensor()\\n assert self.color_sensor\\n assert self.ir_sensor\\n assert self.touch_sensor\\n self.arm_motor.position = 0\\n self.pixy = ev3.Sensor(driver_name=\\\"pixy-lego\\\")\\n assert self.pixy\\n\\n self.right_motor_encoder = self.right_motor.position\\n self.left_motor_encoder = self.left_motor.position\",\n \"def __init__(self, X, y):\\n pass\",\n \"def __init__(self):\\n self.t_height = 291\\n self.t_left = 65\\n self.t_right = 144\\n self.points = Pix()\",\n \"def __init__(self, motion, **kwargs):\\n super(ShiftIn, self).__init__(motion)\",\n \"def __init__(self):\\n\\n\\t\\tself.position = np.array([0, 0])\",\n \"def __init__(self, coordinate, speed_vec, heading):\\n self.__heading = heading\\n super().__init__(coordinate, speed_vec, Ship.RADIUS)\",\n \"def __init__(self, name: str):\\n self._name = name\\n self._yaw = Motion(\\\"yaw\\\")\\n self._pitch = Motion(\\\"pitch\\\")\\n self._roll = Motion(\\\"roll\\\")\\n self._sway = Motion(\\\"sway\\\")\\n self._surge = Motion(\\\"surge\\\")\\n self._heave = Motion(\\\"heave\\\")\",\n \"def __init__(self, pts=[]):\\n self.set_points(pts)\",\n \"def __init__(self, angle, x, y):\\n pygame.sprite.Sprite.__init__(self)\\n self.image = pygame.image.load(\\\"Image/Trafico.png\\\")\\n self.rect = self.image.get_rect()\\n self.image_orig = self.image\\n self.speed = 2\\n self.direction = angle\\n self.steering = 90\\n self.x = x\\n self.y = y\",\n \"def __init__(self, path=\\\"IdentityFunction\\\"):\\n self.path = path\\n self.heal = lambda X: X\\n self.heal_tf = lambda X: X\",\n \"def __init__(self, num_points = 5000):\\n self.num_points = num_points\\n\\n #all walks start at 0.0\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, x, y):\\n self.x, self.y = x, y\",\n \"def __init__(self, update_interval = None, **kwds):\\n super().__init__(**kwds)\\n self.am_moving = False\\n self.pos_dict = self.stage.position()\\n\\n # Pretend it takes 200ms to move, regardless of the actual distance.\\n #\\n self.move_timer = QtCore.QTimer()\\n self.move_timer.setInterval(200)\\n self.move_timer.setSingleShot(True)\\n self.move_timer.timeout.connect(self.handleMoveTimer)\\n \\n # Each time this timer fires we'll 'query' the stage for it's\\n # current position.\\n #\\n self.update_timer = QtCore.QTimer()\\n self.update_timer.setInterval(update_interval)\\n self.update_timer.timeout.connect(self.handleUpdateTimer)\\n self.update_timer.start()\\n\\n # We use a 'relay' signal as the stage might return\\n # stale information when it is moving. However the\\n # HardwareWorker that is querying the stage might not\\n # know that the stage is moving.\\n #\\n self.positionUpdate.connect(self.handlePositionUpdate)\",\n \"def __init__(self, paths):\\n self.paths = paths\",\n \"def __init__(self, path):\\n self.path = os.path.abspath(path)\",\n \"def __init__(self, model: models.ModelWrapper, path_coords: Tensor, target_distances: Tensor = None):\\n self.model = model\\n self.path_coords = path_coords.clone()\\n self.target_distances = target_distances\\n self._check_device()\\n\\n # This will raise an exception if gradients are computed without adapt_to_config() being called\\n self.spring_constant = -1\\n self.weight_decay = -1\",\n \"def __init__(self, x1, y1):\\n self.x = x1\\n self.y = y1\",\n \"def __init__(self, x, y = 505):\\n super(PlayerProjectile, self).__init__(image = PlayerProjectile.image,\\n x = x, y = y,\\n dy = PlayerProjectile.speed)\",\n \"def __init__(self, pos, radius):\\n super().__init__(pos, radius)\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7836744","0.7791446","0.77425086","0.68546695","0.6578746","0.63941026","0.63739896","0.6288861","0.62869287","0.62845355","0.62569","0.62209356","0.6177456","0.6177456","0.6177456","0.6177456","0.6142657","0.6134843","0.6126099","0.6106433","0.60999274","0.60934275","0.60652196","0.6057515","0.6047204","0.60419565","0.60369724","0.6029752","0.5951331","0.5951331","0.59467345","0.59465665","0.59343076","0.59343076","0.592668","0.59245723","0.590726","0.59013444","0.5893018","0.589125","0.589125","0.589125","0.589125","0.58830535","0.58630776","0.58559036","0.58514667","0.5847235","0.5846012","0.5841233","0.58220327","0.5821929","0.58085054","0.58085054","0.5806929","0.579784","0.5788376","0.5778699","0.5777281","0.57761914","0.577341","0.57689744","0.5761687","0.5757969","0.5756996","0.5756354","0.5741067","0.573737","0.57353675","0.57339317","0.5724292","0.57206637","0.57196605","0.5712075","0.5712075","0.5708085","0.57048213","0.5702455","0.5693958","0.5691692","0.56898457","0.5685584","0.56848305","0.56816554","0.5679057","0.56734526","0.567248","0.56705445","0.5668684","0.5666519","0.56659055","0.56568056","0.56515247","0.56506","0.56498784","0.5647769","0.5647769","0.5647769","0.5647769","0.5647769"],"string":"[\n \"0.7836744\",\n \"0.7791446\",\n \"0.77425086\",\n \"0.68546695\",\n \"0.6578746\",\n \"0.63941026\",\n \"0.63739896\",\n \"0.6288861\",\n \"0.62869287\",\n \"0.62845355\",\n \"0.62569\",\n \"0.62209356\",\n \"0.6177456\",\n \"0.6177456\",\n \"0.6177456\",\n \"0.6177456\",\n \"0.6142657\",\n \"0.6134843\",\n \"0.6126099\",\n \"0.6106433\",\n \"0.60999274\",\n \"0.60934275\",\n \"0.60652196\",\n \"0.6057515\",\n \"0.6047204\",\n \"0.60419565\",\n \"0.60369724\",\n \"0.6029752\",\n \"0.5951331\",\n \"0.5951331\",\n \"0.59467345\",\n \"0.59465665\",\n \"0.59343076\",\n \"0.59343076\",\n \"0.592668\",\n \"0.59245723\",\n \"0.590726\",\n \"0.59013444\",\n \"0.5893018\",\n \"0.589125\",\n \"0.589125\",\n \"0.589125\",\n \"0.589125\",\n \"0.58830535\",\n \"0.58630776\",\n \"0.58559036\",\n \"0.58514667\",\n \"0.5847235\",\n \"0.5846012\",\n \"0.5841233\",\n \"0.58220327\",\n \"0.5821929\",\n \"0.58085054\",\n \"0.58085054\",\n \"0.5806929\",\n \"0.579784\",\n \"0.5788376\",\n \"0.5778699\",\n \"0.5777281\",\n \"0.57761914\",\n \"0.577341\",\n \"0.57689744\",\n \"0.5761687\",\n \"0.5757969\",\n \"0.5756996\",\n \"0.5756354\",\n \"0.5741067\",\n \"0.573737\",\n \"0.57353675\",\n \"0.57339317\",\n \"0.5724292\",\n \"0.57206637\",\n \"0.57196605\",\n \"0.5712075\",\n \"0.5712075\",\n \"0.5708085\",\n \"0.57048213\",\n \"0.5702455\",\n \"0.5693958\",\n \"0.5691692\",\n \"0.56898457\",\n \"0.5685584\",\n \"0.56848305\",\n \"0.56816554\",\n \"0.5679057\",\n \"0.56734526\",\n \"0.567248\",\n \"0.56705445\",\n \"0.5668684\",\n \"0.5666519\",\n \"0.56659055\",\n \"0.56568056\",\n \"0.56515247\",\n \"0.56506\",\n \"0.56498784\",\n \"0.5647769\",\n \"0.5647769\",\n \"0.5647769\",\n \"0.5647769\",\n \"0.5647769\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76483566"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":20287,"cells":{"query":{"kind":"string","value":"Returns where the arm end effector should be at time t"},"document":{"kind":"string","value":"def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0","def end_time(self) -> float:\r\n ...","def endTime(self):\n return self.params['tend']","def get_last(t_, w_):\n return t_ - tf.constant(1)","def end(self):\n return self._t0 + self.length","def getEndTime(self):\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)","def end_effectors_pos(self):\n def relative_pos_in_egocentric_frame(physics):\n end_effector = physics.bind(self._entity.end_effectors).xpos\n torso = physics.bind(self._entity.root_body).xpos\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\n return observable.Generic(relative_pos_in_egocentric_frame)","def est_am(t,y):\n ch=t>t_eq\n y1=y[ch]\n return y1[-1]-y1[0]","def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\n\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\n naturalLog = np.log(numeratorLN/denomLN)\n\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\n brackets = F - Fp + product1\n\n product2 = (1/Ks)*brackets\n time = tp + product2 - endingTime\n return time","def getEndTime(self):\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)","def find_exit_time(self):\n \n # check when last bead starts moving\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\n nonzero = np.flatnonzero( vel_last_bead )\n \n if nonzero.size == 0:\n warnings.warn('The wave did not exit the chain or it could not be determined.')\n return np.nan\n else:\n exit_index = np.min( nonzero )\n time = self.get_time()\n exit_time = time[exit_index]\n return exit_time","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)","def timeofflight(xhat0):\n\t\timport poincare\n\t\t#Find the point on the computed poincare section, closest to the x0\n\t\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\n\t\t#Take its time of flight as\n\t\tif imin < np.size(ps,0)-1: \n\t\t\tTapproximate = ps[imin+1,0]-ps[imin,0]\n\t\telse:\n\t\t\tTapproximate = ps[imin,0]-ps[imin-1,0]\n\t\tprint(\"Tapproximate:\")\n\t\tprint(Tapproximate)\n\t\t#Integrate for a little bit longer than the approximated integration time:\n\t\tstoptime = 1.2*Tapproximate\n\t\tnumpoints = int(stoptime/0.01)\n\t\t#Integration time array:\n\t\tt = np.linspace(0, stoptime, numpoints)\n\t\txhatphi0 = np.append(xhat0, np.array([0], float))\n\t\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\n\t\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\n\t\t#Compute Poincare section:\n\t\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\n\t\tprint(\"psreturn:\")\n\t\tprint(psreturn)\n\t\t#Take the time nearest to the approximated time. This is due to the\n\t\t#fact that the array ps sometimes includes the initial point and sometimes\n\t\t#does not, hence we are not always sure the position of the first return.\n\t\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\n\t\ttof = psreturn[itof,0]\n\t\treturn tof","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def get_delta_t(self):\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\n - self.gv.t_queue[self.gv.filter_min_bound]","def at(self, t):\n return self.start + (self.end - self.start) * t","def end_time(self):\n pass","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def end_time(self):\n # TODO: use pd.Timestamp instead\n return self.time[-1].to_pydatetime()","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def get_trace_abs(self, norm=True):\n if self.Et is not None:\n # Center peak in time\n ind = np.argmax(abs(self.Et))\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\n Et = np.abs(np.roll(self.Et, shift))\n if norm is True:\n Et /= Et.max()\n else:\n Et = None\n return Et","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def _dy(self, T):\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])","def end_point(self) -> Vec3:\n v = list(self.vertices([self.dxf.end_angle]))\n return v[0]","def _reached_temperature_end_point(self, T, Tend):\n if Tend is None:\n # End point not give\n return False\n\n if self._integration_direction == \"increasing\":\n if T > Tend:\n return True\n elif self._integration_direction == \"decreasing\":\n if T < Tend:\n return True\n return False","def end_time(self, t):\r\n # Increase temperature while silent.\r\n if np.count_nonzero(self.next_note) == 0:\r\n self.silent_time += 1\r\n if self.silent_time >= NOTES_PER_BAR:\r\n self.temperature += 0.1\r\n else:\r\n self.silent_time = 0\r\n self.temperature = self.default_temp\r\n \r\n self.notes_memory.append(self.next_note)\r\n # Consistent with dataset representation\r\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\r\n self.results.append(self.next_note)\r\n # Reset next note\r\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\r\n return self.results[-1]","def find_alert_time(self) -> None:\n \n # Also not clear from the paper how to doe this,\n # use the first 10 data points in the light curve to determine the magnitude\n # baseline\n\n mean_mag = np.mean(self.mags[:10])\n std_mag = np.std(self.mags[:10])\n\n num_above = 0 \n i = 9\n\n while num_above < 3 and i < len(self.times)-1:\n \n i += 1 \n\n if self.mags[i] < mean_mag - std_mag:\n num_above += 1\n else:\n num_above = 0.0\n\n if len(self.times) - 1 == i:\n print(\"Give me more training data, not alerted yet, this is probably going to fail\")\n \n return self.times[i-1]","def eval(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[:len(res)//2]","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def getEndTime(self):\n return _osgAnimation.Channel_getEndTime(self)","def line_segment(t, # Array of times for each position\n t_now # Current time (float)\n ):\n i = np.argwhere(t > t_now)\n if len(i) > 0:\n if i[0] != 0: # if the current time is not less than the starting time\n segment_starting_index = i[0][0] - 1\n else:\n segment_starting_index = 0\n\n segment_end_index = i[0][0]\n\n else: # if the current time is more than the last point (destination) time\n segment_starting_index = t.shape[0]\n segment_end_index = t.shape[0]\n\n return segment_starting_index, segment_end_index","def end_abs(self):\n if self.end == float('inf'):\n return self.track.duration\n else:\n return self.end","def time_step(self):\n\n rho_rel = np.abs(self.rho_dt / self.rho)\n rho_rel_max = np.max(rho_rel)\n e_rel = np.abs(self.e_dt / self.e)\n e_rel_max = np.max(e_rel)\n x_rel = np.abs(self.u / self.dx)\n x_rel_max = np.max(x_rel)\n y_rel = np.abs(self.w / self.dy)\n y_rel_max = np.max(y_rel)\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\n delta = np.max(np.abs(rel))\n\n if 0.1 <= delta <= 1e3:\n self.dt = self.p / delta\n else:\n self.dt = self.p","def end_time(self):\n return RPR.GetAudioAccessorEndTime(self.id)","def run_e(self, t):\n if t > self.n_t:\n raise IndexError('Maximum simulated timesteps exceeded in E step')\n if self.pf.t >= t:\n raise IndexError(\n 'Particle filter already run past given time point')\n while self.pf.t < t:\n self.pf.advance()\n self.pf.calculate_means_sdevs()\n\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))","def end_of_horizon_cost_rule(_m):\r\n\r\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\r\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\r","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def end(self):\r\n hours = self.length // 60\r\n minutes = self.length % 60\r\n return time(self.start.hour + hours, self.start.minute + minutes)","def get_end(self):\n\n return self.end_cycle","def _get_end_time(self):\n return self.__end_time","def get_end(self):\n return self._start + self._duration","def diff(t, y):\n origin = root.vectorize()\n root.tensorize(y)\n self.time = t if not imaginary else None\n self.eom()\n ans = root.vectorize(use_aux=True)\n root.tensorize(origin)\n return ans","def inc_end(self):\n return self._exc_end - TIMERANGE_PRECISION","def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\n i,u = self.getSegment(t,endBehavior)\n if i<0: return self.milestones[0]\n elif i+1>=len(self.milestones): return self.milestones[-1]\n #linear interpolate between milestones[i] and milestones[i+1]\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])","def eval(self,t,endBehavior='halt'):\n self._skip_deriv = True\n res = Trajectory.eval_state(self,t,endBehavior)\n self._skip_deriv = False\n return res[:len(res)//2]","def timeEnd(self)->datetime:\n if self._scenario == LM_HardDate.Scenario.ValidSince:\n raise SdkError(\"timeEnd not defined for scenario 'ValidSince'\")\n\n return self._lic.params['timeEnd'].value","def evap(self, lai, tl, ta, qa):#average ta and tl!!\n\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\n\t\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \n\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\n\t return 0.\n\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\n\t return (self.tx*self.ZT*self.TAI*10**6/dt)\n\t else:\n\t return fsev","def get_end(self):\n return self.start + timedelta(minutes=self.duration)","def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to the array\n\t\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\n\t\tdUdt = dUdt + self.getHeatFlux(temperature)\n\t\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\n\t\treturn numpy.append(dNdt,dTdt)","def time_end(self):\n return self._time_end","def tLoss(self, dt, qt, tl, ta, qa):\n\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def after(self, time: float) -> 'Trajectory':\n return self.split(time)[1]","def lerp(self, t):\n pass","def set_T_lm(self):\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) )","def end_time(self):\n return from_ts(self.end_time_ms)","def elapsed_raw(self, start=\"__enter__\", end=\"__exit__\"):\n return self.laps[end] - self.laps[start]","def get_vehicle_end_index(self):\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def cal_end(self):\n return self.datetime_end","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def update(self, tfinal):\n t = 0; kk = 0\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\n self.omega = np.zeros((nstep,self.npts))\n self.theta = np.zeros((nstep,self.npts))\n\n while t <(tfinal+1e-10):\n self.return_map()\n self.omega[kk] = self.y[0]\n self.theta[kk] = self.y[1]\n\n self.y = RK4(self.y, self.dt, t, self.deri)\n kk += 1; t += self.dt\n\n return self","def get_terminating_ray(self):\n return self._terminating_ray","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def end_time(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"end_time\")","def get_current_ee_pose(self):\n #self.arm_endpoint = #magic tf call that I can add\n while True:\n try:\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\n break # once the transform is obtained move on\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\n continue # if it fails try again\n point = [translation[0], translation[1], translation[2]]\n self.arm_endpoint = np.array(point)\n # rospy.logerr(self.arm_endpoint)","def o(r, t):\n return r/t**0.5","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def roty(self, t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s],\n [0, 1, 0],\n [-s, 0, c]])","def getEnd(self) -> long:\n ...","def trapezoid(t, params):\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n\n envelope = tf.ones_like(t, dtype=tf.float64)\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\n return envelope","def _get_end(self):\n return self._end","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def ricker(dt, pt):\n nt = int(2 * pt / dt)\n c = np.zeros(nt)\n t0 = pt / dt\n a_ricker = 4 / pt\n\n for it in range(0, nt):\n t = ((it + 1) - t0) * dt\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\n\n return c","def end_time(self):\n return self.time_parser.end_time","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def horde_end(self):","def roty(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])","def out(self, t: any, dim=(None, None)) -> any:\n lB = self.interval[0] # Lower Boundary\n uB = self.interval[1] # Upper Boundary\n # Initialize random step vector each sampling period using comprehensive list.\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\n step_vector[0] = self.ss # keep the steady state value as first\n u = np.zeros(shape=dim) # Initialize step control input array u.\n j = 0\n\n ramp_Step = self.saw_time\n count = 1\n for i in range(len(t)): # Excluding the last point\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\n j += 1\n count = 1\n\n if self.ss is not None and j == 0:\n u[i, :] = self.ss\n else:\n if count != ramp_Step:\n\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\n count += 1\n else:\n u[i, :] = step_vector[j]\n return u","def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\n dT = self.deriv(t,endBehavior)\n return so3.deskew(dT[0])+dT[1]","def getETA():","def getETA():"],"string":"[\n \"def endTime(self) -> float:\\n try: return self.times[-1]\\n except IndexError: return 0.0\",\n \"def end_time(self) -> float:\\r\\n ...\",\n \"def endTime(self):\\n return self.params['tend']\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def end(self):\\n return self._t0 + self.length\",\n \"def getEndTime(self):\\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)\",\n \"def end_effectors_pos(self):\\n def relative_pos_in_egocentric_frame(physics):\\n end_effector = physics.bind(self._entity.end_effectors).xpos\\n torso = physics.bind(self._entity.root_body).xpos\\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\\n return observable.Generic(relative_pos_in_egocentric_frame)\",\n \"def est_am(t,y):\\n ch=t>t_eq\\n y1=y[ch]\\n return y1[-1]-y1[0]\",\n \"def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\\n\\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\\n naturalLog = np.log(numeratorLN/denomLN)\\n\\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\\n brackets = F - Fp + product1\\n\\n product2 = (1/Ks)*brackets\\n time = tp + product2 - endingTime\\n return time\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)\",\n \"def find_exit_time(self):\\n \\n # check when last bead starts moving\\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\\n nonzero = np.flatnonzero( vel_last_bead )\\n \\n if nonzero.size == 0:\\n warnings.warn('The wave did not exit the chain or it could not be determined.')\\n return np.nan\\n else:\\n exit_index = np.min( nonzero )\\n time = self.get_time()\\n exit_time = time[exit_index]\\n return exit_time\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)\",\n \"def timeofflight(xhat0):\\n\\t\\timport poincare\\n\\t\\t#Find the point on the computed poincare section, closest to the x0\\n\\t\\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\\n\\t\\t#Take its time of flight as\\n\\t\\tif imin < np.size(ps,0)-1: \\n\\t\\t\\tTapproximate = ps[imin+1,0]-ps[imin,0]\\n\\t\\telse:\\n\\t\\t\\tTapproximate = ps[imin,0]-ps[imin-1,0]\\n\\t\\tprint(\\\"Tapproximate:\\\")\\n\\t\\tprint(Tapproximate)\\n\\t\\t#Integrate for a little bit longer than the approximated integration time:\\n\\t\\tstoptime = 1.2*Tapproximate\\n\\t\\tnumpoints = int(stoptime/0.01)\\n\\t\\t#Integration time array:\\n\\t\\tt = np.linspace(0, stoptime, numpoints)\\n\\t\\txhatphi0 = np.append(xhat0, np.array([0], float))\\n\\t\\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\\n\\t\\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\\n\\t\\t#Compute Poincare section:\\n\\t\\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\\n\\t\\tprint(\\\"psreturn:\\\")\\n\\t\\tprint(psreturn)\\n\\t\\t#Take the time nearest to the approximated time. This is due to the\\n\\t\\t#fact that the array ps sometimes includes the initial point and sometimes\\n\\t\\t#does not, hence we are not always sure the position of the first return.\\n\\t\\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\\n\\t\\ttof = psreturn[itof,0]\\n\\t\\treturn tof\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def get_delta_t(self):\\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\\\\n - self.gv.t_queue[self.gv.filter_min_bound]\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def end_time(self):\\n pass\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def end_time(self):\\n # TODO: use pd.Timestamp instead\\n return self.time[-1].to_pydatetime()\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def get_trace_abs(self, norm=True):\\n if self.Et is not None:\\n # Center peak in time\\n ind = np.argmax(abs(self.Et))\\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\\n Et = np.abs(np.roll(self.Et, shift))\\n if norm is True:\\n Et /= Et.max()\\n else:\\n Et = None\\n return Et\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def _dy(self, T):\\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])\",\n \"def end_point(self) -> Vec3:\\n v = list(self.vertices([self.dxf.end_angle]))\\n return v[0]\",\n \"def _reached_temperature_end_point(self, T, Tend):\\n if Tend is None:\\n # End point not give\\n return False\\n\\n if self._integration_direction == \\\"increasing\\\":\\n if T > Tend:\\n return True\\n elif self._integration_direction == \\\"decreasing\\\":\\n if T < Tend:\\n return True\\n return False\",\n \"def end_time(self, t):\\r\\n # Increase temperature while silent.\\r\\n if np.count_nonzero(self.next_note) == 0:\\r\\n self.silent_time += 1\\r\\n if self.silent_time >= NOTES_PER_BAR:\\r\\n self.temperature += 0.1\\r\\n else:\\r\\n self.silent_time = 0\\r\\n self.temperature = self.default_temp\\r\\n \\r\\n self.notes_memory.append(self.next_note)\\r\\n # Consistent with dataset representation\\r\\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\\r\\n self.results.append(self.next_note)\\r\\n # Reset next note\\r\\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\\r\\n return self.results[-1]\",\n \"def find_alert_time(self) -> None:\\n \\n # Also not clear from the paper how to doe this,\\n # use the first 10 data points in the light curve to determine the magnitude\\n # baseline\\n\\n mean_mag = np.mean(self.mags[:10])\\n std_mag = np.std(self.mags[:10])\\n\\n num_above = 0 \\n i = 9\\n\\n while num_above < 3 and i < len(self.times)-1:\\n \\n i += 1 \\n\\n if self.mags[i] < mean_mag - std_mag:\\n num_above += 1\\n else:\\n num_above = 0.0\\n\\n if len(self.times) - 1 == i:\\n print(\\\"Give me more training data, not alerted yet, this is probably going to fail\\\")\\n \\n return self.times[i-1]\",\n \"def eval(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[:len(res)//2]\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def getEndTime(self):\\n return _osgAnimation.Channel_getEndTime(self)\",\n \"def line_segment(t, # Array of times for each position\\n t_now # Current time (float)\\n ):\\n i = np.argwhere(t > t_now)\\n if len(i) > 0:\\n if i[0] != 0: # if the current time is not less than the starting time\\n segment_starting_index = i[0][0] - 1\\n else:\\n segment_starting_index = 0\\n\\n segment_end_index = i[0][0]\\n\\n else: # if the current time is more than the last point (destination) time\\n segment_starting_index = t.shape[0]\\n segment_end_index = t.shape[0]\\n\\n return segment_starting_index, segment_end_index\",\n \"def end_abs(self):\\n if self.end == float('inf'):\\n return self.track.duration\\n else:\\n return self.end\",\n \"def time_step(self):\\n\\n rho_rel = np.abs(self.rho_dt / self.rho)\\n rho_rel_max = np.max(rho_rel)\\n e_rel = np.abs(self.e_dt / self.e)\\n e_rel_max = np.max(e_rel)\\n x_rel = np.abs(self.u / self.dx)\\n x_rel_max = np.max(x_rel)\\n y_rel = np.abs(self.w / self.dy)\\n y_rel_max = np.max(y_rel)\\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\\n delta = np.max(np.abs(rel))\\n\\n if 0.1 <= delta <= 1e3:\\n self.dt = self.p / delta\\n else:\\n self.dt = self.p\",\n \"def end_time(self):\\n return RPR.GetAudioAccessorEndTime(self.id)\",\n \"def run_e(self, t):\\n if t > self.n_t:\\n raise IndexError('Maximum simulated timesteps exceeded in E step')\\n if self.pf.t >= t:\\n raise IndexError(\\n 'Particle filter already run past given time point')\\n while self.pf.t < t:\\n self.pf.advance()\\n self.pf.calculate_means_sdevs()\\n\\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))\",\n \"def end_of_horizon_cost_rule(_m):\\r\\n\\r\\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\\r\\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\\r\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end(self):\\r\\n hours = self.length // 60\\r\\n minutes = self.length % 60\\r\\n return time(self.start.hour + hours, self.start.minute + minutes)\",\n \"def get_end(self):\\n\\n return self.end_cycle\",\n \"def _get_end_time(self):\\n return self.__end_time\",\n \"def get_end(self):\\n return self._start + self._duration\",\n \"def diff(t, y):\\n origin = root.vectorize()\\n root.tensorize(y)\\n self.time = t if not imaginary else None\\n self.eom()\\n ans = root.vectorize(use_aux=True)\\n root.tensorize(origin)\\n return ans\",\n \"def inc_end(self):\\n return self._exc_end - TIMERANGE_PRECISION\",\n \"def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\\n i,u = self.getSegment(t,endBehavior)\\n if i<0: return self.milestones[0]\\n elif i+1>=len(self.milestones): return self.milestones[-1]\\n #linear interpolate between milestones[i] and milestones[i+1]\\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\",\n \"def eval(self,t,endBehavior='halt'):\\n self._skip_deriv = True\\n res = Trajectory.eval_state(self,t,endBehavior)\\n self._skip_deriv = False\\n return res[:len(res)//2]\",\n \"def timeEnd(self)->datetime:\\n if self._scenario == LM_HardDate.Scenario.ValidSince:\\n raise SdkError(\\\"timeEnd not defined for scenario 'ValidSince'\\\")\\n\\n return self._lic.params['timeEnd'].value\",\n \"def evap(self, lai, tl, ta, qa):#average ta and tl!!\\n\\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\\n\\t\\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \\n\\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\\n\\t return 0.\\n\\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\\n\\t return (self.tx*self.ZT*self.TAI*10**6/dt)\\n\\t else:\\n\\t return fsev\",\n \"def get_end(self):\\n return self.start + timedelta(minutes=self.duration)\",\n \"def rightSideOfODE(self, Y, t):\\n\\t\\ttemperature = Y[-1]\\n\\t\\tamounts = Y[:-1]\\n\\t\\tself.amounts = amounts\\n\\t\\t# first get the species amount changes (as an array)\\n\\t\\tdNdt = -1 * self.getMolarFluxes(temperature)\\n\\t\\t# then get the temperature change, and append it to the array\\n\\t\\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\\n\\t\\tdUdt = dUdt + self.getHeatFlux(temperature)\\n\\t\\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\\n\\t\\treturn numpy.append(dNdt,dTdt)\",\n \"def time_end(self):\\n return self._time_end\",\n \"def tLoss(self, dt, qt, tl, ta, qa):\\n\\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def after(self, time: float) -> 'Trajectory':\\n return self.split(time)[1]\",\n \"def lerp(self, t):\\n pass\",\n \"def set_T_lm(self):\\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) )\",\n \"def end_time(self):\\n return from_ts(self.end_time_ms)\",\n \"def elapsed_raw(self, start=\\\"__enter__\\\", end=\\\"__exit__\\\"):\\n return self.laps[end] - self.laps[start]\",\n \"def get_vehicle_end_index(self):\\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def cal_end(self):\\n return self.datetime_end\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def update(self, tfinal):\\n t = 0; kk = 0\\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\\n self.omega = np.zeros((nstep,self.npts))\\n self.theta = np.zeros((nstep,self.npts))\\n\\n while t <(tfinal+1e-10):\\n self.return_map()\\n self.omega[kk] = self.y[0]\\n self.theta[kk] = self.y[1]\\n\\n self.y = RK4(self.y, self.dt, t, self.deri)\\n kk += 1; t += self.dt\\n\\n return self\",\n \"def get_terminating_ray(self):\\n return self._terminating_ray\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end_time(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def get_current_ee_pose(self):\\n #self.arm_endpoint = #magic tf call that I can add\\n while True:\\n try:\\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\\n break # once the transform is obtained move on\\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\\n continue # if it fails try again\\n point = [translation[0], translation[1], translation[2]]\\n self.arm_endpoint = np.array(point)\\n # rospy.logerr(self.arm_endpoint)\",\n \"def o(r, t):\\n return r/t**0.5\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def roty(self, t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s],\\n [0, 1, 0],\\n [-s, 0, c]])\",\n \"def getEnd(self) -> long:\\n ...\",\n \"def trapezoid(t, params):\\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n\\n envelope = tf.ones_like(t, dtype=tf.float64)\\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\\n return envelope\",\n \"def _get_end(self):\\n return self._end\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def ricker(dt, pt):\\n nt = int(2 * pt / dt)\\n c = np.zeros(nt)\\n t0 = pt / dt\\n a_ricker = 4 / pt\\n\\n for it in range(0, nt):\\n t = ((it + 1) - t0) * dt\\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\\n\\n return c\",\n \"def end_time(self):\\n return self.time_parser.end_time\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def horde_end(self):\",\n \"def roty(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])\",\n \"def out(self, t: any, dim=(None, None)) -> any:\\n lB = self.interval[0] # Lower Boundary\\n uB = self.interval[1] # Upper Boundary\\n # Initialize random step vector each sampling period using comprehensive list.\\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\\n step_vector[0] = self.ss # keep the steady state value as first\\n u = np.zeros(shape=dim) # Initialize step control input array u.\\n j = 0\\n\\n ramp_Step = self.saw_time\\n count = 1\\n for i in range(len(t)): # Excluding the last point\\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\\n j += 1\\n count = 1\\n\\n if self.ss is not None and j == 0:\\n u[i, :] = self.ss\\n else:\\n if count != ramp_Step:\\n\\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\\n count += 1\\n else:\\n u[i, :] = step_vector[j]\\n return u\",\n \"def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\\n dT = self.deriv(t,endBehavior)\\n return so3.deskew(dT[0])+dT[1]\",\n \"def getETA():\",\n \"def getETA():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6262754","0.60054207","0.59560645","0.5919242","0.59007686","0.58521706","0.5844045","0.580404","0.5791151","0.5790337","0.5788008","0.57607013","0.57595277","0.57300097","0.57146317","0.5713964","0.56925106","0.56845766","0.56776744","0.56025434","0.5577776","0.5577258","0.5561718","0.5554804","0.5550632","0.55414397","0.5509652","0.5486134","0.54807806","0.5450397","0.5448296","0.5435491","0.5428117","0.5421442","0.5420882","0.5407447","0.53956217","0.5393599","0.53911644","0.5388739","0.53826755","0.538183","0.53771454","0.5370922","0.53657544","0.53590137","0.5338765","0.53361785","0.5324579","0.5317156","0.5305034","0.5301146","0.52967286","0.529175","0.5290008","0.52892494","0.5269293","0.5254921","0.5254921","0.524881","0.5248734","0.52469486","0.52455217","0.5238649","0.5232238","0.5228608","0.5228394","0.52274954","0.52269995","0.52246207","0.52191484","0.5211364","0.5211364","0.52056676","0.5203241","0.52024585","0.5195268","0.5193534","0.51899034","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5184724","0.5183763","0.51775163","0.5172201","0.51709485","0.5164134","0.5155358","0.51551783","0.5154484","0.5141973","0.5139901","0.5139446","0.51381594","0.51364684","0.51364684"],"string":"[\n \"0.6262754\",\n \"0.60054207\",\n \"0.59560645\",\n \"0.5919242\",\n \"0.59007686\",\n \"0.58521706\",\n \"0.5844045\",\n \"0.580404\",\n \"0.5791151\",\n \"0.5790337\",\n \"0.5788008\",\n \"0.57607013\",\n \"0.57595277\",\n \"0.57300097\",\n \"0.57146317\",\n \"0.5713964\",\n \"0.56925106\",\n \"0.56845766\",\n \"0.56776744\",\n \"0.56025434\",\n \"0.5577776\",\n \"0.5577258\",\n \"0.5561718\",\n \"0.5554804\",\n \"0.5550632\",\n \"0.55414397\",\n \"0.5509652\",\n \"0.5486134\",\n \"0.54807806\",\n \"0.5450397\",\n \"0.5448296\",\n \"0.5435491\",\n \"0.5428117\",\n \"0.5421442\",\n \"0.5420882\",\n \"0.5407447\",\n \"0.53956217\",\n \"0.5393599\",\n \"0.53911644\",\n \"0.5388739\",\n \"0.53826755\",\n \"0.538183\",\n \"0.53771454\",\n \"0.5370922\",\n \"0.53657544\",\n \"0.53590137\",\n \"0.5338765\",\n \"0.53361785\",\n \"0.5324579\",\n \"0.5317156\",\n \"0.5305034\",\n \"0.5301146\",\n \"0.52967286\",\n \"0.529175\",\n \"0.5290008\",\n \"0.52892494\",\n \"0.5269293\",\n \"0.5254921\",\n \"0.5254921\",\n \"0.524881\",\n \"0.5248734\",\n \"0.52469486\",\n \"0.52455217\",\n \"0.5238649\",\n \"0.5232238\",\n \"0.5228608\",\n \"0.5228394\",\n \"0.52274954\",\n \"0.52269995\",\n \"0.52246207\",\n \"0.52191484\",\n \"0.5211364\",\n \"0.5211364\",\n \"0.52056676\",\n \"0.5203241\",\n \"0.52024585\",\n \"0.5195268\",\n \"0.5193534\",\n \"0.51899034\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5184724\",\n \"0.5183763\",\n \"0.51775163\",\n \"0.5172201\",\n \"0.51709485\",\n \"0.5164134\",\n \"0.5155358\",\n \"0.51551783\",\n \"0.5154484\",\n \"0.5141973\",\n \"0.5139901\",\n \"0.5139446\",\n \"0.51381594\",\n \"0.51364684\",\n \"0.51364684\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5366723"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":20288,"cells":{"query":{"kind":"string","value":"Returns the arm's desired x,y,z velocity in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_position()"},"document":{"kind":"string","value":"def target_velocity(self, time):\n\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\n\n return avg_vel"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def target_velocity(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_velocity(path_time)","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def target_velocity(self, time):\n pass","def target_velocity(self, time):\n pass","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def robot_arm_pos(self):\n return self.sim.data.qpos[self.arm_index]","def get_position(self, t0):\n my_pos_x=np.random.uniform(-20, 20)\n my_pos_y=np.random.uniform(-20, 20)\n r=np.array([my_pos_x, my_pos_y])\n x_y=np.zeros(shape=(self.no_planets-1, 2))\n tol=1e-5\n diff=np.zeros(self.no_planets-1)\n for k in range(self.no_planets-1):\n r1=np.linalg.norm(r)\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\n x1=0\n y1=0\n x2=self.positionFunction(t0)[0,k]\n y2=self.positionFunction(t0)[1,k]\n x3=self.positionFunction(t0)[0,k+1]\n y3=self.positionFunction(t0)[1, k+1]\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\n x_y[k, 0]=x\n x_y[k, 1]=y\n diff[k]=difference\n if (diff > tol).any():\n print diff.max()\n print \"Oh no, one failed :(\"\n sys.exit(1)\n print \"My pos x:\", my_pos_x\n print \"My pos y:\", my_pos_y\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3","def target_velocity(self, s):\n # YOUR CODE HERE\n if s > self.total_length:\n s = self.total_length\n angular = np.array([0, 0 ,0])\n else:\n angular = np.array([0,0,self.targ_angular])\n\n theta = s/self.total_length*self.angle\n v_x = np.cos(theta)*self.targ_speed\n if self.left_turn:\n v_y = np.sin(theta)*self.targ_speed\n else:\n v_y = -np.sin(theta)*self.targ_speed\n \n linear = np.array([v_x, v_y, 0])\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\n \n toRet = [linear, angular]\n \n return toRet","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def _compute_solar_torque(self):\n pass","def target_position(self, time):\n return self.target(time, self.positions, self.dt, self.num_way)","def target_position(self, time):\n return self.target(time, self.positions, self.dt, self.num_way)","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])","def getVelocity(self):\n return self.v","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def target_velocity(self, s):\n if s > self.total_length:\n linear = np.array([0,0,0])\n else:\n linear = np.array([self.sign*self.targ_speed, 0, 0])\n \n angular = np.array([0,0,0])\n toRet = [linear, angular]\n\n return toRet","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def get_velocity(self):\n return self.momentum/self.mass","def test_velocity(self):\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\n # r must contain 2 elements, otherwise the density and pressure are nan\n r = np.array([0.7, 0.8])\n t = 6.25e-6\n solrt = sol(r, t)\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def u_exact(self, t):\n\n # some abbreviations\n wE = self.params.omega_E\n wB = self.params.omega_B\n N = self.params.nparts\n u0 = self.params.u0\n\n if N != 1:\n raise ProblemError('u_exact is only valid for a single particle')\n\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\n\n wbar = np.sqrt(2) * wE\n\n # position and velocity in z direction is easy to compute\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\n\n # define temp. variables to compute complex position\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\n Rp = u0[0][0] - Rm\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\n Ip = u0[0][1] - Im\n\n # compute position in complex notation\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n # compute velocity as time derivative of the position\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n\n # get the appropriate real and imaginary parts\n u.pos[0, 0] = w.real\n u.vel[0, 0] = dw.real\n u.pos[1, 0] = w.imag\n u.vel[1, 0] = dw.imag\n\n return u","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def get_target_tile(self):\n if self.tank.flag is not None:\n x, y = self.tank.start_position\n else:\n self.get_flag() # Ensure that we have initialized it.\n x, y = self.flag.x, self.flag.y\n return Vec2d(int(x), int(y))","def position(t):\n return c + tangent_vec * 7 * t ** 2","def relative_velocity(self):\n return self.base_platform.relative_velocity","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def shoot(self):\n pt = self.pt()\n assert pt >= 0\n m = self.mass()\n assert m >= 0\n sqrt_pt2_m2 = math.sqrt( pt**2 + m**2 )\n y = self.rap()\n e = sqrt_pt2_m2 * math.cosh(y)\n pz = sqrt_pt2_m2 * math.sinh(y)\n phi = self.phi()\n px = pt * math.cos(phi);\n py = pt * math.sin(phi);\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def orbitalVelocity( self ): # returns [m/s]\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\n return velocity","def eval_2pts(self, vector, t):\n if t < 0 or t > 1:\n raise Exception(\"Cannot Eval \", e, \" with t=\", t, \": t Should Satisfy 0<=t<=1.\")\n else:\n return Vector((1-t)*self.x + t*vector.x, (1-t)*self.y + t*vector.y, (1-t)*self.z + t*vector.z)","def getTopLeftVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = (0,0,0)\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity","def velocity(self):\n return self._velocity","def velocity(self):\n return self._velocity","def compute_velocity(self, time_since_last_frame: float) -> None:\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\n self.velocity_kts = (true_dist /\n self.secs_since_last_seen) / 1.94384\n self.cart_coords = new_cart_coords","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def move(self, t):\n if self.visible == True:\n self.x += self.vx * t\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\n\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\n self.phi = t * v_norm / self.radius\n\n glPushMatrix()\n glLoadIdentity()\n\n if v_norm > 0.0:\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\n glMultMatrixd(self.matrix)\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\n\n glPopMatrix()\n\n # Friction!!! Could do it as global parameter\n if v_norm > 0.0:\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\n\n if v_prime_norm < 0.0:\n v_prime_norm = 0.0\n\n self.vx *= v_prime_norm / v_norm\n self.vy *= v_prime_norm / v_norm\n\n return True\n # Add comment\n return False","def get_velocity(self):\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s","def shoot(self):\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n theta = self.theta()\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def shoot(self):\n e = self.energy()\n y = self.rap()\n sqrt_pt2_m2 = e / math.cosh(y)\n pz = sqrt_pt2_m2 * math.sinh(y)\n m = self.mass()\n pt = math.sqrt( sqrt_pt2_m2**2 - m**2 )\n phi = self.phi()\n px = pt * math.cos(phi);\n py = pt * math.sin(phi);\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def getVelocity(self):\n\n return self.vel","def shoot(self):\n theta = self.theta()\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def velocity(self):\n return self.base_platform.velocity","def get_vsolar(self):\n return self.read_register(4098, 1, 3)","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def compute_observation(self):\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\n robotEuler = p.getEulerFromQuaternion(robotOrn)\n linear, angular = p.getBaseVelocity(self.botId)\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))","def get_angular_velocity(r, T):\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\n # velocity = 2(pi)r/T\n return (2*math.pi*r)/T","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def _get_next_velocity(self):\n\n self._predict_state()\n\n # curr = pos_quat_to_euler(self.curr_quat)\n dest = pos_quat_to_euler(self.dest_quat_predict)\n error = self.calc_error(self.dest_quat_predict)\n # TODO error should be computed for phi, th axis individually\n\n # TODO recommend_velocity to reach desired setpoint at a given velocity\n phi_vel = self.motor_phi.recommend_velocity(dest[0])\n th_vel = self.motor_th .recommend_velocity(dest[1])\n\n if error < 0.05:\n return 0.0, 0.0\n\n # TODO this is lame\n #scale = error * 4\n #phi_vel = scale * phi_vel\n #th_vel = scale * th_vel\n\n return phi_vel, th_vel\n\n # TODO PID (control algo)... or should it be handled closer to motors?\n # TODO Path planning\n # TODO Velocity-accel curve to estimate time required to get to point\n # - Cache its integral and use as lookup to estimate if we can get\n # to point without overshoot","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def acceleration(v,u,t):\n return ((v-u)/t)","def distance(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.position(rf), t.position(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def position(self, l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n pos = x + v * t + (1/2.0) * g * t**2\n \n if squeeze:\n pos = np.squeeze(pos, axis=0)\n return pos","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def t2u(self, t ):\n \n if t < self.time_final:\n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n u = self.u_sol[i,:]\n \n else:\n u = self.ubar\n \n return u","def get_camera_observation(self, t):\n if not self.enable_cameras:\n warnings.warn(\n \"Cameras are not enabled, so images in the camera observation\"\n \" are not initialized. Create `TriFingerPlatform` with\"\n \" `enable_cameras=True` to get rendered camera images.\"\n )\n\n current_t = self.simfinger._t\n\n if t < 0:\n raise ValueError(\"Cannot access time index less than zero.\")\n elif t == current_t:\n return self._camera_observation_t\n elif t == current_t + 1:\n return self._get_current_camera_observation(t)\n else:\n raise ValueError(\n \"Given time index t has to match with index of the current\"\n \" step or the next one.\"\n )","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def mTV(self):\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\n # approximated with the wing root chordplane\n return distance / (self.spanW / 2)","def step(self, dt):\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)","def target_position(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_position(path_time)","def target_velocity(self, s):\n raise NotImplementedError()","def initial_velocity(self) -> float:\n return self._initial_velocity","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def f( self , x , u , t ):\n \n dx = np.zeros(self.n) # State derivative vector\n \n ################################################\n # Place holder: put the equations of motion here\n raise NotImplementedError\n ################################################\n \n return dx","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def getXVelocity(self):\n return self._vx","def state(self, t):\n return self.mus[:, :, t + 1], self.Vs[:, :, t + 1]","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def tke(self):\n if len(self._obj.t) < 2:\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\n\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'({vel_units})^2')\n return self._obj","def __call__(self, t):\n t = t - self.min_t\n return self._ploy1d(t)","def update_position(self, event):\n\n # Create a copy of the most recent stored twist data to perform calculations\n with self.lock:\n velocity_data = copy.deepcopy(self.twist)\n\n # Time elapsed since last update position call\n if hasattr(event, 'last_real'):\n if event.last_real is None:\n time = rospy.Duration(0.05)\n else:\n time = event.current_real - event.last_real\n \n time = time.to_sec()\n\n # Calculate angle turned in the given time using omega = theta/time\n angle = velocity_data.angular.z*time\n\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\n distance = velocity_data.linear.x*time\n\n # Calculate yaw of the robot\n self.vehicle_yaw += angle\n\n # Calculate vehicle x, y, z position coordinates\n # TODO recalculate the position based on traveling in a circular arc.\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\n\n # Calculate z position using linear interpolation and create cloud array\n \n # 1. Create ranges to be used in interpolation function\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\n\n # 2. Create array of points to be converted to point cloud for vizualization\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\n terrain_x = terrain_mesh_x.ravel()\n terrain_y = terrain_mesh_y.ravel()\n terrain_z = self.gaussian_array.ravel()\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\n\n # 3. Create interpolation function based on the ranges and gaussian data\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\n\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\n # TODO compute z height based on footprint\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\n\n # Convert Euler Angles to Quarternion\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\n\n # Broadcast vehicle frame which is a child of the world frame\n br = tf.TransformBroadcaster()\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \n V_rotation, rospy.Time.now(),\"vehicle_frame\", \"map\")\n\n # Construct the homogenous transformation matrix for map to vehicle frame\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \n map_T_V[:3,3] = np.array(V_translation)\n\n # Create footprint of vehicle\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\n V_footprint_x = V_footprint_mesh_x.ravel()\n V_footprint_y = V_footprint_mesh_y.ravel()\n\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\n # and its interpolated z value. Add this point to a list of points for visualization.\n # TODO Flatten into a single matrix multiply to remove for loop\n V_viz_points = []\n for i in range(V_footprint_x.shape[0]):\n p = Point()\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\n p.x = V_footprint_point[0, 0]\n p.y = V_footprint_point[1, 0]\n p.z = V_footprint_point[2, 0]\n V_viz_points.append(p)\n\n #####################################################################################\n # Create a copy of the most recent stored JointState data to perform calculations\n with self.joint_lock:\n joint_data = copy.deepcopy(self.joint)\n\n # If the data is empty on first run, fill with 0.0\n if not joint_data.velocity:\n joint_data.velocity = [0.0,0.0]\n \n # Calculate angle based on velocity data and time\n angle = joint_data.velocity[0]*time\n angle2 = joint_data.velocity[1]*time\n\n self.joint1_pitch += angle\n self.joint2_pitch += angle2\n\n # Transformations from vehicle frame to Joint1 and Joint2\n \n # Static rotation about z-axis \n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\n translation = [0.0, 0.0, 0.0]\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\n V_T_SRz[:3,3] = np.array(translation)\n\n # Dynamic rotation about the y-axis of Joint 1\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\n [0.0, 1.0, 0.0],\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\n\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\n\n SRz_T_J1 = np.zeros((4,4))\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\n SRz_T_J1[:4,3] = trans_SRz_T_J1\n\n # Translation based on length of Joint 1 arm \n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\n translation = [self.joint1_length, 0.0, 0.0]\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\n J1_T_STx[:3,3] = np.array(translation)\n\n # Dynamic rotation about y-axis of Joint 2\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\n translation = [0.0, 0.0, 0.0]\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\n STx_T_J2[:3,3] = np.array(translation)\n\n # matrix multiplication to form the homogenous matrices\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\n\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\n\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\n ripper_tip_point_viz = Point()\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\n V_viz_points.append(ripper_tip_point_viz)\n\n # use the ripper's position as an index value to access the gaussian array\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\n\n # Create a range of index values surrounding index_x and y\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\n\n # First check if the index is within the gaussian array, if it is, then check if the tip of\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\n # it to the surrounding cells, provided those cells are also within the gaussian array\n # TODO Remove use of for loops and excess if statements\n\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\n for i in range(nearby_index_cells_x.shape[0]):\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\n \n\n # Publish all messages\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def predict(self, t : float) -> vector :\n '''@ Zstar : vector'''\n '''@ dt : float'''\n '''@ dtau : float'''\n '''@ F : array'''\n dt = t - self.t\n dtau = self._normalizeDeltaTime(dt)\n F = self.stateTransitionMatrix(self.order+1, dtau)\n Zstar = F @ self.Z;\n return Zstar;","def update(self, t, dt):\n # update boundary values\n self._apply_boundary_conditions(t,dt)\n #update current empirical wind velocity\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\n # initialise wind speed derivative arrays\n du_dt = scipy.zeros((self.nx, self.ny))\n dv_dt = scipy.zeros((self.nx, self.ny))\n # approximate spatial first derivatives with centred finite difference\n # equations for both components of wind field\n du_dx, du_dy = self._centred_first_derivs(self._u)\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\n # second derivatives with second order finite difference equations\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\n # = [sf_x-2f(x,y)] / (dx*dx)\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\n # = [sf_y-2f(x,y)] / (dy*dy)\n # second finite differences are not computed in full as the common\n # f(x,y) term in both expressions can be extracted out to reduce\n # the number of +/- operations required\n su_x, su_y = self._centred_first_sums(self._u)\n sv_x, sv_y = self._centred_first_sums(self._v)\n # use finite difference method to approximate time derivatives across\n # simulation region interior from defining PDEs\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\n self._Bx * su_x + self._By * su_y -\n self._C * self._u_int)\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\n self._Bx * sv_x + self._By * sv_y -\n self._C * self._v_int)\n # perform update with Euler integration\n self._u_int += du_dt * dt\n self._v_int += dv_dt * dt\n # update spline interpolators\n self._set_interpolators()","def present_velocity(self):\n return self._read(MX_PRESENT_VELOCITY)","def target_velocity(self, s):\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\n # self.transition += self.subpaths[self.current_path].total_length()\n # self.current_path += 1\n\n if s > self.total_length:\n s = self.total_length\n\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\n linear = np.dot(self.g, linear)\n\n return [linear, angular]"],"string":"[\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def target_velocity(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_velocity(path_time)\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def target_velocity(self, time):\\n pass\",\n \"def target_velocity(self, time):\\n pass\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def robot_arm_pos(self):\\n return self.sim.data.qpos[self.arm_index]\",\n \"def get_position(self, t0):\\n my_pos_x=np.random.uniform(-20, 20)\\n my_pos_y=np.random.uniform(-20, 20)\\n r=np.array([my_pos_x, my_pos_y])\\n x_y=np.zeros(shape=(self.no_planets-1, 2))\\n tol=1e-5\\n diff=np.zeros(self.no_planets-1)\\n for k in range(self.no_planets-1):\\n r1=np.linalg.norm(r)\\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\\n x1=0\\n y1=0\\n x2=self.positionFunction(t0)[0,k]\\n y2=self.positionFunction(t0)[1,k]\\n x3=self.positionFunction(t0)[0,k+1]\\n y3=self.positionFunction(t0)[1, k+1]\\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\\n x_y[k, 0]=x\\n x_y[k, 1]=y\\n diff[k]=difference\\n if (diff > tol).any():\\n print diff.max()\\n print \\\"Oh no, one failed :(\\\"\\n sys.exit(1)\\n print \\\"My pos x:\\\", my_pos_x\\n print \\\"My pos y:\\\", my_pos_y\\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3\",\n \"def target_velocity(self, s):\\n # YOUR CODE HERE\\n if s > self.total_length:\\n s = self.total_length\\n angular = np.array([0, 0 ,0])\\n else:\\n angular = np.array([0,0,self.targ_angular])\\n\\n theta = s/self.total_length*self.angle\\n v_x = np.cos(theta)*self.targ_speed\\n if self.left_turn:\\n v_y = np.sin(theta)*self.targ_speed\\n else:\\n v_y = -np.sin(theta)*self.targ_speed\\n \\n linear = np.array([v_x, v_y, 0])\\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\\n \\n toRet = [linear, angular]\\n \\n return toRet\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def target_position(self, time):\\n return self.target(time, self.positions, self.dt, self.num_way)\",\n \"def target_position(self, time):\\n return self.target(time, self.positions, self.dt, self.num_way)\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def target_acceleration(self, time):\\n x_a = -self.w**2*self.r*sin(self.w*time)\\n y_a = -self.w**2*self.r*cos(self.w*time)\\n z_a = 0\\n # raise NotImplementedError\\n return np.array([x_a,y_a,z_a])\",\n \"def getVelocity(self):\\n return self.v\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def target_velocity(self, s):\\n if s > self.total_length:\\n linear = np.array([0,0,0])\\n else:\\n linear = np.array([self.sign*self.targ_speed, 0, 0])\\n \\n angular = np.array([0,0,0])\\n toRet = [linear, angular]\\n\\n return toRet\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def get_velocity(self):\\n return self.momentum/self.mass\",\n \"def test_velocity(self):\\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\\n # r must contain 2 elements, otherwise the density and pressure are nan\\n r = np.array([0.7, 0.8])\\n t = 6.25e-6\\n solrt = sol(r, t)\\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def u_exact(self, t):\\n\\n # some abbreviations\\n wE = self.params.omega_E\\n wB = self.params.omega_B\\n N = self.params.nparts\\n u0 = self.params.u0\\n\\n if N != 1:\\n raise ProblemError('u_exact is only valid for a single particle')\\n\\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\\n\\n wbar = np.sqrt(2) * wE\\n\\n # position and velocity in z direction is easy to compute\\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\\n\\n # define temp. variables to compute complex position\\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\\n Rp = u0[0][0] - Rm\\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\\n Ip = u0[0][1] - Im\\n\\n # compute position in complex notation\\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n # compute velocity as time derivative of the position\\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n\\n # get the appropriate real and imaginary parts\\n u.pos[0, 0] = w.real\\n u.vel[0, 0] = dw.real\\n u.pos[1, 0] = w.imag\\n u.vel[1, 0] = dw.imag\\n\\n return u\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def get_target_tile(self):\\n if self.tank.flag is not None:\\n x, y = self.tank.start_position\\n else:\\n self.get_flag() # Ensure that we have initialized it.\\n x, y = self.flag.x, self.flag.y\\n return Vec2d(int(x), int(y))\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def relative_velocity(self):\\n return self.base_platform.relative_velocity\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def shoot(self):\\n pt = self.pt()\\n assert pt >= 0\\n m = self.mass()\\n assert m >= 0\\n sqrt_pt2_m2 = math.sqrt( pt**2 + m**2 )\\n y = self.rap()\\n e = sqrt_pt2_m2 * math.cosh(y)\\n pz = sqrt_pt2_m2 * math.sinh(y)\\n phi = self.phi()\\n px = pt * math.cos(phi);\\n py = pt * math.sin(phi);\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def orbitalVelocity( self ): # returns [m/s]\\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\\n return velocity\",\n \"def eval_2pts(self, vector, t):\\n if t < 0 or t > 1:\\n raise Exception(\\\"Cannot Eval \\\", e, \\\" with t=\\\", t, \\\": t Should Satisfy 0<=t<=1.\\\")\\n else:\\n return Vector((1-t)*self.x + t*vector.x, (1-t)*self.y + t*vector.y, (1-t)*self.z + t*vector.z)\",\n \"def getTopLeftVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = (0,0,0)\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\",\n \"def velocity(self):\\n return self._velocity\",\n \"def velocity(self):\\n return self._velocity\",\n \"def compute_velocity(self, time_since_last_frame: float) -> None:\\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\\n self.velocity_kts = (true_dist /\\n self.secs_since_last_seen) / 1.94384\\n self.cart_coords = new_cart_coords\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def move(self, t):\\n if self.visible == True:\\n self.x += self.vx * t\\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\\n\\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\\n self.phi = t * v_norm / self.radius\\n\\n glPushMatrix()\\n glLoadIdentity()\\n\\n if v_norm > 0.0:\\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\\n glMultMatrixd(self.matrix)\\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n\\n glPopMatrix()\\n\\n # Friction!!! Could do it as global parameter\\n if v_norm > 0.0:\\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\\n\\n if v_prime_norm < 0.0:\\n v_prime_norm = 0.0\\n\\n self.vx *= v_prime_norm / v_norm\\n self.vy *= v_prime_norm / v_norm\\n\\n return True\\n # Add comment\\n return False\",\n \"def get_velocity(self):\\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s\",\n \"def shoot(self):\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n theta = self.theta()\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def shoot(self):\\n e = self.energy()\\n y = self.rap()\\n sqrt_pt2_m2 = e / math.cosh(y)\\n pz = sqrt_pt2_m2 * math.sinh(y)\\n m = self.mass()\\n pt = math.sqrt( sqrt_pt2_m2**2 - m**2 )\\n phi = self.phi()\\n px = pt * math.cos(phi);\\n py = pt * math.sin(phi);\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def getVelocity(self):\\n\\n return self.vel\",\n \"def shoot(self):\\n theta = self.theta()\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def velocity(self):\\n return self.base_platform.velocity\",\n \"def get_vsolar(self):\\n return self.read_register(4098, 1, 3)\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def compute_observation(self):\\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\\n robotEuler = p.getEulerFromQuaternion(robotOrn)\\n linear, angular = p.getBaseVelocity(self.botId)\\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))\",\n \"def get_angular_velocity(r, T):\\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\\n # velocity = 2(pi)r/T\\n return (2*math.pi*r)/T\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def _get_next_velocity(self):\\n\\n self._predict_state()\\n\\n # curr = pos_quat_to_euler(self.curr_quat)\\n dest = pos_quat_to_euler(self.dest_quat_predict)\\n error = self.calc_error(self.dest_quat_predict)\\n # TODO error should be computed for phi, th axis individually\\n\\n # TODO recommend_velocity to reach desired setpoint at a given velocity\\n phi_vel = self.motor_phi.recommend_velocity(dest[0])\\n th_vel = self.motor_th .recommend_velocity(dest[1])\\n\\n if error < 0.05:\\n return 0.0, 0.0\\n\\n # TODO this is lame\\n #scale = error * 4\\n #phi_vel = scale * phi_vel\\n #th_vel = scale * th_vel\\n\\n return phi_vel, th_vel\\n\\n # TODO PID (control algo)... or should it be handled closer to motors?\\n # TODO Path planning\\n # TODO Velocity-accel curve to estimate time required to get to point\\n # - Cache its integral and use as lookup to estimate if we can get\\n # to point without overshoot\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def distance(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.position(rf), t.position(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def position(self, l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n pos = x + v * t + (1/2.0) * g * t**2\\n \\n if squeeze:\\n pos = np.squeeze(pos, axis=0)\\n return pos\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def t2u(self, t ):\\n \\n if t < self.time_final:\\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n u = self.u_sol[i,:]\\n \\n else:\\n u = self.ubar\\n \\n return u\",\n \"def get_camera_observation(self, t):\\n if not self.enable_cameras:\\n warnings.warn(\\n \\\"Cameras are not enabled, so images in the camera observation\\\"\\n \\\" are not initialized. Create `TriFingerPlatform` with\\\"\\n \\\" `enable_cameras=True` to get rendered camera images.\\\"\\n )\\n\\n current_t = self.simfinger._t\\n\\n if t < 0:\\n raise ValueError(\\\"Cannot access time index less than zero.\\\")\\n elif t == current_t:\\n return self._camera_observation_t\\n elif t == current_t + 1:\\n return self._get_current_camera_observation(t)\\n else:\\n raise ValueError(\\n \\\"Given time index t has to match with index of the current\\\"\\n \\\" step or the next one.\\\"\\n )\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def mTV(self):\\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\\n # approximated with the wing root chordplane\\n return distance / (self.spanW / 2)\",\n \"def step(self, dt):\\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)\",\n \"def target_position(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_position(path_time)\",\n \"def target_velocity(self, s):\\n raise NotImplementedError()\",\n \"def initial_velocity(self) -> float:\\n return self._initial_velocity\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def f( self , x , u , t ):\\n \\n dx = np.zeros(self.n) # State derivative vector\\n \\n ################################################\\n # Place holder: put the equations of motion here\\n raise NotImplementedError\\n ################################################\\n \\n return dx\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def getXVelocity(self):\\n return self._vx\",\n \"def state(self, t):\\n return self.mus[:, :, t + 1], self.Vs[:, :, t + 1]\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def tke(self):\\n if len(self._obj.t) < 2:\\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\\n\\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\\\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'({vel_units})^2')\\n return self._obj\",\n \"def __call__(self, t):\\n t = t - self.min_t\\n return self._ploy1d(t)\",\n \"def update_position(self, event):\\n\\n # Create a copy of the most recent stored twist data to perform calculations\\n with self.lock:\\n velocity_data = copy.deepcopy(self.twist)\\n\\n # Time elapsed since last update position call\\n if hasattr(event, 'last_real'):\\n if event.last_real is None:\\n time = rospy.Duration(0.05)\\n else:\\n time = event.current_real - event.last_real\\n \\n time = time.to_sec()\\n\\n # Calculate angle turned in the given time using omega = theta/time\\n angle = velocity_data.angular.z*time\\n\\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\\n distance = velocity_data.linear.x*time\\n\\n # Calculate yaw of the robot\\n self.vehicle_yaw += angle\\n\\n # Calculate vehicle x, y, z position coordinates\\n # TODO recalculate the position based on traveling in a circular arc.\\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\\n\\n # Calculate z position using linear interpolation and create cloud array\\n \\n # 1. Create ranges to be used in interpolation function\\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\\n\\n # 2. Create array of points to be converted to point cloud for vizualization\\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\\n terrain_x = terrain_mesh_x.ravel()\\n terrain_y = terrain_mesh_y.ravel()\\n terrain_z = self.gaussian_array.ravel()\\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\\n\\n # 3. Create interpolation function based on the ranges and gaussian data\\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\\n\\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\\n # TODO compute z height based on footprint\\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\\n\\n # Convert Euler Angles to Quarternion\\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\\n\\n # Broadcast vehicle frame which is a child of the world frame\\n br = tf.TransformBroadcaster()\\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \\n V_rotation, rospy.Time.now(),\\\"vehicle_frame\\\", \\\"map\\\")\\n\\n # Construct the homogenous transformation matrix for map to vehicle frame\\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \\n map_T_V[:3,3] = np.array(V_translation)\\n\\n # Create footprint of vehicle\\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\\n V_footprint_x = V_footprint_mesh_x.ravel()\\n V_footprint_y = V_footprint_mesh_y.ravel()\\n\\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\\n # and its interpolated z value. Add this point to a list of points for visualization.\\n # TODO Flatten into a single matrix multiply to remove for loop\\n V_viz_points = []\\n for i in range(V_footprint_x.shape[0]):\\n p = Point()\\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\\n p.x = V_footprint_point[0, 0]\\n p.y = V_footprint_point[1, 0]\\n p.z = V_footprint_point[2, 0]\\n V_viz_points.append(p)\\n\\n #####################################################################################\\n # Create a copy of the most recent stored JointState data to perform calculations\\n with self.joint_lock:\\n joint_data = copy.deepcopy(self.joint)\\n\\n # If the data is empty on first run, fill with 0.0\\n if not joint_data.velocity:\\n joint_data.velocity = [0.0,0.0]\\n \\n # Calculate angle based on velocity data and time\\n angle = joint_data.velocity[0]*time\\n angle2 = joint_data.velocity[1]*time\\n\\n self.joint1_pitch += angle\\n self.joint2_pitch += angle2\\n\\n # Transformations from vehicle frame to Joint1 and Joint2\\n \\n # Static rotation about z-axis \\n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\\n translation = [0.0, 0.0, 0.0]\\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\\n V_T_SRz[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about the y-axis of Joint 1\\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\\n [0.0, 1.0, 0.0],\\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\\n\\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\\n\\n SRz_T_J1 = np.zeros((4,4))\\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\\n SRz_T_J1[:4,3] = trans_SRz_T_J1\\n\\n # Translation based on length of Joint 1 arm \\n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\\n translation = [self.joint1_length, 0.0, 0.0]\\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\\n J1_T_STx[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about y-axis of Joint 2\\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\\n translation = [0.0, 0.0, 0.0]\\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\\n STx_T_J2[:3,3] = np.array(translation)\\n\\n # matrix multiplication to form the homogenous matrices\\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\\n\\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\\n\\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\\n ripper_tip_point_viz = Point()\\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\\n V_viz_points.append(ripper_tip_point_viz)\\n\\n # use the ripper's position as an index value to access the gaussian array\\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\\n\\n # Create a range of index values surrounding index_x and y\\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\\n\\n # First check if the index is within the gaussian array, if it is, then check if the tip of\\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\\n # it to the surrounding cells, provided those cells are also within the gaussian array\\n # TODO Remove use of for loops and excess if statements\\n\\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\\n for i in range(nearby_index_cells_x.shape[0]):\\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\\n \\n\\n # Publish all messages\\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def predict(self, t : float) -> vector :\\n '''@ Zstar : vector'''\\n '''@ dt : float'''\\n '''@ dtau : float'''\\n '''@ F : array'''\\n dt = t - self.t\\n dtau = self._normalizeDeltaTime(dt)\\n F = self.stateTransitionMatrix(self.order+1, dtau)\\n Zstar = F @ self.Z;\\n return Zstar;\",\n \"def update(self, t, dt):\\n # update boundary values\\n self._apply_boundary_conditions(t,dt)\\n #update current empirical wind velocity\\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\\n # initialise wind speed derivative arrays\\n du_dt = scipy.zeros((self.nx, self.ny))\\n dv_dt = scipy.zeros((self.nx, self.ny))\\n # approximate spatial first derivatives with centred finite difference\\n # equations for both components of wind field\\n du_dx, du_dy = self._centred_first_derivs(self._u)\\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\\n # second derivatives with second order finite difference equations\\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\\n # = [sf_x-2f(x,y)] / (dx*dx)\\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\\n # = [sf_y-2f(x,y)] / (dy*dy)\\n # second finite differences are not computed in full as the common\\n # f(x,y) term in both expressions can be extracted out to reduce\\n # the number of +/- operations required\\n su_x, su_y = self._centred_first_sums(self._u)\\n sv_x, sv_y = self._centred_first_sums(self._v)\\n # use finite difference method to approximate time derivatives across\\n # simulation region interior from defining PDEs\\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\\n self._Bx * su_x + self._By * su_y -\\n self._C * self._u_int)\\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\\n self._Bx * sv_x + self._By * sv_y -\\n self._C * self._v_int)\\n # perform update with Euler integration\\n self._u_int += du_dt * dt\\n self._v_int += dv_dt * dt\\n # update spline interpolators\\n self._set_interpolators()\",\n \"def present_velocity(self):\\n return self._read(MX_PRESENT_VELOCITY)\",\n \"def target_velocity(self, s):\\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\\n # self.transition += self.subpaths[self.current_path].total_length()\\n # self.current_path += 1\\n\\n if s > self.total_length:\\n s = self.total_length\\n\\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\\n linear = np.dot(self.g, linear)\\n\\n return [linear, angular]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7266593","0.649724","0.64403063","0.6348583","0.63289547","0.63289547","0.6319826","0.62879527","0.62594193","0.6220879","0.62026346","0.61803794","0.61693144","0.6166686","0.6114781","0.6070687","0.6070687","0.6061902","0.60361063","0.59944755","0.59561765","0.5931238","0.5927597","0.5917937","0.59013146","0.58943117","0.58943117","0.5882164","0.587323","0.58715063","0.586134","0.58551997","0.5852569","0.58368766","0.58335805","0.5797316","0.57820654","0.577693","0.5767607","0.57643074","0.57419","0.57340986","0.5693993","0.5689291","0.5678971","0.56712","0.56560403","0.5648199","0.56448835","0.5642814","0.56396085","0.56396085","0.5636548","0.5615795","0.5607865","0.5603468","0.5602153","0.55894315","0.5572371","0.5569519","0.5567448","0.55625075","0.55592006","0.55586576","0.5556144","0.55533576","0.5546564","0.5540163","0.55156326","0.5511587","0.5503018","0.55027556","0.5489997","0.5489666","0.5487341","0.54558575","0.5439748","0.5430346","0.5421015","0.5418774","0.5409859","0.54051816","0.54039884","0.5401532","0.5396253","0.5395646","0.539228","0.5391394","0.53846157","0.53750545","0.5373591","0.53727835","0.53703547","0.53642565","0.53549933","0.53540766","0.53521365","0.53504103","0.53419006","0.5337168"],"string":"[\n \"0.7266593\",\n \"0.649724\",\n \"0.64403063\",\n \"0.6348583\",\n \"0.63289547\",\n \"0.63289547\",\n \"0.6319826\",\n \"0.62879527\",\n \"0.62594193\",\n \"0.6220879\",\n \"0.62026346\",\n \"0.61803794\",\n \"0.61693144\",\n \"0.6166686\",\n \"0.6114781\",\n \"0.6070687\",\n \"0.6070687\",\n \"0.6061902\",\n \"0.60361063\",\n \"0.59944755\",\n \"0.59561765\",\n \"0.5931238\",\n \"0.5927597\",\n \"0.5917937\",\n \"0.59013146\",\n \"0.58943117\",\n \"0.58943117\",\n \"0.5882164\",\n \"0.587323\",\n \"0.58715063\",\n \"0.586134\",\n \"0.58551997\",\n \"0.5852569\",\n \"0.58368766\",\n \"0.58335805\",\n \"0.5797316\",\n \"0.57820654\",\n \"0.577693\",\n \"0.5767607\",\n \"0.57643074\",\n \"0.57419\",\n \"0.57340986\",\n \"0.5693993\",\n \"0.5689291\",\n \"0.5678971\",\n \"0.56712\",\n \"0.56560403\",\n \"0.5648199\",\n \"0.56448835\",\n \"0.5642814\",\n \"0.56396085\",\n \"0.56396085\",\n \"0.5636548\",\n \"0.5615795\",\n \"0.5607865\",\n \"0.5603468\",\n \"0.5602153\",\n \"0.55894315\",\n \"0.5572371\",\n \"0.5569519\",\n \"0.5567448\",\n \"0.55625075\",\n \"0.55592006\",\n \"0.55586576\",\n \"0.5556144\",\n \"0.55533576\",\n \"0.5546564\",\n \"0.5540163\",\n \"0.55156326\",\n \"0.5511587\",\n \"0.5503018\",\n \"0.55027556\",\n \"0.5489997\",\n \"0.5489666\",\n \"0.5487341\",\n \"0.54558575\",\n \"0.5439748\",\n \"0.5430346\",\n \"0.5421015\",\n \"0.5418774\",\n \"0.5409859\",\n \"0.54051816\",\n \"0.54039884\",\n \"0.5401532\",\n \"0.5396253\",\n \"0.5395646\",\n \"0.539228\",\n \"0.5391394\",\n \"0.53846157\",\n \"0.53750545\",\n \"0.5373591\",\n \"0.53727835\",\n \"0.53703547\",\n \"0.53642565\",\n \"0.53549933\",\n \"0.53540766\",\n \"0.53521365\",\n \"0.53504103\",\n \"0.53419006\",\n \"0.5337168\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.592703"},"document_rank":{"kind":"string","value":"23"}}},{"rowIdx":20289,"cells":{"query":{"kind":"string","value":"Returns the arm's desired x,y,z acceleration in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_velocity()"},"document":{"kind":"string","value":"def target_acceleration(self, time):\n return np.array([0, 0, 0])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])","def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def acceleration(v,u,t):\n return ((v-u)/t)","def acceleration(self):\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n \n ax = self._obj['u']*ux + self._obj['v']*uy\n ay = self._obj['u']*vx + self._obj['v']*vy\n\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\n\n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'{vel_units}^2')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\n\n\n return self._obj","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def get_acceleration(self,v,el,T_s,T_i):\n\n rad = radiation.Radiation()\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n g = rad.getGravity(el)\n\n\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\n\n Cd = .5 # Drag Coefficient\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\n\n if F_d > 0:\n F_d = F_d * self.Upsilon\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\n\n return accel","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def target_acceleration(self, time):\n #return np.array([0, 0, 0])\n if time <= self.total_time/4:\n return self.path1.target_acceleration(time)\n elif time <= self.total_time/2:\n return self.path2.target_acceleration(time)\n elif time <= self.total_time/4*3:\n return self.path3.target_acceleration(time)\n else:\n return self.path4.target_acceleration(time)","def target_acceleration(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_acceleration(path_time)","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def acceleration(self):\n return self.__accel","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def _compute_solar_torque(self):\n pass","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def to_cart(self, t):\n # mean motion:\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\n # mean anomaly at t:\n M = n * (t - self.t0) + self.M0\n # print(np.fmod(M, 2*np.pi))\n # solve Kepler equation, get eccentric anomaly:\n E = self.kepler(self.e, M)\n cosE = np.cos(E)\n sinE = np.sin(E)\n # get true anomaly and distance from focus:\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\n # r = self.a*(1 - self.e*cosE)\n #\n sinw = np.sin(self.w)\n cosw = np.cos(self.w)\n sinu = sinw * cosv + cosw * sinv\n cosu = cosw * cosv - sinw * sinv\n # position\n cosNode = np.cos(self.Node)\n sinNode = np.sin(self.Node)\n cosi = np.cos(self.i)\n sini = np.sin(self.i)\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\n z = r * sinu * sini\n # velocity\n p = self.a * (1.0 - self.e ** 2)\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\n vz = z * V_1 / r + cosu * sini * V_2\n\n state = np.array([x, y, z, vx, vy, vz])\n state = np.reshape(np.asarray(state), (3, 2), 'F')\n\n return state","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def advanceVelocity(self,time,acceleration):\n if not isinstance(acceleration,Cartesian3DVector):\n raise CoordinateException(\"Advancing particle momentum with the incorrect acceleration type.\")\n return self.v + time*acceleration","def acceleration(self):\n # speed is by formula: x axis speed: by cos of the heading and y\n # axis by sine of the heading\n self.x_speed += math.cos(math.radians(self.degrees))\n self.y_speed += math.sin(math.radians(self.degrees))","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def compute_acceleration(self, x, y):\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\n return np.array([a_x, a_y])","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def tidal_acc(self, xyz):\r\n assert(xyz.shape[1] == 3)\r\n\r\n # create solar mass variable, if not already extant\r\n try:\r\n self.M\r\n except AttributeError:\r\n self.M = Constant(2e33) # solar mass in g\r\n\r\n # get the vector of x-values\r\n x = xyz[:, 0]\r\n\r\n # create an all-zero force vector\r\n acc = np.zeros_like(xyz)\r\n\r\n # get the heliocentric distance at the current time\r\n dist = self.trajectory(self.t)\r\n\r\n # get the acceleration as the difference between the acceleration at\r\n # the points and the acceleration at the c.o.m.\r\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\r\n return(acc)","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def predict(self, t : float) -> vector :\n '''@ Zstar : vector'''\n '''@ dt : float'''\n '''@ dtau : float'''\n '''@ F : array'''\n dt = t - self.t\n dtau = self._normalizeDeltaTime(dt)\n F = self.stateTransitionMatrix(self.order+1, dtau)\n Zstar = F @ self.Z;\n return Zstar;","def get_acceleration(self):\n return self.acceleration","def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\n\n #project forwards in time\n sim_interval = self.sim_interval\n sim_interval_sq = sim_interval*sim_interval\n cmd_vel = list(cmd_vel)\n current_speed = list(current_speed)\n\n max_acc_x = self.robot.max_acc_x\n max_acc_th = self.robot.max_acc_th\n max_decc_x = self.robot.max_dacc_x\n max_decc_th = self.robot.max_dacc_th\n\n\n code = \"\"\"\n double x, y, th;\n x = y = th = 0;\n\n double vx, vth;\n vx = current_speed[0];\n vth = current_speed[1];\n\n double cmd_x = cmd_vel[0];\n double cmd_th = cmd_vel[1];\n\n //are we accelerating or decelerating?\n double acc_x;\n double acc_th;\n\n bool b_ax = false;\n if (cmd_x > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = accs[2];\n acc_x = -1*acc_x;\n }\n\n bool b_ath = false;\n if (cmd_th > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1* (double) accs[3];\n\n }\n\n py::list traj;\n\n //delay at the beginning\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //application of the command\n for (double i=0; i<=time_applied; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //delay before decellerating\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //now we apply a stop\n b_ax = false;\n if (0 > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = -1 * (double) accs[2];\n }\n\n b_ath = false;\n if (0 > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1 * (double) accs[3];\n }\n\n for (double i=0; i<=time_decc; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx) < 1e-6) vx = 0;\n\n //check if we have exceeded our target\n if (b_ax && (vx > 0 )) vx = 0;\n if (!b_ax && (vx < 0 )) vx = 0;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth) < 1e-6) vth = 0;\n if (b_ath && (vth > 0 )) vth = 0;\n if (!b_ath && (vth < 0 )) vth = 0;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n\n\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\n if (stopped) break;\n\n }\n\n return_val = traj;\n \"\"\"\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\n 'time_decc'], type_converters=converters.blitz)\n\n return traj","def update_rk3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n try:\n\n kap1 = (self.vel, self.force(self.pos,\n self.vel,\n self.time))\n\n pos = self.pos+0.5*delta_t*kap1[0]\n vel = self.vel+0.5*delta_t*kap1[1]\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n 0.5*delta_t, drag=False)\n\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\n\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\n\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n except Collision.CollisionException as col:\n col.vel = self.vel+col.delta_t*kap1[0]\n raise col\n\n self.time += self.delta_t","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def _get_alpha(self, m_t, v_t):\n return max(0, ((-m_t * self._psi \n + math.sqrt((m_t ** 2 * self._phi ** 4) \n / 4 + v_t * self._phi ** 2 * self._xi)) \n / (v_t * self._xi)))","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def update_ab3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 2:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.set_old(kap, 2)\n\n self.time += delta_t\n\n else:\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\n\n try:\n tmp = [self.get_old(0)]\n except IndexError:\n tmp = []\n kap = update_ab2(self)\n if tmp:\n self._old = self._old + tmp\n\n return kap","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def target_velocity(self, time):\n\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\n\n return avg_vel","def target_acceleration(self, time):\n pass","def target_acceleration(self, time):\n pass","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def update(self, t=1):\n\n\t\t# Update acceleration based on available fuel & throttle\n\t\tthrottle = self.throttle if self.fuel >= 1 else self.throttle * self.fuel\n\t\tself.acceleration = self.thrust * throttle / self.total_mass - GRAVITY\n\n\t\tself.velocity += self.acceleration / t\n\t\tself.altitude += self.velocity / t\n\t\t\n\t\t# Collide with the ground\n\t\tif self.altitude <= 0:\n\t\t\tself.reset_motion()\n\n\t\t# Update remaining fuel\n\t\tif self.fuel * t >= self.throttle:\n\t\t\tself.fuel -= self.throttle * self.fuel_consumption / t\n\t\t\tif self.fuel < 0:\n\t\t\t\tself.fuel = 0","def get_control_input(self, dt):\n \n desired_z = 3.0\n actual_z = self.internal_state.transform.translation.z\n \n # Convert to quaternion object for use by euler_from_quaternion()\n quaternion = np.array([self.internal_state.transform.rotation.x,\n self.internal_state.transform.rotation.y,\n self.internal_state.transform.rotation.z,\n self.internal_state.transform.rotation.w])\n \n # Determine the euler angles\n euler = euler_from_quaternion(quaternion)\n roll = euler[0]\n pitch = euler[1]\n yaw = euler[2]\n \n # Corrections for yaw wrap around\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \n np.abs(np.abs(yaw) - np.pi) < 0.2):\n # Add or subtract 2 pi depending on crossing direction\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \n \n \n # Determine current yaw rate for yaw rate controller\n yaw_rate = (yaw - self.yaw_old) / dt\n \n # After use, update the old yaw value with the current yaw\n self.yaw_old = yaw\n \n # Determine current climb rate\n climb_rate = (actual_z - self.z_old) / dt\n \n # After use, update the old altitude with the current altitude\n self.z_old = actual_z\n \n # Find the errors between desired and actual signals\n err_roll = self.desired_roll - roll\n err_pitch = self.desired_pitch - pitch\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\n err_climb_rate = self.desired_climb_rate - climb_rate\n \n # Set the hover motor speed\n motor_control = self.hover_speed * self.unit_hover_cmd\n \n # Roll controller\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\n \n # Pitch controller\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\n \n # Yaw rate controller (assuming small angles)\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\n \n # Climb rate controller\n motor_control += ((self.climb_Pgain * err_climb_rate +\n self.climb_Igain * self.internal_climb_error +\n self.climb_Dgain / dt * (err_climb_rate - \n self.internal_old_climb_rate_error)) * \n self.unit_hover_cmd)\n \n # Update the cumulative errors for integration\n self.internal_roll_error += err_roll * dt\n self.internal_pitch_error += err_pitch * dt\n self.internal_yaw_error += err_yaw_rate * dt\n self.internal_climb_error += err_climb_rate * dt\n \n # Update old error with current errors for differentiation\n self.internal_old_roll_error = err_roll\n self.internal_old_pitch_error = err_pitch\n self.internal_old_yaw_rate_error = err_yaw_rate\n self.internal_old_climb_rate_error = err_climb_rate\n \n \n # Return the minimum of the \n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)","def evaluate(self, _t):\n\n temp = self.init_temp - (self.decay*_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def calculate_acceleration(self) -> np.array:\n F = self.calculate_net_force()\n m = self.mass\n a = F / m\n\n return a","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def get_current_thrust_direction(self,\n time: float) -> np.array:\n # Interpolate with time\n angle = self.thrust_angle_interpolator.interpolate(time)\n # Set thrust in vertical frame and transpose it\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\n # Update flight conditions (this is needed to let tudat know to update all variables)\n self.vehicle_body.flight_conditions.update_conditions(time)\n # Get aerodynamic angle calculator\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\n frames.AerodynamicsReferenceFrames.vertical_frame,\n frames.AerodynamicsReferenceFrames.inertial_frame)\n # Compute the thrust in the inertial frame\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\n thrust_direction_vertical_frame)\n return thrust_inertial_frame","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def move(self, t):\n if self.visible == True:\n self.x += self.vx * t\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\n\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\n self.phi = t * v_norm / self.radius\n\n glPushMatrix()\n glLoadIdentity()\n\n if v_norm > 0.0:\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\n glMultMatrixd(self.matrix)\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\n\n glPopMatrix()\n\n # Friction!!! Could do it as global parameter\n if v_norm > 0.0:\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\n\n if v_prime_norm < 0.0:\n v_prime_norm = 0.0\n\n self.vx *= v_prime_norm / v_norm\n self.vy *= v_prime_norm / v_norm\n\n return True\n # Add comment\n return False","def u_exact(self, t):\n\n # some abbreviations\n wE = self.params.omega_E\n wB = self.params.omega_B\n N = self.params.nparts\n u0 = self.params.u0\n\n if N != 1:\n raise ProblemError('u_exact is only valid for a single particle')\n\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\n\n wbar = np.sqrt(2) * wE\n\n # position and velocity in z direction is easy to compute\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\n\n # define temp. variables to compute complex position\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\n Rp = u0[0][0] - Rm\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\n Ip = u0[0][1] - Im\n\n # compute position in complex notation\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n # compute velocity as time derivative of the position\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n\n # get the appropriate real and imaginary parts\n u.pos[0, 0] = w.real\n u.vel[0, 0] = dw.real\n u.pos[1, 0] = w.imag\n u.vel[1, 0] = dw.imag\n\n return u","def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation","def get_position(self, t0):\n my_pos_x=np.random.uniform(-20, 20)\n my_pos_y=np.random.uniform(-20, 20)\n r=np.array([my_pos_x, my_pos_y])\n x_y=np.zeros(shape=(self.no_planets-1, 2))\n tol=1e-5\n diff=np.zeros(self.no_planets-1)\n for k in range(self.no_planets-1):\n r1=np.linalg.norm(r)\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\n x1=0\n y1=0\n x2=self.positionFunction(t0)[0,k]\n y2=self.positionFunction(t0)[1,k]\n x3=self.positionFunction(t0)[0,k+1]\n y3=self.positionFunction(t0)[1, k+1]\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\n x_y[k, 0]=x\n x_y[k, 1]=y\n diff[k]=difference\n if (diff > tol).any():\n print diff.max()\n print \"Oh no, one failed :(\"\n sys.exit(1)\n print \"My pos x:\", my_pos_x\n print \"My pos y:\", my_pos_y\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def forward_kinematics(self):\n temp_T = Matrix.eye(3)\n for i in range(len(self.lengths)):\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\n temp_T = temp_T * angle_mat * len_mat\n \n self.final_T = np.array(temp_T,dtype=float)\n \n return self.final_T","def position(t):\n return c + tangent_vec * 7 * t ** 2","def f( self , x , u , t ):\n \n dx = np.zeros(self.n) # State derivative vector\n \n ################################################\n # Place holder: put the equations of motion here\n raise NotImplementedError\n ################################################\n \n return dx","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def evaluate(self, _t):\n\n temp = self.init_temp*(self.decay**_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def motors_update(t, x, u, params={}):\n tm = params['motor']['tm'] # Motor torque constant\n cr = params['motor']['cr'] # Motor speed constant\n wb = params['motor']['wb'] # Motor base speed\n\n u = np.clip(u / 199999, 0, 1)\n accel = [(cr * throttle + wb - speed) / tm for throttle, speed in zip(u, x)]\n\n return accel","def get_D_C3H8_air(self, T):\n\n self.set_TempPres_dependents(T)\n\n self.D_C3H8_air = (\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\n )\n\n return self.D_C3H8_air","def thetas (self,lag):\n tanthetas = [0,0,0]\n for k in range(3,self.n):\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\n tanthetas.append(tantheta_k)\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles","def spaceship_acceleration_x(dt, rotation):\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))","def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\r\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\r\n * c)) ** 2) - 1.0)\r\n self.xa_track.append(x)\r\n p = qe * self.t[i]\r\n self.pa.append(p)\r\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\r\n jv = self.t[i] * qe / (m * c)\r\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\r\n self.va.append(v)\r\n print 'Analytical solution of the differential equation of motion'","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def acc(x: float, v: float, t: float) -> float:\n return -k*v - np.sin(x) + c*np.cos(omega*t)","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def initial_velocity(self) -> float:\n return self._initial_velocity","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def compute_velocity(self, time_since_last_frame: float) -> None:\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\n self.velocity_kts = (true_dist /\n self.secs_since_last_seen) / 1.94384\n self.cart_coords = new_cart_coords","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def integrate(self, t):\n t0 = self.t0\n if t-t0 <= self.max_step_size:\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \n \n else :\n n = (t-t0) / self.max_step_size\n dt = (t-t0)/int(n+1)\n \n while t0 < t :\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\n t0 += dt\n \n return self.y0","def UpdateCromer(self, deltaT):\n self.velocity += self.acceleration * deltaT\n self.position += self.velocity * deltaT","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n theta_t = self.get_ik(self.target_position(t))\n # print(self.target_position(t))\n #theta_t = np.array(theta_t)\n # print(theta_t)\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here? cause you're mean\n\n point.positions = theta_t\n point.velocities = (theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def verlet_next_pos(pos_t,vel_t,accel_t,dt):\n pos_t_plus_dt = pos_t.copy()\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \n\n return pos_t_plus_dt","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def _compute_gravity_torque(self):\n pass","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\n \n error_x = goal_x - curr_x\n error_y = goal_y - curr_y\n error_z = goal_z - curr_z\n error_rot_z = goal_rot_z - curr_rot_z\n\n self.output_x = 0.0\n self.output_y = 0.0\n self.output_z = 0.0\n self.output_rot_z = 0.0\n\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\n # self.current_time = time.time()\n self.current_time = rospy.get_time()\n delta_time = self.current_time - self.last_time\n delta_error_x = error_x - self.last_error_x\n delta_error_y = error_y - self.last_error_y\n delta_error_z = error_z - self.last_error_z\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\n\n # print(\"delta_time:\", delta_time)\n\n if (delta_time >= self.sample_time):\n self.PTerm_x = self.Kp_x * error_x\n self.PTerm_y = self.Kp_y * error_y\n self.PTerm_z = self.Kp_z * error_z\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\n\n self.ITerm_x += error_x * delta_time\n self.ITerm_y += error_y * delta_time\n self.ITerm_z += error_z * delta_time\n self.ITerm_rot_z += error_rot_z * delta_time\n\n if (self.ITerm_x < -self.windup_guard):\n self.ITerm_x = -self.windup_guard\n elif (self.ITerm_x > self.windup_guard):\n self.ITerm_x = self.windup_guard\n \n if (self.ITerm_y < -self.windup_guard):\n self.ITerm_y = -self.windup_guard\n elif (self.ITerm_y > self.windup_guard):\n self.ITerm_y = self.windup_guard\n\n if (self.ITerm_z < -self.windup_guard):\n self.ITerm_z = -self.windup_guard\n elif (self.ITerm_z > self.windup_guard):\n self.ITerm_z = self.windup_guard\n \n if (self.ITerm_rot_z < -self.windup_guard):\n self.ITerm_rot_z = -self.windup_guard\n elif (self.ITerm_rot_z > self.windup_guard):\n self.ITerm_rot_z = self.windup_guard\n\n self.DTerm_x = 0.0\n self.DTerm_y = 0.0\n self.DTerm_z = 0.0\n self.DTerm_rot_z = 0.0\n if delta_time > 0:\n self.DTerm_x = delta_error_x / delta_time\n self.DTerm_y = delta_error_y / delta_time\n self.DTerm_z = delta_error_z / delta_time\n self.DTerm_rot_z = delta_error_rot_z / delta_time\n\n\n # Remember last time and last error for next calculation\n self.last_time = self.current_time\n self.last_error_x = error_x\n self.last_error_y = error_y\n self.last_error_z = error_z\n self.last_error_rot_z = error_rot_z\n\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\n \n return self.output_x, self.output_y, self.output_z, self.output_rot_z","def __call__(self,\n x0: Union[float, np.ndarray],\n xt: Union[float, np.ndarray],\n t: float) -> Union[float, np.ndarray]:\n sig2t = (self._model.diffusion(x0, t) ** 2) * 2 * t\n mut = x0 + self._model.drift(x0, t) * t\n return np.exp(-(xt - mut) ** 2 / sig2t) / np.sqrt(np.pi * sig2t)"],"string":"[\n \"def target_acceleration(self, time):\\n x_a = -self.w**2*self.r*sin(self.w*time)\\n y_a = -self.w**2*self.r*cos(self.w*time)\\n z_a = 0\\n # raise NotImplementedError\\n return np.array([x_a,y_a,z_a])\",\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def acceleration(self):\\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n \\n ax = self._obj['u']*ux + self._obj['v']*uy\\n ay = self._obj['u']*vx + self._obj['v']*vy\\n\\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\\n\\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'{vel_units}^2')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\\n\\n\\n return self._obj\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def get_acceleration(self,v,el,T_s,T_i):\\n\\n rad = radiation.Radiation()\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n g = rad.getGravity(el)\\n\\n\\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\\n\\n Cd = .5 # Drag Coefficient\\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\\n\\n if F_d > 0:\\n F_d = F_d * self.Upsilon\\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\\n\\n return accel\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def target_acceleration(self, time):\\n #return np.array([0, 0, 0])\\n if time <= self.total_time/4:\\n return self.path1.target_acceleration(time)\\n elif time <= self.total_time/2:\\n return self.path2.target_acceleration(time)\\n elif time <= self.total_time/4*3:\\n return self.path3.target_acceleration(time)\\n else:\\n return self.path4.target_acceleration(time)\",\n \"def target_acceleration(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_acceleration(path_time)\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def acceleration(self):\\n return self.__accel\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def to_cart(self, t):\\n # mean motion:\\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\\n # mean anomaly at t:\\n M = n * (t - self.t0) + self.M0\\n # print(np.fmod(M, 2*np.pi))\\n # solve Kepler equation, get eccentric anomaly:\\n E = self.kepler(self.e, M)\\n cosE = np.cos(E)\\n sinE = np.sin(E)\\n # get true anomaly and distance from focus:\\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\\n # r = self.a*(1 - self.e*cosE)\\n #\\n sinw = np.sin(self.w)\\n cosw = np.cos(self.w)\\n sinu = sinw * cosv + cosw * sinv\\n cosu = cosw * cosv - sinw * sinv\\n # position\\n cosNode = np.cos(self.Node)\\n sinNode = np.sin(self.Node)\\n cosi = np.cos(self.i)\\n sini = np.sin(self.i)\\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\\n z = r * sinu * sini\\n # velocity\\n p = self.a * (1.0 - self.e ** 2)\\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\\n vz = z * V_1 / r + cosu * sini * V_2\\n\\n state = np.array([x, y, z, vx, vy, vz])\\n state = np.reshape(np.asarray(state), (3, 2), 'F')\\n\\n return state\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def advanceVelocity(self,time,acceleration):\\n if not isinstance(acceleration,Cartesian3DVector):\\n raise CoordinateException(\\\"Advancing particle momentum with the incorrect acceleration type.\\\")\\n return self.v + time*acceleration\",\n \"def acceleration(self):\\n # speed is by formula: x axis speed: by cos of the heading and y\\n # axis by sine of the heading\\n self.x_speed += math.cos(math.radians(self.degrees))\\n self.y_speed += math.sin(math.radians(self.degrees))\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def compute_acceleration(self, x, y):\\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\\n return np.array([a_x, a_y])\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def tidal_acc(self, xyz):\\r\\n assert(xyz.shape[1] == 3)\\r\\n\\r\\n # create solar mass variable, if not already extant\\r\\n try:\\r\\n self.M\\r\\n except AttributeError:\\r\\n self.M = Constant(2e33) # solar mass in g\\r\\n\\r\\n # get the vector of x-values\\r\\n x = xyz[:, 0]\\r\\n\\r\\n # create an all-zero force vector\\r\\n acc = np.zeros_like(xyz)\\r\\n\\r\\n # get the heliocentric distance at the current time\\r\\n dist = self.trajectory(self.t)\\r\\n\\r\\n # get the acceleration as the difference between the acceleration at\\r\\n # the points and the acceleration at the c.o.m.\\r\\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\\r\\n return(acc)\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def predict(self, t : float) -> vector :\\n '''@ Zstar : vector'''\\n '''@ dt : float'''\\n '''@ dtau : float'''\\n '''@ F : array'''\\n dt = t - self.t\\n dtau = self._normalizeDeltaTime(dt)\\n F = self.stateTransitionMatrix(self.order+1, dtau)\\n Zstar = F @ self.Z;\\n return Zstar;\",\n \"def get_acceleration(self):\\n return self.acceleration\",\n \"def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\\n\\n #project forwards in time\\n sim_interval = self.sim_interval\\n sim_interval_sq = sim_interval*sim_interval\\n cmd_vel = list(cmd_vel)\\n current_speed = list(current_speed)\\n\\n max_acc_x = self.robot.max_acc_x\\n max_acc_th = self.robot.max_acc_th\\n max_decc_x = self.robot.max_dacc_x\\n max_decc_th = self.robot.max_dacc_th\\n\\n\\n code = \\\"\\\"\\\"\\n double x, y, th;\\n x = y = th = 0;\\n\\n double vx, vth;\\n vx = current_speed[0];\\n vth = current_speed[1];\\n\\n double cmd_x = cmd_vel[0];\\n double cmd_th = cmd_vel[1];\\n\\n //are we accelerating or decelerating?\\n double acc_x;\\n double acc_th;\\n\\n bool b_ax = false;\\n if (cmd_x > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = accs[2];\\n acc_x = -1*acc_x;\\n }\\n\\n bool b_ath = false;\\n if (cmd_th > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1* (double) accs[3];\\n\\n }\\n\\n py::list traj;\\n\\n //delay at the beginning\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //application of the command\\n for (double i=0; i<=time_applied; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //delay before decellerating\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //now we apply a stop\\n b_ax = false;\\n if (0 > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = -1 * (double) accs[2];\\n }\\n\\n b_ath = false;\\n if (0 > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1 * (double) accs[3];\\n }\\n\\n for (double i=0; i<=time_decc; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx) < 1e-6) vx = 0;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > 0 )) vx = 0;\\n if (!b_ax && (vx < 0 )) vx = 0;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth) < 1e-6) vth = 0;\\n if (b_ath && (vth > 0 )) vth = 0;\\n if (!b_ath && (vth < 0 )) vth = 0;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n\\n\\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\\n if (stopped) break;\\n\\n }\\n\\n return_val = traj;\\n \\\"\\\"\\\"\\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\\n 'time_decc'], type_converters=converters.blitz)\\n\\n return traj\",\n \"def update_rk3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n try:\\n\\n kap1 = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time))\\n\\n pos = self.pos+0.5*delta_t*kap1[0]\\n vel = self.vel+0.5*delta_t*kap1[1]\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n 0.5*delta_t, drag=False)\\n\\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\\n\\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\\n\\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n except Collision.CollisionException as col:\\n col.vel = self.vel+col.delta_t*kap1[0]\\n raise col\\n\\n self.time += self.delta_t\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def _get_alpha(self, m_t, v_t):\\n return max(0, ((-m_t * self._psi \\n + math.sqrt((m_t ** 2 * self._phi ** 4) \\n / 4 + v_t * self._phi ** 2 * self._xi)) \\n / (v_t * self._xi)))\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def update_ab3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 2:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n\\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.set_old(kap, 2)\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\\n\\n try:\\n tmp = [self.get_old(0)]\\n except IndexError:\\n tmp = []\\n kap = update_ab2(self)\\n if tmp:\\n self._old = self._old + tmp\\n\\n return kap\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def target_velocity(self, time):\\n\\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\\n\\n return avg_vel\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def update(self, t=1):\\n\\n\\t\\t# Update acceleration based on available fuel & throttle\\n\\t\\tthrottle = self.throttle if self.fuel >= 1 else self.throttle * self.fuel\\n\\t\\tself.acceleration = self.thrust * throttle / self.total_mass - GRAVITY\\n\\n\\t\\tself.velocity += self.acceleration / t\\n\\t\\tself.altitude += self.velocity / t\\n\\t\\t\\n\\t\\t# Collide with the ground\\n\\t\\tif self.altitude <= 0:\\n\\t\\t\\tself.reset_motion()\\n\\n\\t\\t# Update remaining fuel\\n\\t\\tif self.fuel * t >= self.throttle:\\n\\t\\t\\tself.fuel -= self.throttle * self.fuel_consumption / t\\n\\t\\t\\tif self.fuel < 0:\\n\\t\\t\\t\\tself.fuel = 0\",\n \"def get_control_input(self, dt):\\n \\n desired_z = 3.0\\n actual_z = self.internal_state.transform.translation.z\\n \\n # Convert to quaternion object for use by euler_from_quaternion()\\n quaternion = np.array([self.internal_state.transform.rotation.x,\\n self.internal_state.transform.rotation.y,\\n self.internal_state.transform.rotation.z,\\n self.internal_state.transform.rotation.w])\\n \\n # Determine the euler angles\\n euler = euler_from_quaternion(quaternion)\\n roll = euler[0]\\n pitch = euler[1]\\n yaw = euler[2]\\n \\n # Corrections for yaw wrap around\\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \\n np.abs(np.abs(yaw) - np.pi) < 0.2):\\n # Add or subtract 2 pi depending on crossing direction\\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \\n \\n \\n # Determine current yaw rate for yaw rate controller\\n yaw_rate = (yaw - self.yaw_old) / dt\\n \\n # After use, update the old yaw value with the current yaw\\n self.yaw_old = yaw\\n \\n # Determine current climb rate\\n climb_rate = (actual_z - self.z_old) / dt\\n \\n # After use, update the old altitude with the current altitude\\n self.z_old = actual_z\\n \\n # Find the errors between desired and actual signals\\n err_roll = self.desired_roll - roll\\n err_pitch = self.desired_pitch - pitch\\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\\n err_climb_rate = self.desired_climb_rate - climb_rate\\n \\n # Set the hover motor speed\\n motor_control = self.hover_speed * self.unit_hover_cmd\\n \\n # Roll controller\\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\\n \\n # Pitch controller\\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\\n \\n # Yaw rate controller (assuming small angles)\\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\\n \\n # Climb rate controller\\n motor_control += ((self.climb_Pgain * err_climb_rate +\\n self.climb_Igain * self.internal_climb_error +\\n self.climb_Dgain / dt * (err_climb_rate - \\n self.internal_old_climb_rate_error)) * \\n self.unit_hover_cmd)\\n \\n # Update the cumulative errors for integration\\n self.internal_roll_error += err_roll * dt\\n self.internal_pitch_error += err_pitch * dt\\n self.internal_yaw_error += err_yaw_rate * dt\\n self.internal_climb_error += err_climb_rate * dt\\n \\n # Update old error with current errors for differentiation\\n self.internal_old_roll_error = err_roll\\n self.internal_old_pitch_error = err_pitch\\n self.internal_old_yaw_rate_error = err_yaw_rate\\n self.internal_old_climb_rate_error = err_climb_rate\\n \\n \\n # Return the minimum of the \\n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp - (self.decay*_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def calculate_acceleration(self) -> np.array:\\n F = self.calculate_net_force()\\n m = self.mass\\n a = F / m\\n\\n return a\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def get_current_thrust_direction(self,\\n time: float) -> np.array:\\n # Interpolate with time\\n angle = self.thrust_angle_interpolator.interpolate(time)\\n # Set thrust in vertical frame and transpose it\\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\\n # Update flight conditions (this is needed to let tudat know to update all variables)\\n self.vehicle_body.flight_conditions.update_conditions(time)\\n # Get aerodynamic angle calculator\\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\\n frames.AerodynamicsReferenceFrames.vertical_frame,\\n frames.AerodynamicsReferenceFrames.inertial_frame)\\n # Compute the thrust in the inertial frame\\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\\n thrust_direction_vertical_frame)\\n return thrust_inertial_frame\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def move(self, t):\\n if self.visible == True:\\n self.x += self.vx * t\\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\\n\\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\\n self.phi = t * v_norm / self.radius\\n\\n glPushMatrix()\\n glLoadIdentity()\\n\\n if v_norm > 0.0:\\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\\n glMultMatrixd(self.matrix)\\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n\\n glPopMatrix()\\n\\n # Friction!!! Could do it as global parameter\\n if v_norm > 0.0:\\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\\n\\n if v_prime_norm < 0.0:\\n v_prime_norm = 0.0\\n\\n self.vx *= v_prime_norm / v_norm\\n self.vy *= v_prime_norm / v_norm\\n\\n return True\\n # Add comment\\n return False\",\n \"def u_exact(self, t):\\n\\n # some abbreviations\\n wE = self.params.omega_E\\n wB = self.params.omega_B\\n N = self.params.nparts\\n u0 = self.params.u0\\n\\n if N != 1:\\n raise ProblemError('u_exact is only valid for a single particle')\\n\\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\\n\\n wbar = np.sqrt(2) * wE\\n\\n # position and velocity in z direction is easy to compute\\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\\n\\n # define temp. variables to compute complex position\\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\\n Rp = u0[0][0] - Rm\\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\\n Ip = u0[0][1] - Im\\n\\n # compute position in complex notation\\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n # compute velocity as time derivative of the position\\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n\\n # get the appropriate real and imaginary parts\\n u.pos[0, 0] = w.real\\n u.vel[0, 0] = dw.real\\n u.pos[1, 0] = w.imag\\n u.vel[1, 0] = dw.imag\\n\\n return u\",\n \"def get_rotation(self) -> np.array:\\n axis = self.get_arms()[1]\\n force = [self.d_x, self.d_y] # \\\"Force applied on the arm\\\"\\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\\n if torque == 1: # Anti clockwise rotation\\n rotation = np.array([[0, -1], [1, 0]])\\n if torque == -1: # Clockwise rotation\\n rotation = np.array([[0, 1], [-1, 0]])\\n if torque == 0: # No rotation\\n rotation = np.array([[0, 0], [0, 0]])\\n return rotation\",\n \"def get_position(self, t0):\\n my_pos_x=np.random.uniform(-20, 20)\\n my_pos_y=np.random.uniform(-20, 20)\\n r=np.array([my_pos_x, my_pos_y])\\n x_y=np.zeros(shape=(self.no_planets-1, 2))\\n tol=1e-5\\n diff=np.zeros(self.no_planets-1)\\n for k in range(self.no_planets-1):\\n r1=np.linalg.norm(r)\\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\\n x1=0\\n y1=0\\n x2=self.positionFunction(t0)[0,k]\\n y2=self.positionFunction(t0)[1,k]\\n x3=self.positionFunction(t0)[0,k+1]\\n y3=self.positionFunction(t0)[1, k+1]\\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\\n x_y[k, 0]=x\\n x_y[k, 1]=y\\n diff[k]=difference\\n if (diff > tol).any():\\n print diff.max()\\n print \\\"Oh no, one failed :(\\\"\\n sys.exit(1)\\n print \\\"My pos x:\\\", my_pos_x\\n print \\\"My pos y:\\\", my_pos_y\\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def forward_kinematics(self):\\n temp_T = Matrix.eye(3)\\n for i in range(len(self.lengths)):\\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\\n temp_T = temp_T * angle_mat * len_mat\\n \\n self.final_T = np.array(temp_T,dtype=float)\\n \\n return self.final_T\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def f( self , x , u , t ):\\n \\n dx = np.zeros(self.n) # State derivative vector\\n \\n ################################################\\n # Place holder: put the equations of motion here\\n raise NotImplementedError\\n ################################################\\n \\n return dx\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp*(self.decay**_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def motors_update(t, x, u, params={}):\\n tm = params['motor']['tm'] # Motor torque constant\\n cr = params['motor']['cr'] # Motor speed constant\\n wb = params['motor']['wb'] # Motor base speed\\n\\n u = np.clip(u / 199999, 0, 1)\\n accel = [(cr * throttle + wb - speed) / tm for throttle, speed in zip(u, x)]\\n\\n return accel\",\n \"def get_D_C3H8_air(self, T):\\n\\n self.set_TempPres_dependents(T)\\n\\n self.D_C3H8_air = (\\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\\n )\\n\\n return self.D_C3H8_air\",\n \"def thetas (self,lag):\\n tanthetas = [0,0,0]\\n for k in range(3,self.n):\\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\\n tanthetas.append(tantheta_k)\\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles\",\n \"def spaceship_acceleration_x(dt, rotation):\\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))\",\n \"def anl_solution(self):\\r\\n\\r\\n m = float(self.mass) / self.nu_m\\r\\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\\\\r\\n / float(self.size_tick * self.size_tick)\\r\\n print 'qE=', qe\\r\\n c = self.light_vel\\r\\n for i in range(0, len(self.obs.obt_g)):\\r\\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\\r\\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\\r\\n * c)) ** 2) - 1.0)\\r\\n self.xa_track.append(x)\\r\\n p = qe * self.t[i]\\r\\n self.pa.append(p)\\r\\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\\r\\n jv = self.t[i] * qe / (m * c)\\r\\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\\r\\n self.va.append(v)\\r\\n print 'Analytical solution of the differential equation of motion'\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def acc(x: float, v: float, t: float) -> float:\\n return -k*v - np.sin(x) + c*np.cos(omega*t)\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def initial_velocity(self) -> float:\\n return self._initial_velocity\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def compute_velocity(self, time_since_last_frame: float) -> None:\\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\\n self.velocity_kts = (true_dist /\\n self.secs_since_last_seen) / 1.94384\\n self.cart_coords = new_cart_coords\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def integrate(self, t):\\n t0 = self.t0\\n if t-t0 <= self.max_step_size:\\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \\n \\n else :\\n n = (t-t0) / self.max_step_size\\n dt = (t-t0)/int(n+1)\\n \\n while t0 < t :\\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\\n t0 += dt\\n \\n return self.y0\",\n \"def UpdateCromer(self, deltaT):\\n self.velocity += self.acceleration * deltaT\\n self.position += self.velocity * deltaT\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n theta_t = self.get_ik(self.target_position(t))\\n # print(self.target_position(t))\\n #theta_t = np.array(theta_t)\\n # print(theta_t)\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here? cause you're mean\\n\\n point.positions = theta_t\\n point.velocities = (theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def verlet_next_pos(pos_t,vel_t,accel_t,dt):\\n pos_t_plus_dt = pos_t.copy()\\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \\n\\n return pos_t_plus_dt\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def _compute_gravity_torque(self):\\n pass\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\\n \\n error_x = goal_x - curr_x\\n error_y = goal_y - curr_y\\n error_z = goal_z - curr_z\\n error_rot_z = goal_rot_z - curr_rot_z\\n\\n self.output_x = 0.0\\n self.output_y = 0.0\\n self.output_z = 0.0\\n self.output_rot_z = 0.0\\n\\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\\n # self.current_time = time.time()\\n self.current_time = rospy.get_time()\\n delta_time = self.current_time - self.last_time\\n delta_error_x = error_x - self.last_error_x\\n delta_error_y = error_y - self.last_error_y\\n delta_error_z = error_z - self.last_error_z\\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\\n\\n # print(\\\"delta_time:\\\", delta_time)\\n\\n if (delta_time >= self.sample_time):\\n self.PTerm_x = self.Kp_x * error_x\\n self.PTerm_y = self.Kp_y * error_y\\n self.PTerm_z = self.Kp_z * error_z\\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\\n\\n self.ITerm_x += error_x * delta_time\\n self.ITerm_y += error_y * delta_time\\n self.ITerm_z += error_z * delta_time\\n self.ITerm_rot_z += error_rot_z * delta_time\\n\\n if (self.ITerm_x < -self.windup_guard):\\n self.ITerm_x = -self.windup_guard\\n elif (self.ITerm_x > self.windup_guard):\\n self.ITerm_x = self.windup_guard\\n \\n if (self.ITerm_y < -self.windup_guard):\\n self.ITerm_y = -self.windup_guard\\n elif (self.ITerm_y > self.windup_guard):\\n self.ITerm_y = self.windup_guard\\n\\n if (self.ITerm_z < -self.windup_guard):\\n self.ITerm_z = -self.windup_guard\\n elif (self.ITerm_z > self.windup_guard):\\n self.ITerm_z = self.windup_guard\\n \\n if (self.ITerm_rot_z < -self.windup_guard):\\n self.ITerm_rot_z = -self.windup_guard\\n elif (self.ITerm_rot_z > self.windup_guard):\\n self.ITerm_rot_z = self.windup_guard\\n\\n self.DTerm_x = 0.0\\n self.DTerm_y = 0.0\\n self.DTerm_z = 0.0\\n self.DTerm_rot_z = 0.0\\n if delta_time > 0:\\n self.DTerm_x = delta_error_x / delta_time\\n self.DTerm_y = delta_error_y / delta_time\\n self.DTerm_z = delta_error_z / delta_time\\n self.DTerm_rot_z = delta_error_rot_z / delta_time\\n\\n\\n # Remember last time and last error for next calculation\\n self.last_time = self.current_time\\n self.last_error_x = error_x\\n self.last_error_y = error_y\\n self.last_error_z = error_z\\n self.last_error_rot_z = error_rot_z\\n\\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\\n \\n return self.output_x, self.output_y, self.output_z, self.output_rot_z\",\n \"def __call__(self,\\n x0: Union[float, np.ndarray],\\n xt: Union[float, np.ndarray],\\n t: float) -> Union[float, np.ndarray]:\\n sig2t = (self._model.diffusion(x0, t) ** 2) * 2 * t\\n mut = x0 + self._model.drift(x0, t) * t\\n return np.exp(-(xt - mut) ** 2 / sig2t) / np.sqrt(np.pi * sig2t)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70134026","0.6654176","0.65230024","0.64852095","0.64031357","0.64031357","0.63639945","0.6288034","0.62409705","0.61979336","0.6173782","0.61587775","0.6142052","0.6091978","0.6033012","0.60062426","0.599504","0.5980418","0.58893937","0.58403546","0.58055806","0.5783974","0.5782522","0.5757616","0.5739489","0.56724524","0.56581587","0.56543696","0.5645363","0.5641847","0.55984366","0.55859786","0.5584969","0.5583669","0.55793774","0.5567482","0.5547899","0.55465716","0.5544459","0.5541313","0.5525292","0.5522926","0.55196613","0.5519318","0.55154526","0.55147296","0.55147296","0.5503303","0.54808474","0.5478539","0.54597026","0.54502434","0.54469335","0.543219","0.5431063","0.54250216","0.54180104","0.5412341","0.5412341","0.5411231","0.54106456","0.5407892","0.5407439","0.540582","0.5397435","0.5397435","0.5384672","0.53808486","0.53702676","0.53669155","0.5361914","0.5356409","0.5356227","0.5349399","0.53480124","0.5333702","0.5328817","0.5327198","0.5324187","0.5316723","0.53159535","0.5314852","0.53133005","0.5308871","0.5306965","0.5305276","0.5303358","0.5295539","0.52873516","0.52727866","0.52710676","0.52681667","0.5267996","0.5265313","0.5255205","0.52544177","0.5254246","0.5251624","0.52513456","0.5251244"],"string":"[\n \"0.70134026\",\n \"0.6654176\",\n \"0.65230024\",\n \"0.64852095\",\n \"0.64031357\",\n \"0.64031357\",\n \"0.63639945\",\n \"0.6288034\",\n \"0.62409705\",\n \"0.61979336\",\n \"0.6173782\",\n \"0.61587775\",\n \"0.6142052\",\n \"0.6091978\",\n \"0.6033012\",\n \"0.60062426\",\n \"0.599504\",\n \"0.5980418\",\n \"0.58893937\",\n \"0.58403546\",\n \"0.58055806\",\n \"0.5783974\",\n \"0.5782522\",\n \"0.5757616\",\n \"0.5739489\",\n \"0.56724524\",\n \"0.56581587\",\n \"0.56543696\",\n \"0.5645363\",\n \"0.5641847\",\n \"0.55984366\",\n \"0.55859786\",\n \"0.5584969\",\n \"0.5583669\",\n \"0.55793774\",\n \"0.5567482\",\n \"0.5547899\",\n \"0.55465716\",\n \"0.5544459\",\n \"0.5541313\",\n \"0.5525292\",\n \"0.5522926\",\n \"0.55196613\",\n \"0.5519318\",\n \"0.55154526\",\n \"0.55147296\",\n \"0.55147296\",\n \"0.5503303\",\n \"0.54808474\",\n \"0.5478539\",\n \"0.54597026\",\n \"0.54502434\",\n \"0.54469335\",\n \"0.543219\",\n \"0.5431063\",\n \"0.54250216\",\n \"0.54180104\",\n \"0.5412341\",\n \"0.5412341\",\n \"0.5411231\",\n \"0.54106456\",\n \"0.5407892\",\n \"0.5407439\",\n \"0.540582\",\n \"0.5397435\",\n \"0.5397435\",\n \"0.5384672\",\n \"0.53808486\",\n \"0.53702676\",\n \"0.53669155\",\n \"0.5361914\",\n \"0.5356409\",\n \"0.5356227\",\n \"0.5349399\",\n \"0.53480124\",\n \"0.5333702\",\n \"0.5328817\",\n \"0.5327198\",\n \"0.5324187\",\n \"0.5316723\",\n \"0.53159535\",\n \"0.5314852\",\n \"0.53133005\",\n \"0.5308871\",\n \"0.5306965\",\n \"0.5305276\",\n \"0.5303358\",\n \"0.5295539\",\n \"0.52873516\",\n \"0.52727866\",\n \"0.52710676\",\n \"0.52681667\",\n \"0.5267996\",\n \"0.5265313\",\n \"0.5255205\",\n \"0.52544177\",\n \"0.5254246\",\n \"0.5251624\",\n \"0.52513456\",\n \"0.5251244\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6153133"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":20290,"cells":{"query":{"kind":"string","value":"Remember to call the constructor of MotionPath"},"document":{"kind":"string","value":"def __init__(self, total_time, kin, limb, ar_tag_pos):\n # raise NotImplementedError\n self.r = .1 \n MotionPath.__init__(self, limb, kin, total_time)\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\n self.ar_tag_pos[2] = 0.282\n self.start_pos = [ar_tag_pos[0],ar_tag_pos[1]+self.r,ar_tag_pos[2]]\n self.w = 2*math.pi/self.total_time"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, limb, kin, total_time, goal_pos, num_way, start_pos=None):\n MotionPath.__init__(self, limb, kin, total_time)\n self.start_pos = start_pos\n self.goal_pos = goal_pos\n self.num_way = num_way\n self.base_frame = 'base'\n self.tool_frame = 'left_hand_camera' # 'left_gripper'\n self.plan_path()\n # self.plot_path()","def __init__(self, limb, kin, total_time, center_pos, num_way, radius, z_height=0.1):\n MotionPath.__init__(self, limb, kin, total_time)\n self.center_pos = center_pos\n self.num_way = num_way\n self.radius = radius\n self.z_height = z_height\n self.base_frame = 'base'\n self.tool_frame = 'left_gripper'\n self.plan_path()\n self.plot_path()","def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):\n #raise NotImplementedError\n MotionPath.__init__(self, limb, kin, total_time)\n start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])\n\n\n #The ar tracking function was not working properly so we added the block below \n #to correct it.\n if start_pos[1]>start_pos[0]:\n a = start_pos[0]\n b = start_pos[1]\n start_pos[0] = b\n start_pos[1] = a\n print(\"### Modified start_pos ###\")\n\n\n ar_tag_pos = np.array([abs(ar_tag_pos[0]), abs(ar_tag_pos[1]), abs(ar_tag_pos[2])])\n if ar_tag_pos[1]>ar_tag_pos[0]:\n a = ar_tag_pos[0]\n b = ar_tag_pos[1]\n ar_tag_pos[0] = b\n ar_tag_pos[1] = a\n self.start_pos = start_pos\n\n print(\"!!!!!!!!!!!!!!!!start_pos!!!!!!!!!!!!!!!!\")\n print(start_pos)\n print(\"!!!!!!!!!ar_tag_pos in LinearPath!!!!!!!!!\")\n print(ar_tag_pos)\n ar_tag_pos[2] = start_pos[2]\n self.ar_tag_pos = ar_tag_pos\n self.points_generated = []","def __init__(self, start_x, start_y):\n self.x = start_x\n self.y = start_y\n\n self._dead_end_direction = [[]]\n self._moved = False\n self._junction_index = [1]\n\n self.path = [[start_x, start_y]]","def __init__(self,path=None, init_pos=None, wind_map_ang=None, \n wind_map_mag=None, inlet_ang=None, inlet_mag=None,\n ground_speed=10, ghost_delta=2.0, traj_res=0.1,\n sim_dt=0.1, mass=3.71, max_tilt_angle=35, \n air_speed=10, command_airspeed = False):\n self.ground_speed = ground_speed\n self.air_speed = air_speed\n self.command_airspeed = command_airspeed\n self.traj_res = traj_res\n self.sim_dt = sim_dt\n self.mass = mass\n self.max_tilt_angle = max_tilt_angle\n self.path = path\n self.payload = 0\n self.air_density = 1.1718938453052181\n if init_pos is None:\n init_x = 0\n init_y = 0\n init_z = 20\n else:\n init_x = init_pos[0]\n init_y = init_pos[1]\n init_z = init_pos[2]\n self.init_state = QuadState(pos=np.array([init_x,init_y,init_z]))\n self.states_hist = []\n self.append_states_hist(0, self.init_state)\n self.ghost_delta = ghost_delta #secs\n self.actual_path = [self.init_state]\n self.xy_path = [(init_x,init_y)]\n dryden_upsample = 10\n if command_airspeed:\n # print(\"commanding airspeed\")\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.air_speed)\n else:\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.ground_speed)\n\n if inlet_ang is not None and inlet_mag is not None:\n self.windField = WindField(wind_map_ang, wind_map_mag, \n inlet_ang, inlet_mag)\n else:\n self.windField = WindField(wind_map_ang, wind_map_mag)","def __init__(self, coords, goal_coords, current_path_length) :\r\n\r\n self.coords = coords #The coordinates of the node\r\n\r\n #Calculating the g(n) value of node\r\n self.calculate_gn_value(current_path_length)\r\n\r\n #Calculating the h(n) value of node\r\n self.calculate_hn_value(goal_coords)\r\n\r\n #Calculating f(n) value of node\r\n self.calculate_fn_value()","def __init__(self):\n self.positionx = 400\n self.positiony = 600\n # direction goes from [0,360)\n self.direction = (45)","def __init__(self):\n self.center = Point()\n self.velocity = Velocity()","def __init__(self, x, y):\n\n self.x = x\n self.y = y\n self.path_x = []\n self.path_y = []\n self.parent = None\n self.cost = 0.0","def __init__(self, mass, x, y,px=0.0,py=0.0):\n self.mass = mass\n self.position = np.array([x,y])\n self.momentum = np.array([px,py])","def __init__(self, mass, radius, position, velocity):\n self.mass = mass\n self.radius = radius\n self.position = position\n self.velocity = velocity\n print(self.velocity)\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\n self.delete = False","def __init__(self):\n super().__init__()\n self.waypoint_vector = [-1, 10]","def __init__(self):\r\n self.position=(0,0)\r\n self.direction = 0.\r\n self.speed = 0\r\n self.state = 0\r\n pass","def __init__(self,mass,time,**kwargs):\n self.setTime(time)\n ParticlePhaseCoordinates.__init__(self,mass,**kwargs)","def __init__(self, inPs, outPs):\n self.angle = 0.0\n self.speed = 16.5\n\n super(MovementControl,self).__init__(inPs, outPs)","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All motion starts at (0,0).\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, x_coor, x_speed, y_coor, y_speed, direction):\n self.__x_coor = x_coor\n self.__x_speed = x_speed\n self.__y_coor = y_coor\n self.__y_speed = y_speed\n self.__direction = direction\n self.__radius = self.TORPEDO_RADIUS","def __init__(self):\n self.position = Vector2()\n self.velocity = Vector2()\n self.update_parameters()\n self.mass = 0.18 # Mass of Sphero robot in kilograms","def __init__(self):\n self.x = 0.0\n self.y = 0.0\n self.theta = 0.0\n self.total_distance_covered = 0.0","def __init__(self, path):\r\n self.path = path\r\n # 0.75 deg per grid box latitudinally\r\n self.lat_unit = 360","def __init__(self):\n raise NotImplementedError('cannot create independent arc')","def __init__(self, x_axis_p, y_axis_p, x_speed=0, y_speed=0, direction=0):\r\n self.__x_axis = x_axis_p\r\n self.__y_axis = y_axis_p\r\n self.__X_speed = x_speed\r\n self.__y_speed = y_speed\r\n self.__direction = direction\r\n self.__lives = 3","def __init__(self, coords, direction):\n self.y, self.x = coords\n self.direction = direction","def __init__(self,x,y,width,height):\n self.x = x\n self.y = y\n self.width = width\n self.height = height\n self.velocity_x = 0.0","def __init__(self, Position, M):\n self.pos = Position # Sets x position\n self.m = M # Sets mass\n # Initial velocity and acceleration set to be zero\n self.vel = np.zeros((2,))\n self.acc = np.zeros((2,))","def __init__(self, position, momentum, mass):\n self.position = position\n self.momentum = momentum\n self.mass = mass","def __init__(self, pos):\r\n self.pos = pos\r\n self.vel = [0, 0]\r\n self.acc = [0, 0]\r\n self.heading = math.pi\r\n self.screen = [0, 0]","def __init__(self, x_0, y_0, initX, initY,h=5):\n self.x_0=x_0\n self.y_0=y_0\n self.x_init=initX\n self.y_init=initY\n self.step=h","def __init__(self, direction=0, x=0, y=0):\n self.direction = direction\n self.x = x\n self.y = y","def __init__(self, path_fun, disp_fun):\n \n if path_fun.nx != 1 or disp_fun.nx != 1:\n raise ValueError(\"path_fun and disp_fun must have 1 input variable\")\n \n # The number of output coordinates is defined by the\n # number of output functions of `path_fun`\n nQ = path_fun.nf\n \n # The number of input coordinates equals the number\n # of path-displacements plus 1.\n if disp_fun.nf % nQ != 0:\n raise ValueError('dispfun.nf must be a multiple of nQ')\n n = disp_fun.nf // nQ # The number of displacement coordinates \n \n nQp = n + 1 # The total number of input coordinates \n \n Qpstr = ['s'] + [f\"d{i:d}\" for i in range(n)]\n Qstr = [f\"Q{i:d}\" for i in range(nQ)]\n \n # The maxderiv is the minimum of either path_fun \n # or disp_fun \n maxderiv = dfun._merged_maxderiv(path_fun.maxderiv, disp_fun.maxderiv)\n \n # If the displace vectors have a finite zlevel, then the \n # zlevel for that term is just 1 more (from the linear dependence on \n # Q'). The total zlevel is then the merged zlevel of the path function\n # and the displacement term \n #\n if disp_fun.zlevel is None:\n disp_zlevel = None \n else: \n disp_zlevel = disp_fun.zlevel + 1 \n zlevel = dfun._merged_zlevel(path_fun.zlevel, disp_zlevel)\n \n super().__init__(self._pathtrans_fun, nQp = nQp, nQ = nQ,\n name = 'Path', Qpstr = Qpstr, Qstr = Qstr,\n maxderiv = maxderiv, zlevel = zlevel)\n \n self.path_fun = path_fun \n self.disp_fun = disp_fun","def __init__(self, new_pt):\n self.x = float(new_pt[0])\n self.y = float(new_pt[1])\n self.next = None\n self.prev = None\n self.distance_to_next = 0\n self.angle = None","def __init__(self):\n self.Robot = Robot()\n self.Omega = matrix()\n # self.Omega.value[0][0] = 1.0\n # self.Omega.value[1][1] = 1.0\n self.Xi = matrix()\n # Xi.value[0][0] = 0.0\n # Xi.value[1][0] = 0.0\n self.measure = {}\n self.landMarkCount = 0\n self.init = False\n self.bearing = 0\n self.x = 0\n self.y = 0\n \n # TODO","def __init__(self, pos=(0,0), dire = 0):\r\n self.initX = self.x = pos[0]\r\n self.initY = self.y = pos[1]\r\n self.initDir = self.dir = math.radians(dire)","def __init__(self, init_pose=None, init_velocities=None, \n init_angle_velocities=None, runtime=5., target_pos=None):\n \n # initial state\n self.state_scale = 1\n \n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\n self.init_pose[2] += 10\n self.init_velocities = np.array([0.,0.,0.])\n self.init_angle_velocities = np.array([0.,0.,0.])\n\n self.runtime = runtime\n \n # Simulation\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \n self.action_repeat = 1\n\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\n self.state_size = self.action_repeat * self.init_state.shape[0]\n \n self.action_low = 0 #-1\n self.action_high = 2*450 #1\n self.action_size = 4\n\n self.action_scale = 1 #450 # 1/2 max of the action \n #self.state_scale = 150 # 1/2 size of the state space\n \n # Goal\n self.target_pose = np.array([0.,0.,150.0])\n\n # The previous position\n self.prev_pose = self.init_pose","def __init__(self, timestep=1.0 * simtk.unit.femtoseconds):\n\n super(VelocityVerletIntegrator, self).__init__(timestep)\n\n self.addPerDofVariable(\"x1\", 0)\n\n self.addUpdateContextState()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m+(x-x1)/dt\")\n self.addConstrainVelocities()","def __init__(self):\n self.x = 0\n self.y = 0","def __init__(self):\n self.x = 0\n self.y = 0","def __init__(self, newPath):\n self.newPath = newPath","def __init__(self, **kwargs):\n self.motion_err = np.array(kwargs.pop('err', [0., 0.]), dtype=float)\n\n pose = np.array(kwargs.pop('pose', [0.,0.,0.]), dtype=float)\n super(XYPhiRobot, self).__init__(pose=pose)","def __init__(self, path, ar_no):\n self.path = path\n self.ar_no = ar_no\n self.dt = pos_neg_detection()\n self.ts = ts_processing(self.path, self.ar_no)","def __init__(self, x=0, y=0, rotation=0):\n self.x, self.y = x, y\n self.rotation = rotation\n\n self.x_speed, self.y_speed = 0, 0","def __init__(self):\n self.mu = None\n self.type = None\n self.direction = None\n self.eq_points = None\n self.init_conds = None\n self.time = None\n self.trajectory = None\n self.initial_point = None\n self.contour_levels = []","def build(self):\n\n pt1 = rs.CurveStartPoint(self.geo)\n pt2 = rs.CurveEndPoint(self.geo)\n\n # get spring direction\n self.dx = round(+ pt2[0] - pt1[0], 5)\n self.dy = round(+ pt2[1] - pt1[1], 5)\n self.dz = round(+ pt2[2] - pt1[2], 5)\n\n # normalize direction\n d = (self.dx ** 2 + self.dy ** 2 + self.dz ** 2) ** 0.5\n self.dx /= d\n self.dy /= d\n self.dz /= d","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All walks start at (0, 0)\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All walks start at (0, 0)\n self.x_values = [0]\n self.y_values = [0]","def __init__(self, num_points = 5000):\n self.num_points = num_points\n\n #all walks start at 0.0\n self.x_values = [0]\n self.y_values = [0]","def __init__(self,):\r\n self.g = 9.81\r\n self.l = 0.5\r\n self.m1 = 1.0\r\n self.m2 = 1.0\r\n self.m3 = 1.0\r\n self.r1 = 1.0\r\n self.r2 = 1.0\r\n self.tau = 0.001\r\n self.theta1 = 1.0\r\n self.theta2 = 1.0\r\n self.theta3 = 1.0","def __init__(self, coordinate, speed_vec, heading):\n self.__heading = heading\n super().__init__(coordinate, speed_vec, Ship.RADIUS)","def __init__(self, x, y):\n # assigning the initial position\n self.x = x\n self.y = y","def imitate_path(self, y_des, plot=False):\n\n # set initial state and goal\n if y_des.ndim == 1:\n y_des = y_des.reshape(1, len(y_des))\n self.y0 = y_des[:, 0].copy()\n self.y_des = y_des.copy()\n self.goal = self.gen_goal(y_des)\n\n # self.check_offset()\n\n # generate function to interpolate the desired trajectory\n import scipy.interpolate\n\n path = jnp.zeros((self.n_dmps, self.timesteps))\n x = jnp.linspace(0, self.cs.run_time, y_des.shape[1])\n for d in range(self.n_dmps):\n path_gen = scipy.interpolate.interp1d(x, y_des[d])\n for t in range(self.timesteps):\n path[d, t] = path_gen(t * self.dt)\n y_des = path\n\n # calculate velocity of y_des with central differences\n dy_des = jnp.gradient(y_des, axis=1) / self.dt\n\n # calculate acceleration of y_des with central differences\n ddy_des = jnp.gradient(dy_des, axis=1) / self.dt\n\n f_target = jnp.zeros((y_des.shape[1], self.n_dmps))\n # find the force required to move along this trajectory\n for d in range(self.n_dmps):\n f_target[:, d] = ddy_des[d] - self.ay[d] * (\n self.by[d] * (self.goal[d] - y_des[d]) - dy_des[d]\n )\n\n # efficiently generate weights to realize f_target\n self.gen_weights(f_target)\n\n if plot is True:\n # plot the basis function activations\n import matplotlib.pyplot as plt\n\n plt.figure()\n plt.subplot(211)\n psi_track = self.gen_psi(self.cs.rollout())\n plt.plot(psi_track)\n plt.title(\"basis functions\")\n\n # plot the desired forcing function vs approx\n for ii in range(self.n_dmps):\n plt.subplot(2, self.n_dmps, self.n_dmps + 1 + ii)\n plt.plot(f_target[:, ii], \"--\", label=\"f_target %i\" % ii)\n for ii in range(self.n_dmps):\n plt.subplot(2, self.n_dmps, self.n_dmps + 1 + ii)\n plt.plot(\n jnp.sum(psi_track * self.w[ii], axis=1) * self.dt,\n label=\"w*psi %i\" % ii,\n )\n plt.legend()\n plt.title(\"DMP forcing function\")\n plt.tight_layout()\n plt.show()\n\n self.reset_state()\n return y_des","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, path):\n self.path = path","def __init__(self, target_velocity, dt, model_type, robot_type):\n super(StraightEnv, self).__init__(\n target_velocity=target_velocity,\n dt=dt,\n model_type=model_type,\n robot_type=robot_type\n )\n\n # Reward function parameters\n self._lambda1 = 0.25\n\n # State in frame of target straight line. See get_initial_state()\n # function for info.\n self._current_state = np.zeros(6)\n\n # Target line to follow. See get_initial_state() function for info.\n self._target_y = 0\n self._target_yaw = 0\n\n # Initialize nodes and set up ROS topics\n rospy.init_node('rl_planner')\n self.publisher = rospy.Publisher('commands/keyboard',\n ackermann_msgs.msg.AckermannDriveStamped, queue_size=1)\n rospy.Subscriber('ekf_localization/odom', nav_msgs.msg.Odometry,\n self._odometry_callback)\n self._sensor_stamp = rospy.Time.now()\n\n # Wait this number of timesteps before computing another action (this\n # is similar to setting a larger dt during training)\n self._num_states_needed = 3\n self._num_states_received = 0","def __init__(self, location):\r\n self.y = location[1]\r\n self.x = location[0]\r\n self.yvel = 0.0\r\n self.xvel = 0.0","def generate_motion_patters(self):\n\n\t\t# Motion primimtives for the forward direction.....................\n\t\td_del = 0.08\t\n\t\tdt = self.dt\n\t\tv = 2\t# Assuming a constant longitudinal velocity\n\t\tdelta = np.arange(-np.pi*self.max_steer/180, d_del + np.pi*self.max_steer/180, d_del)\n\t\tprint(\"Number of motion patterns in forward directon: {}\".format(len(delta)))\n\t\tfor d in delta:\n\t\t\tx0 = self.x0\n\t\t\ty0 = self.y0\n\t\t\ttheta0 = self.theta0\n\t\t\tp = np.array([x0, y0, theta0])\n\t\t\t\n\t\t\tfor i in range(self.num_steps):\n\t\t\t\tx0 += v*cos(theta0)*dt\n\t\t\t\ty0 += v*sin(theta0)*dt\n\t\t\t\ttheta0 += v*tan(d)*dt/self.L\n\t\t\t\tp = np.vstack((p,np.array([x0, y0, theta0])))\n\n\t\t\t# Adding the motion primitive array to the list\n\t\t\tself.motion_primitives.append(p)\n\n\t\t\n\t\t# Motion primitives for the backward direction ...................\n\t\td_del = 0.1\n\t\tv = -1.2\n\t\tdelta = np.arange(-np.pi*self.max_steer/180, d_del + np.pi*self.max_steer/180, d_del)\n\t\tprint(\"Number of motion patterns for the backward direction: {}\".format(len(delta)))\n\t\tfor d in delta:\n\t\t\tx0 = self.x0\n\t\t\ty0 = self.y0\n\t\t\ttheta0 = self.theta0\n\t\t\tp = np.array([x0, y0, theta0])\n\n\t\t\tfor i in range(self.num_steps):\n\t\t\t\tx0 += v*cos(theta0)*dt\n\t\t\t\ty0 += v*sin(theta0)*dt\n\t\t\t\ttheta0 += v*tan(d)*dt/self.L\n\t\t\t\tp=np.vstack((p, np.array([x0, y0, theta0])))\n\t\t\t# Adding the motion primitive array to the list\n\t\t\tself.motion_primitives.append(p)","def __init__(self, d):\n\t\tself._coords = [0] * d","def __init__(self, direction, position):\n self.direction = normalize(direction)\n self.position = np.array(position)","def __init__(self, x_pos, y_pos, radius, colour, moving = False):\n\t\t\n\t\tself.x_pos = x_pos\n\t\tself.y_pos = y_pos\n\t\tself.radius = radius\n\t\tself.diameter = 2*radius\n\t\tself.colour = colour\n\t\tself.moving = moving\n\t\tself.x_vec = 0\n\t\tself.y_vec = 0","def __init__(self, goal_pos=7.5, *args, **kwargs):\n super(Attacker, self).__init__(*args, **kwargs)\n self.goal_p=goal_pos\n goal = (-1.5+3*np.random.rand(), self.goal_p)\n self.path, self.status = passPath(self.getRobotConf(self.bot), self.ballEngine.getBallPose(), goal, kick=True)","def __init__(self):\n\n self.X = None\n self.y = None","def __init__(self):\n\n self.X = None\n self.y = None","def __init__(self, goal_pos=0.72, *args, **kwargs):\n super(Goalie, self).__init__(*args, **kwargs)\n self.goal=goal_pos","def __init__(self,name,speed,depth_of_view,view_angle,x_coor = \"\",y_coor = \"\"):\n self.name = name\n self.speed = speed # That will the instantenous speed of the robot\n self.depth_of_view = depth_of_view # That will the instantenous depth of view of the robot\n self.view_angle = view_angle # That will the instantenous view angle of the robot\n self.type = \"Robot\" #Specift the object type\n self.x = x_coor # store the position of the robot\n self.y = y_coor # store the position of the robot\n self.kind = name #Store its kind to give the GUI","def __init__(self, path):\n self._path = path","def __init__(self, startpos = (75,75), angle = 0, colour = (240,100,100),\n maxSpeed = 20, maxAccel = 1, maxAngle = 0.1,\n width = 1600, height = 900, maze = None,\n intermediates = (8,), inputdistance = [50,100,150], inputangle = [1.2,0.6,0,-0.6,-1.2],\n parentname = \"\", parentcolour = (240,100,100), name = None,orders = [1,2,3,4,5,6,7,8]):\n self.startpos, self.startangle, self.colour = startpos, angle, colour\n self.maxSpeed, self.maxAccel, self.maxAngle = maxSpeed, maxAccel, maxAngle\n self.maze = maze\n self.width, self.height = width, height\n self.parentname, self.parentcolour = parentname, parentcolour\n # Create dimensions array based on input, intermediate dimensions and output (4)\n self.inputType = 1 # 0: point, 1: linear\n self.setDimension(inputdistance,inputangle,intermediates,orders)\n self.drag = 0.99\n self.initWeights()\n self.sightLength = 200\n \n if name is not None: \n self.name = name\n else:\n self.name = self.getName()\n \n self.reset()","def __init__(self, angle: float):\n # FIXME No coordinates for position, because assumed to always be towards cue ball...\n self.ang = angle","def __init__(self, x, y):","def __init__(self,circlePos,circleRad,circleVel):\n self.circlePos=circlePos\n self.circleRad=circleRad\n self.circleVel=circleVel","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def __init__(self):\n self.X = None\n self.y = None","def build(self, trajectory):\n pass","def __init__(self, motion, **kwargs):\n super(ShiftIn, self).__init__(motion)","def __init__(self, start_pos, end_pos, direction):\n self.s_pos = start_pos\n self.e_pos = end_pos\n self.dir = direction","def __init__(self, position, anim, rotation, rotSpeed, rotPoint, entf_rotPoint, movSpeed, radius, textur, divisions):\n self.position = position # Position im XYZ-Raum\n self.anim = anim # Animationen an/aus\n self.rotation = rotation # Rotation um die eigene Achse\n self.rotSpeed = rotSpeed # Rotationsgeschwindigkeit\n self.rotPoint = rotPoint # Punkt, um den sich der Planet bewegen soll\n self.entf_rotPoint = entf_rotPoint # Entfernung von ebendiesem Punkt\n self.movSpeed = movSpeed # Orbitalgeschwindigkeit\n self.radius = radius # Radius des Himmelskoerpers\n self.textur = textur # Textur\n self.divisions = divisions # Unterteilungen. Mehr = feinere, schoenere Kugel\n self.top = False","def __init__(self, x_traj=[], y_traj=[], period=0, num_div_action=5,\n closed=True, differential_car=True, discrete_input=False):\n\n # Size of the space\n self.max_x = SPACE_X / 2 # [m]\n self.max_y = SPACE_Y / 2 # [m]\n self.state = []\n self.x_trajectory = x_traj\n self.y_trajectory = y_traj\n self.r= 0.0325 # [m] wheel´s radius\n self.rho = 0.133 # [m] distance between wheel\n self.time = period # frames per second\n\n # More steps for Ackerman model because circuit is longer\n if discrete_input:\n self.max_steps = 600\n else:\n self.max_steps = 600\n\n self.constant = -0.1\n self.x_ant = 0.0\n self.y_ant = 0.0\n # Sqr of the limit distance\n self.zone_0_limit = ZONE0_LIMIT\n self.zone_1_limit = ZONE1_LIMIT\n self.zone_2_limit = ZONE2_LIMIT\n if discrete_input:\n self.zone_2_limit = 0.08\n else:\n self.zone_2_limit = ZONE2_LIMIT\n\n self.num_div_action = num_div_action\n self.num_div_state = num_div_action\n\n # It is to inform if it´s an closed circuit without ending\n self.closed = closed\n\n # Distance between axis in Ackerman car\n self.l_ack = 0.245\n # Radius of wheels of the Ackerman car\n self.r_ack = 0.035\n # Maximum angle of the wheels of the Ackerman car\n self.alpha_ack = 25.34*np.pi/180\n\n # Choose car model\n self.differential_car = differential_car\n\n self.discrete_input = discrete_input\n\n # parameters to add noise to x, y, angle values\n # self.mu = 0\n # self.sigmaxy = 0.002\n # self.sigmaangle = 2*np.pi/180","def __init__(self, name: str):\n self._name = name\n self._yaw = Motion(\"yaw\")\n self._pitch = Motion(\"pitch\")\n self._roll = Motion(\"roll\")\n self._sway = Motion(\"sway\")\n self._surge = Motion(\"surge\")\n self._heave = Motion(\"heave\")","def __init__(self, motion, **kwargs):\n super(ShiftWeight, self).__init__(motion)","def __init__(self):\n # Lynx Dimensions in mm\n self.L1 = 76.2 # distance between joint 0 and joint 1\n self.L2 = 146.05 # distance between joint 1 and joint 2\n self.L3 = 187.325 # distance between joint 2 and joint 3\n self.L4 = 34 # distance between joint 3 and joint 4\n self.L5 = 34 # distance between joint 4 and center of gripper\n\n # Joint limits\n self.lowerLim = np.array([-1.4, -1.2, -1.8, -1.9, -2.0, -15]).reshape((1, 6)) # Lower joint limits in radians (grip in mm (negative closes more firmly))\n self.upperLim = np.array([1.4, 1.4, 1.7, 1.7, 1.5, 30]).reshape((1, 6)) # Upper joint limits in radians (grip in mm)","def __init__(self,start_coord, motion = \"Ornstein-Uhlenbeck\",\\\n history = None,params={\"L\":0.20,\"delta\":0.25}):\n if history is None:\n history = []\n self.StartCoord = start_coord\n self.Coord = start_coord\n self.History = history\n self.History.append(start_coord)\n self.Params = params\n self.ProcessType = motion\n self.Perturbations = []","def __init__(self):\n self.parameter = [[(0,1),(1,1),(0,0),(1,0)],\n [(1,0),(1,0),(0,1),(0,1)],\n [(1,0),(0,1),(1,0),(0,1)],\n [(0,0),(0,0),(0,0),(0,0)]]\n \"\"\"Distance is number of whole route from origin to destination\"\"\"\n self.distance = 100\n \"\"\"action sets\"\"\"\n self.action = [0,55,75]\n self.maxSpeed = self.action[-1]\n \"\"\"time period for each stage\"\"\"\n self.time_interval = 0.5\n \"\"\"Number of stages we want to check. Here we can use this to limit the\n travel time, since sometimes we want driver to arrive in a time window.\n For example, if stage is 4, that means we want to driver finish route within \n 2 hours. \"\"\"\n self.stage = 4\n self.time_block = 0.5\n self.distance_block = 25","def __init__(self, pos):\r\n self.pos = pos","def __init__(self, X, y):\n pass","def __init__(self):\n self.rot_axis = 1","def movement(self):","def __init__(self, x, y, th):\n self.x = x\n self.y = y\n self.th = th","def __init__(self, path=\"IdentityFunction\"):\n self.path = path\n self.heal = lambda X: X\n self.heal_tf = lambda X: X","def __init__(self):\n self.position = 0","def path(e,a,q,i,period, timediff, offset):\n b = a*np.sqrt(1-e**2)\n c=np.sqrt(a**2-b**2)\n #t = ((timediff*np.pi*b)/period)\n #t1 = ((timediff)*np.pi*b)/period\n #print(t1-t)\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\n #print(t)\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\n theta=0 #need a real theta value \n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\n \n \n return xcoord, ycoord, zcoord","def __init__(self, coordinates, emissivity = 0.4): \n\t\tsuper().__init__(coordinates)\n\t\tself.emissivity = emissivity\n\t\tself.type = 'thermometer'","def __init__(self, d):\n self._coords = [0]*d","def __init__(self, mass, position, velocity):\n self.mass = mass\n self.position = position\n self.velocity = velocity","def __init__(self, origin, direction):\r\n self.origin = np.array(origin)\r\n self.direction = np.array(direction)","def __init__(self, x1, y1):\n self.x = x1\n self.y = y1","def __init__(self, angle, x, y):\n pygame.sprite.Sprite.__init__(self)\n self.image = pygame.image.load(\"Image/Trafico.png\")\n self.rect = self.image.get_rect()\n self.image_orig = self.image\n self.speed = 2\n self.direction = angle\n self.steering = 90\n self.x = x\n self.y = y","def __init__(self, center, waypoints, firepoints):\n super().__init__(center, MallFighter.MALL_FIGHTER_SPEED, MallFighter.ANIMATION_DELAY, *MallFighter.FILE_PATH)\n self.fire_idx = 0\n self.way_idx = 0\n self.waypoints = waypoints\n self.firepoints = firepoints","def __init__(self, x=0, y=0, angle=90):\n self.x = x\n self.y = y\n self.angle = angle"],"string":"[\n \"def __init__(self, limb, kin, total_time, goal_pos, num_way, start_pos=None):\\n MotionPath.__init__(self, limb, kin, total_time)\\n self.start_pos = start_pos\\n self.goal_pos = goal_pos\\n self.num_way = num_way\\n self.base_frame = 'base'\\n self.tool_frame = 'left_hand_camera' # 'left_gripper'\\n self.plan_path()\\n # self.plot_path()\",\n \"def __init__(self, limb, kin, total_time, center_pos, num_way, radius, z_height=0.1):\\n MotionPath.__init__(self, limb, kin, total_time)\\n self.center_pos = center_pos\\n self.num_way = num_way\\n self.radius = radius\\n self.z_height = z_height\\n self.base_frame = 'base'\\n self.tool_frame = 'left_gripper'\\n self.plan_path()\\n self.plot_path()\",\n \"def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):\\n #raise NotImplementedError\\n MotionPath.__init__(self, limb, kin, total_time)\\n start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])\\n\\n\\n #The ar tracking function was not working properly so we added the block below \\n #to correct it.\\n if start_pos[1]>start_pos[0]:\\n a = start_pos[0]\\n b = start_pos[1]\\n start_pos[0] = b\\n start_pos[1] = a\\n print(\\\"### Modified start_pos ###\\\")\\n\\n\\n ar_tag_pos = np.array([abs(ar_tag_pos[0]), abs(ar_tag_pos[1]), abs(ar_tag_pos[2])])\\n if ar_tag_pos[1]>ar_tag_pos[0]:\\n a = ar_tag_pos[0]\\n b = ar_tag_pos[1]\\n ar_tag_pos[0] = b\\n ar_tag_pos[1] = a\\n self.start_pos = start_pos\\n\\n print(\\\"!!!!!!!!!!!!!!!!start_pos!!!!!!!!!!!!!!!!\\\")\\n print(start_pos)\\n print(\\\"!!!!!!!!!ar_tag_pos in LinearPath!!!!!!!!!\\\")\\n print(ar_tag_pos)\\n ar_tag_pos[2] = start_pos[2]\\n self.ar_tag_pos = ar_tag_pos\\n self.points_generated = []\",\n \"def __init__(self, start_x, start_y):\\n self.x = start_x\\n self.y = start_y\\n\\n self._dead_end_direction = [[]]\\n self._moved = False\\n self._junction_index = [1]\\n\\n self.path = [[start_x, start_y]]\",\n \"def __init__(self,path=None, init_pos=None, wind_map_ang=None, \\n wind_map_mag=None, inlet_ang=None, inlet_mag=None,\\n ground_speed=10, ghost_delta=2.0, traj_res=0.1,\\n sim_dt=0.1, mass=3.71, max_tilt_angle=35, \\n air_speed=10, command_airspeed = False):\\n self.ground_speed = ground_speed\\n self.air_speed = air_speed\\n self.command_airspeed = command_airspeed\\n self.traj_res = traj_res\\n self.sim_dt = sim_dt\\n self.mass = mass\\n self.max_tilt_angle = max_tilt_angle\\n self.path = path\\n self.payload = 0\\n self.air_density = 1.1718938453052181\\n if init_pos is None:\\n init_x = 0\\n init_y = 0\\n init_z = 20\\n else:\\n init_x = init_pos[0]\\n init_y = init_pos[1]\\n init_z = init_pos[2]\\n self.init_state = QuadState(pos=np.array([init_x,init_y,init_z]))\\n self.states_hist = []\\n self.append_states_hist(0, self.init_state)\\n self.ghost_delta = ghost_delta #secs\\n self.actual_path = [self.init_state]\\n self.xy_path = [(init_x,init_y)]\\n dryden_upsample = 10\\n if command_airspeed:\\n # print(\\\"commanding airspeed\\\")\\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.air_speed)\\n else:\\n self.dryden = DrydenSim(self.sim_dt/dryden_upsample, self.ground_speed)\\n\\n if inlet_ang is not None and inlet_mag is not None:\\n self.windField = WindField(wind_map_ang, wind_map_mag, \\n inlet_ang, inlet_mag)\\n else:\\n self.windField = WindField(wind_map_ang, wind_map_mag)\",\n \"def __init__(self, coords, goal_coords, current_path_length) :\\r\\n\\r\\n self.coords = coords #The coordinates of the node\\r\\n\\r\\n #Calculating the g(n) value of node\\r\\n self.calculate_gn_value(current_path_length)\\r\\n\\r\\n #Calculating the h(n) value of node\\r\\n self.calculate_hn_value(goal_coords)\\r\\n\\r\\n #Calculating f(n) value of node\\r\\n self.calculate_fn_value()\",\n \"def __init__(self):\\n self.positionx = 400\\n self.positiony = 600\\n # direction goes from [0,360)\\n self.direction = (45)\",\n \"def __init__(self):\\n self.center = Point()\\n self.velocity = Velocity()\",\n \"def __init__(self, x, y):\\n\\n self.x = x\\n self.y = y\\n self.path_x = []\\n self.path_y = []\\n self.parent = None\\n self.cost = 0.0\",\n \"def __init__(self, mass, x, y,px=0.0,py=0.0):\\n self.mass = mass\\n self.position = np.array([x,y])\\n self.momentum = np.array([px,py])\",\n \"def __init__(self, mass, radius, position, velocity):\\n self.mass = mass\\n self.radius = radius\\n self.position = position\\n self.velocity = velocity\\n print(self.velocity)\\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\\n self.delete = False\",\n \"def __init__(self):\\n super().__init__()\\n self.waypoint_vector = [-1, 10]\",\n \"def __init__(self):\\r\\n self.position=(0,0)\\r\\n self.direction = 0.\\r\\n self.speed = 0\\r\\n self.state = 0\\r\\n pass\",\n \"def __init__(self,mass,time,**kwargs):\\n self.setTime(time)\\n ParticlePhaseCoordinates.__init__(self,mass,**kwargs)\",\n \"def __init__(self, inPs, outPs):\\n self.angle = 0.0\\n self.speed = 16.5\\n\\n super(MovementControl,self).__init__(inPs, outPs)\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All motion starts at (0,0).\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, x_coor, x_speed, y_coor, y_speed, direction):\\n self.__x_coor = x_coor\\n self.__x_speed = x_speed\\n self.__y_coor = y_coor\\n self.__y_speed = y_speed\\n self.__direction = direction\\n self.__radius = self.TORPEDO_RADIUS\",\n \"def __init__(self):\\n self.position = Vector2()\\n self.velocity = Vector2()\\n self.update_parameters()\\n self.mass = 0.18 # Mass of Sphero robot in kilograms\",\n \"def __init__(self):\\n self.x = 0.0\\n self.y = 0.0\\n self.theta = 0.0\\n self.total_distance_covered = 0.0\",\n \"def __init__(self, path):\\r\\n self.path = path\\r\\n # 0.75 deg per grid box latitudinally\\r\\n self.lat_unit = 360\",\n \"def __init__(self):\\n raise NotImplementedError('cannot create independent arc')\",\n \"def __init__(self, x_axis_p, y_axis_p, x_speed=0, y_speed=0, direction=0):\\r\\n self.__x_axis = x_axis_p\\r\\n self.__y_axis = y_axis_p\\r\\n self.__X_speed = x_speed\\r\\n self.__y_speed = y_speed\\r\\n self.__direction = direction\\r\\n self.__lives = 3\",\n \"def __init__(self, coords, direction):\\n self.y, self.x = coords\\n self.direction = direction\",\n \"def __init__(self,x,y,width,height):\\n self.x = x\\n self.y = y\\n self.width = width\\n self.height = height\\n self.velocity_x = 0.0\",\n \"def __init__(self, Position, M):\\n self.pos = Position # Sets x position\\n self.m = M # Sets mass\\n # Initial velocity and acceleration set to be zero\\n self.vel = np.zeros((2,))\\n self.acc = np.zeros((2,))\",\n \"def __init__(self, position, momentum, mass):\\n self.position = position\\n self.momentum = momentum\\n self.mass = mass\",\n \"def __init__(self, pos):\\r\\n self.pos = pos\\r\\n self.vel = [0, 0]\\r\\n self.acc = [0, 0]\\r\\n self.heading = math.pi\\r\\n self.screen = [0, 0]\",\n \"def __init__(self, x_0, y_0, initX, initY,h=5):\\n self.x_0=x_0\\n self.y_0=y_0\\n self.x_init=initX\\n self.y_init=initY\\n self.step=h\",\n \"def __init__(self, direction=0, x=0, y=0):\\n self.direction = direction\\n self.x = x\\n self.y = y\",\n \"def __init__(self, path_fun, disp_fun):\\n \\n if path_fun.nx != 1 or disp_fun.nx != 1:\\n raise ValueError(\\\"path_fun and disp_fun must have 1 input variable\\\")\\n \\n # The number of output coordinates is defined by the\\n # number of output functions of `path_fun`\\n nQ = path_fun.nf\\n \\n # The number of input coordinates equals the number\\n # of path-displacements plus 1.\\n if disp_fun.nf % nQ != 0:\\n raise ValueError('dispfun.nf must be a multiple of nQ')\\n n = disp_fun.nf // nQ # The number of displacement coordinates \\n \\n nQp = n + 1 # The total number of input coordinates \\n \\n Qpstr = ['s'] + [f\\\"d{i:d}\\\" for i in range(n)]\\n Qstr = [f\\\"Q{i:d}\\\" for i in range(nQ)]\\n \\n # The maxderiv is the minimum of either path_fun \\n # or disp_fun \\n maxderiv = dfun._merged_maxderiv(path_fun.maxderiv, disp_fun.maxderiv)\\n \\n # If the displace vectors have a finite zlevel, then the \\n # zlevel for that term is just 1 more (from the linear dependence on \\n # Q'). The total zlevel is then the merged zlevel of the path function\\n # and the displacement term \\n #\\n if disp_fun.zlevel is None:\\n disp_zlevel = None \\n else: \\n disp_zlevel = disp_fun.zlevel + 1 \\n zlevel = dfun._merged_zlevel(path_fun.zlevel, disp_zlevel)\\n \\n super().__init__(self._pathtrans_fun, nQp = nQp, nQ = nQ,\\n name = 'Path', Qpstr = Qpstr, Qstr = Qstr,\\n maxderiv = maxderiv, zlevel = zlevel)\\n \\n self.path_fun = path_fun \\n self.disp_fun = disp_fun\",\n \"def __init__(self, new_pt):\\n self.x = float(new_pt[0])\\n self.y = float(new_pt[1])\\n self.next = None\\n self.prev = None\\n self.distance_to_next = 0\\n self.angle = None\",\n \"def __init__(self):\\n self.Robot = Robot()\\n self.Omega = matrix()\\n # self.Omega.value[0][0] = 1.0\\n # self.Omega.value[1][1] = 1.0\\n self.Xi = matrix()\\n # Xi.value[0][0] = 0.0\\n # Xi.value[1][0] = 0.0\\n self.measure = {}\\n self.landMarkCount = 0\\n self.init = False\\n self.bearing = 0\\n self.x = 0\\n self.y = 0\\n \\n # TODO\",\n \"def __init__(self, pos=(0,0), dire = 0):\\r\\n self.initX = self.x = pos[0]\\r\\n self.initY = self.y = pos[1]\\r\\n self.initDir = self.dir = math.radians(dire)\",\n \"def __init__(self, init_pose=None, init_velocities=None, \\n init_angle_velocities=None, runtime=5., target_pos=None):\\n \\n # initial state\\n self.state_scale = 1\\n \\n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\\n self.init_pose[2] += 10\\n self.init_velocities = np.array([0.,0.,0.])\\n self.init_angle_velocities = np.array([0.,0.,0.])\\n\\n self.runtime = runtime\\n \\n # Simulation\\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \\n self.action_repeat = 1\\n\\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\\n self.state_size = self.action_repeat * self.init_state.shape[0]\\n \\n self.action_low = 0 #-1\\n self.action_high = 2*450 #1\\n self.action_size = 4\\n\\n self.action_scale = 1 #450 # 1/2 max of the action \\n #self.state_scale = 150 # 1/2 size of the state space\\n \\n # Goal\\n self.target_pose = np.array([0.,0.,150.0])\\n\\n # The previous position\\n self.prev_pose = self.init_pose\",\n \"def __init__(self, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n super(VelocityVerletIntegrator, self).__init__(timestep)\\n\\n self.addPerDofVariable(\\\"x1\\\", 0)\\n\\n self.addUpdateContextState()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x+dt*v\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m+(x-x1)/dt\\\")\\n self.addConstrainVelocities()\",\n \"def __init__(self):\\n self.x = 0\\n self.y = 0\",\n \"def __init__(self):\\n self.x = 0\\n self.y = 0\",\n \"def __init__(self, newPath):\\n self.newPath = newPath\",\n \"def __init__(self, **kwargs):\\n self.motion_err = np.array(kwargs.pop('err', [0., 0.]), dtype=float)\\n\\n pose = np.array(kwargs.pop('pose', [0.,0.,0.]), dtype=float)\\n super(XYPhiRobot, self).__init__(pose=pose)\",\n \"def __init__(self, path, ar_no):\\n self.path = path\\n self.ar_no = ar_no\\n self.dt = pos_neg_detection()\\n self.ts = ts_processing(self.path, self.ar_no)\",\n \"def __init__(self, x=0, y=0, rotation=0):\\n self.x, self.y = x, y\\n self.rotation = rotation\\n\\n self.x_speed, self.y_speed = 0, 0\",\n \"def __init__(self):\\n self.mu = None\\n self.type = None\\n self.direction = None\\n self.eq_points = None\\n self.init_conds = None\\n self.time = None\\n self.trajectory = None\\n self.initial_point = None\\n self.contour_levels = []\",\n \"def build(self):\\n\\n pt1 = rs.CurveStartPoint(self.geo)\\n pt2 = rs.CurveEndPoint(self.geo)\\n\\n # get spring direction\\n self.dx = round(+ pt2[0] - pt1[0], 5)\\n self.dy = round(+ pt2[1] - pt1[1], 5)\\n self.dz = round(+ pt2[2] - pt1[2], 5)\\n\\n # normalize direction\\n d = (self.dx ** 2 + self.dy ** 2 + self.dz ** 2) ** 0.5\\n self.dx /= d\\n self.dy /= d\\n self.dz /= d\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All walks start at (0, 0)\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, num_points=5000):\\n self.num_points = num_points\\n\\n # All walks start at (0, 0)\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self, num_points = 5000):\\n self.num_points = num_points\\n\\n #all walks start at 0.0\\n self.x_values = [0]\\n self.y_values = [0]\",\n \"def __init__(self,):\\r\\n self.g = 9.81\\r\\n self.l = 0.5\\r\\n self.m1 = 1.0\\r\\n self.m2 = 1.0\\r\\n self.m3 = 1.0\\r\\n self.r1 = 1.0\\r\\n self.r2 = 1.0\\r\\n self.tau = 0.001\\r\\n self.theta1 = 1.0\\r\\n self.theta2 = 1.0\\r\\n self.theta3 = 1.0\",\n \"def __init__(self, coordinate, speed_vec, heading):\\n self.__heading = heading\\n super().__init__(coordinate, speed_vec, Ship.RADIUS)\",\n \"def __init__(self, x, y):\\n # assigning the initial position\\n self.x = x\\n self.y = y\",\n \"def imitate_path(self, y_des, plot=False):\\n\\n # set initial state and goal\\n if y_des.ndim == 1:\\n y_des = y_des.reshape(1, len(y_des))\\n self.y0 = y_des[:, 0].copy()\\n self.y_des = y_des.copy()\\n self.goal = self.gen_goal(y_des)\\n\\n # self.check_offset()\\n\\n # generate function to interpolate the desired trajectory\\n import scipy.interpolate\\n\\n path = jnp.zeros((self.n_dmps, self.timesteps))\\n x = jnp.linspace(0, self.cs.run_time, y_des.shape[1])\\n for d in range(self.n_dmps):\\n path_gen = scipy.interpolate.interp1d(x, y_des[d])\\n for t in range(self.timesteps):\\n path[d, t] = path_gen(t * self.dt)\\n y_des = path\\n\\n # calculate velocity of y_des with central differences\\n dy_des = jnp.gradient(y_des, axis=1) / self.dt\\n\\n # calculate acceleration of y_des with central differences\\n ddy_des = jnp.gradient(dy_des, axis=1) / self.dt\\n\\n f_target = jnp.zeros((y_des.shape[1], self.n_dmps))\\n # find the force required to move along this trajectory\\n for d in range(self.n_dmps):\\n f_target[:, d] = ddy_des[d] - self.ay[d] * (\\n self.by[d] * (self.goal[d] - y_des[d]) - dy_des[d]\\n )\\n\\n # efficiently generate weights to realize f_target\\n self.gen_weights(f_target)\\n\\n if plot is True:\\n # plot the basis function activations\\n import matplotlib.pyplot as plt\\n\\n plt.figure()\\n plt.subplot(211)\\n psi_track = self.gen_psi(self.cs.rollout())\\n plt.plot(psi_track)\\n plt.title(\\\"basis functions\\\")\\n\\n # plot the desired forcing function vs approx\\n for ii in range(self.n_dmps):\\n plt.subplot(2, self.n_dmps, self.n_dmps + 1 + ii)\\n plt.plot(f_target[:, ii], \\\"--\\\", label=\\\"f_target %i\\\" % ii)\\n for ii in range(self.n_dmps):\\n plt.subplot(2, self.n_dmps, self.n_dmps + 1 + ii)\\n plt.plot(\\n jnp.sum(psi_track * self.w[ii], axis=1) * self.dt,\\n label=\\\"w*psi %i\\\" % ii,\\n )\\n plt.legend()\\n plt.title(\\\"DMP forcing function\\\")\\n plt.tight_layout()\\n plt.show()\\n\\n self.reset_state()\\n return y_des\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, path):\\n self.path = path\",\n \"def __init__(self, target_velocity, dt, model_type, robot_type):\\n super(StraightEnv, self).__init__(\\n target_velocity=target_velocity,\\n dt=dt,\\n model_type=model_type,\\n robot_type=robot_type\\n )\\n\\n # Reward function parameters\\n self._lambda1 = 0.25\\n\\n # State in frame of target straight line. See get_initial_state()\\n # function for info.\\n self._current_state = np.zeros(6)\\n\\n # Target line to follow. See get_initial_state() function for info.\\n self._target_y = 0\\n self._target_yaw = 0\\n\\n # Initialize nodes and set up ROS topics\\n rospy.init_node('rl_planner')\\n self.publisher = rospy.Publisher('commands/keyboard',\\n ackermann_msgs.msg.AckermannDriveStamped, queue_size=1)\\n rospy.Subscriber('ekf_localization/odom', nav_msgs.msg.Odometry,\\n self._odometry_callback)\\n self._sensor_stamp = rospy.Time.now()\\n\\n # Wait this number of timesteps before computing another action (this\\n # is similar to setting a larger dt during training)\\n self._num_states_needed = 3\\n self._num_states_received = 0\",\n \"def __init__(self, location):\\r\\n self.y = location[1]\\r\\n self.x = location[0]\\r\\n self.yvel = 0.0\\r\\n self.xvel = 0.0\",\n \"def generate_motion_patters(self):\\n\\n\\t\\t# Motion primimtives for the forward direction.....................\\n\\t\\td_del = 0.08\\t\\n\\t\\tdt = self.dt\\n\\t\\tv = 2\\t# Assuming a constant longitudinal velocity\\n\\t\\tdelta = np.arange(-np.pi*self.max_steer/180, d_del + np.pi*self.max_steer/180, d_del)\\n\\t\\tprint(\\\"Number of motion patterns in forward directon: {}\\\".format(len(delta)))\\n\\t\\tfor d in delta:\\n\\t\\t\\tx0 = self.x0\\n\\t\\t\\ty0 = self.y0\\n\\t\\t\\ttheta0 = self.theta0\\n\\t\\t\\tp = np.array([x0, y0, theta0])\\n\\t\\t\\t\\n\\t\\t\\tfor i in range(self.num_steps):\\n\\t\\t\\t\\tx0 += v*cos(theta0)*dt\\n\\t\\t\\t\\ty0 += v*sin(theta0)*dt\\n\\t\\t\\t\\ttheta0 += v*tan(d)*dt/self.L\\n\\t\\t\\t\\tp = np.vstack((p,np.array([x0, y0, theta0])))\\n\\n\\t\\t\\t# Adding the motion primitive array to the list\\n\\t\\t\\tself.motion_primitives.append(p)\\n\\n\\t\\t\\n\\t\\t# Motion primitives for the backward direction ...................\\n\\t\\td_del = 0.1\\n\\t\\tv = -1.2\\n\\t\\tdelta = np.arange(-np.pi*self.max_steer/180, d_del + np.pi*self.max_steer/180, d_del)\\n\\t\\tprint(\\\"Number of motion patterns for the backward direction: {}\\\".format(len(delta)))\\n\\t\\tfor d in delta:\\n\\t\\t\\tx0 = self.x0\\n\\t\\t\\ty0 = self.y0\\n\\t\\t\\ttheta0 = self.theta0\\n\\t\\t\\tp = np.array([x0, y0, theta0])\\n\\n\\t\\t\\tfor i in range(self.num_steps):\\n\\t\\t\\t\\tx0 += v*cos(theta0)*dt\\n\\t\\t\\t\\ty0 += v*sin(theta0)*dt\\n\\t\\t\\t\\ttheta0 += v*tan(d)*dt/self.L\\n\\t\\t\\t\\tp=np.vstack((p, np.array([x0, y0, theta0])))\\n\\t\\t\\t# Adding the motion primitive array to the list\\n\\t\\t\\tself.motion_primitives.append(p)\",\n \"def __init__(self, d):\\n\\t\\tself._coords = [0] * d\",\n \"def __init__(self, direction, position):\\n self.direction = normalize(direction)\\n self.position = np.array(position)\",\n \"def __init__(self, x_pos, y_pos, radius, colour, moving = False):\\n\\t\\t\\n\\t\\tself.x_pos = x_pos\\n\\t\\tself.y_pos = y_pos\\n\\t\\tself.radius = radius\\n\\t\\tself.diameter = 2*radius\\n\\t\\tself.colour = colour\\n\\t\\tself.moving = moving\\n\\t\\tself.x_vec = 0\\n\\t\\tself.y_vec = 0\",\n \"def __init__(self, goal_pos=7.5, *args, **kwargs):\\n super(Attacker, self).__init__(*args, **kwargs)\\n self.goal_p=goal_pos\\n goal = (-1.5+3*np.random.rand(), self.goal_p)\\n self.path, self.status = passPath(self.getRobotConf(self.bot), self.ballEngine.getBallPose(), goal, kick=True)\",\n \"def __init__(self):\\n\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n\\n self.X = None\\n self.y = None\",\n \"def __init__(self, goal_pos=0.72, *args, **kwargs):\\n super(Goalie, self).__init__(*args, **kwargs)\\n self.goal=goal_pos\",\n \"def __init__(self,name,speed,depth_of_view,view_angle,x_coor = \\\"\\\",y_coor = \\\"\\\"):\\n self.name = name\\n self.speed = speed # That will the instantenous speed of the robot\\n self.depth_of_view = depth_of_view # That will the instantenous depth of view of the robot\\n self.view_angle = view_angle # That will the instantenous view angle of the robot\\n self.type = \\\"Robot\\\" #Specift the object type\\n self.x = x_coor # store the position of the robot\\n self.y = y_coor # store the position of the robot\\n self.kind = name #Store its kind to give the GUI\",\n \"def __init__(self, path):\\n self._path = path\",\n \"def __init__(self, startpos = (75,75), angle = 0, colour = (240,100,100),\\n maxSpeed = 20, maxAccel = 1, maxAngle = 0.1,\\n width = 1600, height = 900, maze = None,\\n intermediates = (8,), inputdistance = [50,100,150], inputangle = [1.2,0.6,0,-0.6,-1.2],\\n parentname = \\\"\\\", parentcolour = (240,100,100), name = None,orders = [1,2,3,4,5,6,7,8]):\\n self.startpos, self.startangle, self.colour = startpos, angle, colour\\n self.maxSpeed, self.maxAccel, self.maxAngle = maxSpeed, maxAccel, maxAngle\\n self.maze = maze\\n self.width, self.height = width, height\\n self.parentname, self.parentcolour = parentname, parentcolour\\n # Create dimensions array based on input, intermediate dimensions and output (4)\\n self.inputType = 1 # 0: point, 1: linear\\n self.setDimension(inputdistance,inputangle,intermediates,orders)\\n self.drag = 0.99\\n self.initWeights()\\n self.sightLength = 200\\n \\n if name is not None: \\n self.name = name\\n else:\\n self.name = self.getName()\\n \\n self.reset()\",\n \"def __init__(self, angle: float):\\n # FIXME No coordinates for position, because assumed to always be towards cue ball...\\n self.ang = angle\",\n \"def __init__(self, x, y):\",\n \"def __init__(self,circlePos,circleRad,circleVel):\\n self.circlePos=circlePos\\n self.circleRad=circleRad\\n self.circleVel=circleVel\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def __init__(self):\\n self.X = None\\n self.y = None\",\n \"def build(self, trajectory):\\n pass\",\n \"def __init__(self, motion, **kwargs):\\n super(ShiftIn, self).__init__(motion)\",\n \"def __init__(self, start_pos, end_pos, direction):\\n self.s_pos = start_pos\\n self.e_pos = end_pos\\n self.dir = direction\",\n \"def __init__(self, position, anim, rotation, rotSpeed, rotPoint, entf_rotPoint, movSpeed, radius, textur, divisions):\\n self.position = position # Position im XYZ-Raum\\n self.anim = anim # Animationen an/aus\\n self.rotation = rotation # Rotation um die eigene Achse\\n self.rotSpeed = rotSpeed # Rotationsgeschwindigkeit\\n self.rotPoint = rotPoint # Punkt, um den sich der Planet bewegen soll\\n self.entf_rotPoint = entf_rotPoint # Entfernung von ebendiesem Punkt\\n self.movSpeed = movSpeed # Orbitalgeschwindigkeit\\n self.radius = radius # Radius des Himmelskoerpers\\n self.textur = textur # Textur\\n self.divisions = divisions # Unterteilungen. Mehr = feinere, schoenere Kugel\\n self.top = False\",\n \"def __init__(self, x_traj=[], y_traj=[], period=0, num_div_action=5,\\n closed=True, differential_car=True, discrete_input=False):\\n\\n # Size of the space\\n self.max_x = SPACE_X / 2 # [m]\\n self.max_y = SPACE_Y / 2 # [m]\\n self.state = []\\n self.x_trajectory = x_traj\\n self.y_trajectory = y_traj\\n self.r= 0.0325 # [m] wheel´s radius\\n self.rho = 0.133 # [m] distance between wheel\\n self.time = period # frames per second\\n\\n # More steps for Ackerman model because circuit is longer\\n if discrete_input:\\n self.max_steps = 600\\n else:\\n self.max_steps = 600\\n\\n self.constant = -0.1\\n self.x_ant = 0.0\\n self.y_ant = 0.0\\n # Sqr of the limit distance\\n self.zone_0_limit = ZONE0_LIMIT\\n self.zone_1_limit = ZONE1_LIMIT\\n self.zone_2_limit = ZONE2_LIMIT\\n if discrete_input:\\n self.zone_2_limit = 0.08\\n else:\\n self.zone_2_limit = ZONE2_LIMIT\\n\\n self.num_div_action = num_div_action\\n self.num_div_state = num_div_action\\n\\n # It is to inform if it´s an closed circuit without ending\\n self.closed = closed\\n\\n # Distance between axis in Ackerman car\\n self.l_ack = 0.245\\n # Radius of wheels of the Ackerman car\\n self.r_ack = 0.035\\n # Maximum angle of the wheels of the Ackerman car\\n self.alpha_ack = 25.34*np.pi/180\\n\\n # Choose car model\\n self.differential_car = differential_car\\n\\n self.discrete_input = discrete_input\\n\\n # parameters to add noise to x, y, angle values\\n # self.mu = 0\\n # self.sigmaxy = 0.002\\n # self.sigmaangle = 2*np.pi/180\",\n \"def __init__(self, name: str):\\n self._name = name\\n self._yaw = Motion(\\\"yaw\\\")\\n self._pitch = Motion(\\\"pitch\\\")\\n self._roll = Motion(\\\"roll\\\")\\n self._sway = Motion(\\\"sway\\\")\\n self._surge = Motion(\\\"surge\\\")\\n self._heave = Motion(\\\"heave\\\")\",\n \"def __init__(self, motion, **kwargs):\\n super(ShiftWeight, self).__init__(motion)\",\n \"def __init__(self):\\n # Lynx Dimensions in mm\\n self.L1 = 76.2 # distance between joint 0 and joint 1\\n self.L2 = 146.05 # distance between joint 1 and joint 2\\n self.L3 = 187.325 # distance between joint 2 and joint 3\\n self.L4 = 34 # distance between joint 3 and joint 4\\n self.L5 = 34 # distance between joint 4 and center of gripper\\n\\n # Joint limits\\n self.lowerLim = np.array([-1.4, -1.2, -1.8, -1.9, -2.0, -15]).reshape((1, 6)) # Lower joint limits in radians (grip in mm (negative closes more firmly))\\n self.upperLim = np.array([1.4, 1.4, 1.7, 1.7, 1.5, 30]).reshape((1, 6)) # Upper joint limits in radians (grip in mm)\",\n \"def __init__(self,start_coord, motion = \\\"Ornstein-Uhlenbeck\\\",\\\\\\n history = None,params={\\\"L\\\":0.20,\\\"delta\\\":0.25}):\\n if history is None:\\n history = []\\n self.StartCoord = start_coord\\n self.Coord = start_coord\\n self.History = history\\n self.History.append(start_coord)\\n self.Params = params\\n self.ProcessType = motion\\n self.Perturbations = []\",\n \"def __init__(self):\\n self.parameter = [[(0,1),(1,1),(0,0),(1,0)],\\n [(1,0),(1,0),(0,1),(0,1)],\\n [(1,0),(0,1),(1,0),(0,1)],\\n [(0,0),(0,0),(0,0),(0,0)]]\\n \\\"\\\"\\\"Distance is number of whole route from origin to destination\\\"\\\"\\\"\\n self.distance = 100\\n \\\"\\\"\\\"action sets\\\"\\\"\\\"\\n self.action = [0,55,75]\\n self.maxSpeed = self.action[-1]\\n \\\"\\\"\\\"time period for each stage\\\"\\\"\\\"\\n self.time_interval = 0.5\\n \\\"\\\"\\\"Number of stages we want to check. Here we can use this to limit the\\n travel time, since sometimes we want driver to arrive in a time window.\\n For example, if stage is 4, that means we want to driver finish route within \\n 2 hours. \\\"\\\"\\\"\\n self.stage = 4\\n self.time_block = 0.5\\n self.distance_block = 25\",\n \"def __init__(self, pos):\\r\\n self.pos = pos\",\n \"def __init__(self, X, y):\\n pass\",\n \"def __init__(self):\\n self.rot_axis = 1\",\n \"def movement(self):\",\n \"def __init__(self, x, y, th):\\n self.x = x\\n self.y = y\\n self.th = th\",\n \"def __init__(self, path=\\\"IdentityFunction\\\"):\\n self.path = path\\n self.heal = lambda X: X\\n self.heal_tf = lambda X: X\",\n \"def __init__(self):\\n self.position = 0\",\n \"def path(e,a,q,i,period, timediff, offset):\\n b = a*np.sqrt(1-e**2)\\n c=np.sqrt(a**2-b**2)\\n #t = ((timediff*np.pi*b)/period)\\n #t1 = ((timediff)*np.pi*b)/period\\n #print(t1-t)\\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\\n #print(t)\\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\\n theta=0 #need a real theta value \\n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\\n \\n \\n return xcoord, ycoord, zcoord\",\n \"def __init__(self, coordinates, emissivity = 0.4): \\n\\t\\tsuper().__init__(coordinates)\\n\\t\\tself.emissivity = emissivity\\n\\t\\tself.type = 'thermometer'\",\n \"def __init__(self, d):\\n self._coords = [0]*d\",\n \"def __init__(self, mass, position, velocity):\\n self.mass = mass\\n self.position = position\\n self.velocity = velocity\",\n \"def __init__(self, origin, direction):\\r\\n self.origin = np.array(origin)\\r\\n self.direction = np.array(direction)\",\n \"def __init__(self, x1, y1):\\n self.x = x1\\n self.y = y1\",\n \"def __init__(self, angle, x, y):\\n pygame.sprite.Sprite.__init__(self)\\n self.image = pygame.image.load(\\\"Image/Trafico.png\\\")\\n self.rect = self.image.get_rect()\\n self.image_orig = self.image\\n self.speed = 2\\n self.direction = angle\\n self.steering = 90\\n self.x = x\\n self.y = y\",\n \"def __init__(self, center, waypoints, firepoints):\\n super().__init__(center, MallFighter.MALL_FIGHTER_SPEED, MallFighter.ANIMATION_DELAY, *MallFighter.FILE_PATH)\\n self.fire_idx = 0\\n self.way_idx = 0\\n self.waypoints = waypoints\\n self.firepoints = firepoints\",\n \"def __init__(self, x=0, y=0, angle=90):\\n self.x = x\\n self.y = y\\n self.angle = angle\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7820282","0.7787644","0.77386826","0.6963891","0.6757834","0.65536493","0.65116596","0.64888525","0.6445253","0.63971484","0.6376502","0.636337","0.63444155","0.6312085","0.6276762","0.6248574","0.62414914","0.6194726","0.6188483","0.6171967","0.61705893","0.6142406","0.6133022","0.6122119","0.60554755","0.60498303","0.6037605","0.6024924","0.5999505","0.59954375","0.59639204","0.5961212","0.5953101","0.59521514","0.5951049","0.5950358","0.5950358","0.5946721","0.593561","0.5927515","0.59237903","0.59165037","0.59141755","0.5908553","0.5908553","0.59084857","0.5908219","0.5900899","0.58889246","0.5885018","0.5861417","0.5861417","0.5861417","0.5861417","0.5850405","0.58492315","0.58443725","0.5843543","0.5841113","0.58353734","0.5827304","0.58246446","0.58246446","0.58200985","0.58101034","0.5806269","0.58026487","0.5800037","0.5797154","0.57935566","0.57923657","0.57923657","0.57923657","0.57923657","0.5791559","0.5789807","0.578873","0.5788442","0.57775426","0.5772836","0.57654047","0.5764858","0.5755955","0.5751285","0.5749398","0.57485527","0.57465744","0.57445073","0.57424545","0.573954","0.5737758","0.5731672","0.5730506","0.57243747","0.5722089","0.5714901","0.57099044","0.5709859","0.57096666","0.57092977"],"string":"[\n \"0.7820282\",\n \"0.7787644\",\n \"0.77386826\",\n \"0.6963891\",\n \"0.6757834\",\n \"0.65536493\",\n \"0.65116596\",\n \"0.64888525\",\n \"0.6445253\",\n \"0.63971484\",\n \"0.6376502\",\n \"0.636337\",\n \"0.63444155\",\n \"0.6312085\",\n \"0.6276762\",\n \"0.6248574\",\n \"0.62414914\",\n \"0.6194726\",\n \"0.6188483\",\n \"0.6171967\",\n \"0.61705893\",\n \"0.6142406\",\n \"0.6133022\",\n \"0.6122119\",\n \"0.60554755\",\n \"0.60498303\",\n \"0.6037605\",\n \"0.6024924\",\n \"0.5999505\",\n \"0.59954375\",\n \"0.59639204\",\n \"0.5961212\",\n \"0.5953101\",\n \"0.59521514\",\n \"0.5951049\",\n \"0.5950358\",\n \"0.5950358\",\n \"0.5946721\",\n \"0.593561\",\n \"0.5927515\",\n \"0.59237903\",\n \"0.59165037\",\n \"0.59141755\",\n \"0.5908553\",\n \"0.5908553\",\n \"0.59084857\",\n \"0.5908219\",\n \"0.5900899\",\n \"0.58889246\",\n \"0.5885018\",\n \"0.5861417\",\n \"0.5861417\",\n \"0.5861417\",\n \"0.5861417\",\n \"0.5850405\",\n \"0.58492315\",\n \"0.58443725\",\n \"0.5843543\",\n \"0.5841113\",\n \"0.58353734\",\n \"0.5827304\",\n \"0.58246446\",\n \"0.58246446\",\n \"0.58200985\",\n \"0.58101034\",\n \"0.5806269\",\n \"0.58026487\",\n \"0.5800037\",\n \"0.5797154\",\n \"0.57935566\",\n \"0.57923657\",\n \"0.57923657\",\n \"0.57923657\",\n \"0.57923657\",\n \"0.5791559\",\n \"0.5789807\",\n \"0.578873\",\n \"0.5788442\",\n \"0.57775426\",\n \"0.5772836\",\n \"0.57654047\",\n \"0.5764858\",\n \"0.5755955\",\n \"0.5751285\",\n \"0.5749398\",\n \"0.57485527\",\n \"0.57465744\",\n \"0.57445073\",\n \"0.57424545\",\n \"0.573954\",\n \"0.5737758\",\n \"0.5731672\",\n \"0.5730506\",\n \"0.57243747\",\n \"0.5722089\",\n \"0.5714901\",\n \"0.57099044\",\n \"0.5709859\",\n \"0.57096666\",\n \"0.57092977\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78976136"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20291,"cells":{"query":{"kind":"string","value":"Returns where the arm end effector should be at time t"},"document":{"kind":"string","value":"def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0","def end_time(self) -> float:\r\n ...","def endTime(self):\n return self.params['tend']","def get_last(t_, w_):\n return t_ - tf.constant(1)","def end(self):\n return self._t0 + self.length","def getEndTime(self):\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)","def end_effectors_pos(self):\n def relative_pos_in_egocentric_frame(physics):\n end_effector = physics.bind(self._entity.end_effectors).xpos\n torso = physics.bind(self._entity.root_body).xpos\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\n return observable.Generic(relative_pos_in_egocentric_frame)","def est_am(t,y):\n ch=t>t_eq\n y1=y[ch]\n return y1[-1]-y1[0]","def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\n\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\n naturalLog = np.log(numeratorLN/denomLN)\n\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\n brackets = F - Fp + product1\n\n product2 = (1/Ks)*brackets\n time = tp + product2 - endingTime\n return time","def getEndTime(self):\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)","def find_exit_time(self):\n \n # check when last bead starts moving\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\n nonzero = np.flatnonzero( vel_last_bead )\n \n if nonzero.size == 0:\n warnings.warn('The wave did not exit the chain or it could not be determined.')\n return np.nan\n else:\n exit_index = np.min( nonzero )\n time = self.get_time()\n exit_time = time[exit_index]\n return exit_time","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)","def timeofflight(xhat0):\n\t\timport poincare\n\t\t#Find the point on the computed poincare section, closest to the x0\n\t\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\n\t\t#Take its time of flight as\n\t\tif imin < np.size(ps,0)-1: \n\t\t\tTapproximate = ps[imin+1,0]-ps[imin,0]\n\t\telse:\n\t\t\tTapproximate = ps[imin,0]-ps[imin-1,0]\n\t\tprint(\"Tapproximate:\")\n\t\tprint(Tapproximate)\n\t\t#Integrate for a little bit longer than the approximated integration time:\n\t\tstoptime = 1.2*Tapproximate\n\t\tnumpoints = int(stoptime/0.01)\n\t\t#Integration time array:\n\t\tt = np.linspace(0, stoptime, numpoints)\n\t\txhatphi0 = np.append(xhat0, np.array([0], float))\n\t\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\n\t\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\n\t\t#Compute Poincare section:\n\t\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\n\t\tprint(\"psreturn:\")\n\t\tprint(psreturn)\n\t\t#Take the time nearest to the approximated time. This is due to the\n\t\t#fact that the array ps sometimes includes the initial point and sometimes\n\t\t#does not, hence we are not always sure the position of the first return.\n\t\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\n\t\ttof = psreturn[itof,0]\n\t\treturn tof","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def get_delta_t(self):\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\n - self.gv.t_queue[self.gv.filter_min_bound]","def at(self, t):\n return self.start + (self.end - self.start) * t","def end_time(self):\n pass","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def end_time(self):\n # TODO: use pd.Timestamp instead\n return self.time[-1].to_pydatetime()","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def get_trace_abs(self, norm=True):\n if self.Et is not None:\n # Center peak in time\n ind = np.argmax(abs(self.Et))\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\n Et = np.abs(np.roll(self.Et, shift))\n if norm is True:\n Et /= Et.max()\n else:\n Et = None\n return Et","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def _dy(self, T):\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])","def end_point(self) -> Vec3:\n v = list(self.vertices([self.dxf.end_angle]))\n return v[0]","def _reached_temperature_end_point(self, T, Tend):\n if Tend is None:\n # End point not give\n return False\n\n if self._integration_direction == \"increasing\":\n if T > Tend:\n return True\n elif self._integration_direction == \"decreasing\":\n if T < Tend:\n return True\n return False","def end_time(self, t):\r\n # Increase temperature while silent.\r\n if np.count_nonzero(self.next_note) == 0:\r\n self.silent_time += 1\r\n if self.silent_time >= NOTES_PER_BAR:\r\n self.temperature += 0.1\r\n else:\r\n self.silent_time = 0\r\n self.temperature = self.default_temp\r\n \r\n self.notes_memory.append(self.next_note)\r\n # Consistent with dataset representation\r\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\r\n self.results.append(self.next_note)\r\n # Reset next note\r\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\r\n return self.results[-1]","def find_alert_time(self) -> None:\n \n # Also not clear from the paper how to doe this,\n # use the first 10 data points in the light curve to determine the magnitude\n # baseline\n\n mean_mag = np.mean(self.mags[:10])\n std_mag = np.std(self.mags[:10])\n\n num_above = 0 \n i = 9\n\n while num_above < 3 and i < len(self.times)-1:\n \n i += 1 \n\n if self.mags[i] < mean_mag - std_mag:\n num_above += 1\n else:\n num_above = 0.0\n\n if len(self.times) - 1 == i:\n print(\"Give me more training data, not alerted yet, this is probably going to fail\")\n \n return self.times[i-1]","def eval(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[:len(res)//2]","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def getEndTime(self):\n return _osgAnimation.Channel_getEndTime(self)","def line_segment(t, # Array of times for each position\n t_now # Current time (float)\n ):\n i = np.argwhere(t > t_now)\n if len(i) > 0:\n if i[0] != 0: # if the current time is not less than the starting time\n segment_starting_index = i[0][0] - 1\n else:\n segment_starting_index = 0\n\n segment_end_index = i[0][0]\n\n else: # if the current time is more than the last point (destination) time\n segment_starting_index = t.shape[0]\n segment_end_index = t.shape[0]\n\n return segment_starting_index, segment_end_index","def end_abs(self):\n if self.end == float('inf'):\n return self.track.duration\n else:\n return self.end","def time_step(self):\n\n rho_rel = np.abs(self.rho_dt / self.rho)\n rho_rel_max = np.max(rho_rel)\n e_rel = np.abs(self.e_dt / self.e)\n e_rel_max = np.max(e_rel)\n x_rel = np.abs(self.u / self.dx)\n x_rel_max = np.max(x_rel)\n y_rel = np.abs(self.w / self.dy)\n y_rel_max = np.max(y_rel)\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\n delta = np.max(np.abs(rel))\n\n if 0.1 <= delta <= 1e3:\n self.dt = self.p / delta\n else:\n self.dt = self.p","def end_time(self):\n return RPR.GetAudioAccessorEndTime(self.id)","def run_e(self, t):\n if t > self.n_t:\n raise IndexError('Maximum simulated timesteps exceeded in E step')\n if self.pf.t >= t:\n raise IndexError(\n 'Particle filter already run past given time point')\n while self.pf.t < t:\n self.pf.advance()\n self.pf.calculate_means_sdevs()\n\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))","def end_of_horizon_cost_rule(_m):\r\n\r\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\r\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\r","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def end(self):\r\n hours = self.length // 60\r\n minutes = self.length % 60\r\n return time(self.start.hour + hours, self.start.minute + minutes)","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def get_end(self):\n\n return self.end_cycle","def _get_end_time(self):\n return self.__end_time","def get_end(self):\n return self._start + self._duration","def diff(t, y):\n origin = root.vectorize()\n root.tensorize(y)\n self.time = t if not imaginary else None\n self.eom()\n ans = root.vectorize(use_aux=True)\n root.tensorize(origin)\n return ans","def inc_end(self):\n return self._exc_end - TIMERANGE_PRECISION","def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\n i,u = self.getSegment(t,endBehavior)\n if i<0: return self.milestones[0]\n elif i+1>=len(self.milestones): return self.milestones[-1]\n #linear interpolate between milestones[i] and milestones[i+1]\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])","def eval(self,t,endBehavior='halt'):\n self._skip_deriv = True\n res = Trajectory.eval_state(self,t,endBehavior)\n self._skip_deriv = False\n return res[:len(res)//2]","def timeEnd(self)->datetime:\n if self._scenario == LM_HardDate.Scenario.ValidSince:\n raise SdkError(\"timeEnd not defined for scenario 'ValidSince'\")\n\n return self._lic.params['timeEnd'].value","def evap(self, lai, tl, ta, qa):#average ta and tl!!\n\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\n\t\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \n\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\n\t return 0.\n\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\n\t return (self.tx*self.ZT*self.TAI*10**6/dt)\n\t else:\n\t return fsev","def get_end(self):\n return self.start + timedelta(minutes=self.duration)","def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to the array\n\t\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\n\t\tdUdt = dUdt + self.getHeatFlux(temperature)\n\t\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\n\t\treturn numpy.append(dNdt,dTdt)","def time_end(self):\n return self._time_end","def tLoss(self, dt, qt, tl, ta, qa):\n\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def after(self, time: float) -> 'Trajectory':\n return self.split(time)[1]","def lerp(self, t):\n pass","def set_T_lm(self):\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) )","def end_time(self):\n return from_ts(self.end_time_ms)","def elapsed_raw(self, start=\"__enter__\", end=\"__exit__\"):\n return self.laps[end] - self.laps[start]","def get_vehicle_end_index(self):\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def cal_end(self):\n return self.datetime_end","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def update(self, tfinal):\n t = 0; kk = 0\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\n self.omega = np.zeros((nstep,self.npts))\n self.theta = np.zeros((nstep,self.npts))\n\n while t <(tfinal+1e-10):\n self.return_map()\n self.omega[kk] = self.y[0]\n self.theta[kk] = self.y[1]\n\n self.y = RK4(self.y, self.dt, t, self.deri)\n kk += 1; t += self.dt\n\n return self","def get_terminating_ray(self):\n return self._terminating_ray","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def end_time(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"end_time\")","def get_current_ee_pose(self):\n #self.arm_endpoint = #magic tf call that I can add\n while True:\n try:\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\n break # once the transform is obtained move on\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\n continue # if it fails try again\n point = [translation[0], translation[1], translation[2]]\n self.arm_endpoint = np.array(point)\n # rospy.logerr(self.arm_endpoint)","def o(r, t):\n return r/t**0.5","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def roty(self, t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s],\n [0, 1, 0],\n [-s, 0, c]])","def getEnd(self) -> long:\n ...","def trapezoid(t, params):\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n\n envelope = tf.ones_like(t, dtype=tf.float64)\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\n return envelope","def _get_end(self):\n return self._end","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def ricker(dt, pt):\n nt = int(2 * pt / dt)\n c = np.zeros(nt)\n t0 = pt / dt\n a_ricker = 4 / pt\n\n for it in range(0, nt):\n t = ((it + 1) - t0) * dt\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\n\n return c","def end_time(self):\n return self.time_parser.end_time","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def horde_end(self):","def roty(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])","def out(self, t: any, dim=(None, None)) -> any:\n lB = self.interval[0] # Lower Boundary\n uB = self.interval[1] # Upper Boundary\n # Initialize random step vector each sampling period using comprehensive list.\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\n step_vector[0] = self.ss # keep the steady state value as first\n u = np.zeros(shape=dim) # Initialize step control input array u.\n j = 0\n\n ramp_Step = self.saw_time\n count = 1\n for i in range(len(t)): # Excluding the last point\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\n j += 1\n count = 1\n\n if self.ss is not None and j == 0:\n u[i, :] = self.ss\n else:\n if count != ramp_Step:\n\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\n count += 1\n else:\n u[i, :] = step_vector[j]\n return u","def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\n dT = self.deriv(t,endBehavior)\n return so3.deskew(dT[0])+dT[1]","def getETA():","def getETA():"],"string":"[\n \"def endTime(self) -> float:\\n try: return self.times[-1]\\n except IndexError: return 0.0\",\n \"def end_time(self) -> float:\\r\\n ...\",\n \"def endTime(self):\\n return self.params['tend']\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def end(self):\\n return self._t0 + self.length\",\n \"def getEndTime(self):\\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)\",\n \"def end_effectors_pos(self):\\n def relative_pos_in_egocentric_frame(physics):\\n end_effector = physics.bind(self._entity.end_effectors).xpos\\n torso = physics.bind(self._entity.root_body).xpos\\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\\n return observable.Generic(relative_pos_in_egocentric_frame)\",\n \"def est_am(t,y):\\n ch=t>t_eq\\n y1=y[ch]\\n return y1[-1]-y1[0]\",\n \"def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\\n\\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\\n naturalLog = np.log(numeratorLN/denomLN)\\n\\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\\n brackets = F - Fp + product1\\n\\n product2 = (1/Ks)*brackets\\n time = tp + product2 - endingTime\\n return time\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)\",\n \"def find_exit_time(self):\\n \\n # check when last bead starts moving\\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\\n nonzero = np.flatnonzero( vel_last_bead )\\n \\n if nonzero.size == 0:\\n warnings.warn('The wave did not exit the chain or it could not be determined.')\\n return np.nan\\n else:\\n exit_index = np.min( nonzero )\\n time = self.get_time()\\n exit_time = time[exit_index]\\n return exit_time\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)\",\n \"def timeofflight(xhat0):\\n\\t\\timport poincare\\n\\t\\t#Find the point on the computed poincare section, closest to the x0\\n\\t\\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\\n\\t\\t#Take its time of flight as\\n\\t\\tif imin < np.size(ps,0)-1: \\n\\t\\t\\tTapproximate = ps[imin+1,0]-ps[imin,0]\\n\\t\\telse:\\n\\t\\t\\tTapproximate = ps[imin,0]-ps[imin-1,0]\\n\\t\\tprint(\\\"Tapproximate:\\\")\\n\\t\\tprint(Tapproximate)\\n\\t\\t#Integrate for a little bit longer than the approximated integration time:\\n\\t\\tstoptime = 1.2*Tapproximate\\n\\t\\tnumpoints = int(stoptime/0.01)\\n\\t\\t#Integration time array:\\n\\t\\tt = np.linspace(0, stoptime, numpoints)\\n\\t\\txhatphi0 = np.append(xhat0, np.array([0], float))\\n\\t\\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\\n\\t\\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\\n\\t\\t#Compute Poincare section:\\n\\t\\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\\n\\t\\tprint(\\\"psreturn:\\\")\\n\\t\\tprint(psreturn)\\n\\t\\t#Take the time nearest to the approximated time. This is due to the\\n\\t\\t#fact that the array ps sometimes includes the initial point and sometimes\\n\\t\\t#does not, hence we are not always sure the position of the first return.\\n\\t\\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\\n\\t\\ttof = psreturn[itof,0]\\n\\t\\treturn tof\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def get_delta_t(self):\\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\\\\n - self.gv.t_queue[self.gv.filter_min_bound]\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def end_time(self):\\n pass\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def end_time(self):\\n # TODO: use pd.Timestamp instead\\n return self.time[-1].to_pydatetime()\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def get_trace_abs(self, norm=True):\\n if self.Et is not None:\\n # Center peak in time\\n ind = np.argmax(abs(self.Et))\\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\\n Et = np.abs(np.roll(self.Et, shift))\\n if norm is True:\\n Et /= Et.max()\\n else:\\n Et = None\\n return Et\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def _dy(self, T):\\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])\",\n \"def end_point(self) -> Vec3:\\n v = list(self.vertices([self.dxf.end_angle]))\\n return v[0]\",\n \"def _reached_temperature_end_point(self, T, Tend):\\n if Tend is None:\\n # End point not give\\n return False\\n\\n if self._integration_direction == \\\"increasing\\\":\\n if T > Tend:\\n return True\\n elif self._integration_direction == \\\"decreasing\\\":\\n if T < Tend:\\n return True\\n return False\",\n \"def end_time(self, t):\\r\\n # Increase temperature while silent.\\r\\n if np.count_nonzero(self.next_note) == 0:\\r\\n self.silent_time += 1\\r\\n if self.silent_time >= NOTES_PER_BAR:\\r\\n self.temperature += 0.1\\r\\n else:\\r\\n self.silent_time = 0\\r\\n self.temperature = self.default_temp\\r\\n \\r\\n self.notes_memory.append(self.next_note)\\r\\n # Consistent with dataset representation\\r\\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\\r\\n self.results.append(self.next_note)\\r\\n # Reset next note\\r\\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\\r\\n return self.results[-1]\",\n \"def find_alert_time(self) -> None:\\n \\n # Also not clear from the paper how to doe this,\\n # use the first 10 data points in the light curve to determine the magnitude\\n # baseline\\n\\n mean_mag = np.mean(self.mags[:10])\\n std_mag = np.std(self.mags[:10])\\n\\n num_above = 0 \\n i = 9\\n\\n while num_above < 3 and i < len(self.times)-1:\\n \\n i += 1 \\n\\n if self.mags[i] < mean_mag - std_mag:\\n num_above += 1\\n else:\\n num_above = 0.0\\n\\n if len(self.times) - 1 == i:\\n print(\\\"Give me more training data, not alerted yet, this is probably going to fail\\\")\\n \\n return self.times[i-1]\",\n \"def eval(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[:len(res)//2]\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def getEndTime(self):\\n return _osgAnimation.Channel_getEndTime(self)\",\n \"def line_segment(t, # Array of times for each position\\n t_now # Current time (float)\\n ):\\n i = np.argwhere(t > t_now)\\n if len(i) > 0:\\n if i[0] != 0: # if the current time is not less than the starting time\\n segment_starting_index = i[0][0] - 1\\n else:\\n segment_starting_index = 0\\n\\n segment_end_index = i[0][0]\\n\\n else: # if the current time is more than the last point (destination) time\\n segment_starting_index = t.shape[0]\\n segment_end_index = t.shape[0]\\n\\n return segment_starting_index, segment_end_index\",\n \"def end_abs(self):\\n if self.end == float('inf'):\\n return self.track.duration\\n else:\\n return self.end\",\n \"def time_step(self):\\n\\n rho_rel = np.abs(self.rho_dt / self.rho)\\n rho_rel_max = np.max(rho_rel)\\n e_rel = np.abs(self.e_dt / self.e)\\n e_rel_max = np.max(e_rel)\\n x_rel = np.abs(self.u / self.dx)\\n x_rel_max = np.max(x_rel)\\n y_rel = np.abs(self.w / self.dy)\\n y_rel_max = np.max(y_rel)\\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\\n delta = np.max(np.abs(rel))\\n\\n if 0.1 <= delta <= 1e3:\\n self.dt = self.p / delta\\n else:\\n self.dt = self.p\",\n \"def end_time(self):\\n return RPR.GetAudioAccessorEndTime(self.id)\",\n \"def run_e(self, t):\\n if t > self.n_t:\\n raise IndexError('Maximum simulated timesteps exceeded in E step')\\n if self.pf.t >= t:\\n raise IndexError(\\n 'Particle filter already run past given time point')\\n while self.pf.t < t:\\n self.pf.advance()\\n self.pf.calculate_means_sdevs()\\n\\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))\",\n \"def end_of_horizon_cost_rule(_m):\\r\\n\\r\\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\\r\\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\\r\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end(self):\\r\\n hours = self.length // 60\\r\\n minutes = self.length % 60\\r\\n return time(self.start.hour + hours, self.start.minute + minutes)\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def get_end(self):\\n\\n return self.end_cycle\",\n \"def _get_end_time(self):\\n return self.__end_time\",\n \"def get_end(self):\\n return self._start + self._duration\",\n \"def diff(t, y):\\n origin = root.vectorize()\\n root.tensorize(y)\\n self.time = t if not imaginary else None\\n self.eom()\\n ans = root.vectorize(use_aux=True)\\n root.tensorize(origin)\\n return ans\",\n \"def inc_end(self):\\n return self._exc_end - TIMERANGE_PRECISION\",\n \"def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\\n i,u = self.getSegment(t,endBehavior)\\n if i<0: return self.milestones[0]\\n elif i+1>=len(self.milestones): return self.milestones[-1]\\n #linear interpolate between milestones[i] and milestones[i+1]\\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\",\n \"def eval(self,t,endBehavior='halt'):\\n self._skip_deriv = True\\n res = Trajectory.eval_state(self,t,endBehavior)\\n self._skip_deriv = False\\n return res[:len(res)//2]\",\n \"def timeEnd(self)->datetime:\\n if self._scenario == LM_HardDate.Scenario.ValidSince:\\n raise SdkError(\\\"timeEnd not defined for scenario 'ValidSince'\\\")\\n\\n return self._lic.params['timeEnd'].value\",\n \"def evap(self, lai, tl, ta, qa):#average ta and tl!!\\n\\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\\n\\t\\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \\n\\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\\n\\t return 0.\\n\\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\\n\\t return (self.tx*self.ZT*self.TAI*10**6/dt)\\n\\t else:\\n\\t return fsev\",\n \"def get_end(self):\\n return self.start + timedelta(minutes=self.duration)\",\n \"def rightSideOfODE(self, Y, t):\\n\\t\\ttemperature = Y[-1]\\n\\t\\tamounts = Y[:-1]\\n\\t\\tself.amounts = amounts\\n\\t\\t# first get the species amount changes (as an array)\\n\\t\\tdNdt = -1 * self.getMolarFluxes(temperature)\\n\\t\\t# then get the temperature change, and append it to the array\\n\\t\\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\\n\\t\\tdUdt = dUdt + self.getHeatFlux(temperature)\\n\\t\\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\\n\\t\\treturn numpy.append(dNdt,dTdt)\",\n \"def time_end(self):\\n return self._time_end\",\n \"def tLoss(self, dt, qt, tl, ta, qa):\\n\\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def after(self, time: float) -> 'Trajectory':\\n return self.split(time)[1]\",\n \"def lerp(self, t):\\n pass\",\n \"def set_T_lm(self):\\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) )\",\n \"def end_time(self):\\n return from_ts(self.end_time_ms)\",\n \"def elapsed_raw(self, start=\\\"__enter__\\\", end=\\\"__exit__\\\"):\\n return self.laps[end] - self.laps[start]\",\n \"def get_vehicle_end_index(self):\\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def cal_end(self):\\n return self.datetime_end\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def update(self, tfinal):\\n t = 0; kk = 0\\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\\n self.omega = np.zeros((nstep,self.npts))\\n self.theta = np.zeros((nstep,self.npts))\\n\\n while t <(tfinal+1e-10):\\n self.return_map()\\n self.omega[kk] = self.y[0]\\n self.theta[kk] = self.y[1]\\n\\n self.y = RK4(self.y, self.dt, t, self.deri)\\n kk += 1; t += self.dt\\n\\n return self\",\n \"def get_terminating_ray(self):\\n return self._terminating_ray\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end_time(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def get_current_ee_pose(self):\\n #self.arm_endpoint = #magic tf call that I can add\\n while True:\\n try:\\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\\n break # once the transform is obtained move on\\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\\n continue # if it fails try again\\n point = [translation[0], translation[1], translation[2]]\\n self.arm_endpoint = np.array(point)\\n # rospy.logerr(self.arm_endpoint)\",\n \"def o(r, t):\\n return r/t**0.5\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def roty(self, t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s],\\n [0, 1, 0],\\n [-s, 0, c]])\",\n \"def getEnd(self) -> long:\\n ...\",\n \"def trapezoid(t, params):\\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n\\n envelope = tf.ones_like(t, dtype=tf.float64)\\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\\n return envelope\",\n \"def _get_end(self):\\n return self._end\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def ricker(dt, pt):\\n nt = int(2 * pt / dt)\\n c = np.zeros(nt)\\n t0 = pt / dt\\n a_ricker = 4 / pt\\n\\n for it in range(0, nt):\\n t = ((it + 1) - t0) * dt\\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\\n\\n return c\",\n \"def end_time(self):\\n return self.time_parser.end_time\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def horde_end(self):\",\n \"def roty(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])\",\n \"def out(self, t: any, dim=(None, None)) -> any:\\n lB = self.interval[0] # Lower Boundary\\n uB = self.interval[1] # Upper Boundary\\n # Initialize random step vector each sampling period using comprehensive list.\\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\\n step_vector[0] = self.ss # keep the steady state value as first\\n u = np.zeros(shape=dim) # Initialize step control input array u.\\n j = 0\\n\\n ramp_Step = self.saw_time\\n count = 1\\n for i in range(len(t)): # Excluding the last point\\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\\n j += 1\\n count = 1\\n\\n if self.ss is not None and j == 0:\\n u[i, :] = self.ss\\n else:\\n if count != ramp_Step:\\n\\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\\n count += 1\\n else:\\n u[i, :] = step_vector[j]\\n return u\",\n \"def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\\n dT = self.deriv(t,endBehavior)\\n return so3.deskew(dT[0])+dT[1]\",\n \"def getETA():\",\n \"def getETA():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6262754","0.60054207","0.59560645","0.5919242","0.59007686","0.58521706","0.5844045","0.580404","0.5791151","0.5790337","0.5788008","0.57607013","0.57595277","0.57300097","0.57146317","0.5713964","0.56925106","0.56845766","0.56776744","0.56025434","0.5577776","0.5577258","0.5561718","0.5554804","0.5550632","0.55414397","0.5509652","0.5486134","0.54807806","0.5450397","0.5448296","0.5435491","0.5428117","0.5421442","0.5420882","0.5407447","0.53956217","0.5393599","0.53911644","0.5388739","0.53826755","0.538183","0.53771454","0.5370922","0.5366723","0.53657544","0.53590137","0.5338765","0.53361785","0.5324579","0.5317156","0.5305034","0.5301146","0.52967286","0.529175","0.5290008","0.52892494","0.5269293","0.5254921","0.5254921","0.524881","0.5248734","0.52469486","0.52455217","0.5238649","0.5232238","0.5228608","0.5228394","0.52274954","0.52269995","0.52246207","0.52191484","0.5211364","0.5211364","0.52056676","0.5203241","0.52024585","0.5195268","0.5193534","0.51899034","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5184724","0.5183763","0.51775163","0.5172201","0.51709485","0.5164134","0.5155358","0.51551783","0.5154484","0.5141973","0.5139901","0.5139446","0.51381594","0.51364684","0.51364684"],"string":"[\n \"0.6262754\",\n \"0.60054207\",\n \"0.59560645\",\n \"0.5919242\",\n \"0.59007686\",\n \"0.58521706\",\n \"0.5844045\",\n \"0.580404\",\n \"0.5791151\",\n \"0.5790337\",\n \"0.5788008\",\n \"0.57607013\",\n \"0.57595277\",\n \"0.57300097\",\n \"0.57146317\",\n \"0.5713964\",\n \"0.56925106\",\n \"0.56845766\",\n \"0.56776744\",\n \"0.56025434\",\n \"0.5577776\",\n \"0.5577258\",\n \"0.5561718\",\n \"0.5554804\",\n \"0.5550632\",\n \"0.55414397\",\n \"0.5509652\",\n \"0.5486134\",\n \"0.54807806\",\n \"0.5450397\",\n \"0.5448296\",\n \"0.5435491\",\n \"0.5428117\",\n \"0.5421442\",\n \"0.5420882\",\n \"0.5407447\",\n \"0.53956217\",\n \"0.5393599\",\n \"0.53911644\",\n \"0.5388739\",\n \"0.53826755\",\n \"0.538183\",\n \"0.53771454\",\n \"0.5370922\",\n \"0.5366723\",\n \"0.53657544\",\n \"0.53590137\",\n \"0.5338765\",\n \"0.53361785\",\n \"0.5324579\",\n \"0.5317156\",\n \"0.5305034\",\n \"0.5301146\",\n \"0.52967286\",\n \"0.529175\",\n \"0.5290008\",\n \"0.52892494\",\n \"0.5269293\",\n \"0.5254921\",\n \"0.5254921\",\n \"0.524881\",\n \"0.5248734\",\n \"0.52469486\",\n \"0.52455217\",\n \"0.5238649\",\n \"0.5232238\",\n \"0.5228608\",\n \"0.5228394\",\n \"0.52274954\",\n \"0.52269995\",\n \"0.52246207\",\n \"0.52191484\",\n \"0.5211364\",\n \"0.5211364\",\n \"0.52056676\",\n \"0.5203241\",\n \"0.52024585\",\n \"0.5195268\",\n \"0.5193534\",\n \"0.51899034\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5184724\",\n \"0.5183763\",\n \"0.51775163\",\n \"0.5172201\",\n \"0.51709485\",\n \"0.5164134\",\n \"0.5155358\",\n \"0.51551783\",\n \"0.5154484\",\n \"0.5141973\",\n \"0.5139901\",\n \"0.5139446\",\n \"0.51381594\",\n \"0.51364684\",\n \"0.51364684\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20292,"cells":{"query":{"kind":"string","value":"Returns the arm's desired velocity in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_position()"},"document":{"kind":"string","value":"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_velocity(path_time)","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def get_velocity(self):\n return self.momentum/self.mass","def target_velocity(self, time):\n pass","def target_velocity(self, time):\n pass","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def orbitalVelocity( self ): # returns [m/s]\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\n return velocity","def target_velocity(self, time):\n\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\n\n return avg_vel","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def getVelocity(self):\n return self.v","def get_velocity(self):\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s","def getVelocity(self):\n\n return self.vel","def velocity(self):\n return self._velocity","def velocity(self):\n return self._velocity","def velocity(self):\n return self.base_platform.velocity","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def target_velocity(self, s):\n # YOUR CODE HERE\n if s > self.total_length:\n s = self.total_length\n angular = np.array([0, 0 ,0])\n else:\n angular = np.array([0,0,self.targ_angular])\n\n theta = s/self.total_length*self.angle\n v_x = np.cos(theta)*self.targ_speed\n if self.left_turn:\n v_y = np.sin(theta)*self.targ_speed\n else:\n v_y = -np.sin(theta)*self.targ_speed\n \n linear = np.array([v_x, v_y, 0])\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\n \n toRet = [linear, angular]\n \n return toRet","def relative_velocity(self):\n return self.base_platform.relative_velocity","def target_velocity(self, s):\n if s > self.total_length:\n linear = np.array([0,0,0])\n else:\n linear = np.array([self.sign*self.targ_speed, 0, 0])\n \n angular = np.array([0,0,0])\n toRet = [linear, angular]\n\n return toRet","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def get_angular_velocity(r, T):\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\n # velocity = 2(pi)r/T\n return (2*math.pi*r)/T","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def _compute_solar_torque(self):\n pass","def target_velocity(self, s):\n raise NotImplementedError()","def initial_velocity(self) -> float:\n return self._initial_velocity","def test_velocity(self):\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\n # r must contain 2 elements, otherwise the density and pressure are nan\n r = np.array([0.7, 0.8])\n t = 6.25e-6\n solrt = sol(r, t)\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def compute_velocity(self, time_since_last_frame: float) -> None:\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\n self.velocity_kts = (true_dist /\n self.secs_since_last_seen) / 1.94384\n self.cart_coords = new_cart_coords","def target_velocity(self, s):\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\n # self.transition += self.subpaths[self.current_path].total_length()\n # self.current_path += 1\n\n if s > self.total_length:\n s = self.total_length\n\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\n linear = np.dot(self.g, linear)\n\n return [linear, angular]","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def velocity_model(self):\n return self._velocity_model","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def get_cmd_velocity(self):\n return self.gripper_io.get_signal_value(\"speed_mps\")","def motor_velocities(self):\n return np.asarray(self._robot_state.velocity)","def velocity(self,l=None, t=None):\n raise RuntimeError('this is a virtual method that must be overwritten')\n return","def goal_velocity(self):\n return self._read(MX_GOAL_VELOCITY)","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def present_velocity(self):\n return self._read(MX_PRESENT_VELOCITY)","def evaluate(self, *args, **kwargs):\n return self.constant_velocity","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def robot_arm_pos(self):\n return self.sim.data.qpos[self.arm_index]","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def get_desired_vel(self, a):\n a_c = self.heading_vector\n # angle of the robot\n angle_a_c = np.arctan2(a_c[1], a_c[0])\n # angle of the heading\n angle_a = np.arctan2(a[1], a[0])\n\n angle_difference = wrap2pi(angle_a_c - angle_a)\n\n if abs(angle_difference) <= (math.pi / 2):\n # modulate translation and rotation\n u = (np.dot(a, a_c) ** self.gamma)*self.u_max\n else:\n # do not translate only rotate\n u = 0\n # proportional controller for heading\n omega = angle_difference * self.K_p\n return [u, omega]","def current_velocity():\n global current_velocity\n while current_velocity is None:\n pass\n return current_velocity","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def phase_velocity(self):\n return 1/np.sqrt(self.mu*self.epsilon)","def mTV(self):\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\n # approximated with the wing root chordplane\n return distance / (self.spanW / 2)","def vel(self,M):\n v = np.sqrt((M*Body.G)/self.r)\n \n return v","def base_velocity(self):\n raise NotImplementedError('Not yet implemented!')","def get_vsolar(self):\n return self.read_register(4098, 1, 3)","def new_velocity(self):\n self.velocity = self.vafter","def _get_vel(self, vehicle_id):\n id1 = self.vehicle_ids[self.vehicle_ids.index(vehicle_id) - 1]\n pos1 = self.positions[id1]\n pos2 = self.positions[vehicle_id]\n\n dist = self.pt.get_distance([pos1[0], pos1[1]], [pos2[0], pos2[1]])\n e = self.e_ref - (dist - self.distance_offset)\n\n vel = self.pids[vehicle_id].get_u(e)\n\n if vel < self.vmin:\n vel = self.vmin\n if vel > self.vmax:\n vel = self.vmax\n\n return vel","def velocity(self):\n return self._vel.to_list()","def acceleration(v,u,t):\n return ((v-u)/t)","def angular_velocity(self):\n trig = gyro_trigger_mode.GET_ANGULAR_VELOCITY_TRIGGER_READ\n if self.__trigger == trig:\n self.read_and_update_angle()\n\n adjusted = (self.__angle - self.__offset)\n if self.__factorSet:\n return adjusted / self.__degPerSecondFactor\n return adjusted","def update(self, t, dt):\n # update boundary values\n self._apply_boundary_conditions(t,dt)\n #update current empirical wind velocity\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\n # initialise wind speed derivative arrays\n du_dt = scipy.zeros((self.nx, self.ny))\n dv_dt = scipy.zeros((self.nx, self.ny))\n # approximate spatial first derivatives with centred finite difference\n # equations for both components of wind field\n du_dx, du_dy = self._centred_first_derivs(self._u)\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\n # second derivatives with second order finite difference equations\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\n # = [sf_x-2f(x,y)] / (dx*dx)\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\n # = [sf_y-2f(x,y)] / (dy*dy)\n # second finite differences are not computed in full as the common\n # f(x,y) term in both expressions can be extracted out to reduce\n # the number of +/- operations required\n su_x, su_y = self._centred_first_sums(self._u)\n sv_x, sv_y = self._centred_first_sums(self._v)\n # use finite difference method to approximate time derivatives across\n # simulation region interior from defining PDEs\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\n self._Bx * su_x + self._By * su_y -\n self._C * self._u_int)\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\n self._Bx * sv_x + self._By * sv_y -\n self._C * self._v_int)\n # perform update with Euler integration\n self._u_int += du_dt * dt\n self._v_int += dv_dt * dt\n # update spline interpolators\n self._set_interpolators()","def getVelocity(grid=None, ppar=None):\n\n vel = np.zeros([grid.nx, grid.ny, grid.nz, 3], dtype=np.float64)\n return vel","def tke(self):\n if len(self._obj.t) < 2:\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\n\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'({vel_units})^2')\n return self._obj","def speed(self) -> float:\n return linalg.norm(self.velocity)","def speed(self):\n return sqrt(self.velocity_x ** 2 + self.velocity_y ** 2)","def exit_velocity(self):\n\n return self.exit_mach() * \\\n (self.specific_heat_ratio * self.gas_constant\n * self.exit_temperature()) ** (1 / 2)","def step(self, dt):\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)","def get_velocity(self, index: int, array: List[float]) -> float:\n velocity_sum = 0.0\n number_iterations = min(self.past_n_steps, index - 1)\n for i in range(number_iterations):\n velocity_sum += (array[index - 1 - i] - array[index - 2 - i])\n\n return velocity_sum / (self.time_step * number_iterations)","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def _get_next_velocity(self):\n\n self._predict_state()\n\n # curr = pos_quat_to_euler(self.curr_quat)\n dest = pos_quat_to_euler(self.dest_quat_predict)\n error = self.calc_error(self.dest_quat_predict)\n # TODO error should be computed for phi, th axis individually\n\n # TODO recommend_velocity to reach desired setpoint at a given velocity\n phi_vel = self.motor_phi.recommend_velocity(dest[0])\n th_vel = self.motor_th .recommend_velocity(dest[1])\n\n if error < 0.05:\n return 0.0, 0.0\n\n # TODO this is lame\n #scale = error * 4\n #phi_vel = scale * phi_vel\n #th_vel = scale * th_vel\n\n return phi_vel, th_vel\n\n # TODO PID (control algo)... or should it be handled closer to motors?\n # TODO Path planning\n # TODO Velocity-accel curve to estimate time required to get to point\n # - Cache its integral and use as lookup to estimate if we can get\n # to point without overshoot","def _compute_velocity(self, last_pos, current_pos, dt):\n # type: (np.ndarray, np.ndarray, float) -> (float, float)\n diff = current_pos - last_pos\n raw_vel = np.sqrt(np.dot(diff, diff)) / dt\n if raw_vel > self._max_velocity:\n raw_vel = self._max_velocity - np.random.normal(0, 0.01)\n # avg_vel = (np.sum(self._history.velocities) + raw_vel) / (self._history.size() + 1)\n self._velocities.append(raw_vel)\n avg_vel = float(np.mean(self._velocities[-self._max_vel_history:]))\n\n return float(raw_vel), float(avg_vel)","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def deriv_angvel(self, t: float,endBehavior: str = 'halt') -> Vector3:\n cw = GeodesicTrajectory.deriv(self,t,endBehavior)\n return so3.deskew(cw)","def compute_vel(self, state, goal):\n\n \"\"\"\n Unicycle model control law:\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\n v = commanded linear velocity of robot\n w = commanded rotational velcoity of robot\n kp = gain parameter where kp > 0\n ka = gain parameter where ka - kp > 0\n kb = gain parameter where kb < 0\n p = distance from robot to goal\n a = angle between current robot heading and heading to goal\n b = error between current heading to goal and target end heading\n \"\"\"\n \n #print('state,goal,v,w')\n #print(state)\n #print(goal)\n\n xr = state[0][0] # m in world frame\n yr = state[1][0] # m in world frame\n thetar = state[2][0] #rads\n\n xg = goal[0] # m in world frame\n yg = goal[1] # m in world frame\n\n dy = yg - yr\n dx = xg - xr\n\n #print('')\n #print(state)\n #print(goal)\n \n # Calculate a\n a = -1*thetar + math.atan2(dy,dx)\n\n #print(a)\n\n if a > math.pi:\n a = a - 2*math.pi\n\n if a < -1*math.pi:\n a = a + 2*math.pi\n\n #print(a)\n\n # Set omega according to control law\n omega = self.ka*a\n if math.fabs(omega) > self.MAX_OMEGA:\n if omega > 0:\n omega = self.MAX_OMEGA\n else:\n omega = -1*self.MAX_OMEGA\n\n # Calculate P\n p = math.sqrt(dy*dy + dx*dx)\n\n # Set v \n v = self.kp*p\n if v > self.MAX_SPEED:\n v = self.MAX_SPEED\n\n # set the done value\n done = (p <= self.done_distance)\n\n #print(v)\n #print(omega)\n\n out_tuple = (v, omega, done)\n \n return out_tuple","def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\n\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\n pyswice.furnsh_c(bskPath + ephemerisPath)\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\n position = positionVelocity[0:3] * 1000\n velocity = positionVelocity[3:6] * 1000\n pyswice.unload_c(bskPath + ephemerisPath)\n\n return position, velocity # [m], [m/s]","def driftRHS(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.linalg.norm(f)\n f = f/fs\n return -f*drift_velocity(fs)","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def t2u(self, t ):\n \n if t < self.time_final:\n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n u = self.u_sol[i,:]\n \n else:\n u = self.ubar\n \n return u","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def calc_vertical_velocity(self):\n # Note: again we make use of the automatically added 'grid' attribute, and the stored coef_w attribute.\n # Here we arbitrarily set the vertical velocity to increase in the\n # y-direction (not very realistic).\n return self.coef_w[0] * self.grid.y[None, :] + self.coef_w[1]","def test_terminalVelocity():\n import nose.tools as nt\n T = 30.; dt = 0.1; g = 9.81; m = 50.;\n Cd = 1.2; rho = 1.0; A = 0.5;\n a = Cd*rho*A/(2.*m)\n v, t = solver(T, dt, -0.1, Cd, rho, A, m)\n nt.assert_almost_equal(v[-1], -sqrt(g/a), delta=1e-4)","def angular_velocities(self, dt: float) -> np.ndarray:\n if not isinstance(dt, float):\n raise TypeError(f\"dt must be a float. Got {type(dt)}.\")\n if dt <= 0:\n raise ValueError(f\"dt must be greater than zero. Got {dt}.\")\n w = np.c_[\n self.w[:-1]*self.x[1:] - self.x[:-1]*self.w[1:] - self.y[:-1]*self.z[1:] + self.z[:-1]*self.y[1:],\n self.w[:-1]*self.y[1:] + self.x[:-1]*self.z[1:] - self.y[:-1]*self.w[1:] - self.z[:-1]*self.x[1:],\n self.w[:-1]*self.z[1:] - self.x[:-1]*self.y[1:] + self.y[:-1]*self.x[1:] - self.z[:-1]*self.w[1:]]\n return 2.0 * w / dt","def compute_observation(self):\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\n robotEuler = p.getEulerFromQuaternion(robotOrn)\n linear, angular = p.getBaseVelocity(self.botId)\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))","def evol_dt(self, psi, t, dt):\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))","def get(cls, approach):\n return approach.velocity","def v(self):\n\n # TODO This translation formula works, but needs simplified.\n\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\n# print(\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\", MuleBot.dcMotorPWMDurationLeft)\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\n# print(\"speed_percentage: \", speed_percentage)\n\n rpm = speed_percentage * self.motorMaxRPM\n# print(\"rpm: \", rpm)\n\n secondsPerMinute = 60\n revs_per_second = rpm / secondsPerMinute\n# print(\"--revs_per_second\", revs_per_second)\n\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\n INCHES_PER_METER = 39.3701\n meters_per_rev = inches_per_rev / INCHES_PER_METER\n# print(\"--meters_per_rev\", meters_per_rev)\n\n meters_per_second = meters_per_rev * revs_per_second\n\n# print(\"--meters_per_second: \", meters_per_second)\n return meters_per_second","def cmd_velocity(self, vn, ve, vd, heading):\n pass","def distance(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.position(rf), t.position(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def get_frame_root_vel(self, frame):\n root_vel = frame[:self.VEL_SIZE].copy()\n return root_vel","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def initial_vel(T,N,masses,dim):\r\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\r\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\r\n rand_v = rand_v - sum_v #Subtract cm-Motion\r\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\r\n T_act = 2/3*K/sc.k/N #Temperature\r\n R_scale = T/T_act #Scaling factor\r\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\r\n return v","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def target_position(self, time):\n return self.target(time, self.positions, self.dt, self.num_way)","def target_position(self, time):\n return self.target(time, self.positions, self.dt, self.num_way)","def tangeant_unit_vector(self, t):\n a = self.a0 + t * self.da\n ca = cos(a)\n sa = sin(a)\n v = Vector((sa, -ca))\n if self.da > 0:\n v = -v\n return v"],"string":"[\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_velocity(path_time)\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def get_velocity(self):\\n return self.momentum/self.mass\",\n \"def target_velocity(self, time):\\n pass\",\n \"def target_velocity(self, time):\\n pass\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def orbitalVelocity( self ): # returns [m/s]\\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\\n return velocity\",\n \"def target_velocity(self, time):\\n\\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\\n\\n return avg_vel\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def getVelocity(self):\\n return self.v\",\n \"def get_velocity(self):\\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s\",\n \"def getVelocity(self):\\n\\n return self.vel\",\n \"def velocity(self):\\n return self._velocity\",\n \"def velocity(self):\\n return self._velocity\",\n \"def velocity(self):\\n return self.base_platform.velocity\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def target_velocity(self, s):\\n # YOUR CODE HERE\\n if s > self.total_length:\\n s = self.total_length\\n angular = np.array([0, 0 ,0])\\n else:\\n angular = np.array([0,0,self.targ_angular])\\n\\n theta = s/self.total_length*self.angle\\n v_x = np.cos(theta)*self.targ_speed\\n if self.left_turn:\\n v_y = np.sin(theta)*self.targ_speed\\n else:\\n v_y = -np.sin(theta)*self.targ_speed\\n \\n linear = np.array([v_x, v_y, 0])\\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\\n \\n toRet = [linear, angular]\\n \\n return toRet\",\n \"def relative_velocity(self):\\n return self.base_platform.relative_velocity\",\n \"def target_velocity(self, s):\\n if s > self.total_length:\\n linear = np.array([0,0,0])\\n else:\\n linear = np.array([self.sign*self.targ_speed, 0, 0])\\n \\n angular = np.array([0,0,0])\\n toRet = [linear, angular]\\n\\n return toRet\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def get_angular_velocity(r, T):\\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\\n # velocity = 2(pi)r/T\\n return (2*math.pi*r)/T\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def target_velocity(self, s):\\n raise NotImplementedError()\",\n \"def initial_velocity(self) -> float:\\n return self._initial_velocity\",\n \"def test_velocity(self):\\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\\n # r must contain 2 elements, otherwise the density and pressure are nan\\n r = np.array([0.7, 0.8])\\n t = 6.25e-6\\n solrt = sol(r, t)\\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def compute_velocity(self, time_since_last_frame: float) -> None:\\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\\n self.velocity_kts = (true_dist /\\n self.secs_since_last_seen) / 1.94384\\n self.cart_coords = new_cart_coords\",\n \"def target_velocity(self, s):\\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\\n # self.transition += self.subpaths[self.current_path].total_length()\\n # self.current_path += 1\\n\\n if s > self.total_length:\\n s = self.total_length\\n\\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\\n linear = np.dot(self.g, linear)\\n\\n return [linear, angular]\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def velocity_model(self):\\n return self._velocity_model\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def get_cmd_velocity(self):\\n return self.gripper_io.get_signal_value(\\\"speed_mps\\\")\",\n \"def motor_velocities(self):\\n return np.asarray(self._robot_state.velocity)\",\n \"def velocity(self,l=None, t=None):\\n raise RuntimeError('this is a virtual method that must be overwritten')\\n return\",\n \"def goal_velocity(self):\\n return self._read(MX_GOAL_VELOCITY)\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def present_velocity(self):\\n return self._read(MX_PRESENT_VELOCITY)\",\n \"def evaluate(self, *args, **kwargs):\\n return self.constant_velocity\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def robot_arm_pos(self):\\n return self.sim.data.qpos[self.arm_index]\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def get_desired_vel(self, a):\\n a_c = self.heading_vector\\n # angle of the robot\\n angle_a_c = np.arctan2(a_c[1], a_c[0])\\n # angle of the heading\\n angle_a = np.arctan2(a[1], a[0])\\n\\n angle_difference = wrap2pi(angle_a_c - angle_a)\\n\\n if abs(angle_difference) <= (math.pi / 2):\\n # modulate translation and rotation\\n u = (np.dot(a, a_c) ** self.gamma)*self.u_max\\n else:\\n # do not translate only rotate\\n u = 0\\n # proportional controller for heading\\n omega = angle_difference * self.K_p\\n return [u, omega]\",\n \"def current_velocity():\\n global current_velocity\\n while current_velocity is None:\\n pass\\n return current_velocity\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def phase_velocity(self):\\n return 1/np.sqrt(self.mu*self.epsilon)\",\n \"def mTV(self):\\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\\n # approximated with the wing root chordplane\\n return distance / (self.spanW / 2)\",\n \"def vel(self,M):\\n v = np.sqrt((M*Body.G)/self.r)\\n \\n return v\",\n \"def base_velocity(self):\\n raise NotImplementedError('Not yet implemented!')\",\n \"def get_vsolar(self):\\n return self.read_register(4098, 1, 3)\",\n \"def new_velocity(self):\\n self.velocity = self.vafter\",\n \"def _get_vel(self, vehicle_id):\\n id1 = self.vehicle_ids[self.vehicle_ids.index(vehicle_id) - 1]\\n pos1 = self.positions[id1]\\n pos2 = self.positions[vehicle_id]\\n\\n dist = self.pt.get_distance([pos1[0], pos1[1]], [pos2[0], pos2[1]])\\n e = self.e_ref - (dist - self.distance_offset)\\n\\n vel = self.pids[vehicle_id].get_u(e)\\n\\n if vel < self.vmin:\\n vel = self.vmin\\n if vel > self.vmax:\\n vel = self.vmax\\n\\n return vel\",\n \"def velocity(self):\\n return self._vel.to_list()\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def angular_velocity(self):\\n trig = gyro_trigger_mode.GET_ANGULAR_VELOCITY_TRIGGER_READ\\n if self.__trigger == trig:\\n self.read_and_update_angle()\\n\\n adjusted = (self.__angle - self.__offset)\\n if self.__factorSet:\\n return adjusted / self.__degPerSecondFactor\\n return adjusted\",\n \"def update(self, t, dt):\\n # update boundary values\\n self._apply_boundary_conditions(t,dt)\\n #update current empirical wind velocity\\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\\n # initialise wind speed derivative arrays\\n du_dt = scipy.zeros((self.nx, self.ny))\\n dv_dt = scipy.zeros((self.nx, self.ny))\\n # approximate spatial first derivatives with centred finite difference\\n # equations for both components of wind field\\n du_dx, du_dy = self._centred_first_derivs(self._u)\\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\\n # second derivatives with second order finite difference equations\\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\\n # = [sf_x-2f(x,y)] / (dx*dx)\\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\\n # = [sf_y-2f(x,y)] / (dy*dy)\\n # second finite differences are not computed in full as the common\\n # f(x,y) term in both expressions can be extracted out to reduce\\n # the number of +/- operations required\\n su_x, su_y = self._centred_first_sums(self._u)\\n sv_x, sv_y = self._centred_first_sums(self._v)\\n # use finite difference method to approximate time derivatives across\\n # simulation region interior from defining PDEs\\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\\n self._Bx * su_x + self._By * su_y -\\n self._C * self._u_int)\\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\\n self._Bx * sv_x + self._By * sv_y -\\n self._C * self._v_int)\\n # perform update with Euler integration\\n self._u_int += du_dt * dt\\n self._v_int += dv_dt * dt\\n # update spline interpolators\\n self._set_interpolators()\",\n \"def getVelocity(grid=None, ppar=None):\\n\\n vel = np.zeros([grid.nx, grid.ny, grid.nz, 3], dtype=np.float64)\\n return vel\",\n \"def tke(self):\\n if len(self._obj.t) < 2:\\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\\n\\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\\\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'({vel_units})^2')\\n return self._obj\",\n \"def speed(self) -> float:\\n return linalg.norm(self.velocity)\",\n \"def speed(self):\\n return sqrt(self.velocity_x ** 2 + self.velocity_y ** 2)\",\n \"def exit_velocity(self):\\n\\n return self.exit_mach() * \\\\\\n (self.specific_heat_ratio * self.gas_constant\\n * self.exit_temperature()) ** (1 / 2)\",\n \"def step(self, dt):\\n return Vector(self.P.x + dt*self.V.x, self.P.y + dt*self.V.y)\",\n \"def get_velocity(self, index: int, array: List[float]) -> float:\\n velocity_sum = 0.0\\n number_iterations = min(self.past_n_steps, index - 1)\\n for i in range(number_iterations):\\n velocity_sum += (array[index - 1 - i] - array[index - 2 - i])\\n\\n return velocity_sum / (self.time_step * number_iterations)\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def _get_next_velocity(self):\\n\\n self._predict_state()\\n\\n # curr = pos_quat_to_euler(self.curr_quat)\\n dest = pos_quat_to_euler(self.dest_quat_predict)\\n error = self.calc_error(self.dest_quat_predict)\\n # TODO error should be computed for phi, th axis individually\\n\\n # TODO recommend_velocity to reach desired setpoint at a given velocity\\n phi_vel = self.motor_phi.recommend_velocity(dest[0])\\n th_vel = self.motor_th .recommend_velocity(dest[1])\\n\\n if error < 0.05:\\n return 0.0, 0.0\\n\\n # TODO this is lame\\n #scale = error * 4\\n #phi_vel = scale * phi_vel\\n #th_vel = scale * th_vel\\n\\n return phi_vel, th_vel\\n\\n # TODO PID (control algo)... or should it be handled closer to motors?\\n # TODO Path planning\\n # TODO Velocity-accel curve to estimate time required to get to point\\n # - Cache its integral and use as lookup to estimate if we can get\\n # to point without overshoot\",\n \"def _compute_velocity(self, last_pos, current_pos, dt):\\n # type: (np.ndarray, np.ndarray, float) -> (float, float)\\n diff = current_pos - last_pos\\n raw_vel = np.sqrt(np.dot(diff, diff)) / dt\\n if raw_vel > self._max_velocity:\\n raw_vel = self._max_velocity - np.random.normal(0, 0.01)\\n # avg_vel = (np.sum(self._history.velocities) + raw_vel) / (self._history.size() + 1)\\n self._velocities.append(raw_vel)\\n avg_vel = float(np.mean(self._velocities[-self._max_vel_history:]))\\n\\n return float(raw_vel), float(avg_vel)\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def deriv_angvel(self, t: float,endBehavior: str = 'halt') -> Vector3:\\n cw = GeodesicTrajectory.deriv(self,t,endBehavior)\\n return so3.deskew(cw)\",\n \"def compute_vel(self, state, goal):\\n\\n \\\"\\\"\\\"\\n Unicycle model control law:\\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\\n v = commanded linear velocity of robot\\n w = commanded rotational velcoity of robot\\n kp = gain parameter where kp > 0\\n ka = gain parameter where ka - kp > 0\\n kb = gain parameter where kb < 0\\n p = distance from robot to goal\\n a = angle between current robot heading and heading to goal\\n b = error between current heading to goal and target end heading\\n \\\"\\\"\\\"\\n \\n #print('state,goal,v,w')\\n #print(state)\\n #print(goal)\\n\\n xr = state[0][0] # m in world frame\\n yr = state[1][0] # m in world frame\\n thetar = state[2][0] #rads\\n\\n xg = goal[0] # m in world frame\\n yg = goal[1] # m in world frame\\n\\n dy = yg - yr\\n dx = xg - xr\\n\\n #print('')\\n #print(state)\\n #print(goal)\\n \\n # Calculate a\\n a = -1*thetar + math.atan2(dy,dx)\\n\\n #print(a)\\n\\n if a > math.pi:\\n a = a - 2*math.pi\\n\\n if a < -1*math.pi:\\n a = a + 2*math.pi\\n\\n #print(a)\\n\\n # Set omega according to control law\\n omega = self.ka*a\\n if math.fabs(omega) > self.MAX_OMEGA:\\n if omega > 0:\\n omega = self.MAX_OMEGA\\n else:\\n omega = -1*self.MAX_OMEGA\\n\\n # Calculate P\\n p = math.sqrt(dy*dy + dx*dx)\\n\\n # Set v \\n v = self.kp*p\\n if v > self.MAX_SPEED:\\n v = self.MAX_SPEED\\n\\n # set the done value\\n done = (p <= self.done_distance)\\n\\n #print(v)\\n #print(omega)\\n\\n out_tuple = (v, omega, done)\\n \\n return out_tuple\",\n \"def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\\n\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\\n pyswice.furnsh_c(bskPath + ephemerisPath)\\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\\n position = positionVelocity[0:3] * 1000\\n velocity = positionVelocity[3:6] * 1000\\n pyswice.unload_c(bskPath + ephemerisPath)\\n\\n return position, velocity # [m], [m/s]\",\n \"def driftRHS(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.linalg.norm(f)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def t2u(self, t ):\\n \\n if t < self.time_final:\\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n u = self.u_sol[i,:]\\n \\n else:\\n u = self.ubar\\n \\n return u\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def calc_vertical_velocity(self):\\n # Note: again we make use of the automatically added 'grid' attribute, and the stored coef_w attribute.\\n # Here we arbitrarily set the vertical velocity to increase in the\\n # y-direction (not very realistic).\\n return self.coef_w[0] * self.grid.y[None, :] + self.coef_w[1]\",\n \"def test_terminalVelocity():\\n import nose.tools as nt\\n T = 30.; dt = 0.1; g = 9.81; m = 50.;\\n Cd = 1.2; rho = 1.0; A = 0.5;\\n a = Cd*rho*A/(2.*m)\\n v, t = solver(T, dt, -0.1, Cd, rho, A, m)\\n nt.assert_almost_equal(v[-1], -sqrt(g/a), delta=1e-4)\",\n \"def angular_velocities(self, dt: float) -> np.ndarray:\\n if not isinstance(dt, float):\\n raise TypeError(f\\\"dt must be a float. Got {type(dt)}.\\\")\\n if dt <= 0:\\n raise ValueError(f\\\"dt must be greater than zero. Got {dt}.\\\")\\n w = np.c_[\\n self.w[:-1]*self.x[1:] - self.x[:-1]*self.w[1:] - self.y[:-1]*self.z[1:] + self.z[:-1]*self.y[1:],\\n self.w[:-1]*self.y[1:] + self.x[:-1]*self.z[1:] - self.y[:-1]*self.w[1:] - self.z[:-1]*self.x[1:],\\n self.w[:-1]*self.z[1:] - self.x[:-1]*self.y[1:] + self.y[:-1]*self.x[1:] - self.z[:-1]*self.w[1:]]\\n return 2.0 * w / dt\",\n \"def compute_observation(self):\\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\\n robotEuler = p.getEulerFromQuaternion(robotOrn)\\n linear, angular = p.getBaseVelocity(self.botId)\\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))\",\n \"def evol_dt(self, psi, t, dt):\\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \\n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))\",\n \"def get(cls, approach):\\n return approach.velocity\",\n \"def v(self):\\n\\n # TODO This translation formula works, but needs simplified.\\n\\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\\n# print(\\\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\\\", MuleBot.dcMotorPWMDurationLeft)\\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\\n# print(\\\"speed_percentage: \\\", speed_percentage)\\n\\n rpm = speed_percentage * self.motorMaxRPM\\n# print(\\\"rpm: \\\", rpm)\\n\\n secondsPerMinute = 60\\n revs_per_second = rpm / secondsPerMinute\\n# print(\\\"--revs_per_second\\\", revs_per_second)\\n\\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\\n INCHES_PER_METER = 39.3701\\n meters_per_rev = inches_per_rev / INCHES_PER_METER\\n# print(\\\"--meters_per_rev\\\", meters_per_rev)\\n\\n meters_per_second = meters_per_rev * revs_per_second\\n\\n# print(\\\"--meters_per_second: \\\", meters_per_second)\\n return meters_per_second\",\n \"def cmd_velocity(self, vn, ve, vd, heading):\\n pass\",\n \"def distance(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.position(rf), t.position(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def get_frame_root_vel(self, frame):\\n root_vel = frame[:self.VEL_SIZE].copy()\\n return root_vel\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def initial_vel(T,N,masses,dim):\\r\\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\\r\\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\\r\\n rand_v = rand_v - sum_v #Subtract cm-Motion\\r\\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\\r\\n T_act = 2/3*K/sc.k/N #Temperature\\r\\n R_scale = T/T_act #Scaling factor\\r\\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\\r\\n return v\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def target_position(self, time):\\n return self.target(time, self.positions, self.dt, self.num_way)\",\n \"def target_position(self, time):\\n return self.target(time, self.positions, self.dt, self.num_way)\",\n \"def tangeant_unit_vector(self, t):\\n a = self.a0 + t * self.da\\n ca = cos(a)\\n sa = sin(a)\\n v = Vector((sa, -ca))\\n if self.da > 0:\\n v = -v\\n return v\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7068331","0.7068331","0.70444334","0.7034289","0.6955907","0.68580544","0.6856776","0.6856776","0.67172503","0.6685114","0.66773754","0.6674364","0.66353154","0.66283923","0.6606402","0.65924555","0.65924555","0.6582541","0.6543292","0.6520295","0.651792","0.6505511","0.6492536","0.6471303","0.64436543","0.64351404","0.64217573","0.6357475","0.63086164","0.63078463","0.6282805","0.6273367","0.61772734","0.61530286","0.61107355","0.6106634","0.6070856","0.60372525","0.6020829","0.59896654","0.5988739","0.59767586","0.5973282","0.59514034","0.59511656","0.594435","0.5939434","0.59326667","0.59318954","0.59209013","0.5909364","0.5903238","0.58987045","0.5894836","0.5890686","0.5889708","0.5878181","0.5876378","0.58704716","0.58431935","0.5833034","0.57872283","0.5785971","0.5780257","0.5776985","0.57730865","0.57620394","0.57614625","0.57566506","0.57557046","0.5746235","0.57430327","0.5735164","0.57332456","0.57314944","0.5724014","0.57141215","0.5706513","0.5706424","0.57028145","0.57000035","0.5699986","0.56996125","0.5692665","0.56799823","0.56545556","0.5640075","0.56389004","0.5616042","0.56131464","0.56082475","0.5607952","0.5606376","0.5604214","0.5600834","0.55985355","0.5592877","0.55895424","0.55895424","0.55821186"],"string":"[\n \"0.7068331\",\n \"0.7068331\",\n \"0.70444334\",\n \"0.7034289\",\n \"0.6955907\",\n \"0.68580544\",\n \"0.6856776\",\n \"0.6856776\",\n \"0.67172503\",\n \"0.6685114\",\n \"0.66773754\",\n \"0.6674364\",\n \"0.66353154\",\n \"0.66283923\",\n \"0.6606402\",\n \"0.65924555\",\n \"0.65924555\",\n \"0.6582541\",\n \"0.6543292\",\n \"0.6520295\",\n \"0.651792\",\n \"0.6505511\",\n \"0.6492536\",\n \"0.6471303\",\n \"0.64436543\",\n \"0.64351404\",\n \"0.64217573\",\n \"0.6357475\",\n \"0.63086164\",\n \"0.63078463\",\n \"0.6282805\",\n \"0.6273367\",\n \"0.61772734\",\n \"0.61530286\",\n \"0.61107355\",\n \"0.6106634\",\n \"0.6070856\",\n \"0.60372525\",\n \"0.6020829\",\n \"0.59896654\",\n \"0.5988739\",\n \"0.59767586\",\n \"0.5973282\",\n \"0.59514034\",\n \"0.59511656\",\n \"0.594435\",\n \"0.5939434\",\n \"0.59326667\",\n \"0.59318954\",\n \"0.59209013\",\n \"0.5909364\",\n \"0.5903238\",\n \"0.58987045\",\n \"0.5894836\",\n \"0.5890686\",\n \"0.5889708\",\n \"0.5878181\",\n \"0.5876378\",\n \"0.58704716\",\n \"0.58431935\",\n \"0.5833034\",\n \"0.57872283\",\n \"0.5785971\",\n \"0.5780257\",\n \"0.5776985\",\n \"0.57730865\",\n \"0.57620394\",\n \"0.57614625\",\n \"0.57566506\",\n \"0.57557046\",\n \"0.5746235\",\n \"0.57430327\",\n \"0.5735164\",\n \"0.57332456\",\n \"0.57314944\",\n \"0.5724014\",\n \"0.57141215\",\n \"0.5706513\",\n \"0.5706424\",\n \"0.57028145\",\n \"0.57000035\",\n \"0.5699986\",\n \"0.56996125\",\n \"0.5692665\",\n \"0.56799823\",\n \"0.56545556\",\n \"0.5640075\",\n \"0.56389004\",\n \"0.5616042\",\n \"0.56131464\",\n \"0.56082475\",\n \"0.5607952\",\n \"0.5606376\",\n \"0.5604214\",\n \"0.5600834\",\n \"0.55985355\",\n \"0.5592877\",\n \"0.55895424\",\n \"0.55895424\",\n \"0.55821186\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72390187"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20293,"cells":{"query":{"kind":"string","value":"Returns the arm's desired x,y,z acceleration in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_velocity()"},"document":{"kind":"string","value":"def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def acceleration(v,u,t):\n return ((v-u)/t)","def acceleration(self):\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n \n ax = self._obj['u']*ux + self._obj['v']*uy\n ay = self._obj['u']*vx + self._obj['v']*vy\n\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\n\n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'{vel_units}^2')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\n\n\n return self._obj","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def get_acceleration(self,v,el,T_s,T_i):\n\n rad = radiation.Radiation()\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n g = rad.getGravity(el)\n\n\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\n\n Cd = .5 # Drag Coefficient\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\n\n if F_d > 0:\n F_d = F_d * self.Upsilon\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\n\n return accel","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def target_acceleration(self, time):\n #return np.array([0, 0, 0])\n if time <= self.total_time/4:\n return self.path1.target_acceleration(time)\n elif time <= self.total_time/2:\n return self.path2.target_acceleration(time)\n elif time <= self.total_time/4*3:\n return self.path3.target_acceleration(time)\n else:\n return self.path4.target_acceleration(time)","def target_acceleration(self, time):\n return np.array([0, 0, 0])","def target_acceleration(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_acceleration(path_time)","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def acceleration(self):\n return self.__accel","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def _compute_solar_torque(self):\n pass","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def to_cart(self, t):\n # mean motion:\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\n # mean anomaly at t:\n M = n * (t - self.t0) + self.M0\n # print(np.fmod(M, 2*np.pi))\n # solve Kepler equation, get eccentric anomaly:\n E = self.kepler(self.e, M)\n cosE = np.cos(E)\n sinE = np.sin(E)\n # get true anomaly and distance from focus:\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\n # r = self.a*(1 - self.e*cosE)\n #\n sinw = np.sin(self.w)\n cosw = np.cos(self.w)\n sinu = sinw * cosv + cosw * sinv\n cosu = cosw * cosv - sinw * sinv\n # position\n cosNode = np.cos(self.Node)\n sinNode = np.sin(self.Node)\n cosi = np.cos(self.i)\n sini = np.sin(self.i)\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\n z = r * sinu * sini\n # velocity\n p = self.a * (1.0 - self.e ** 2)\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\n vz = z * V_1 / r + cosu * sini * V_2\n\n state = np.array([x, y, z, vx, vy, vz])\n state = np.reshape(np.asarray(state), (3, 2), 'F')\n\n return state","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def advanceVelocity(self,time,acceleration):\n if not isinstance(acceleration,Cartesian3DVector):\n raise CoordinateException(\"Advancing particle momentum with the incorrect acceleration type.\")\n return self.v + time*acceleration","def acceleration(self):\n # speed is by formula: x axis speed: by cos of the heading and y\n # axis by sine of the heading\n self.x_speed += math.cos(math.radians(self.degrees))\n self.y_speed += math.sin(math.radians(self.degrees))","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def compute_acceleration(self, x, y):\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\n return np.array([a_x, a_y])","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def tidal_acc(self, xyz):\r\n assert(xyz.shape[1] == 3)\r\n\r\n # create solar mass variable, if not already extant\r\n try:\r\n self.M\r\n except AttributeError:\r\n self.M = Constant(2e33) # solar mass in g\r\n\r\n # get the vector of x-values\r\n x = xyz[:, 0]\r\n\r\n # create an all-zero force vector\r\n acc = np.zeros_like(xyz)\r\n\r\n # get the heliocentric distance at the current time\r\n dist = self.trajectory(self.t)\r\n\r\n # get the acceleration as the difference between the acceleration at\r\n # the points and the acceleration at the c.o.m.\r\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\r\n return(acc)","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def predict(self, t : float) -> vector :\n '''@ Zstar : vector'''\n '''@ dt : float'''\n '''@ dtau : float'''\n '''@ F : array'''\n dt = t - self.t\n dtau = self._normalizeDeltaTime(dt)\n F = self.stateTransitionMatrix(self.order+1, dtau)\n Zstar = F @ self.Z;\n return Zstar;","def get_acceleration(self):\n return self.acceleration","def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\n\n #project forwards in time\n sim_interval = self.sim_interval\n sim_interval_sq = sim_interval*sim_interval\n cmd_vel = list(cmd_vel)\n current_speed = list(current_speed)\n\n max_acc_x = self.robot.max_acc_x\n max_acc_th = self.robot.max_acc_th\n max_decc_x = self.robot.max_dacc_x\n max_decc_th = self.robot.max_dacc_th\n\n\n code = \"\"\"\n double x, y, th;\n x = y = th = 0;\n\n double vx, vth;\n vx = current_speed[0];\n vth = current_speed[1];\n\n double cmd_x = cmd_vel[0];\n double cmd_th = cmd_vel[1];\n\n //are we accelerating or decelerating?\n double acc_x;\n double acc_th;\n\n bool b_ax = false;\n if (cmd_x > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = accs[2];\n acc_x = -1*acc_x;\n }\n\n bool b_ath = false;\n if (cmd_th > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1* (double) accs[3];\n\n }\n\n py::list traj;\n\n //delay at the beginning\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //application of the command\n for (double i=0; i<=time_applied; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //delay before decellerating\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //now we apply a stop\n b_ax = false;\n if (0 > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = -1 * (double) accs[2];\n }\n\n b_ath = false;\n if (0 > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1 * (double) accs[3];\n }\n\n for (double i=0; i<=time_decc; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx) < 1e-6) vx = 0;\n\n //check if we have exceeded our target\n if (b_ax && (vx > 0 )) vx = 0;\n if (!b_ax && (vx < 0 )) vx = 0;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth) < 1e-6) vth = 0;\n if (b_ath && (vth > 0 )) vth = 0;\n if (!b_ath && (vth < 0 )) vth = 0;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n\n\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\n if (stopped) break;\n\n }\n\n return_val = traj;\n \"\"\"\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\n 'time_decc'], type_converters=converters.blitz)\n\n return traj","def update_rk3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n try:\n\n kap1 = (self.vel, self.force(self.pos,\n self.vel,\n self.time))\n\n pos = self.pos+0.5*delta_t*kap1[0]\n vel = self.vel+0.5*delta_t*kap1[1]\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n 0.5*delta_t, drag=False)\n\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\n\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\n\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n except Collision.CollisionException as col:\n col.vel = self.vel+col.delta_t*kap1[0]\n raise col\n\n self.time += self.delta_t","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def _get_alpha(self, m_t, v_t):\n return max(0, ((-m_t * self._psi \n + math.sqrt((m_t ** 2 * self._phi ** 4) \n / 4 + v_t * self._phi ** 2 * self._xi)) \n / (v_t * self._xi)))","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def update_ab3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 2:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.set_old(kap, 2)\n\n self.time += delta_t\n\n else:\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\n\n try:\n tmp = [self.get_old(0)]\n except IndexError:\n tmp = []\n kap = update_ab2(self)\n if tmp:\n self._old = self._old + tmp\n\n return kap","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def target_velocity(self, time):\n\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\n\n return avg_vel","def target_acceleration(self, time):\n pass","def target_acceleration(self, time):\n pass","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def update(self, t=1):\n\n\t\t# Update acceleration based on available fuel & throttle\n\t\tthrottle = self.throttle if self.fuel >= 1 else self.throttle * self.fuel\n\t\tself.acceleration = self.thrust * throttle / self.total_mass - GRAVITY\n\n\t\tself.velocity += self.acceleration / t\n\t\tself.altitude += self.velocity / t\n\t\t\n\t\t# Collide with the ground\n\t\tif self.altitude <= 0:\n\t\t\tself.reset_motion()\n\n\t\t# Update remaining fuel\n\t\tif self.fuel * t >= self.throttle:\n\t\t\tself.fuel -= self.throttle * self.fuel_consumption / t\n\t\t\tif self.fuel < 0:\n\t\t\t\tself.fuel = 0","def get_control_input(self, dt):\n \n desired_z = 3.0\n actual_z = self.internal_state.transform.translation.z\n \n # Convert to quaternion object for use by euler_from_quaternion()\n quaternion = np.array([self.internal_state.transform.rotation.x,\n self.internal_state.transform.rotation.y,\n self.internal_state.transform.rotation.z,\n self.internal_state.transform.rotation.w])\n \n # Determine the euler angles\n euler = euler_from_quaternion(quaternion)\n roll = euler[0]\n pitch = euler[1]\n yaw = euler[2]\n \n # Corrections for yaw wrap around\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \n np.abs(np.abs(yaw) - np.pi) < 0.2):\n # Add or subtract 2 pi depending on crossing direction\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \n \n \n # Determine current yaw rate for yaw rate controller\n yaw_rate = (yaw - self.yaw_old) / dt\n \n # After use, update the old yaw value with the current yaw\n self.yaw_old = yaw\n \n # Determine current climb rate\n climb_rate = (actual_z - self.z_old) / dt\n \n # After use, update the old altitude with the current altitude\n self.z_old = actual_z\n \n # Find the errors between desired and actual signals\n err_roll = self.desired_roll - roll\n err_pitch = self.desired_pitch - pitch\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\n err_climb_rate = self.desired_climb_rate - climb_rate\n \n # Set the hover motor speed\n motor_control = self.hover_speed * self.unit_hover_cmd\n \n # Roll controller\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\n \n # Pitch controller\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\n \n # Yaw rate controller (assuming small angles)\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\n \n # Climb rate controller\n motor_control += ((self.climb_Pgain * err_climb_rate +\n self.climb_Igain * self.internal_climb_error +\n self.climb_Dgain / dt * (err_climb_rate - \n self.internal_old_climb_rate_error)) * \n self.unit_hover_cmd)\n \n # Update the cumulative errors for integration\n self.internal_roll_error += err_roll * dt\n self.internal_pitch_error += err_pitch * dt\n self.internal_yaw_error += err_yaw_rate * dt\n self.internal_climb_error += err_climb_rate * dt\n \n # Update old error with current errors for differentiation\n self.internal_old_roll_error = err_roll\n self.internal_old_pitch_error = err_pitch\n self.internal_old_yaw_rate_error = err_yaw_rate\n self.internal_old_climb_rate_error = err_climb_rate\n \n \n # Return the minimum of the \n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)","def evaluate(self, _t):\n\n temp = self.init_temp - (self.decay*_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def calculate_acceleration(self) -> np.array:\n F = self.calculate_net_force()\n m = self.mass\n a = F / m\n\n return a","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def get_current_thrust_direction(self,\n time: float) -> np.array:\n # Interpolate with time\n angle = self.thrust_angle_interpolator.interpolate(time)\n # Set thrust in vertical frame and transpose it\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\n # Update flight conditions (this is needed to let tudat know to update all variables)\n self.vehicle_body.flight_conditions.update_conditions(time)\n # Get aerodynamic angle calculator\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\n frames.AerodynamicsReferenceFrames.vertical_frame,\n frames.AerodynamicsReferenceFrames.inertial_frame)\n # Compute the thrust in the inertial frame\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\n thrust_direction_vertical_frame)\n return thrust_inertial_frame","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def move(self, t):\n if self.visible == True:\n self.x += self.vx * t\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\n\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\n self.phi = t * v_norm / self.radius\n\n glPushMatrix()\n glLoadIdentity()\n\n if v_norm > 0.0:\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\n glMultMatrixd(self.matrix)\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\n\n glPopMatrix()\n\n # Friction!!! Could do it as global parameter\n if v_norm > 0.0:\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\n\n if v_prime_norm < 0.0:\n v_prime_norm = 0.0\n\n self.vx *= v_prime_norm / v_norm\n self.vy *= v_prime_norm / v_norm\n\n return True\n # Add comment\n return False","def u_exact(self, t):\n\n # some abbreviations\n wE = self.params.omega_E\n wB = self.params.omega_B\n N = self.params.nparts\n u0 = self.params.u0\n\n if N != 1:\n raise ProblemError('u_exact is only valid for a single particle')\n\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\n\n wbar = np.sqrt(2) * wE\n\n # position and velocity in z direction is easy to compute\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\n\n # define temp. variables to compute complex position\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\n Rp = u0[0][0] - Rm\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\n Ip = u0[0][1] - Im\n\n # compute position in complex notation\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n # compute velocity as time derivative of the position\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\n\n # get the appropriate real and imaginary parts\n u.pos[0, 0] = w.real\n u.vel[0, 0] = dw.real\n u.pos[1, 0] = w.imag\n u.vel[1, 0] = dw.imag\n\n return u","def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation","def get_position(self, t0):\n my_pos_x=np.random.uniform(-20, 20)\n my_pos_y=np.random.uniform(-20, 20)\n r=np.array([my_pos_x, my_pos_y])\n x_y=np.zeros(shape=(self.no_planets-1, 2))\n tol=1e-5\n diff=np.zeros(self.no_planets-1)\n for k in range(self.no_planets-1):\n r1=np.linalg.norm(r)\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\n x1=0\n y1=0\n x2=self.positionFunction(t0)[0,k]\n y2=self.positionFunction(t0)[1,k]\n x3=self.positionFunction(t0)[0,k+1]\n y3=self.positionFunction(t0)[1, k+1]\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\n x_y[k, 0]=x\n x_y[k, 1]=y\n diff[k]=difference\n if (diff > tol).any():\n print diff.max()\n print \"Oh no, one failed :(\"\n sys.exit(1)\n print \"My pos x:\", my_pos_x\n print \"My pos y:\", my_pos_y\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def forward_kinematics(self):\n temp_T = Matrix.eye(3)\n for i in range(len(self.lengths)):\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\n temp_T = temp_T * angle_mat * len_mat\n \n self.final_T = np.array(temp_T,dtype=float)\n \n return self.final_T","def position(t):\n return c + tangent_vec * 7 * t ** 2","def f( self , x , u , t ):\n \n dx = np.zeros(self.n) # State derivative vector\n \n ################################################\n # Place holder: put the equations of motion here\n raise NotImplementedError\n ################################################\n \n return dx","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def evaluate(self, _t):\n\n temp = self.init_temp*(self.decay**_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def motors_update(t, x, u, params={}):\n tm = params['motor']['tm'] # Motor torque constant\n cr = params['motor']['cr'] # Motor speed constant\n wb = params['motor']['wb'] # Motor base speed\n\n u = np.clip(u / 199999, 0, 1)\n accel = [(cr * throttle + wb - speed) / tm for throttle, speed in zip(u, x)]\n\n return accel","def get_D_C3H8_air(self, T):\n\n self.set_TempPres_dependents(T)\n\n self.D_C3H8_air = (\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\n )\n\n return self.D_C3H8_air","def thetas (self,lag):\n tanthetas = [0,0,0]\n for k in range(3,self.n):\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\n tanthetas.append(tantheta_k)\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles","def spaceship_acceleration_x(dt, rotation):\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))","def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\r\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\r\n * c)) ** 2) - 1.0)\r\n self.xa_track.append(x)\r\n p = qe * self.t[i]\r\n self.pa.append(p)\r\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\r\n jv = self.t[i] * qe / (m * c)\r\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\r\n self.va.append(v)\r\n print 'Analytical solution of the differential equation of motion'","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def acc(x: float, v: float, t: float) -> float:\n return -k*v - np.sin(x) + c*np.cos(omega*t)","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def initial_velocity(self) -> float:\n return self._initial_velocity","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n e = self.energy()\n m = self.mass()\n p = math.sqrt( e**2 - m**2 )\n pz = p * math.cos(theta)\n pt = p * math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def compute_velocity(self, time_since_last_frame: float) -> None:\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\n self.velocity_kts = (true_dist /\n self.secs_since_last_seen) / 1.94384\n self.cart_coords = new_cart_coords","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def integrate(self, t):\n t0 = self.t0\n if t-t0 <= self.max_step_size:\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \n \n else :\n n = (t-t0) / self.max_step_size\n dt = (t-t0)/int(n+1)\n \n while t0 < t :\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\n t0 += dt\n \n return self.y0","def UpdateCromer(self, deltaT):\n self.velocity += self.acceleration * deltaT\n self.position += self.velocity * deltaT","def shoot(self):\n eta = self.eta()\n theta = 2 * math.atan(math.exp(-eta));\n pt = self.pt()\n p = pt / math.sin(theta)\n phi = self.phi()\n px = pt * math.cos(phi)\n py = pt * math.sin(phi)\n pz = p * math.cos(theta)\n m = self.mass()\n e = math.sqrt( p**2 + m**2 )\n v4 = ROOT.TLorentzVector(px, py, pz, e)\n return v4","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n theta_t = self.get_ik(self.target_position(t))\n # print(self.target_position(t))\n #theta_t = np.array(theta_t)\n # print(theta_t)\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here? cause you're mean\n\n point.positions = theta_t\n point.velocities = (theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def verlet_next_pos(pos_t,vel_t,accel_t,dt):\n pos_t_plus_dt = pos_t.copy()\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \n\n return pos_t_plus_dt","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def _compute_gravity_torque(self):\n pass","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\n \n error_x = goal_x - curr_x\n error_y = goal_y - curr_y\n error_z = goal_z - curr_z\n error_rot_z = goal_rot_z - curr_rot_z\n\n self.output_x = 0.0\n self.output_y = 0.0\n self.output_z = 0.0\n self.output_rot_z = 0.0\n\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\n # self.current_time = time.time()\n self.current_time = rospy.get_time()\n delta_time = self.current_time - self.last_time\n delta_error_x = error_x - self.last_error_x\n delta_error_y = error_y - self.last_error_y\n delta_error_z = error_z - self.last_error_z\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\n\n # print(\"delta_time:\", delta_time)\n\n if (delta_time >= self.sample_time):\n self.PTerm_x = self.Kp_x * error_x\n self.PTerm_y = self.Kp_y * error_y\n self.PTerm_z = self.Kp_z * error_z\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\n\n self.ITerm_x += error_x * delta_time\n self.ITerm_y += error_y * delta_time\n self.ITerm_z += error_z * delta_time\n self.ITerm_rot_z += error_rot_z * delta_time\n\n if (self.ITerm_x < -self.windup_guard):\n self.ITerm_x = -self.windup_guard\n elif (self.ITerm_x > self.windup_guard):\n self.ITerm_x = self.windup_guard\n \n if (self.ITerm_y < -self.windup_guard):\n self.ITerm_y = -self.windup_guard\n elif (self.ITerm_y > self.windup_guard):\n self.ITerm_y = self.windup_guard\n\n if (self.ITerm_z < -self.windup_guard):\n self.ITerm_z = -self.windup_guard\n elif (self.ITerm_z > self.windup_guard):\n self.ITerm_z = self.windup_guard\n \n if (self.ITerm_rot_z < -self.windup_guard):\n self.ITerm_rot_z = -self.windup_guard\n elif (self.ITerm_rot_z > self.windup_guard):\n self.ITerm_rot_z = self.windup_guard\n\n self.DTerm_x = 0.0\n self.DTerm_y = 0.0\n self.DTerm_z = 0.0\n self.DTerm_rot_z = 0.0\n if delta_time > 0:\n self.DTerm_x = delta_error_x / delta_time\n self.DTerm_y = delta_error_y / delta_time\n self.DTerm_z = delta_error_z / delta_time\n self.DTerm_rot_z = delta_error_rot_z / delta_time\n\n\n # Remember last time and last error for next calculation\n self.last_time = self.current_time\n self.last_error_x = error_x\n self.last_error_y = error_y\n self.last_error_z = error_z\n self.last_error_rot_z = error_rot_z\n\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\n \n return self.output_x, self.output_y, self.output_z, self.output_rot_z","def __call__(self,\n x0: Union[float, np.ndarray],\n xt: Union[float, np.ndarray],\n t: float) -> Union[float, np.ndarray]:\n sig2t = (self._model.diffusion(x0, t) ** 2) * 2 * t\n mut = x0 + self._model.drift(x0, t) * t\n return np.exp(-(xt - mut) ** 2 / sig2t) / np.sqrt(np.pi * sig2t)"],"string":"[\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def acceleration(self):\\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n \\n ax = self._obj['u']*ux + self._obj['v']*uy\\n ay = self._obj['u']*vx + self._obj['v']*vy\\n\\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\\n\\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'{vel_units}^2')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\\n\\n\\n return self._obj\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def get_acceleration(self,v,el,T_s,T_i):\\n\\n rad = radiation.Radiation()\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n g = rad.getGravity(el)\\n\\n\\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\\n\\n Cd = .5 # Drag Coefficient\\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\\n\\n if F_d > 0:\\n F_d = F_d * self.Upsilon\\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\\n\\n return accel\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def target_acceleration(self, time):\\n #return np.array([0, 0, 0])\\n if time <= self.total_time/4:\\n return self.path1.target_acceleration(time)\\n elif time <= self.total_time/2:\\n return self.path2.target_acceleration(time)\\n elif time <= self.total_time/4*3:\\n return self.path3.target_acceleration(time)\\n else:\\n return self.path4.target_acceleration(time)\",\n \"def target_acceleration(self, time):\\n return np.array([0, 0, 0])\",\n \"def target_acceleration(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_acceleration(path_time)\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def acceleration(self):\\n return self.__accel\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def to_cart(self, t):\\n # mean motion:\\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\\n # mean anomaly at t:\\n M = n * (t - self.t0) + self.M0\\n # print(np.fmod(M, 2*np.pi))\\n # solve Kepler equation, get eccentric anomaly:\\n E = self.kepler(self.e, M)\\n cosE = np.cos(E)\\n sinE = np.sin(E)\\n # get true anomaly and distance from focus:\\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\\n # r = self.a*(1 - self.e*cosE)\\n #\\n sinw = np.sin(self.w)\\n cosw = np.cos(self.w)\\n sinu = sinw * cosv + cosw * sinv\\n cosu = cosw * cosv - sinw * sinv\\n # position\\n cosNode = np.cos(self.Node)\\n sinNode = np.sin(self.Node)\\n cosi = np.cos(self.i)\\n sini = np.sin(self.i)\\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\\n z = r * sinu * sini\\n # velocity\\n p = self.a * (1.0 - self.e ** 2)\\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\\n vz = z * V_1 / r + cosu * sini * V_2\\n\\n state = np.array([x, y, z, vx, vy, vz])\\n state = np.reshape(np.asarray(state), (3, 2), 'F')\\n\\n return state\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def advanceVelocity(self,time,acceleration):\\n if not isinstance(acceleration,Cartesian3DVector):\\n raise CoordinateException(\\\"Advancing particle momentum with the incorrect acceleration type.\\\")\\n return self.v + time*acceleration\",\n \"def acceleration(self):\\n # speed is by formula: x axis speed: by cos of the heading and y\\n # axis by sine of the heading\\n self.x_speed += math.cos(math.radians(self.degrees))\\n self.y_speed += math.sin(math.radians(self.degrees))\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def compute_acceleration(self, x, y):\\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\\n return np.array([a_x, a_y])\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def tidal_acc(self, xyz):\\r\\n assert(xyz.shape[1] == 3)\\r\\n\\r\\n # create solar mass variable, if not already extant\\r\\n try:\\r\\n self.M\\r\\n except AttributeError:\\r\\n self.M = Constant(2e33) # solar mass in g\\r\\n\\r\\n # get the vector of x-values\\r\\n x = xyz[:, 0]\\r\\n\\r\\n # create an all-zero force vector\\r\\n acc = np.zeros_like(xyz)\\r\\n\\r\\n # get the heliocentric distance at the current time\\r\\n dist = self.trajectory(self.t)\\r\\n\\r\\n # get the acceleration as the difference between the acceleration at\\r\\n # the points and the acceleration at the c.o.m.\\r\\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\\r\\n return(acc)\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def predict(self, t : float) -> vector :\\n '''@ Zstar : vector'''\\n '''@ dt : float'''\\n '''@ dtau : float'''\\n '''@ F : array'''\\n dt = t - self.t\\n dtau = self._normalizeDeltaTime(dt)\\n F = self.stateTransitionMatrix(self.order+1, dtau)\\n Zstar = F @ self.Z;\\n return Zstar;\",\n \"def get_acceleration(self):\\n return self.acceleration\",\n \"def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\\n\\n #project forwards in time\\n sim_interval = self.sim_interval\\n sim_interval_sq = sim_interval*sim_interval\\n cmd_vel = list(cmd_vel)\\n current_speed = list(current_speed)\\n\\n max_acc_x = self.robot.max_acc_x\\n max_acc_th = self.robot.max_acc_th\\n max_decc_x = self.robot.max_dacc_x\\n max_decc_th = self.robot.max_dacc_th\\n\\n\\n code = \\\"\\\"\\\"\\n double x, y, th;\\n x = y = th = 0;\\n\\n double vx, vth;\\n vx = current_speed[0];\\n vth = current_speed[1];\\n\\n double cmd_x = cmd_vel[0];\\n double cmd_th = cmd_vel[1];\\n\\n //are we accelerating or decelerating?\\n double acc_x;\\n double acc_th;\\n\\n bool b_ax = false;\\n if (cmd_x > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = accs[2];\\n acc_x = -1*acc_x;\\n }\\n\\n bool b_ath = false;\\n if (cmd_th > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1* (double) accs[3];\\n\\n }\\n\\n py::list traj;\\n\\n //delay at the beginning\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //application of the command\\n for (double i=0; i<=time_applied; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //delay before decellerating\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //now we apply a stop\\n b_ax = false;\\n if (0 > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = -1 * (double) accs[2];\\n }\\n\\n b_ath = false;\\n if (0 > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1 * (double) accs[3];\\n }\\n\\n for (double i=0; i<=time_decc; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx) < 1e-6) vx = 0;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > 0 )) vx = 0;\\n if (!b_ax && (vx < 0 )) vx = 0;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth) < 1e-6) vth = 0;\\n if (b_ath && (vth > 0 )) vth = 0;\\n if (!b_ath && (vth < 0 )) vth = 0;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n\\n\\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\\n if (stopped) break;\\n\\n }\\n\\n return_val = traj;\\n \\\"\\\"\\\"\\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\\n 'time_decc'], type_converters=converters.blitz)\\n\\n return traj\",\n \"def update_rk3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n try:\\n\\n kap1 = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time))\\n\\n pos = self.pos+0.5*delta_t*kap1[0]\\n vel = self.vel+0.5*delta_t*kap1[1]\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n 0.5*delta_t, drag=False)\\n\\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\\n\\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\\n\\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n except Collision.CollisionException as col:\\n col.vel = self.vel+col.delta_t*kap1[0]\\n raise col\\n\\n self.time += self.delta_t\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def _get_alpha(self, m_t, v_t):\\n return max(0, ((-m_t * self._psi \\n + math.sqrt((m_t ** 2 * self._phi ** 4) \\n / 4 + v_t * self._phi ** 2 * self._xi)) \\n / (v_t * self._xi)))\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def update_ab3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 2:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n\\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.set_old(kap, 2)\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\\n\\n try:\\n tmp = [self.get_old(0)]\\n except IndexError:\\n tmp = []\\n kap = update_ab2(self)\\n if tmp:\\n self._old = self._old + tmp\\n\\n return kap\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def target_velocity(self, time):\\n\\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\\n\\n return avg_vel\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def update(self, t=1):\\n\\n\\t\\t# Update acceleration based on available fuel & throttle\\n\\t\\tthrottle = self.throttle if self.fuel >= 1 else self.throttle * self.fuel\\n\\t\\tself.acceleration = self.thrust * throttle / self.total_mass - GRAVITY\\n\\n\\t\\tself.velocity += self.acceleration / t\\n\\t\\tself.altitude += self.velocity / t\\n\\t\\t\\n\\t\\t# Collide with the ground\\n\\t\\tif self.altitude <= 0:\\n\\t\\t\\tself.reset_motion()\\n\\n\\t\\t# Update remaining fuel\\n\\t\\tif self.fuel * t >= self.throttle:\\n\\t\\t\\tself.fuel -= self.throttle * self.fuel_consumption / t\\n\\t\\t\\tif self.fuel < 0:\\n\\t\\t\\t\\tself.fuel = 0\",\n \"def get_control_input(self, dt):\\n \\n desired_z = 3.0\\n actual_z = self.internal_state.transform.translation.z\\n \\n # Convert to quaternion object for use by euler_from_quaternion()\\n quaternion = np.array([self.internal_state.transform.rotation.x,\\n self.internal_state.transform.rotation.y,\\n self.internal_state.transform.rotation.z,\\n self.internal_state.transform.rotation.w])\\n \\n # Determine the euler angles\\n euler = euler_from_quaternion(quaternion)\\n roll = euler[0]\\n pitch = euler[1]\\n yaw = euler[2]\\n \\n # Corrections for yaw wrap around\\n if (not np.sign(yaw) == np.sign(self.yaw_old) and \\n np.abs(np.abs(yaw) - np.pi) < 0.2):\\n # Add or subtract 2 pi depending on crossing direction\\n self.yaw_old = self.yaw_old + np.sign(yaw) * 2 * np.pi \\n \\n \\n # Determine current yaw rate for yaw rate controller\\n yaw_rate = (yaw - self.yaw_old) / dt\\n \\n # After use, update the old yaw value with the current yaw\\n self.yaw_old = yaw\\n \\n # Determine current climb rate\\n climb_rate = (actual_z - self.z_old) / dt\\n \\n # After use, update the old altitude with the current altitude\\n self.z_old = actual_z\\n \\n # Find the errors between desired and actual signals\\n err_roll = self.desired_roll - roll\\n err_pitch = self.desired_pitch - pitch\\n err_yaw_rate = self.desired_yaw_rate - yaw_rate\\n err_climb_rate = self.desired_climb_rate - climb_rate\\n \\n # Set the hover motor speed\\n motor_control = self.hover_speed * self.unit_hover_cmd\\n \\n # Roll controller\\n motor_control += self.roll_Pgain * self.unit_roll_cmd * err_roll\\n \\n # Pitch controller\\n motor_control += self.roll_Pgain * self.unit_pitch_cmd * err_pitch\\n \\n # Yaw rate controller (assuming small angles)\\n motor_control += self.yaw_rate_Pgain * self.unit_yaw_cmd * err_yaw_rate\\n \\n # Climb rate controller\\n motor_control += ((self.climb_Pgain * err_climb_rate +\\n self.climb_Igain * self.internal_climb_error +\\n self.climb_Dgain / dt * (err_climb_rate - \\n self.internal_old_climb_rate_error)) * \\n self.unit_hover_cmd)\\n \\n # Update the cumulative errors for integration\\n self.internal_roll_error += err_roll * dt\\n self.internal_pitch_error += err_pitch * dt\\n self.internal_yaw_error += err_yaw_rate * dt\\n self.internal_climb_error += err_climb_rate * dt\\n \\n # Update old error with current errors for differentiation\\n self.internal_old_roll_error = err_roll\\n self.internal_old_pitch_error = err_pitch\\n self.internal_old_yaw_rate_error = err_yaw_rate\\n self.internal_old_climb_rate_error = err_climb_rate\\n \\n \\n # Return the minimum of the \\n return np.clip(motor_control, self.motor_cmd_min, self.motor_cmd_max)\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp - (self.decay*_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def calculate_acceleration(self) -> np.array:\\n F = self.calculate_net_force()\\n m = self.mass\\n a = F / m\\n\\n return a\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def get_current_thrust_direction(self,\\n time: float) -> np.array:\\n # Interpolate with time\\n angle = self.thrust_angle_interpolator.interpolate(time)\\n # Set thrust in vertical frame and transpose it\\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\\n # Update flight conditions (this is needed to let tudat know to update all variables)\\n self.vehicle_body.flight_conditions.update_conditions(time)\\n # Get aerodynamic angle calculator\\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\\n frames.AerodynamicsReferenceFrames.vertical_frame,\\n frames.AerodynamicsReferenceFrames.inertial_frame)\\n # Compute the thrust in the inertial frame\\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\\n thrust_direction_vertical_frame)\\n return thrust_inertial_frame\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def move(self, t):\\n if self.visible == True:\\n self.x += self.vx * t\\n self.y += self.vy * t # Maybe do this to the end?! Like in article https://gafferongames.com/post/integration_basics/\\n\\n v_norm = np.sqrt(self.vx ** 2 + self.vy ** 2)\\n self.phi = t * v_norm / self.radius\\n\\n glPushMatrix()\\n glLoadIdentity()\\n\\n if v_norm > 0.0:\\n glRotatef(self.phi * 180.0 / np.pi, -self.vy / v_norm, self.vx / v_norm, 0.0)\\n glMultMatrixd(self.matrix)\\n self.matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n\\n glPopMatrix()\\n\\n # Friction!!! Could do it as global parameter\\n if v_norm > 0.0:\\n v_prime_norm = v_norm - 68 * t # tune this parameter for real effect\\n\\n if v_prime_norm < 0.0:\\n v_prime_norm = 0.0\\n\\n self.vx *= v_prime_norm / v_norm\\n self.vy *= v_prime_norm / v_norm\\n\\n return True\\n # Add comment\\n return False\",\n \"def u_exact(self, t):\\n\\n # some abbreviations\\n wE = self.params.omega_E\\n wB = self.params.omega_B\\n N = self.params.nparts\\n u0 = self.params.u0\\n\\n if N != 1:\\n raise ProblemError('u_exact is only valid for a single particle')\\n\\n u = self.dtype_u(((3, 1), self.init[1], self.init[2]))\\n\\n wbar = np.sqrt(2) * wE\\n\\n # position and velocity in z direction is easy to compute\\n u.pos[2, 0] = u0[0][2] * np.cos(wbar * t) + u0[1][2] / wbar * np.sin(wbar * t)\\n u.vel[2, 0] = -u0[0][2] * wbar * np.sin(wbar * t) + u0[1][2] * np.cos(wbar * t)\\n\\n # define temp. variables to compute complex position\\n Op = 1 / 2 * (wB + np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Om = 1 / 2 * (wB - np.sqrt(wB ** 2 - 4 * wE ** 2))\\n Rm = (Op * u0[0][0] + u0[1][1]) / (Op - Om)\\n Rp = u0[0][0] - Rm\\n Im = (Op * u0[0][1] - u0[1][0]) / (Op - Om)\\n Ip = u0[0][1] - Im\\n\\n # compute position in complex notation\\n w = (Rp + Ip * 1j) * np.exp(-Op * t * 1j) + (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n # compute velocity as time derivative of the position\\n dw = -1j * Op * (Rp + Ip * 1j) * np.exp(-Op * t * 1j) - 1j * Om * (Rm + Im * 1j) * np.exp(-Om * t * 1j)\\n\\n # get the appropriate real and imaginary parts\\n u.pos[0, 0] = w.real\\n u.vel[0, 0] = dw.real\\n u.pos[1, 0] = w.imag\\n u.vel[1, 0] = dw.imag\\n\\n return u\",\n \"def get_rotation(self) -> np.array:\\n axis = self.get_arms()[1]\\n force = [self.d_x, self.d_y] # \\\"Force applied on the arm\\\"\\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\\n if torque == 1: # Anti clockwise rotation\\n rotation = np.array([[0, -1], [1, 0]])\\n if torque == -1: # Clockwise rotation\\n rotation = np.array([[0, 1], [-1, 0]])\\n if torque == 0: # No rotation\\n rotation = np.array([[0, 0], [0, 0]])\\n return rotation\",\n \"def get_position(self, t0):\\n my_pos_x=np.random.uniform(-20, 20)\\n my_pos_y=np.random.uniform(-20, 20)\\n r=np.array([my_pos_x, my_pos_y])\\n x_y=np.zeros(shape=(self.no_planets-1, 2))\\n tol=1e-5\\n diff=np.zeros(self.no_planets-1)\\n for k in range(self.no_planets-1):\\n r1=np.linalg.norm(r)\\n r2=np.linalg.norm(r-self.positionFunction(t0)[:, k])\\n r3=np.linalg.norm(r-self.positionFunction(t0)[:, k+1])\\n x1=0\\n y1=0\\n x2=self.positionFunction(t0)[0,k]\\n y2=self.positionFunction(t0)[1,k]\\n x3=self.positionFunction(t0)[0,k+1]\\n y3=self.positionFunction(t0)[1, k+1]\\n x,y,difference=self.triangulate_analytic(x1,y1,r1,x2,y2,r2,x3,y3,r3)\\n x_y[k, 0]=x\\n x_y[k, 1]=y\\n diff[k]=difference\\n if (diff > tol).any():\\n print diff.max()\\n print \\\"Oh no, one failed :(\\\"\\n sys.exit(1)\\n print \\\"My pos x:\\\", my_pos_x\\n print \\\"My pos y:\\\", my_pos_y\\n #return x1, y1, r1, x2, y2, r2, x3, y3, r3\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def forward_kinematics(self):\\n temp_T = Matrix.eye(3)\\n for i in range(len(self.lengths)):\\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\\n temp_T = temp_T * angle_mat * len_mat\\n \\n self.final_T = np.array(temp_T,dtype=float)\\n \\n return self.final_T\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def f( self , x , u , t ):\\n \\n dx = np.zeros(self.n) # State derivative vector\\n \\n ################################################\\n # Place holder: put the equations of motion here\\n raise NotImplementedError\\n ################################################\\n \\n return dx\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp*(self.decay**_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def motors_update(t, x, u, params={}):\\n tm = params['motor']['tm'] # Motor torque constant\\n cr = params['motor']['cr'] # Motor speed constant\\n wb = params['motor']['wb'] # Motor base speed\\n\\n u = np.clip(u / 199999, 0, 1)\\n accel = [(cr * throttle + wb - speed) / tm for throttle, speed in zip(u, x)]\\n\\n return accel\",\n \"def get_D_C3H8_air(self, T):\\n\\n self.set_TempPres_dependents(T)\\n\\n self.D_C3H8_air = (\\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\\n )\\n\\n return self.D_C3H8_air\",\n \"def thetas (self,lag):\\n tanthetas = [0,0,0]\\n for k in range(3,self.n):\\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\\n tanthetas.append(tantheta_k)\\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles\",\n \"def spaceship_acceleration_x(dt, rotation):\\n return dt * SPACESHIP_ACCELERATION * cos(radians(rotation))\",\n \"def anl_solution(self):\\r\\n\\r\\n m = float(self.mass) / self.nu_m\\r\\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\\\\r\\n / float(self.size_tick * self.size_tick)\\r\\n print 'qE=', qe\\r\\n c = self.light_vel\\r\\n for i in range(0, len(self.obs.obt_g)):\\r\\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\\r\\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\\r\\n * c)) ** 2) - 1.0)\\r\\n self.xa_track.append(x)\\r\\n p = qe * self.t[i]\\r\\n self.pa.append(p)\\r\\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\\r\\n jv = self.t[i] * qe / (m * c)\\r\\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\\r\\n self.va.append(v)\\r\\n print 'Analytical solution of the differential equation of motion'\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def acc(x: float, v: float, t: float) -> float:\\n return -k*v - np.sin(x) + c*np.cos(omega*t)\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def initial_velocity(self) -> float:\\n return self._initial_velocity\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n e = self.energy()\\n m = self.mass()\\n p = math.sqrt( e**2 - m**2 )\\n pz = p * math.cos(theta)\\n pt = p * math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def compute_velocity(self, time_since_last_frame: float) -> None:\\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\\n self.velocity_kts = (true_dist /\\n self.secs_since_last_seen) / 1.94384\\n self.cart_coords = new_cart_coords\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def integrate(self, t):\\n t0 = self.t0\\n if t-t0 <= self.max_step_size:\\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \\n \\n else :\\n n = (t-t0) / self.max_step_size\\n dt = (t-t0)/int(n+1)\\n \\n while t0 < t :\\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\\n t0 += dt\\n \\n return self.y0\",\n \"def UpdateCromer(self, deltaT):\\n self.velocity += self.acceleration * deltaT\\n self.position += self.velocity * deltaT\",\n \"def shoot(self):\\n eta = self.eta()\\n theta = 2 * math.atan(math.exp(-eta));\\n pt = self.pt()\\n p = pt / math.sin(theta)\\n phi = self.phi()\\n px = pt * math.cos(phi)\\n py = pt * math.sin(phi)\\n pz = p * math.cos(theta)\\n m = self.mass()\\n e = math.sqrt( p**2 + m**2 )\\n v4 = ROOT.TLorentzVector(px, py, pz, e)\\n return v4\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n theta_t = self.get_ik(self.target_position(t))\\n # print(self.target_position(t))\\n #theta_t = np.array(theta_t)\\n # print(theta_t)\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here? cause you're mean\\n\\n point.positions = theta_t\\n point.velocities = (theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def verlet_next_pos(pos_t,vel_t,accel_t,dt):\\n pos_t_plus_dt = pos_t.copy()\\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \\n\\n return pos_t_plus_dt\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def _compute_gravity_torque(self):\\n pass\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def run(self, curr_x, goal_x, curr_y, goal_y, curr_z, goal_z, curr_rot_z, goal_rot_z, current_time=None):\\n \\n error_x = goal_x - curr_x\\n error_y = goal_y - curr_y\\n error_z = goal_z - curr_z\\n error_rot_z = goal_rot_z - curr_rot_z\\n\\n self.output_x = 0.0\\n self.output_y = 0.0\\n self.output_z = 0.0\\n self.output_rot_z = 0.0\\n\\n # self.current_time = current_time if current_time is not None else rospy.get_rostime()\\n # self.current_time = time.time()\\n self.current_time = rospy.get_time()\\n delta_time = self.current_time - self.last_time\\n delta_error_x = error_x - self.last_error_x\\n delta_error_y = error_y - self.last_error_y\\n delta_error_z = error_z - self.last_error_z\\n delta_error_rot_z = error_rot_z - self.last_error_rot_z\\n\\n # print(\\\"delta_time:\\\", delta_time)\\n\\n if (delta_time >= self.sample_time):\\n self.PTerm_x = self.Kp_x * error_x\\n self.PTerm_y = self.Kp_y * error_y\\n self.PTerm_z = self.Kp_z * error_z\\n self.PTerm_rot_z = self.Kp_rotz * error_rot_z\\n\\n self.ITerm_x += error_x * delta_time\\n self.ITerm_y += error_y * delta_time\\n self.ITerm_z += error_z * delta_time\\n self.ITerm_rot_z += error_rot_z * delta_time\\n\\n if (self.ITerm_x < -self.windup_guard):\\n self.ITerm_x = -self.windup_guard\\n elif (self.ITerm_x > self.windup_guard):\\n self.ITerm_x = self.windup_guard\\n \\n if (self.ITerm_y < -self.windup_guard):\\n self.ITerm_y = -self.windup_guard\\n elif (self.ITerm_y > self.windup_guard):\\n self.ITerm_y = self.windup_guard\\n\\n if (self.ITerm_z < -self.windup_guard):\\n self.ITerm_z = -self.windup_guard\\n elif (self.ITerm_z > self.windup_guard):\\n self.ITerm_z = self.windup_guard\\n \\n if (self.ITerm_rot_z < -self.windup_guard):\\n self.ITerm_rot_z = -self.windup_guard\\n elif (self.ITerm_rot_z > self.windup_guard):\\n self.ITerm_rot_z = self.windup_guard\\n\\n self.DTerm_x = 0.0\\n self.DTerm_y = 0.0\\n self.DTerm_z = 0.0\\n self.DTerm_rot_z = 0.0\\n if delta_time > 0:\\n self.DTerm_x = delta_error_x / delta_time\\n self.DTerm_y = delta_error_y / delta_time\\n self.DTerm_z = delta_error_z / delta_time\\n self.DTerm_rot_z = delta_error_rot_z / delta_time\\n\\n\\n # Remember last time and last error for next calculation\\n self.last_time = self.current_time\\n self.last_error_x = error_x\\n self.last_error_y = error_y\\n self.last_error_z = error_z\\n self.last_error_rot_z = error_rot_z\\n\\n self.output_x = self.PTerm_x + (self.Ki_x * self.ITerm_x) + (self.Kd_x * self.DTerm_x)\\n self.output_y = self.PTerm_y + (self.Ki_y * self.ITerm_y) + (self.Kd_y * self.DTerm_y)\\n self.output_z = self.PTerm_z + (self.Ki_z * self.ITerm_z) + (self.Kd_z * self.DTerm_z)\\n self.output_rot_z = self.PTerm_rot_z + (self.Ki_rotz * self.ITerm_rot_z) + (self.Kd_rotz * self.DTerm_rot_z)\\n \\n return self.output_x, self.output_y, self.output_z, self.output_rot_z\",\n \"def __call__(self,\\n x0: Union[float, np.ndarray],\\n xt: Union[float, np.ndarray],\\n t: float) -> Union[float, np.ndarray]:\\n sig2t = (self._model.diffusion(x0, t) ** 2) * 2 * t\\n mut = x0 + self._model.drift(x0, t) * t\\n return np.exp(-(xt - mut) ** 2 / sig2t) / np.sqrt(np.pi * sig2t)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6654176","0.65230024","0.64852095","0.64031357","0.64031357","0.63639945","0.6288034","0.62409705","0.61979336","0.6173782","0.61587775","0.6153133","0.6142052","0.6091978","0.6033012","0.60062426","0.599504","0.5980418","0.58893937","0.58403546","0.58055806","0.5783974","0.5782522","0.5757616","0.5739489","0.56724524","0.56581587","0.56543696","0.5645363","0.5641847","0.55984366","0.55859786","0.5584969","0.5583669","0.55793774","0.5567482","0.5547899","0.55465716","0.5544459","0.5541313","0.5525292","0.5522926","0.55196613","0.5519318","0.55154526","0.55147296","0.55147296","0.5503303","0.54808474","0.5478539","0.54597026","0.54502434","0.54469335","0.543219","0.5431063","0.54250216","0.54180104","0.5412341","0.5412341","0.5411231","0.54106456","0.5407892","0.5407439","0.540582","0.5397435","0.5397435","0.5384672","0.53808486","0.53702676","0.53669155","0.5361914","0.5356409","0.5356227","0.5349399","0.53480124","0.5333702","0.5328817","0.5327198","0.5324187","0.5316723","0.53159535","0.5314852","0.53133005","0.5308871","0.5306965","0.5305276","0.5303358","0.5295539","0.52873516","0.52727866","0.52710676","0.52681667","0.5267996","0.5265313","0.5255205","0.52544177","0.5254246","0.5251624","0.52513456","0.5251244"],"string":"[\n \"0.6654176\",\n \"0.65230024\",\n \"0.64852095\",\n \"0.64031357\",\n \"0.64031357\",\n \"0.63639945\",\n \"0.6288034\",\n \"0.62409705\",\n \"0.61979336\",\n \"0.6173782\",\n \"0.61587775\",\n \"0.6153133\",\n \"0.6142052\",\n \"0.6091978\",\n \"0.6033012\",\n \"0.60062426\",\n \"0.599504\",\n \"0.5980418\",\n \"0.58893937\",\n \"0.58403546\",\n \"0.58055806\",\n \"0.5783974\",\n \"0.5782522\",\n \"0.5757616\",\n \"0.5739489\",\n \"0.56724524\",\n \"0.56581587\",\n \"0.56543696\",\n \"0.5645363\",\n \"0.5641847\",\n \"0.55984366\",\n \"0.55859786\",\n \"0.5584969\",\n \"0.5583669\",\n \"0.55793774\",\n \"0.5567482\",\n \"0.5547899\",\n \"0.55465716\",\n \"0.5544459\",\n \"0.5541313\",\n \"0.5525292\",\n \"0.5522926\",\n \"0.55196613\",\n \"0.5519318\",\n \"0.55154526\",\n \"0.55147296\",\n \"0.55147296\",\n \"0.5503303\",\n \"0.54808474\",\n \"0.5478539\",\n \"0.54597026\",\n \"0.54502434\",\n \"0.54469335\",\n \"0.543219\",\n \"0.5431063\",\n \"0.54250216\",\n \"0.54180104\",\n \"0.5412341\",\n \"0.5412341\",\n \"0.5411231\",\n \"0.54106456\",\n \"0.5407892\",\n \"0.5407439\",\n \"0.540582\",\n \"0.5397435\",\n \"0.5397435\",\n \"0.5384672\",\n \"0.53808486\",\n \"0.53702676\",\n \"0.53669155\",\n \"0.5361914\",\n \"0.5356409\",\n \"0.5356227\",\n \"0.5349399\",\n \"0.53480124\",\n \"0.5333702\",\n \"0.5328817\",\n \"0.5327198\",\n \"0.5324187\",\n \"0.5316723\",\n \"0.53159535\",\n \"0.5314852\",\n \"0.53133005\",\n \"0.5308871\",\n \"0.5306965\",\n \"0.5305276\",\n \"0.5303358\",\n \"0.5295539\",\n \"0.52873516\",\n \"0.52727866\",\n \"0.52710676\",\n \"0.52681667\",\n \"0.5267996\",\n \"0.5265313\",\n \"0.5255205\",\n \"0.52544177\",\n \"0.5254246\",\n \"0.5251624\",\n \"0.52513456\",\n \"0.5251244\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70134026"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20294,"cells":{"query":{"kind":"string","value":"Returns where the arm end effector should be at time t"},"document":{"kind":"string","value":"def target_position(self, time):\n \"\"\"\n start_pos = self.points[self.cur_start]\n seg_time = time - self.last_checkpoint_time\n\n #The arguement of target-velocity dosent matter\n cur_pos = self.target_velocity(time)*seg_time + start_pos\n\n \n # or time > (self.total_time / 4)*(self.cur_start + 1)\n cur_pos_norm = length(cur_pos - start_pos)\n\n next_corner = self.points[(self.cur_start + 1)%4]\n \n seg_norm = length(next_corner - start_pos)\n print(\"cur_pos : \", cur_pos, \"segment: \", self.cur_start, seg_norm - cur_pos_norm)\n\n if cur_pos_norm >= seg_norm:\n self.cur_start = (self.cur_start + 1) % 4\n self.last_checkpoint_time = time\n return cur_pos\n \"\"\"\n\n #Possibly use rospy.sleep()\n total_time = self.total_time\n\n\n if time < total_time/4:\n return self.path1.target_position(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time < total_time/2:\n return self.path2.target_position(time - (total_time/4 + 0.5))\n # return self.path2.target_position(time - (total_time/4 ))\n\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= total_time/4*3:\n return self.path3.target_position(time - (total_time/2 + 1))\n # return self.path3.target_position(time - (total_time/2))\n\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n else:\n return self.path4.target_position(time - (total_time/4*3 + 1.5))\n # return self.path4.target_position(time - (total_time/4*3))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0","def end_time(self) -> float:\r\n ...","def endTime(self):\n return self.params['tend']","def get_last(t_, w_):\n return t_ - tf.constant(1)","def end(self):\n return self._t0 + self.length","def getEndTime(self):\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)","def end_effectors_pos(self):\n def relative_pos_in_egocentric_frame(physics):\n end_effector = physics.bind(self._entity.end_effectors).xpos\n torso = physics.bind(self._entity.root_body).xpos\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\n return observable.Generic(relative_pos_in_egocentric_frame)","def est_am(t,y):\n ch=t>t_eq\n y1=y[ch]\n return y1[-1]-y1[0]","def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\n\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\n naturalLog = np.log(numeratorLN/denomLN)\n\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\n brackets = F - Fp + product1\n\n product2 = (1/Ks)*brackets\n time = tp + product2 - endingTime\n return time","def getEndTime(self):\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)","def find_exit_time(self):\n \n # check when last bead starts moving\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\n nonzero = np.flatnonzero( vel_last_bead )\n \n if nonzero.size == 0:\n warnings.warn('The wave did not exit the chain or it could not be determined.')\n return np.nan\n else:\n exit_index = np.min( nonzero )\n time = self.get_time()\n exit_time = time[exit_index]\n return exit_time","def getEndTime(self):\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)","def timeofflight(xhat0):\n\t\timport poincare\n\t\t#Find the point on the computed poincare section, closest to the x0\n\t\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\n\t\t#Take its time of flight as\n\t\tif imin < np.size(ps,0)-1: \n\t\t\tTapproximate = ps[imin+1,0]-ps[imin,0]\n\t\telse:\n\t\t\tTapproximate = ps[imin,0]-ps[imin-1,0]\n\t\tprint(\"Tapproximate:\")\n\t\tprint(Tapproximate)\n\t\t#Integrate for a little bit longer than the approximated integration time:\n\t\tstoptime = 1.2*Tapproximate\n\t\tnumpoints = int(stoptime/0.01)\n\t\t#Integration time array:\n\t\tt = np.linspace(0, stoptime, numpoints)\n\t\txhatphi0 = np.append(xhat0, np.array([0], float))\n\t\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\n\t\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\n\t\t#Compute Poincare section:\n\t\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\n\t\tprint(\"psreturn:\")\n\t\tprint(psreturn)\n\t\t#Take the time nearest to the approximated time. This is due to the\n\t\t#fact that the array ps sometimes includes the initial point and sometimes\n\t\t#does not, hence we are not always sure the position of the first return.\n\t\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\n\t\ttof = psreturn[itof,0]\n\t\treturn tof","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def point_on_ray(self, t=0.5):\n\n assert 0. <= t <=1., 't must be between 0 and 1'\n\n\n return self.detector_origin + (self._origin - self.detector_origin) * t","def get_delta_t(self):\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\n - self.gv.t_queue[self.gv.filter_min_bound]","def at(self, t):\n return self.start + (self.end - self.start) * t","def end_time(self):\n pass","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def end_time(self):\n # TODO: use pd.Timestamp instead\n return self.time[-1].to_pydatetime()","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def get_trace_abs(self, norm=True):\n if self.Et is not None:\n # Center peak in time\n ind = np.argmax(abs(self.Et))\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\n Et = np.abs(np.roll(self.Et, shift))\n if norm is True:\n Et /= Et.max()\n else:\n Et = None\n return Et","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def _dy(self, T):\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])","def end_point(self) -> Vec3:\n v = list(self.vertices([self.dxf.end_angle]))\n return v[0]","def _reached_temperature_end_point(self, T, Tend):\n if Tend is None:\n # End point not give\n return False\n\n if self._integration_direction == \"increasing\":\n if T > Tend:\n return True\n elif self._integration_direction == \"decreasing\":\n if T < Tend:\n return True\n return False","def end_time(self, t):\r\n # Increase temperature while silent.\r\n if np.count_nonzero(self.next_note) == 0:\r\n self.silent_time += 1\r\n if self.silent_time >= NOTES_PER_BAR:\r\n self.temperature += 0.1\r\n else:\r\n self.silent_time = 0\r\n self.temperature = self.default_temp\r\n \r\n self.notes_memory.append(self.next_note)\r\n # Consistent with dataset representation\r\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\r\n self.results.append(self.next_note)\r\n # Reset next note\r\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\r\n return self.results[-1]","def find_alert_time(self) -> None:\n \n # Also not clear from the paper how to doe this,\n # use the first 10 data points in the light curve to determine the magnitude\n # baseline\n\n mean_mag = np.mean(self.mags[:10])\n std_mag = np.std(self.mags[:10])\n\n num_above = 0 \n i = 9\n\n while num_above < 3 and i < len(self.times)-1:\n \n i += 1 \n\n if self.mags[i] < mean_mag - std_mag:\n num_above += 1\n else:\n num_above = 0.0\n\n if len(self.times) - 1 == i:\n print(\"Give me more training data, not alerted yet, this is probably going to fail\")\n \n return self.times[i-1]","def eval(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[:len(res)//2]","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def getEndTime(self):\n return _osgAnimation.Channel_getEndTime(self)","def line_segment(t, # Array of times for each position\n t_now # Current time (float)\n ):\n i = np.argwhere(t > t_now)\n if len(i) > 0:\n if i[0] != 0: # if the current time is not less than the starting time\n segment_starting_index = i[0][0] - 1\n else:\n segment_starting_index = 0\n\n segment_end_index = i[0][0]\n\n else: # if the current time is more than the last point (destination) time\n segment_starting_index = t.shape[0]\n segment_end_index = t.shape[0]\n\n return segment_starting_index, segment_end_index","def end_abs(self):\n if self.end == float('inf'):\n return self.track.duration\n else:\n return self.end","def time_step(self):\n\n rho_rel = np.abs(self.rho_dt / self.rho)\n rho_rel_max = np.max(rho_rel)\n e_rel = np.abs(self.e_dt / self.e)\n e_rel_max = np.max(e_rel)\n x_rel = np.abs(self.u / self.dx)\n x_rel_max = np.max(x_rel)\n y_rel = np.abs(self.w / self.dy)\n y_rel_max = np.max(y_rel)\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\n delta = np.max(np.abs(rel))\n\n if 0.1 <= delta <= 1e3:\n self.dt = self.p / delta\n else:\n self.dt = self.p","def end_time(self):\n return RPR.GetAudioAccessorEndTime(self.id)","def run_e(self, t):\n if t > self.n_t:\n raise IndexError('Maximum simulated timesteps exceeded in E step')\n if self.pf.t >= t:\n raise IndexError(\n 'Particle filter already run past given time point')\n while self.pf.t < t:\n self.pf.advance()\n self.pf.calculate_means_sdevs()\n\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))","def end_of_horizon_cost_rule(_m):\r\n\r\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\r\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\r","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def end(self):\r\n hours = self.length // 60\r\n minutes = self.length % 60\r\n return time(self.start.hour + hours, self.start.minute + minutes)","def target_position(self, time):\n # get joint positions and use fk to get end effector position?\n # ar_tag from topic\n\n cur_pos = self.target_velocity(time)*time + self.start_pos\n\n self.points_generated.append(cur_pos)\n #print(self.start_pos)\n # print(cur_pos)\n return cur_pos","def get_end(self):\n\n return self.end_cycle","def _get_end_time(self):\n return self.__end_time","def get_end(self):\n return self._start + self._duration","def diff(t, y):\n origin = root.vectorize()\n root.tensorize(y)\n self.time = t if not imaginary else None\n self.eom()\n ans = root.vectorize(use_aux=True)\n root.tensorize(origin)\n return ans","def inc_end(self):\n return self._exc_end - TIMERANGE_PRECISION","def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\n i,u = self.getSegment(t,endBehavior)\n if i<0: return self.milestones[0]\n elif i+1>=len(self.milestones): return self.milestones[-1]\n #linear interpolate between milestones[i] and milestones[i+1]\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])","def eval(self,t,endBehavior='halt'):\n self._skip_deriv = True\n res = Trajectory.eval_state(self,t,endBehavior)\n self._skip_deriv = False\n return res[:len(res)//2]","def timeEnd(self)->datetime:\n if self._scenario == LM_HardDate.Scenario.ValidSince:\n raise SdkError(\"timeEnd not defined for scenario 'ValidSince'\")\n\n return self._lic.params['timeEnd'].value","def evap(self, lai, tl, ta, qa):#average ta and tl!!\n\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\n\t\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \n\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\n\t return 0.\n\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\n\t return (self.tx*self.ZT*self.TAI*10**6/dt)\n\t else:\n\t return fsev","def get_end(self):\n return self.start + timedelta(minutes=self.duration)","def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to the array\n\t\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\n\t\tdUdt = dUdt + self.getHeatFlux(temperature)\n\t\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\n\t\treturn numpy.append(dNdt,dTdt)","def time_end(self):\n return self._time_end","def tLoss(self, dt, qt, tl, ta, qa):\n\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def end_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"end_time\")","def after(self, time: float) -> 'Trajectory':\n return self.split(time)[1]","def lerp(self, t):\n pass","def set_T_lm(self):\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) )","def end_time(self):\n return from_ts(self.end_time_ms)","def elapsed_raw(self, start=\"__enter__\", end=\"__exit__\"):\n return self.laps[end] - self.laps[start]","def get_vehicle_end_index(self):\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]","def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\n return self.to_se3(res)","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def cal_end(self):\n return self.datetime_end","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def update(self, tfinal):\n t = 0; kk = 0\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\n self.omega = np.zeros((nstep,self.npts))\n self.theta = np.zeros((nstep,self.npts))\n\n while t <(tfinal+1e-10):\n self.return_map()\n self.omega[kk] = self.y[0]\n self.theta[kk] = self.y[1]\n\n self.y = RK4(self.y, self.dt, t, self.deri)\n kk += 1; t += self.dt\n\n return self","def get_terminating_ray(self):\n return self._terminating_ray","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def deriv(self,t,endBehavior='halt'):\n res = Trajectory.eval_state(self,t,endBehavior)\n return res[len(res)//2:]","def end_time(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"end_time\")","def get_current_ee_pose(self):\n #self.arm_endpoint = #magic tf call that I can add\n while True:\n try:\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\n break # once the transform is obtained move on\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\n continue # if it fails try again\n point = [translation[0], translation[1], translation[2]]\n self.arm_endpoint = np.array(point)\n # rospy.logerr(self.arm_endpoint)","def o(r, t):\n return r/t**0.5","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def end_time(self):\n return self._end_time","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def roty(self, t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s],\n [0, 1, 0],\n [-s, 0, c]])","def getEnd(self) -> long:\n ...","def trapezoid(t, params):\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n\n envelope = tf.ones_like(t, dtype=tf.float64)\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\n return envelope","def _get_end(self):\n return self._end","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def ricker(dt, pt):\n nt = int(2 * pt / dt)\n c = np.zeros(nt)\n t0 = pt / dt\n a_ricker = 4 / pt\n\n for it in range(0, nt):\n t = ((it + 1) - t0) * dt\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\n\n return c","def end_time(self):\n return self.time_parser.end_time","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def horde_end(self):","def roty(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])","def out(self, t: any, dim=(None, None)) -> any:\n lB = self.interval[0] # Lower Boundary\n uB = self.interval[1] # Upper Boundary\n # Initialize random step vector each sampling period using comprehensive list.\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\n step_vector[0] = self.ss # keep the steady state value as first\n u = np.zeros(shape=dim) # Initialize step control input array u.\n j = 0\n\n ramp_Step = self.saw_time\n count = 1\n for i in range(len(t)): # Excluding the last point\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\n j += 1\n count = 1\n\n if self.ss is not None and j == 0:\n u[i, :] = self.ss\n else:\n if count != ramp_Step:\n\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\n count += 1\n else:\n u[i, :] = step_vector[j]\n return u","def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\n dT = self.deriv(t,endBehavior)\n return so3.deskew(dT[0])+dT[1]","def getETA():","def getETA():"],"string":"[\n \"def endTime(self) -> float:\\n try: return self.times[-1]\\n except IndexError: return 0.0\",\n \"def end_time(self) -> float:\\r\\n ...\",\n \"def endTime(self):\\n return self.params['tend']\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def end(self):\\n return self._t0 + self.length\",\n \"def getEndTime(self):\\n return _osgAnimation.MatrixLinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec3LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec4LinearSampler_getEndTime(self)\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearSampler_getEndTime(self)\",\n \"def end_effectors_pos(self):\\n def relative_pos_in_egocentric_frame(physics):\\n end_effector = physics.bind(self._entity.end_effectors).xpos\\n torso = physics.bind(self._entity.root_body).xpos\\n xmat = np.reshape(physics.bind(self._entity.root_body).xmat, (3, 3))\\n return np.reshape(np.dot(end_effector - torso, xmat), -1)\\n return observable.Generic(relative_pos_in_egocentric_frame)\",\n \"def est_am(t,y):\\n ch=t>t_eq\\n y1=y[ch]\\n return y1[-1]-y1[0]\",\n \"def stormEnd(tp, Ks, F, Fp, presHead, thetaSat, thetaInit, endingTime):\\n\\n numeratorLN = Fp + np.absolute(presHead)*(thetaSat - thetaInit)\\n denomLN = F + np.absolute(presHead)*(thetaSat - thetaInit)\\n naturalLog = np.log(numeratorLN/denomLN)\\n\\n product1 = np.absolute(presHead)*(thetaSat - thetaInit)*naturalLog\\n brackets = F - Fp + product1\\n\\n product2 = (1/Ks)*brackets\\n time = tp + product2 - endingTime\\n return time\",\n \"def getEndTime(self):\\n return _osgAnimation.Vec2LinearSampler_getEndTime(self)\",\n \"def find_exit_time(self):\\n \\n # check when last bead starts moving\\n vel_last_bead = self.get_bead_velocity(self.get_N()-1)\\n nonzero = np.flatnonzero( vel_last_bead )\\n \\n if nonzero.size == 0:\\n warnings.warn('The wave did not exit the chain or it could not be determined.')\\n return np.nan\\n else:\\n exit_index = np.min( nonzero )\\n time = self.get_time()\\n exit_time = time[exit_index]\\n return exit_time\",\n \"def getEndTime(self):\\n return _osgAnimation.QuatSphericalLinearChannel_getEndTime(self)\",\n \"def timeofflight(xhat0):\\n\\t\\timport poincare\\n\\t\\t#Find the point on the computed poincare section, closest to the x0\\n\\t\\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\\n\\t\\t#Take its time of flight as\\n\\t\\tif imin < np.size(ps,0)-1: \\n\\t\\t\\tTapproximate = ps[imin+1,0]-ps[imin,0]\\n\\t\\telse:\\n\\t\\t\\tTapproximate = ps[imin,0]-ps[imin-1,0]\\n\\t\\tprint(\\\"Tapproximate:\\\")\\n\\t\\tprint(Tapproximate)\\n\\t\\t#Integrate for a little bit longer than the approximated integration time:\\n\\t\\tstoptime = 1.2*Tapproximate\\n\\t\\tnumpoints = int(stoptime/0.01)\\n\\t\\t#Integration time array:\\n\\t\\tt = np.linspace(0, stoptime, numpoints)\\n\\t\\txhatphi0 = np.append(xhat0, np.array([0], float))\\n\\t\\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\\n\\t\\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\\n\\t\\t#Compute Poincare section:\\n\\t\\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\\n\\t\\tprint(\\\"psreturn:\\\")\\n\\t\\tprint(psreturn)\\n\\t\\t#Take the time nearest to the approximated time. This is due to the\\n\\t\\t#fact that the array ps sometimes includes the initial point and sometimes\\n\\t\\t#does not, hence we are not always sure the position of the first return.\\n\\t\\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\\n\\t\\ttof = psreturn[itof,0]\\n\\t\\treturn tof\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def point_on_ray(self, t=0.5):\\n\\n assert 0. <= t <=1., 't must be between 0 and 1'\\n\\n\\n return self.detector_origin + (self._origin - self.detector_origin) * t\",\n \"def get_delta_t(self):\\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\\\\n - self.gv.t_queue[self.gv.filter_min_bound]\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def end_time(self):\\n pass\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def end_time(self):\\n # TODO: use pd.Timestamp instead\\n return self.time[-1].to_pydatetime()\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def get_trace_abs(self, norm=True):\\n if self.Et is not None:\\n # Center peak in time\\n ind = np.argmax(abs(self.Et))\\n shift = (self.Et.shape[0] / 2 - ind).astype(np.int)\\n Et = np.abs(np.roll(self.Et, shift))\\n if norm is True:\\n Et /= Et.max()\\n else:\\n Et = None\\n return Et\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def _dy(self, T):\\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])\",\n \"def end_point(self) -> Vec3:\\n v = list(self.vertices([self.dxf.end_angle]))\\n return v[0]\",\n \"def _reached_temperature_end_point(self, T, Tend):\\n if Tend is None:\\n # End point not give\\n return False\\n\\n if self._integration_direction == \\\"increasing\\\":\\n if T > Tend:\\n return True\\n elif self._integration_direction == \\\"decreasing\\\":\\n if T < Tend:\\n return True\\n return False\",\n \"def end_time(self, t):\\r\\n # Increase temperature while silent.\\r\\n if np.count_nonzero(self.next_note) == 0:\\r\\n self.silent_time += 1\\r\\n if self.silent_time >= NOTES_PER_BAR:\\r\\n self.temperature += 0.1\\r\\n else:\\r\\n self.silent_time = 0\\r\\n self.temperature = self.default_temp\\r\\n \\r\\n self.notes_memory.append(self.next_note)\\r\\n # Consistent with dataset representation\\r\\n self.beat_memory.append(compute_beat(t, NOTES_PER_BAR))\\r\\n self.results.append(self.next_note)\\r\\n # Reset next note\\r\\n self.next_note = np.zeros((NUM_NOTES, NOTE_UNITS))\\r\\n return self.results[-1]\",\n \"def find_alert_time(self) -> None:\\n \\n # Also not clear from the paper how to doe this,\\n # use the first 10 data points in the light curve to determine the magnitude\\n # baseline\\n\\n mean_mag = np.mean(self.mags[:10])\\n std_mag = np.std(self.mags[:10])\\n\\n num_above = 0 \\n i = 9\\n\\n while num_above < 3 and i < len(self.times)-1:\\n \\n i += 1 \\n\\n if self.mags[i] < mean_mag - std_mag:\\n num_above += 1\\n else:\\n num_above = 0.0\\n\\n if len(self.times) - 1 == i:\\n print(\\\"Give me more training data, not alerted yet, this is probably going to fail\\\")\\n \\n return self.times[i-1]\",\n \"def eval(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[:len(res)//2]\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def getEndTime(self):\\n return _osgAnimation.Channel_getEndTime(self)\",\n \"def line_segment(t, # Array of times for each position\\n t_now # Current time (float)\\n ):\\n i = np.argwhere(t > t_now)\\n if len(i) > 0:\\n if i[0] != 0: # if the current time is not less than the starting time\\n segment_starting_index = i[0][0] - 1\\n else:\\n segment_starting_index = 0\\n\\n segment_end_index = i[0][0]\\n\\n else: # if the current time is more than the last point (destination) time\\n segment_starting_index = t.shape[0]\\n segment_end_index = t.shape[0]\\n\\n return segment_starting_index, segment_end_index\",\n \"def end_abs(self):\\n if self.end == float('inf'):\\n return self.track.duration\\n else:\\n return self.end\",\n \"def time_step(self):\\n\\n rho_rel = np.abs(self.rho_dt / self.rho)\\n rho_rel_max = np.max(rho_rel)\\n e_rel = np.abs(self.e_dt / self.e)\\n e_rel_max = np.max(e_rel)\\n x_rel = np.abs(self.u / self.dx)\\n x_rel_max = np.max(x_rel)\\n y_rel = np.abs(self.w / self.dy)\\n y_rel_max = np.max(y_rel)\\n rel = [rho_rel_max, e_rel_max, x_rel_max, y_rel_max]\\n delta = np.max(np.abs(rel))\\n\\n if 0.1 <= delta <= 1e3:\\n self.dt = self.p / delta\\n else:\\n self.dt = self.p\",\n \"def end_time(self):\\n return RPR.GetAudioAccessorEndTime(self.id)\",\n \"def run_e(self, t):\\n if t > self.n_t:\\n raise IndexError('Maximum simulated timesteps exceeded in E step')\\n if self.pf.t >= t:\\n raise IndexError(\\n 'Particle filter already run past given time point')\\n while self.pf.t < t:\\n self.pf.advance()\\n self.pf.calculate_means_sdevs()\\n\\n # print 'Path SNR ' + str(SNR(self.xr[0][0:t], self.pf.means[0:t, 0]))\",\n \"def end_of_horizon_cost_rule(_m):\\r\\n\\r\\n return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * (m.OP[m.Y.last()] + m.FOM[m.Y.last()])\\r\\n # return (m.DELTA[m.Y.last()] / m.INTEREST_RATE) * m.FOM[m.Y.last()]\\r\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end(self):\\r\\n hours = self.length // 60\\r\\n minutes = self.length % 60\\r\\n return time(self.start.hour + hours, self.start.minute + minutes)\",\n \"def target_position(self, time):\\n # get joint positions and use fk to get end effector position?\\n # ar_tag from topic\\n\\n cur_pos = self.target_velocity(time)*time + self.start_pos\\n\\n self.points_generated.append(cur_pos)\\n #print(self.start_pos)\\n # print(cur_pos)\\n return cur_pos\",\n \"def get_end(self):\\n\\n return self.end_cycle\",\n \"def _get_end_time(self):\\n return self.__end_time\",\n \"def get_end(self):\\n return self._start + self._duration\",\n \"def diff(t, y):\\n origin = root.vectorize()\\n root.tensorize(y)\\n self.time = t if not imaginary else None\\n self.eom()\\n ans = root.vectorize(use_aux=True)\\n root.tensorize(origin)\\n return ans\",\n \"def inc_end(self):\\n return self._exc_end - TIMERANGE_PRECISION\",\n \"def eval_state(self, t: float, endBehavior: str = 'halt') -> Vector:\\n i,u = self.getSegment(t,endBehavior)\\n if i<0: return self.milestones[0]\\n elif i+1>=len(self.milestones): return self.milestones[-1]\\n #linear interpolate between milestones[i] and milestones[i+1]\\n return self.interpolate_state(self.milestones[i],self.milestones[i+1],u,self.times[i+1]-self.times[i])\",\n \"def eval(self,t,endBehavior='halt'):\\n self._skip_deriv = True\\n res = Trajectory.eval_state(self,t,endBehavior)\\n self._skip_deriv = False\\n return res[:len(res)//2]\",\n \"def timeEnd(self)->datetime:\\n if self._scenario == LM_HardDate.Scenario.ValidSince:\\n raise SdkError(\\\"timeEnd not defined for scenario 'ValidSince'\\\")\\n\\n return self._lic.params['timeEnd'].value\",\n \"def evap(self, lai, tl, ta, qa):#average ta and tl!!\\n\\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\\n\\t\\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \\n\\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\\n\\t return 0.\\n\\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\\n\\t return (self.tx*self.ZT*self.TAI*10**6/dt)\\n\\t else:\\n\\t return fsev\",\n \"def get_end(self):\\n return self.start + timedelta(minutes=self.duration)\",\n \"def rightSideOfODE(self, Y, t):\\n\\t\\ttemperature = Y[-1]\\n\\t\\tamounts = Y[:-1]\\n\\t\\tself.amounts = amounts\\n\\t\\t# first get the species amount changes (as an array)\\n\\t\\tdNdt = -1 * self.getMolarFluxes(temperature)\\n\\t\\t# then get the temperature change, and append it to the array\\n\\t\\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\\n\\t\\tdUdt = dUdt + self.getHeatFlux(temperature)\\n\\t\\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\\n\\t\\treturn numpy.append(dNdt,dTdt)\",\n \"def time_end(self):\\n return self._time_end\",\n \"def tLoss(self, dt, qt, tl, ta, qa):\\n\\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def end_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def after(self, time: float) -> 'Trajectory':\\n return self.split(time)[1]\",\n \"def lerp(self, t):\\n pass\",\n \"def set_T_lm(self):\\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) )\",\n \"def end_time(self):\\n return from_ts(self.end_time_ms)\",\n \"def elapsed_raw(self, start=\\\"__enter__\\\", end=\\\"__exit__\\\"):\\n return self.laps[end] - self.laps[start]\",\n \"def get_vehicle_end_index(self):\\n return [len(self.matrix) - 1 for i in range(len(self.vehicles))]\",\n \"def eval(self, t: float, endBehavior: str = 'halt') -> RigidTransform:\\n res = GeodesicHermiteTrajectory.eval(self,t,endBehavior)\\n return self.to_se3(res)\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def cal_end(self):\\n return self.datetime_end\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def update(self, tfinal):\\n t = 0; kk = 0\\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\\n self.omega = np.zeros((nstep,self.npts))\\n self.theta = np.zeros((nstep,self.npts))\\n\\n while t <(tfinal+1e-10):\\n self.return_map()\\n self.omega[kk] = self.y[0]\\n self.theta[kk] = self.y[1]\\n\\n self.y = RK4(self.y, self.dt, t, self.deri)\\n kk += 1; t += self.dt\\n\\n return self\",\n \"def get_terminating_ray(self):\\n return self._terminating_ray\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def deriv(self,t,endBehavior='halt'):\\n res = Trajectory.eval_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def end_time(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"end_time\\\")\",\n \"def get_current_ee_pose(self):\\n #self.arm_endpoint = #magic tf call that I can add\\n while True:\\n try:\\n translation, rotation = self.listener.lookupTransform('world_frame', 'palm_frame', rospy.Time()) #j2s7s300_end_effector\\n break # once the transform is obtained move on\\n except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):\\n continue # if it fails try again\\n point = [translation[0], translation[1], translation[2]]\\n self.arm_endpoint = np.array(point)\\n # rospy.logerr(self.arm_endpoint)\",\n \"def o(r, t):\\n return r/t**0.5\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def end_time(self):\\n return self._end_time\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def roty(self, t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s],\\n [0, 1, 0],\\n [-s, 0, c]])\",\n \"def getEnd(self) -> long:\\n ...\",\n \"def trapezoid(t, params):\\n risefall = tf.cast(params['risefall'].get_value(), dtype=tf.float64)\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n\\n envelope = tf.ones_like(t, dtype=tf.float64)\\n envelope = tf.where(tf.less_equal(t, risefall * 2.5), t / (risefall * 2.5), envelope)\\n envelope = tf.where(tf.greater_equal(t, t_final - risefall * 2.5), (t_final - t) / (risefall * 2.5), envelope)\\n return envelope\",\n \"def _get_end(self):\\n return self._end\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def ricker(dt, pt):\\n nt = int(2 * pt / dt)\\n c = np.zeros(nt)\\n t0 = pt / dt\\n a_ricker = 4 / pt\\n\\n for it in range(0, nt):\\n t = ((it + 1) - t0) * dt\\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\\n\\n return c\",\n \"def end_time(self):\\n return self.time_parser.end_time\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def horde_end(self):\",\n \"def roty(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])\",\n \"def out(self, t: any, dim=(None, None)) -> any:\\n lB = self.interval[0] # Lower Boundary\\n uB = self.interval[1] # Upper Boundary\\n # Initialize random step vector each sampling period using comprehensive list.\\n step_vector = [round(uniform(lB, uB), 1) for _ in range(self.n_step)]\\n step_vector[0] = self.ss # keep the steady state value as first\\n u = np.zeros(shape=dim) # Initialize step control input array u.\\n j = 0\\n\\n ramp_Step = self.saw_time\\n count = 1\\n for i in range(len(t)): # Excluding the last point\\n if t[i] % self.step_time == 0 and t[i] != 0 and j+1 != len(step_vector) and i != len(t)-1: # No last step\\n j += 1\\n count = 1\\n\\n if self.ss is not None and j == 0:\\n u[i, :] = self.ss\\n else:\\n if count != ramp_Step:\\n\\n u[i, :] = (step_vector[j] - step_vector[j-1]) * (count / ramp_Step) + step_vector[j-1]\\n count += 1\\n else:\\n u[i, :] = step_vector[j]\\n return u\",\n \"def deriv_screw(self, t: float, endBehavior: str = 'halt') -> Vector:\\n dT = self.deriv(t,endBehavior)\\n return so3.deskew(dT[0])+dT[1]\",\n \"def getETA():\",\n \"def getETA():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6262754","0.60054207","0.59560645","0.5919242","0.59007686","0.58521706","0.5844045","0.580404","0.5791151","0.5790337","0.5788008","0.57607013","0.57595277","0.57300097","0.57146317","0.5713964","0.56925106","0.56845766","0.56776744","0.56025434","0.5577776","0.5577258","0.5561718","0.5554804","0.5550632","0.55414397","0.5509652","0.5486134","0.54807806","0.5450397","0.5448296","0.5435491","0.5428117","0.5421442","0.5420882","0.5407447","0.53956217","0.5393599","0.53911644","0.5388739","0.53826755","0.538183","0.53771454","0.5370922","0.5366723","0.53657544","0.53590137","0.5338765","0.53361785","0.5324579","0.5317156","0.5305034","0.5301146","0.52967286","0.529175","0.5290008","0.52892494","0.5269293","0.5254921","0.5254921","0.524881","0.5248734","0.52469486","0.52455217","0.5238649","0.5232238","0.5228608","0.5228394","0.52274954","0.52269995","0.52246207","0.52191484","0.5211364","0.5211364","0.52056676","0.5203241","0.52024585","0.5195268","0.5193534","0.51899034","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5185348","0.5184724","0.5183763","0.51775163","0.5172201","0.51709485","0.5164134","0.5155358","0.51551783","0.5154484","0.5141973","0.5139901","0.5139446","0.51381594","0.51364684","0.51364684"],"string":"[\n \"0.6262754\",\n \"0.60054207\",\n \"0.59560645\",\n \"0.5919242\",\n \"0.59007686\",\n \"0.58521706\",\n \"0.5844045\",\n \"0.580404\",\n \"0.5791151\",\n \"0.5790337\",\n \"0.5788008\",\n \"0.57607013\",\n \"0.57595277\",\n \"0.57300097\",\n \"0.57146317\",\n \"0.5713964\",\n \"0.56925106\",\n \"0.56845766\",\n \"0.56776744\",\n \"0.56025434\",\n \"0.5577776\",\n \"0.5577258\",\n \"0.5561718\",\n \"0.5554804\",\n \"0.5550632\",\n \"0.55414397\",\n \"0.5509652\",\n \"0.5486134\",\n \"0.54807806\",\n \"0.5450397\",\n \"0.5448296\",\n \"0.5435491\",\n \"0.5428117\",\n \"0.5421442\",\n \"0.5420882\",\n \"0.5407447\",\n \"0.53956217\",\n \"0.5393599\",\n \"0.53911644\",\n \"0.5388739\",\n \"0.53826755\",\n \"0.538183\",\n \"0.53771454\",\n \"0.5370922\",\n \"0.5366723\",\n \"0.53657544\",\n \"0.53590137\",\n \"0.5338765\",\n \"0.53361785\",\n \"0.5324579\",\n \"0.5317156\",\n \"0.5305034\",\n \"0.5301146\",\n \"0.52967286\",\n \"0.529175\",\n \"0.5290008\",\n \"0.52892494\",\n \"0.5269293\",\n \"0.5254921\",\n \"0.5254921\",\n \"0.524881\",\n \"0.5248734\",\n \"0.52469486\",\n \"0.52455217\",\n \"0.5238649\",\n \"0.5232238\",\n \"0.5228608\",\n \"0.5228394\",\n \"0.52274954\",\n \"0.52269995\",\n \"0.52246207\",\n \"0.52191484\",\n \"0.5211364\",\n \"0.5211364\",\n \"0.52056676\",\n \"0.5203241\",\n \"0.52024585\",\n \"0.5195268\",\n \"0.5193534\",\n \"0.51899034\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5185348\",\n \"0.5184724\",\n \"0.5183763\",\n \"0.51775163\",\n \"0.5172201\",\n \"0.51709485\",\n \"0.5164134\",\n \"0.5155358\",\n \"0.51551783\",\n \"0.5154484\",\n \"0.5141973\",\n \"0.5139901\",\n \"0.5139446\",\n \"0.51381594\",\n \"0.51364684\",\n \"0.51364684\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20295,"cells":{"query":{"kind":"string","value":"Returns the arm's desired velocity in workspace coordinates at time t"},"document":{"kind":"string","value":"def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)","def robot_arm_vel(self):\n return self.sim.data.qvel[self.arm_index]","def velocity(self,l=None, t=None, squeeze=True):\n # convert the l or t input to a t input:\n if t is None and l is None:\n raise IOError('you must input l or t.')\n if t is None:\n l = np.array(l)\n if len(l.shape) == 0:\n l = np.array([l])\n t = self.time(l=l, squeeze=squeeze)\n else:\n t = np.array(t)\n if len(t.shape) == 0:\n t = np.array([t])\n \n #formatting to make sure I can perform the array operations\n g = np.expand_dims(\n np.expand_dims(self.params.GRAVITY,0),0)\n t = np.expand_dims(t - self.t,2)\n x = np.expand_dims(self.x,0)\n v = np.expand_dims(self.v,0)\n \n vel = v + g * t\n \n if squeeze:\n vel = np.squeeze(vel, axis=0)\n return vel","def get_angular_velocity(r, T):\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\n # velocity = 2(pi)r/T\n return (2*math.pi*r)/T","def getVelocity(self):\n return self.v","def obtain_vel_timestep(self, tstep):\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"FlowSolution_%04d\" % tstep][\"VelocityZ\"][\" data\"][:, :, :])]), 0, 1)","def get_velocity(self):\n return self.momentum/self.mass","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def target_velocity(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_velocity(path_time)","def velocity_trajectory(self):\n return self._read(MX_VELOCITY_TRAJECTORY)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)","def _compute_solar_torque(self):\n pass","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def orbitalVelocity( self ): # returns [m/s]\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\n return velocity","def target_velocity(self, time):\n pass","def target_velocity(self, time):\n pass","def target_velocity(self, s):\n # YOUR CODE HERE\n if s > self.total_length:\n s = self.total_length\n angular = np.array([0, 0 ,0])\n else:\n angular = np.array([0,0,self.targ_angular])\n\n theta = s/self.total_length*self.angle\n v_x = np.cos(theta)*self.targ_speed\n if self.left_turn:\n v_y = np.sin(theta)*self.targ_speed\n else:\n v_y = -np.sin(theta)*self.targ_speed\n \n linear = np.array([v_x, v_y, 0])\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\n \n toRet = [linear, angular]\n \n return toRet","def get_velocity(self):\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s","def test_velocity(self):\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\n # r must contain 2 elements, otherwise the density and pressure are nan\n r = np.array([0.7, 0.8])\n t = 6.25e-6\n solrt = sol(r, t)\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)","def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\n\n bal = sphere_balloon.Sphere_Balloon()\n rad = radiation.Radiation()\n\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n\n rho_int = p_atm/(self.Rsp_air*T_i)\n tm_air = rho_int*self.vol*self.Cp_air0\n\n #Numerically integrate change in Surface Temperature\n coord[\"alt\"] = el\n q_rad = rad.get_rad_total(t,coord)\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\n q_int = bal.get_sum_q_int(T_s, T_i, el)\n dT_sdt = (q_surf-q_int)/self.k\n\n #Numerically integrate change in Surface Temperature\n tm_air = rho_atm*self.vol*self.Cp_air0\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\n\n #Add the new surface and internal Temperatures\n T_s_new = T_s+dT_sdt*self.dt\n T_i_new = T_i+dT_idt*self.dt\n\n #solve for accellration, position, and velocity\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\n zdot = v + dzdotdt*self.dt\n z = el+zdot*self.dt\n\n #Add the new velocity and position\n if z < self.min_alt:\n v_new = 0\n el_new = self.min_alt\n else:\n v_new = zdot\n el_new = z\n\n # Venting commands for an altitude setpoint. Vent is either on or off.\n if el_new > alt_sp:\n self.mdot = self.vent\n\n if el_new < alt_sp:\n self.mdot = 0\n\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]","def velocity(self) -> np.ndarray:\n return self._state[3:5]","def get_vsolar(self):\n return self.read_register(4098, 1, 3)","def velocity(self):\n return self.base_platform.velocity","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def get_start_velocity(self):\n # uniform circular motion have a start velocity of omega\n # TODO generate from start position and rotation direction\n return np.array([0, self.wz, 0])","def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\n\t\t\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\n\t\t\tself.velocity = (xdist,ydist,time.total_seconds())\n\t\treturn self.velocity\n\t\t\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())","def velocity(self):\n return self._velocity","def velocity(self):\n return self._velocity","def getVelocity(self):\n\n return self.vel","def target_velocity(self, time):\n\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\n\n return avg_vel","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def target_velocity(self, s):\n if s > self.total_length:\n linear = np.array([0,0,0])\n else:\n linear = np.array([self.sign*self.targ_speed, 0, 0])\n \n angular = np.array([0,0,0])\n toRet = [linear, angular]\n\n return toRet","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\n\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\n pyswice.furnsh_c(bskPath + ephemerisPath)\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\n position = positionVelocity[0:3] * 1000\n velocity = positionVelocity[3:6] * 1000\n pyswice.unload_c(bskPath + ephemerisPath)\n\n return position, velocity # [m], [m/s]","def VerletHope2(r, v, beta,dt,R_dust,M_dust):\n # Deceptively simple (read about Velocity Verlet on wikipedia)\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\n \n return (r_new, v_new)","def motor_velocities(self):\n return np.asarray(self._robot_state.velocity)","def relative_velocity(self):\n return self.base_platform.relative_velocity","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def driftRHS(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.linalg.norm(f)\n f = f/fs\n return -f*drift_velocity(fs)","def verlet(self,t,dt,r0,r1):\r\n r2 = np.zeros([2,self.particles.size])\r\n\r\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\r\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\r\n dx = MXT - MX\r\n dx = dx\r\n\r\n dy = MYT - MY\r\n dy = dy\r\n\r\n r2 = np.square(dx)+np.square(dy)\r\n\r\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\r\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\r\n\r\n r2 = (2*r1 - r0 + np.transpose(fv(r1[0,:],r1[1,:],dx,dy,r2,t/self.dt,True,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2)) * (dt**2))\r\n #The transpose is necessary because I messed up the shapes when I did the fv function.\r\n\r\n #JV: this needs to change if we want to include particles with mass diferent than 1 (in reduced units),\r\n # in other words, diferent particles than the Argon gas\r\n\r\n return r2[0,:],r2[1,:]","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def velocity(self,level='cell'):\r\n\r\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\r\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \r\n vels = []\r\n vols = self.last_sim_step_volume()\r\n \r\n if level=='cell':\r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n return vels\r\n \r\n elif level=='section': \r\n # 先计算每一个元胞的再按照volume计算加权平均\r\n \r\n # 计算第一个元胞\r\n vol = vols[0]\r\n outflow = self.flows[0]\r\n if vol == 0 :\r\n vels.append(0)\r\n else :\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n \r\n # 计算中间元胞\r\n for i in range(1,self.cells_number-1):\r\n vol = vols[i]\r\n outflow = self.flows[i]\r\n if vol == 0 :\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2))\r\n\r\n # 计算最后一个元胞\r\n vol = vols[-1]\r\n outflow = self.outflow\r\n if vol==0:\r\n vels.append(0)\r\n else:\r\n vel = outflow*3600/(vol/self.cell_length)\r\n vels.append(round(vel,2)) \r\n\r\n \r\n # 将速度按照volume加权平均\r\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\r\n sum_vol = sum(vols)\r\n if sum_vol == 0:\r\n avg_vel = 0\r\n else:\r\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\r\n \r\n return avg_vel\r\n\r\n\r\n else :\r\n raise ValueError('no such level for collecting data')","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def test_terminalVelocity():\n import nose.tools as nt\n T = 30.; dt = 0.1; g = 9.81; m = 50.;\n Cd = 1.2; rho = 1.0; A = 0.5;\n a = Cd*rho*A/(2.*m)\n v, t = solver(T, dt, -0.1, Cd, rho, A, m)\n nt.assert_almost_equal(v[-1], -sqrt(g/a), delta=1e-4)","def acceleration(v,u,t):\n return ((v-u)/t)","def getVelocity(grid=None, ppar=None):\n\n vel = np.zeros([grid.nx, grid.ny, grid.nz, 3], dtype=np.float64)\n return vel","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def update(self, t, dt):\n # update boundary values\n self._apply_boundary_conditions(t,dt)\n #update current empirical wind velocity\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\n # initialise wind speed derivative arrays\n du_dt = scipy.zeros((self.nx, self.ny))\n dv_dt = scipy.zeros((self.nx, self.ny))\n # approximate spatial first derivatives with centred finite difference\n # equations for both components of wind field\n du_dx, du_dy = self._centred_first_derivs(self._u)\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\n # second derivatives with second order finite difference equations\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\n # = [sf_x-2f(x,y)] / (dx*dx)\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\n # = [sf_y-2f(x,y)] / (dy*dy)\n # second finite differences are not computed in full as the common\n # f(x,y) term in both expressions can be extracted out to reduce\n # the number of +/- operations required\n su_x, su_y = self._centred_first_sums(self._u)\n sv_x, sv_y = self._centred_first_sums(self._v)\n # use finite difference method to approximate time derivatives across\n # simulation region interior from defining PDEs\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\n self._Bx * su_x + self._By * su_y -\n self._C * self._u_int)\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\n self._Bx * sv_x + self._By * sv_y -\n self._C * self._v_int)\n # perform update with Euler integration\n self._u_int += du_dt * dt\n self._v_int += dv_dt * dt\n # update spline interpolators\n self._set_interpolators()","def compute_vel(self, state, goal):\n\n \"\"\"\n Unicycle model control law:\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\n v = commanded linear velocity of robot\n w = commanded rotational velcoity of robot\n kp = gain parameter where kp > 0\n ka = gain parameter where ka - kp > 0\n kb = gain parameter where kb < 0\n p = distance from robot to goal\n a = angle between current robot heading and heading to goal\n b = error between current heading to goal and target end heading\n \"\"\"\n \n #print('state,goal,v,w')\n #print(state)\n #print(goal)\n\n xr = state[0][0] # m in world frame\n yr = state[1][0] # m in world frame\n thetar = state[2][0] #rads\n\n xg = goal[0] # m in world frame\n yg = goal[1] # m in world frame\n\n dy = yg - yr\n dx = xg - xr\n\n #print('')\n #print(state)\n #print(goal)\n \n # Calculate a\n a = -1*thetar + math.atan2(dy,dx)\n\n #print(a)\n\n if a > math.pi:\n a = a - 2*math.pi\n\n if a < -1*math.pi:\n a = a + 2*math.pi\n\n #print(a)\n\n # Set omega according to control law\n omega = self.ka*a\n if math.fabs(omega) > self.MAX_OMEGA:\n if omega > 0:\n omega = self.MAX_OMEGA\n else:\n omega = -1*self.MAX_OMEGA\n\n # Calculate P\n p = math.sqrt(dy*dy + dx*dx)\n\n # Set v \n v = self.kp*p\n if v > self.MAX_SPEED:\n v = self.MAX_SPEED\n\n # set the done value\n done = (p <= self.done_distance)\n\n #print(v)\n #print(omega)\n\n out_tuple = (v, omega, done)\n \n return out_tuple","def compute_velocity(self, time_since_last_frame: float) -> None:\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\n self.velocity_kts = (true_dist /\n self.secs_since_last_seen) / 1.94384\n self.cart_coords = new_cart_coords","def angular_velocities(self, dt: float) -> np.ndarray:\n if not isinstance(dt, float):\n raise TypeError(f\"dt must be a float. Got {type(dt)}.\")\n if dt <= 0:\n raise ValueError(f\"dt must be greater than zero. Got {dt}.\")\n w = np.c_[\n self.w[:-1]*self.x[1:] - self.x[:-1]*self.w[1:] - self.y[:-1]*self.z[1:] + self.z[:-1]*self.y[1:],\n self.w[:-1]*self.y[1:] + self.x[:-1]*self.z[1:] - self.y[:-1]*self.w[1:] - self.z[:-1]*self.x[1:],\n self.w[:-1]*self.z[1:] - self.x[:-1]*self.y[1:] + self.y[:-1]*self.x[1:] - self.z[:-1]*self.w[1:]]\n return 2.0 * w / dt","def velocity(self,l=None, t=None):\n raise RuntimeError('this is a virtual method that must be overwritten')\n return","def velocity_model(self):\n return self._velocity_model","def v(self):\n\n # TODO This translation formula works, but needs simplified.\n\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\n# print(\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\", MuleBot.dcMotorPWMDurationLeft)\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\n# print(\"speed_percentage: \", speed_percentage)\n\n rpm = speed_percentage * self.motorMaxRPM\n# print(\"rpm: \", rpm)\n\n secondsPerMinute = 60\n revs_per_second = rpm / secondsPerMinute\n# print(\"--revs_per_second\", revs_per_second)\n\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\n INCHES_PER_METER = 39.3701\n meters_per_rev = inches_per_rev / INCHES_PER_METER\n# print(\"--meters_per_rev\", meters_per_rev)\n\n meters_per_second = meters_per_rev * revs_per_second\n\n# print(\"--meters_per_second: \", meters_per_second)\n return meters_per_second","def driftRHS_3D(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\n f = f/fs\n return -f*drift_velocity(fs)","def initial_vel(T,N,masses,dim):\r\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\r\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\r\n rand_v = rand_v - sum_v #Subtract cm-Motion\r\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\r\n T_act = 2/3*K/sc.k/N #Temperature\r\n R_scale = T/T_act #Scaling factor\r\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\r\n return v","def get_desired_vel(self, a):\n a_c = self.heading_vector\n # angle of the robot\n angle_a_c = np.arctan2(a_c[1], a_c[0])\n # angle of the heading\n angle_a = np.arctan2(a[1], a[0])\n\n angle_difference = wrap2pi(angle_a_c - angle_a)\n\n if abs(angle_difference) <= (math.pi / 2):\n # modulate translation and rotation\n u = (np.dot(a, a_c) ** self.gamma)*self.u_max\n else:\n # do not translate only rotate\n u = 0\n # proportional controller for heading\n omega = angle_difference * self.K_p\n return [u, omega]","def velocity_field(xt,yt,x0,y0,velf,dia,tsr,solidity):\n rad = dia/2.\n rot = tsr*velf/rad\n\n # Calculating EMG distribution parameters\n loc,spr,skw,scl = vorticity(tsr,solidity)\n \n # Translating the turbine position\n x0t = x0 - xt\n y0t = y0 - yt\n \n # Integration of the vorticity profile using Fortran code (vorticity.f90; _vortrun.so)\n vel_vs = dblquad(_vortmodel.integrand,0.,35.*dia,lambda x: -4.*dia,lambda x: 4.*dia, args=(x0t,y0t,dia,loc[0],loc[1],loc[2],spr[0],spr[1],skw[0],skw[1],scl[0],scl[1],scl[2]))\n \n # Calculating velocity deficit\n vel = (vel_vs[0]*(rot))/(2.*pi)\n vel = (vel + velf)/velf # normalization of velocity\n \n return vel","def current_velocity():\n global current_velocity\n while current_velocity is None:\n pass\n return current_velocity","def compute_observation(self):\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\n robotEuler = p.getEulerFromQuaternion(robotOrn)\n linear, angular = p.getBaseVelocity(self.botId)\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))","def evol_dt(self, psi, t, dt):\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))","def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\n rad = dia/2.\n tsr = rad*fabs(rot)/Vinf\n solidity = (chord*B)/rad\n\n # Translating the turbine position\n x0t = x0 - xt\n y0t = y0 - yt\n\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\n\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\n if param is None:\n loc1 = _parameterval(tsr,solidity,coef0)\n loc2 = _parameterval(tsr,solidity,coef1)\n loc3 = _parameterval(tsr,solidity,coef2)\n spr1 = _parameterval(tsr,solidity,coef3)\n spr2 = _parameterval(tsr,solidity,coef4)\n skw1 = _parameterval(tsr,solidity,coef5)\n skw2 = _parameterval(tsr,solidity,coef6)\n scl1 = _parameterval(tsr,solidity,coef7)\n scl2 = _parameterval(tsr,solidity,coef8)\n scl3 = _parameterval(tsr,solidity,coef9)\n\n else:\n # Reading in EMG distribution parameters\n loc1 = param[0]\n loc2 = param[1]\n loc3 = param[2]\n spr1 = param[3]\n spr2 = param[4]\n skw1 = param[5]\n skw2 = param[6]\n scl1 = param[7]\n scl2 = param[8]\n scl3 = param[9]\n\n ###################################\n if veltype == 'vort':\n # VORTICITY CALCULATION (NO INTEGRATION)\n if x0t < 0.:\n vel = 0.\n else:\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\n ###################################\n else:\n # Integration of the vorticity profile to calculate velocity\n if integration == 'simp':\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\n inte = 1 # Simpson's Rule\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\n\n if param is not None:\n print \"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\"\n\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\n\n if veltype == 'all':\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs*Vinf + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])\n ###################################\n elif integration == 'gskr':\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\n xbound = (scl3+5.)*dia\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\n\n if veltype == 'all':\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys/Vinf\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])/Vinf\n ###################################\n\n return vel","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def robot_arm_pos(self):\n return self.sim.data.qpos[self.arm_index]","def mTV(self):\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\n # approximated with the wing root chordplane\n return distance / (self.spanW / 2)","def LeapFrog(self,r,v,dt):\n\n rhalf = r + np.asarray(v)*(dt/2) #Taking a half step forward with positional vector\n # predict the final velocity at the next timestep using the acceleration field at the rhalf position \n vnew = v + self.M31Accel(rhalf)*dt\n # predict the final position using the average of the current velocity and the final velocity\n rnew = r + 0.5*(v+vnew)*dt\n \n return rnew,vnew","def get_cmd_velocity(self):\n return self.gripper_io.get_signal_value(\"speed_mps\")","def evaluate(self, *args, **kwargs):\n return self.constant_velocity","def _position_and_velocity(self, jd):\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\n self.elevation.au, jd.gast)\n pos = einsum('ij...,j...->i...', jd.MT, pos)\n vel = einsum('ij...,j...->i...', jd.MT, vel)\n return pos, vel","def setRobotVelocity(self,vel):\n linear = vel[0]\n angular = vel[1]\n if not (self.orientation):\n # Kinematic model for differential robot.\n print(\"or 0\")\n\n wl = (linear - (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\n wr = (linear + (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\n\n # At input 1000, angular velocity is 1 cycle / s or 2*pi/s.\n velLeft = int(wl * BETA/(2*math.pi))\n velRight = int(wr * BETA/(2*math.pi))\n print(\"left: \" + str(velLeft))\n print(\"right: \" + str(velRight))\n self.setMotorSpeed(velRight,velLeft)\n else:\n print(\"or 1\")\n # Kinematic model for differential robot.\n wl = (linear - (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\n wr = (linear + (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\n\n # At input 1000, angular velocity is 1 cycle / s or 2*pi/s.\n velLeft = int(wl * BETA/(2*math.pi))\n velRight = int(wr * BETA/(2*math.pi))\n print(\"left: \" + str(velLeft))\n print(\"right: \" + str(velRight))\n self.setMotorSpeed(velRight, velLeft)","def vel(self,M):\n v = np.sqrt((M*Body.G)/self.r)\n \n return v","def base_velocity(self):\n raise NotImplementedError('Not yet implemented!')","def execute(self, state, dt):\n \n # The goal:\n theta_g = state.goal*math.pi/180\n \n # The robot:\n \n x_r, y_r, theta = state.pose\n # print(\"current Robot pose: ({}, {}, {})\".format(x_r, y_r, theta), file=sys.stderr)\n \n # 1. Calculate simple proportional error\n error = (theta_g - theta + math.pi)%(2*math.pi) - math.pi\n # print(\"current err: ({})\".format(error), file=sys.stderr)\n \n # 2. Calculate desired omega\n w_ = self.kp*error\n \n # 3. The linear velocity is given to us:\n v_ = state.velocity\n # print(\"current v, w: ({}, {})\".format(v_, w_), file=sys.stderr)\n \n\n return [v_, w_]","def get_velocity_vortex(strength, xv, yv, X, Y):\r\n u = +strength / (2 * math.pi) * (Y - yv) / ((X - xv)**2 + (Y - yv)**2)\r\n v = -strength / (2 * math.pi) * (X - xv) / ((X - xv)**2 + (Y - yv)**2)\r\n \r\n return u, v","def rhs(states, t, parameters, values=None):\n # Imports\n import numpy as np\n import math\n\n # Assign states\n assert(len(states) == 6)\n vlv, vrv, v1s, v2s, v1p, v2p = states\n\n # Assign parameters\n assert(len(parameters) == 38)\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\n twitchperiod=parameters[37]\n\n # Init return args\n if values is None:\n values = np.zeros((6,), dtype=np.float_)\n else:\n assert isinstance(values, np.ndarray) and values.shape == (6,)\n\n # Expressions for the Time varying elastance component\n t_lv = math.fmod(t, bcl)\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\n twitchperiod else 0)\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\n plv = p_epi + (-restVlv + vlv)*Elv\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\n prv = p_epi + (-restVrv + vrv)*Erv\n\n # Expressions for the Pressures and flows component\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\n rest_v1s/c1s)\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\n rest_v2s/c2s)\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\n rest_v1p/c1p)\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\n rest_v2p/c2p)\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\n q1_s = (-p2s + p1s)/R1_s\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\n q1_p = (-p2p + p1p)/R1_p\n\n # Expressions for the Ventricular volumes component\n values[0] = -qart_s + q_mit\n values[1] = -qart_p + q_tric\n\n # Expressions for the Systemic volumes component\n values[2] = -q1_s + qart_s\n values[3] = -q_tric + q1_s\n\n # Expressions for the Pulmonary volumes component\n values[4] = -q1_p + qart_p\n values[5] = -q_mit + q1_p\n\n # Return results\n return values","def verlet_next_vel(vel_t,accel_t,accel_t_plus_dt,dt):\n vel_t_plus_dt = vel_t.copy()\n vel_t_plus_dt += 0.5 * (accel_t + accel_t_plus_dt) * dt\n return vel_t_plus_dt","def target_velocity(self, s):\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\n # self.transition += self.subpaths[self.current_path].total_length()\n # self.current_path += 1\n\n if s > self.total_length:\n s = self.total_length\n\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\n linear = np.dot(self.g, linear)\n\n return [linear, angular]","def get_velocity(self, index: int, array: List[float]) -> float:\n velocity_sum = 0.0\n number_iterations = min(self.past_n_steps, index - 1)\n for i in range(number_iterations):\n velocity_sum += (array[index - 1 - i] - array[index - 2 - i])\n\n return velocity_sum / (self.time_step * number_iterations)","def lunar_phase(cls, tee):\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)","def f_2(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n # velocity equation for the ball after the bounce\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def present_velocity(self):\n return self._read(MX_PRESENT_VELOCITY)","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def tke(self):\n if len(self._obj.t) < 2:\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\n\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'({vel_units})^2')\n return self._obj","def velocity(self):\n return self._vel.to_list()","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def verlet_next_pos(pos_t,vel_t,accel_t,dt):\n pos_t_plus_dt = pos_t.copy()\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \n\n return pos_t_plus_dt","def __init__(self, mass, radius, position, velocity):\n self.mass = mass\n self.radius = radius\n self.position = position\n self.velocity = velocity\n print(self.velocity)\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\n self.delete = False","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def test_vertical_velocity_dry_air():\n omega = 1 * units('microbar/second')\n w_truth = -0.7995291 * units('cm/s')\n w_test = vertical_velocity(omega, 1000. * units.mbar, 273.15 * units.K)\n assert_almost_equal(w_test, w_truth, 6)","def initial_velocity(self) -> float:\n return self._initial_velocity","def get(cls, approach):\n return approach.velocity","def test_velocity_vs_current(self):\n t, x_n, x_p = self.t, self.x_n, self.x_p\n\n beta_n = self.model.param.beta_n\n beta_n = self.param.evaluate(beta_n)\n beta_p = self.model.param.beta_p\n beta_p = self.param.evaluate(beta_p)\n\n np.testing.assert_array_almost_equal(\n self.v_box(t, x_n), beta_n * self.i_e(t, x_n)\n )\n np.testing.assert_array_almost_equal(\n self.v_box(t, x_p), beta_p * self.i_e(t, x_p)\n )","def target_velocity(self, s):\n raise NotImplementedError()","def runge_integrator(self, t, y, dt, tau):\n\n k1 = self.plant.rhs(t, y, tau)\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\n return (k1 + 2 * (k2 + k3) + k4) / 6.0","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))"],"string":"[\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def vel(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a1 + 2.0 * self.a2 * t + 3.0 * self.a3 * pow(t, 2) + 4.0 * self.a4 * pow(t, 3) + 5.0 * self.a5 * pow(t, 4)\",\n \"def robot_arm_vel(self):\\n return self.sim.data.qvel[self.arm_index]\",\n \"def velocity(self,l=None, t=None, squeeze=True):\\n # convert the l or t input to a t input:\\n if t is None and l is None:\\n raise IOError('you must input l or t.')\\n if t is None:\\n l = np.array(l)\\n if len(l.shape) == 0:\\n l = np.array([l])\\n t = self.time(l=l, squeeze=squeeze)\\n else:\\n t = np.array(t)\\n if len(t.shape) == 0:\\n t = np.array([t])\\n \\n #formatting to make sure I can perform the array operations\\n g = np.expand_dims(\\n np.expand_dims(self.params.GRAVITY,0),0)\\n t = np.expand_dims(t - self.t,2)\\n x = np.expand_dims(self.x,0)\\n v = np.expand_dims(self.v,0)\\n \\n vel = v + g * t\\n \\n if squeeze:\\n vel = np.squeeze(vel, axis=0)\\n return vel\",\n \"def get_angular_velocity(r, T):\\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\\n # velocity = 2(pi)r/T\\n return (2*math.pi*r)/T\",\n \"def getVelocity(self):\\n return self.v\",\n \"def obtain_vel_timestep(self, tstep):\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"FlowSolution_%04d\\\" % tstep][\\\"VelocityZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def get_velocity(self):\\n return self.momentum/self.mass\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def target_velocity(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_velocity(path_time)\",\n \"def velocity_trajectory(self):\\n return self._read(MX_VELOCITY_TRAJECTORY)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def target_velocity(self, time):\\n return self.target(time, self.velocities, self.dt, self.num_way)\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def orbitalVelocity( self ): # returns [m/s]\\n velocity = self.orbitalAngularVelocity * self.r # current orbital velocity [m/s]\\n return velocity\",\n \"def target_velocity(self, time):\\n pass\",\n \"def target_velocity(self, time):\\n pass\",\n \"def target_velocity(self, s):\\n # YOUR CODE HERE\\n if s > self.total_length:\\n s = self.total_length\\n angular = np.array([0, 0 ,0])\\n else:\\n angular = np.array([0,0,self.targ_angular])\\n\\n theta = s/self.total_length*self.angle\\n v_x = np.cos(theta)*self.targ_speed\\n if self.left_turn:\\n v_y = np.sin(theta)*self.targ_speed\\n else:\\n v_y = -np.sin(theta)*self.targ_speed\\n \\n linear = np.array([v_x, v_y, 0])\\n # linear = np.append(np.dot(self.g, np.array([v_x, v_y, 0]))[:2], [0])\\n \\n toRet = [linear, angular]\\n \\n return toRet\",\n \"def get_velocity(self):\\n return (self._I85_msg_from_device(self.node.sdo[0x606c].phys)) / 10 # rad/s\",\n \"def test_velocity(self):\\n sol = Mader(p_cj=3.0e11, d_cj=8.0e5, gamma=3.0, u_piston=0.0)\\n # r must contain 2 elements, otherwise the density and pressure are nan\\n r = np.array([0.7, 0.8])\\n t = 6.25e-6\\n solrt = sol(r, t)\\n np.testing.assert_allclose(solrt.velocity[0], 144000.0)\",\n \"def solveVerticalTrajectory(self,t,T_s,T_i,el,v,coord,alt_sp,v_sp):\\n\\n bal = sphere_balloon.Sphere_Balloon()\\n rad = radiation.Radiation()\\n\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n\\n rho_int = p_atm/(self.Rsp_air*T_i)\\n tm_air = rho_int*self.vol*self.Cp_air0\\n\\n #Numerically integrate change in Surface Temperature\\n coord[\\\"alt\\\"] = el\\n q_rad = rad.get_rad_total(t,coord)\\n q_surf = bal.get_sum_q_surf(q_rad, T_s, el, v)\\n q_int = bal.get_sum_q_int(T_s, T_i, el)\\n dT_sdt = (q_surf-q_int)/self.k\\n\\n #Numerically integrate change in Surface Temperature\\n tm_air = rho_atm*self.vol*self.Cp_air0\\n dT_idt = (q_int-self.get_convection_vent(T_i,el))/tm_air\\n\\n #Add the new surface and internal Temperatures\\n T_s_new = T_s+dT_sdt*self.dt\\n T_i_new = T_i+dT_idt*self.dt\\n\\n #solve for accellration, position, and velocity\\n dzdotdt = self.get_acceleration(v,el,T_s,T_i)\\n zdot = v + dzdotdt*self.dt\\n z = el+zdot*self.dt\\n\\n #Add the new velocity and position\\n if z < self.min_alt:\\n v_new = 0\\n el_new = self.min_alt\\n else:\\n v_new = zdot\\n el_new = z\\n\\n # Venting commands for an altitude setpoint. Vent is either on or off.\\n if el_new > alt_sp:\\n self.mdot = self.vent\\n\\n if el_new < alt_sp:\\n self.mdot = 0\\n\\n return [T_s_new,T_i_new,T_atm,el_new,v_new, q_rad, q_surf, q_int]\",\n \"def velocity(self) -> np.ndarray:\\n return self._state[3:5]\",\n \"def get_vsolar(self):\\n return self.read_register(4098, 1, 3)\",\n \"def velocity(self):\\n return self.base_platform.velocity\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def get_start_velocity(self):\\n # uniform circular motion have a start velocity of omega\\n # TODO generate from start position and rotation direction\\n return np.array([0, self.wz, 0])\",\n \"def getVelocity(self):\\n\\t\\tif len(self.prevPositions) < 2:\\n\\t\\t\\tself.velocity = 0\\n\\t\\telse:\\n\\t\\t\\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\\n\\t\\t\\txdist = self.position[0][0] - self.prevPositions[len(self.prevPositions)-1][0][0]\\n\\t\\t\\tydist = self.position[0][1] - self.prevPositions[len(self.prevPositions)-1][0][1]\\n\\t\\t\\tself.velocity = (xdist,ydist,time.total_seconds())\\n\\t\\treturn self.velocity\\n\\t\\t\\t#speed = math.pow(math.pow(1.0*xdist,2) + math.pow(1.0*ydist,2),0.5) / (1.0*time.total_seconds())\",\n \"def velocity(self):\\n return self._velocity\",\n \"def velocity(self):\\n return self._velocity\",\n \"def getVelocity(self):\\n\\n return self.vel\",\n \"def target_velocity(self, time):\\n\\n avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time\\n\\n return avg_vel\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def target_velocity(self, s):\\n if s > self.total_length:\\n linear = np.array([0,0,0])\\n else:\\n linear = np.array([self.sign*self.targ_speed, 0, 0])\\n \\n angular = np.array([0,0,0])\\n toRet = [linear, angular]\\n\\n return toRet\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def planetPositionVelocity(planetName, time, ephemerisPath = '/supportData/EphemerisData/pck00010.tpc', observer = 'SSB', frame = 'J2000'):\\n\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/de430.bsp')\\n pyswice.furnsh_c(bskPath + '/supportData/EphemerisData/naif0012.tls') #load leap seconds\\n pyswice.furnsh_c(bskPath + ephemerisPath)\\n positionVelocity = pyswice.spkRead(planetName, time, frame, observer)\\n position = positionVelocity[0:3] * 1000\\n velocity = positionVelocity[3:6] * 1000\\n pyswice.unload_c(bskPath + ephemerisPath)\\n\\n return position, velocity # [m], [m/s]\",\n \"def VerletHope2(r, v, beta,dt,R_dust,M_dust):\\n # Deceptively simple (read about Velocity Verlet on wikipedia)\\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\\n \\n return (r_new, v_new)\",\n \"def motor_velocities(self):\\n return np.asarray(self._robot_state.velocity)\",\n \"def relative_velocity(self):\\n return self.base_platform.relative_velocity\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def driftRHS(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.linalg.norm(f)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def verlet(self,t,dt,r0,r1):\\r\\n r2 = np.zeros([2,self.particles.size])\\r\\n\\r\\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\\r\\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\\r\\n dx = MXT - MX\\r\\n dx = dx\\r\\n\\r\\n dy = MYT - MY\\r\\n dy = dy\\r\\n\\r\\n r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\\r\\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\\r\\n\\r\\n r2 = (2*r1 - r0 + np.transpose(fv(r1[0,:],r1[1,:],dx,dy,r2,t/self.dt,True,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2)) * (dt**2))\\r\\n #The transpose is necessary because I messed up the shapes when I did the fv function.\\r\\n\\r\\n #JV: this needs to change if we want to include particles with mass diferent than 1 (in reduced units),\\r\\n # in other words, diferent particles than the Argon gas\\r\\n\\r\\n return r2[0,:],r2[1,:]\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def velocity(self,level='cell'):\\r\\n\\r\\n # 每个section中总是储存t+1时刻的volume，t到t+1的flow，即一个仿真步长（step）过程中的流量和仿真步长结束时的元胞中车辆数\\r\\n # 但计算速度需要用到仿真步长开始时的元胞密度，因此要对应时刻的元胞中车辆数vol_t = Vol_t+1 + outflow_t - inflow_t \\r\\n vels = []\\r\\n vols = self.last_sim_step_volume()\\r\\n \\r\\n if level=='cell':\\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n return vels\\r\\n \\r\\n elif level=='section': \\r\\n # 先计算每一个元胞的再按照volume计算加权平均\\r\\n \\r\\n # 计算第一个元胞\\r\\n vol = vols[0]\\r\\n outflow = self.flows[0]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else :\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n \\r\\n # 计算中间元胞\\r\\n for i in range(1,self.cells_number-1):\\r\\n vol = vols[i]\\r\\n outflow = self.flows[i]\\r\\n if vol == 0 :\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2))\\r\\n\\r\\n # 计算最后一个元胞\\r\\n vol = vols[-1]\\r\\n outflow = self.outflow\\r\\n if vol==0:\\r\\n vels.append(0)\\r\\n else:\\r\\n vel = outflow*3600/(vol/self.cell_length)\\r\\n vels.append(round(vel,2)) \\r\\n\\r\\n \\r\\n # 将速度按照volume加权平均\\r\\n weighted_vels = [vel*vol for vel, vol in zip(vels,vols)]\\r\\n sum_vol = sum(vols)\\r\\n if sum_vol == 0:\\r\\n avg_vel = 0\\r\\n else:\\r\\n avg_vel = round(sum(weighted_vels)/sum_vol,2)\\r\\n \\r\\n return avg_vel\\r\\n\\r\\n\\r\\n else :\\r\\n raise ValueError('no such level for collecting data')\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def test_terminalVelocity():\\n import nose.tools as nt\\n T = 30.; dt = 0.1; g = 9.81; m = 50.;\\n Cd = 1.2; rho = 1.0; A = 0.5;\\n a = Cd*rho*A/(2.*m)\\n v, t = solver(T, dt, -0.1, Cd, rho, A, m)\\n nt.assert_almost_equal(v[-1], -sqrt(g/a), delta=1e-4)\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def getVelocity(grid=None, ppar=None):\\n\\n vel = np.zeros([grid.nx, grid.ny, grid.nz, 3], dtype=np.float64)\\n return vel\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def update(self, t, dt):\\n # update boundary values\\n self._apply_boundary_conditions(t,dt)\\n #update current empirical wind velocity\\n corner_mean_index = int(scipy.floor(t/self.wind_update_period))\\n self._empirical_velocity = self.u_av[corner_mean_index], self.v_av[corner_mean_index]\\n # initialise wind speed derivative arrays\\n du_dt = scipy.zeros((self.nx, self.ny))\\n dv_dt = scipy.zeros((self.nx, self.ny))\\n # approximate spatial first derivatives with centred finite difference\\n # equations for both components of wind field\\n du_dx, du_dy = self._centred_first_derivs(self._u)\\n dv_dx, dv_dy = self._centred_first_derivs(self._v)\\n # calculate centred first sums i.e. sf_x = f(x+dx,y)+f(x-dx,y) and\\n # sf_y = f(x,y+dy)-f(x,y-dy) as first step in approximating spatial\\n # second derivatives with second order finite difference equations\\n # d2f/dx2 ~ [f(x+dx,y)-2f(x,y)+f(x-dx,y)] / (dx*dx)\\n # = [sf_x-2f(x,y)] / (dx*dx)\\n # d2f/dy2 ~ [f(x,y+dy)-2f(x,y)+f(x,y-dy)] / (dy*dy)\\n # = [sf_y-2f(x,y)] / (dy*dy)\\n # second finite differences are not computed in full as the common\\n # f(x,y) term in both expressions can be extracted out to reduce\\n # the number of +/- operations required\\n su_x, su_y = self._centred_first_sums(self._u)\\n sv_x, sv_y = self._centred_first_sums(self._v)\\n # use finite difference method to approximate time derivatives across\\n # simulation region interior from defining PDEs\\n # du/dt = -(u*du/dx + v*du/dy) + 0.5*Kx*d2u/dx2 + 0.5*Ky*d2u/dy2\\n # dv/dt = -(u*dv/dx + v*dv/dy) + 0.5*Kx*d2v/dx2 + 0.5*Ky*d2v/dy2\\n du_dt = (-self._u_int * du_dx - self._v_int * du_dy +\\n self._Bx * su_x + self._By * su_y -\\n self._C * self._u_int)\\n dv_dt = (-self._u_int * dv_dx - self._v_int * dv_dy +\\n self._Bx * sv_x + self._By * sv_y -\\n self._C * self._v_int)\\n # perform update with Euler integration\\n self._u_int += du_dt * dt\\n self._v_int += dv_dt * dt\\n # update spline interpolators\\n self._set_interpolators()\",\n \"def compute_vel(self, state, goal):\\n\\n \\\"\\\"\\\"\\n Unicycle model control law:\\n [v;w] = [kp 0 0; 0 ka kb]*[p;a;b]\\n v = commanded linear velocity of robot\\n w = commanded rotational velcoity of robot\\n kp = gain parameter where kp > 0\\n ka = gain parameter where ka - kp > 0\\n kb = gain parameter where kb < 0\\n p = distance from robot to goal\\n a = angle between current robot heading and heading to goal\\n b = error between current heading to goal and target end heading\\n \\\"\\\"\\\"\\n \\n #print('state,goal,v,w')\\n #print(state)\\n #print(goal)\\n\\n xr = state[0][0] # m in world frame\\n yr = state[1][0] # m in world frame\\n thetar = state[2][0] #rads\\n\\n xg = goal[0] # m in world frame\\n yg = goal[1] # m in world frame\\n\\n dy = yg - yr\\n dx = xg - xr\\n\\n #print('')\\n #print(state)\\n #print(goal)\\n \\n # Calculate a\\n a = -1*thetar + math.atan2(dy,dx)\\n\\n #print(a)\\n\\n if a > math.pi:\\n a = a - 2*math.pi\\n\\n if a < -1*math.pi:\\n a = a + 2*math.pi\\n\\n #print(a)\\n\\n # Set omega according to control law\\n omega = self.ka*a\\n if math.fabs(omega) > self.MAX_OMEGA:\\n if omega > 0:\\n omega = self.MAX_OMEGA\\n else:\\n omega = -1*self.MAX_OMEGA\\n\\n # Calculate P\\n p = math.sqrt(dy*dy + dx*dx)\\n\\n # Set v \\n v = self.kp*p\\n if v > self.MAX_SPEED:\\n v = self.MAX_SPEED\\n\\n # set the done value\\n done = (p <= self.done_distance)\\n\\n #print(v)\\n #print(omega)\\n\\n out_tuple = (v, omega, done)\\n \\n return out_tuple\",\n \"def compute_velocity(self, time_since_last_frame: float) -> None:\\n new_cart_coords = get_cartesian_coord(self.lat, self.lon, self.alt)\\n # new_cart_coords = tuple((self.v_coord, self.u_coord, self.alt))\\n if self.cart_coords is not None and self.secs_since_last_seen and self.secs_since_last_seen > 0:\\n true_dist = compute_dist(new_cart_coords, self.cart_coords)\\n self.velocity_kts = (true_dist /\\n self.secs_since_last_seen) / 1.94384\\n self.cart_coords = new_cart_coords\",\n \"def angular_velocities(self, dt: float) -> np.ndarray:\\n if not isinstance(dt, float):\\n raise TypeError(f\\\"dt must be a float. Got {type(dt)}.\\\")\\n if dt <= 0:\\n raise ValueError(f\\\"dt must be greater than zero. Got {dt}.\\\")\\n w = np.c_[\\n self.w[:-1]*self.x[1:] - self.x[:-1]*self.w[1:] - self.y[:-1]*self.z[1:] + self.z[:-1]*self.y[1:],\\n self.w[:-1]*self.y[1:] + self.x[:-1]*self.z[1:] - self.y[:-1]*self.w[1:] - self.z[:-1]*self.x[1:],\\n self.w[:-1]*self.z[1:] - self.x[:-1]*self.y[1:] + self.y[:-1]*self.x[1:] - self.z[:-1]*self.w[1:]]\\n return 2.0 * w / dt\",\n \"def velocity(self,l=None, t=None):\\n raise RuntimeError('this is a virtual method that must be overwritten')\\n return\",\n \"def velocity_model(self):\\n return self._velocity_model\",\n \"def v(self):\\n\\n # TODO This translation formula works, but needs simplified.\\n\\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\\n# print(\\\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\\\", MuleBot.dcMotorPWMDurationLeft)\\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\\n# print(\\\"speed_percentage: \\\", speed_percentage)\\n\\n rpm = speed_percentage * self.motorMaxRPM\\n# print(\\\"rpm: \\\", rpm)\\n\\n secondsPerMinute = 60\\n revs_per_second = rpm / secondsPerMinute\\n# print(\\\"--revs_per_second\\\", revs_per_second)\\n\\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\\n INCHES_PER_METER = 39.3701\\n meters_per_rev = inches_per_rev / INCHES_PER_METER\\n# print(\\\"--meters_per_rev\\\", meters_per_rev)\\n\\n meters_per_second = meters_per_rev * revs_per_second\\n\\n# print(\\\"--meters_per_second: \\\", meters_per_second)\\n return meters_per_second\",\n \"def driftRHS_3D(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.sqrt(f[0]**2 + f[1]**2 + f[2]**2)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def initial_vel(T,N,masses,dim):\\r\\n rand_v = np.random.uniform(-1,1,(N,dim)) #random velocities\\r\\n sum_v = np.sum(rand_v, axis = 0)/N #Total velocity\\r\\n rand_v = rand_v - sum_v #Subtract cm-Motion\\r\\n K = np.sum(np.sum(rand_v**2,axis = 1)*masses)/2 #Kinetic energy\\r\\n T_act = 2/3*K/sc.k/N #Temperature\\r\\n R_scale = T/T_act #Scaling factor\\r\\n v = np.transpose(rand_v*np.sqrt(R_scale)) #rescalte to reach T\\r\\n return v\",\n \"def get_desired_vel(self, a):\\n a_c = self.heading_vector\\n # angle of the robot\\n angle_a_c = np.arctan2(a_c[1], a_c[0])\\n # angle of the heading\\n angle_a = np.arctan2(a[1], a[0])\\n\\n angle_difference = wrap2pi(angle_a_c - angle_a)\\n\\n if abs(angle_difference) <= (math.pi / 2):\\n # modulate translation and rotation\\n u = (np.dot(a, a_c) ** self.gamma)*self.u_max\\n else:\\n # do not translate only rotate\\n u = 0\\n # proportional controller for heading\\n omega = angle_difference * self.K_p\\n return [u, omega]\",\n \"def velocity_field(xt,yt,x0,y0,velf,dia,tsr,solidity):\\n rad = dia/2.\\n rot = tsr*velf/rad\\n\\n # Calculating EMG distribution parameters\\n loc,spr,skw,scl = vorticity(tsr,solidity)\\n \\n # Translating the turbine position\\n x0t = x0 - xt\\n y0t = y0 - yt\\n \\n # Integration of the vorticity profile using Fortran code (vorticity.f90; _vortrun.so)\\n vel_vs = dblquad(_vortmodel.integrand,0.,35.*dia,lambda x: -4.*dia,lambda x: 4.*dia, args=(x0t,y0t,dia,loc[0],loc[1],loc[2],spr[0],spr[1],skw[0],skw[1],scl[0],scl[1],scl[2]))\\n \\n # Calculating velocity deficit\\n vel = (vel_vs[0]*(rot))/(2.*pi)\\n vel = (vel + velf)/velf # normalization of velocity\\n \\n return vel\",\n \"def current_velocity():\\n global current_velocity\\n while current_velocity is None:\\n pass\\n return current_velocity\",\n \"def compute_observation(self):\\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\\n robotEuler = p.getEulerFromQuaternion(robotOrn)\\n linear, angular = p.getBaseVelocity(self.botId)\\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))\",\n \"def evol_dt(self, psi, t, dt):\\n V_action = np.exp(- 1.0j * dt * self.get_potential(t))\\n kin_action = np.exp(- 1.0j * dt * self.grid_kin) \\n return V_action*self.k_to_x(kin_action * self.x_to_k(psi))\",\n \"def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\\n rad = dia/2.\\n tsr = rad*fabs(rot)/Vinf\\n solidity = (chord*B)/rad\\n\\n # Translating the turbine position\\n x0t = x0 - xt\\n y0t = y0 - yt\\n\\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\\n\\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\\n if param is None:\\n loc1 = _parameterval(tsr,solidity,coef0)\\n loc2 = _parameterval(tsr,solidity,coef1)\\n loc3 = _parameterval(tsr,solidity,coef2)\\n spr1 = _parameterval(tsr,solidity,coef3)\\n spr2 = _parameterval(tsr,solidity,coef4)\\n skw1 = _parameterval(tsr,solidity,coef5)\\n skw2 = _parameterval(tsr,solidity,coef6)\\n scl1 = _parameterval(tsr,solidity,coef7)\\n scl2 = _parameterval(tsr,solidity,coef8)\\n scl3 = _parameterval(tsr,solidity,coef9)\\n\\n else:\\n # Reading in EMG distribution parameters\\n loc1 = param[0]\\n loc2 = param[1]\\n loc3 = param[2]\\n spr1 = param[3]\\n spr2 = param[4]\\n skw1 = param[5]\\n skw2 = param[6]\\n scl1 = param[7]\\n scl2 = param[8]\\n scl3 = param[9]\\n\\n ###################################\\n if veltype == 'vort':\\n # VORTICITY CALCULATION (NO INTEGRATION)\\n if x0t < 0.:\\n vel = 0.\\n else:\\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\\n ###################################\\n else:\\n # Integration of the vorticity profile to calculate velocity\\n if integration == 'simp':\\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\\n inte = 1 # Simpson's Rule\\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\\n\\n if param is not None:\\n print \\\"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\\\"\\n\\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs*Vinf + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])\\n ###################################\\n elif integration == 'gskr':\\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\\n xbound = (scl3+5.)*dia\\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys/Vinf\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])/Vinf\\n ###################################\\n\\n return vel\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def robot_arm_pos(self):\\n return self.sim.data.qpos[self.arm_index]\",\n \"def mTV(self):\\n distance = abs(self.vertPosT - self.vertPosW) # distance between htp and vortex shred plane,\\n # approximated with the wing root chordplane\\n return distance / (self.spanW / 2)\",\n \"def LeapFrog(self,r,v,dt):\\n\\n rhalf = r + np.asarray(v)*(dt/2) #Taking a half step forward with positional vector\\n # predict the final velocity at the next timestep using the acceleration field at the rhalf position \\n vnew = v + self.M31Accel(rhalf)*dt\\n # predict the final position using the average of the current velocity and the final velocity\\n rnew = r + 0.5*(v+vnew)*dt\\n \\n return rnew,vnew\",\n \"def get_cmd_velocity(self):\\n return self.gripper_io.get_signal_value(\\\"speed_mps\\\")\",\n \"def evaluate(self, *args, **kwargs):\\n return self.constant_velocity\",\n \"def _position_and_velocity(self, jd):\\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\\n self.elevation.au, jd.gast)\\n pos = einsum('ij...,j...->i...', jd.MT, pos)\\n vel = einsum('ij...,j...->i...', jd.MT, vel)\\n return pos, vel\",\n \"def setRobotVelocity(self,vel):\\n linear = vel[0]\\n angular = vel[1]\\n if not (self.orientation):\\n # Kinematic model for differential robot.\\n print(\\\"or 0\\\")\\n\\n wl = (linear - (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\\n wr = (linear + (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\\n\\n # At input 1000, angular velocity is 1 cycle / s or 2*pi/s.\\n velLeft = int(wl * BETA/(2*math.pi))\\n velRight = int(wr * BETA/(2*math.pi))\\n print(\\\"left: \\\" + str(velLeft))\\n print(\\\"right: \\\" + str(velRight))\\n self.setMotorSpeed(velRight,velLeft)\\n else:\\n print(\\\"or 1\\\")\\n # Kinematic model for differential robot.\\n wl = (linear - (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\\n wr = (linear + (WHEEL_SEPARATION / 2.) * angular) / WHEEL_DIAMETER\\n\\n # At input 1000, angular velocity is 1 cycle / s or 2*pi/s.\\n velLeft = int(wl * BETA/(2*math.pi))\\n velRight = int(wr * BETA/(2*math.pi))\\n print(\\\"left: \\\" + str(velLeft))\\n print(\\\"right: \\\" + str(velRight))\\n self.setMotorSpeed(velRight, velLeft)\",\n \"def vel(self,M):\\n v = np.sqrt((M*Body.G)/self.r)\\n \\n return v\",\n \"def base_velocity(self):\\n raise NotImplementedError('Not yet implemented!')\",\n \"def execute(self, state, dt):\\n \\n # The goal:\\n theta_g = state.goal*math.pi/180\\n \\n # The robot:\\n \\n x_r, y_r, theta = state.pose\\n # print(\\\"current Robot pose: ({}, {}, {})\\\".format(x_r, y_r, theta), file=sys.stderr)\\n \\n # 1. Calculate simple proportional error\\n error = (theta_g - theta + math.pi)%(2*math.pi) - math.pi\\n # print(\\\"current err: ({})\\\".format(error), file=sys.stderr)\\n \\n # 2. Calculate desired omega\\n w_ = self.kp*error\\n \\n # 3. The linear velocity is given to us:\\n v_ = state.velocity\\n # print(\\\"current v, w: ({}, {})\\\".format(v_, w_), file=sys.stderr)\\n \\n\\n return [v_, w_]\",\n \"def get_velocity_vortex(strength, xv, yv, X, Y):\\r\\n u = +strength / (2 * math.pi) * (Y - yv) / ((X - xv)**2 + (Y - yv)**2)\\r\\n v = -strength / (2 * math.pi) * (X - xv) / ((X - xv)**2 + (Y - yv)**2)\\r\\n \\r\\n return u, v\",\n \"def rhs(states, t, parameters, values=None):\\n # Imports\\n import numpy as np\\n import math\\n\\n # Assign states\\n assert(len(states) == 6)\\n vlv, vrv, v1s, v2s, v1p, v2p = states\\n\\n # Assign parameters\\n assert(len(parameters) == 38)\\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\\\\n twitchperiod=parameters[37]\\n\\n # Init return args\\n if values is None:\\n values = np.zeros((6,), dtype=np.float_)\\n else:\\n assert isinstance(values, np.ndarray) and values.shape == (6,)\\n\\n # Expressions for the Time varying elastance component\\n t_lv = math.fmod(t, bcl)\\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\\\\n twitchperiod else 0)\\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\\n plv = p_epi + (-restVlv + vlv)*Elv\\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\\n prv = p_epi + (-restVrv + vrv)*Erv\\n\\n # Expressions for the Pressures and flows component\\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\\\\n rest_v1s/c1s)\\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\\\\n rest_v2s/c2s)\\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\\\\n rest_v1p/c1p)\\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\\\\n rest_v2p/c2p)\\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\\n q1_s = (-p2s + p1s)/R1_s\\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\\n q1_p = (-p2p + p1p)/R1_p\\n\\n # Expressions for the Ventricular volumes component\\n values[0] = -qart_s + q_mit\\n values[1] = -qart_p + q_tric\\n\\n # Expressions for the Systemic volumes component\\n values[2] = -q1_s + qart_s\\n values[3] = -q_tric + q1_s\\n\\n # Expressions for the Pulmonary volumes component\\n values[4] = -q1_p + qart_p\\n values[5] = -q_mit + q1_p\\n\\n # Return results\\n return values\",\n \"def verlet_next_vel(vel_t,accel_t,accel_t_plus_dt,dt):\\n vel_t_plus_dt = vel_t.copy()\\n vel_t_plus_dt += 0.5 * (accel_t + accel_t_plus_dt) * dt\\n return vel_t_plus_dt\",\n \"def target_velocity(self, s):\\n # if s - self.transition >= self.subpaths[self.current_path].total_length():\\n # self.transition += self.subpaths[self.current_path].total_length()\\n # self.current_path += 1\\n\\n if s > self.total_length:\\n s = self.total_length\\n\\n linear, angular = self.subpaths[self.current_path].target_velocity(s-self.transition)\\n linear = np.dot(self.g, linear)\\n\\n return [linear, angular]\",\n \"def get_velocity(self, index: int, array: List[float]) -> float:\\n velocity_sum = 0.0\\n number_iterations = min(self.past_n_steps, index - 1)\\n for i in range(number_iterations):\\n velocity_sum += (array[index - 1 - i] - array[index - 2 - i])\\n\\n return velocity_sum / (self.time_step * number_iterations)\",\n \"def lunar_phase(cls, tee):\\n return mod(cls.lunar_longitude(tee) - cls.hindu_solar_longitude(tee), 360)\",\n \"def f_2(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n # velocity equation for the ball after the bounce\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def present_velocity(self):\\n return self._read(MX_PRESENT_VELOCITY)\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def tke(self):\\n if len(self._obj.t) < 2:\\n raise ValueError('TKE is not defined for a single vector field, use .piv.ke()')\\n\\n self._obj['w'] = (self._obj['u'] - self._obj['u'].mean(dim='t'))**2 + \\\\\\n (self._obj['v'] - self._obj['v'].mean(dim='t'))**2\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'({vel_units})^2')\\n return self._obj\",\n \"def velocity(self):\\n return self._vel.to_list()\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def verlet_next_pos(pos_t,vel_t,accel_t,dt):\\n pos_t_plus_dt = pos_t.copy()\\n pos_t_plus_dt += vel_t * dt + 0.5 * accel_t * (dt**2) \\n\\n return pos_t_plus_dt\",\n \"def __init__(self, mass, radius, position, velocity):\\n self.mass = mass\\n self.radius = radius\\n self.position = position\\n self.velocity = velocity\\n print(self.velocity)\\n self.vafter = np.copy(velocity) # temp storage for velocity of next step\\n self.delete = False\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def test_vertical_velocity_dry_air():\\n omega = 1 * units('microbar/second')\\n w_truth = -0.7995291 * units('cm/s')\\n w_test = vertical_velocity(omega, 1000. * units.mbar, 273.15 * units.K)\\n assert_almost_equal(w_test, w_truth, 6)\",\n \"def initial_velocity(self) -> float:\\n return self._initial_velocity\",\n \"def get(cls, approach):\\n return approach.velocity\",\n \"def test_velocity_vs_current(self):\\n t, x_n, x_p = self.t, self.x_n, self.x_p\\n\\n beta_n = self.model.param.beta_n\\n beta_n = self.param.evaluate(beta_n)\\n beta_p = self.model.param.beta_p\\n beta_p = self.param.evaluate(beta_p)\\n\\n np.testing.assert_array_almost_equal(\\n self.v_box(t, x_n), beta_n * self.i_e(t, x_n)\\n )\\n np.testing.assert_array_almost_equal(\\n self.v_box(t, x_p), beta_p * self.i_e(t, x_p)\\n )\",\n \"def target_velocity(self, s):\\n raise NotImplementedError()\",\n \"def runge_integrator(self, t, y, dt, tau):\\n\\n k1 = self.plant.rhs(t, y, tau)\\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\\n return (k1 + 2 * (k2 + k3) + k4) / 6.0\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7120653","0.697146","0.6872062","0.6827393","0.6781933","0.6706172","0.66989666","0.66028404","0.6586185","0.6578873","0.65184575","0.65106213","0.65106213","0.64967805","0.6452281","0.64379877","0.6426943","0.6426943","0.6386043","0.63796675","0.6378949","0.63727677","0.63514704","0.63107514","0.6301826","0.62634295","0.62310654","0.6217248","0.61855173","0.61855173","0.61651677","0.61611575","0.61602676","0.61568636","0.6143614","0.60957783","0.6094248","0.6067698","0.60598886","0.60337365","0.6014168","0.60107774","0.60024184","0.600116","0.5994084","0.5987753","0.5986797","0.59723437","0.59683686","0.5961913","0.5955842","0.59547275","0.5950548","0.5948409","0.58986926","0.5895288","0.58869714","0.58790153","0.5872906","0.58574206","0.5855076","0.58440953","0.5837328","0.5833752","0.58288455","0.5827681","0.58118975","0.580428","0.5800991","0.5798764","0.5793747","0.5792533","0.5792324","0.5790515","0.57826424","0.578199","0.5779821","0.57700527","0.57651013","0.57640857","0.57636064","0.5752255","0.57370216","0.57321614","0.57260776","0.5715162","0.57120675","0.57109666","0.57060593","0.5703843","0.5701492","0.5697778","0.5690006","0.5678224","0.56645024","0.5658885","0.56518257","0.5646756","0.5642656","0.56389433"],"string":"[\n \"0.7120653\",\n \"0.697146\",\n \"0.6872062\",\n \"0.6827393\",\n \"0.6781933\",\n \"0.6706172\",\n \"0.66989666\",\n \"0.66028404\",\n \"0.6586185\",\n \"0.6578873\",\n \"0.65184575\",\n \"0.65106213\",\n \"0.65106213\",\n \"0.64967805\",\n \"0.6452281\",\n \"0.64379877\",\n \"0.6426943\",\n \"0.6426943\",\n \"0.6386043\",\n \"0.63796675\",\n \"0.6378949\",\n \"0.63727677\",\n \"0.63514704\",\n \"0.63107514\",\n \"0.6301826\",\n \"0.62634295\",\n \"0.62310654\",\n \"0.6217248\",\n \"0.61855173\",\n \"0.61855173\",\n \"0.61651677\",\n \"0.61611575\",\n \"0.61602676\",\n \"0.61568636\",\n \"0.6143614\",\n \"0.60957783\",\n \"0.6094248\",\n \"0.6067698\",\n \"0.60598886\",\n \"0.60337365\",\n \"0.6014168\",\n \"0.60107774\",\n \"0.60024184\",\n \"0.600116\",\n \"0.5994084\",\n \"0.5987753\",\n \"0.5986797\",\n \"0.59723437\",\n \"0.59683686\",\n \"0.5961913\",\n \"0.5955842\",\n \"0.59547275\",\n \"0.5950548\",\n \"0.5948409\",\n \"0.58986926\",\n \"0.5895288\",\n \"0.58869714\",\n \"0.58790153\",\n \"0.5872906\",\n \"0.58574206\",\n \"0.5855076\",\n \"0.58440953\",\n \"0.5837328\",\n \"0.5833752\",\n \"0.58288455\",\n \"0.5827681\",\n \"0.58118975\",\n \"0.580428\",\n \"0.5800991\",\n \"0.5798764\",\n \"0.5793747\",\n \"0.5792533\",\n \"0.5792324\",\n \"0.5790515\",\n \"0.57826424\",\n \"0.578199\",\n \"0.5779821\",\n \"0.57700527\",\n \"0.57651013\",\n \"0.57640857\",\n \"0.57636064\",\n \"0.5752255\",\n \"0.57370216\",\n \"0.57321614\",\n \"0.57260776\",\n \"0.5715162\",\n \"0.57120675\",\n \"0.57109666\",\n \"0.57060593\",\n \"0.5703843\",\n \"0.5701492\",\n \"0.5697778\",\n \"0.5690006\",\n \"0.5678224\",\n \"0.56645024\",\n \"0.5658885\",\n \"0.56518257\",\n \"0.5646756\",\n \"0.5642656\",\n \"0.56389433\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6284519"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":20296,"cells":{"query":{"kind":"string","value":"Returns the arm's desired acceleration in workspace coordinates at time t"},"document":{"kind":"string","value":"def target_acceleration(self, time):\n #return np.array([0, 0, 0])\n if time <= self.total_time/4:\n return self.path1.target_acceleration(time)\n elif time <= self.total_time/2:\n return self.path2.target_acceleration(time)\n elif time <= self.total_time/4*3:\n return self.path3.target_acceleration(time)\n else:\n return self.path4.target_acceleration(time)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])","def acceleration(v,u,t):\n return ((v-u)/t)","def get_acceleration(self,v,el,T_s,T_i):\n\n rad = radiation.Radiation()\n T_atm = rad.getTemp(el)\n p_atm = rad.getPressure(el)\n rho_atm = rad.getDensity(el)\n g = rad.getGravity(el)\n\n\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\n\n Cd = .5 # Drag Coefficient\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\n\n if F_d > 0:\n F_d = F_d * self.Upsilon\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\n\n return accel","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def target_acceleration(self, time):\n return self.target(time, self.accelerations, self.dt, self.num_way)","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def eval_accel(self,t,endBehavior='halt') -> Vector:\n res = Trajectory.deriv_state(self,t,endBehavior)\n return res[len(res)//2:]","def target_acceleration(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_acceleration(path_time)","def target_acceleration(self, time):\n return np.array([0, 0, 0])","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def acceleration(self):\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\n \n ax = self._obj['u']*ux + self._obj['v']*uy\n ay = self._obj['u']*vx + self._obj['v']*vy\n\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\n\n if len(self._obj.attrs['units']) == 4:\n vel_units = self._obj.attrs['units'][-1]\n self._obj.attrs['units'].append(f'{vel_units}^2')\n else:\n vel_units = self._obj.attrs['units'][-2]\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\n\n\n return self._obj","def to_cart(self, t):\n # mean motion:\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\n # mean anomaly at t:\n M = n * (t - self.t0) + self.M0\n # print(np.fmod(M, 2*np.pi))\n # solve Kepler equation, get eccentric anomaly:\n E = self.kepler(self.e, M)\n cosE = np.cos(E)\n sinE = np.sin(E)\n # get true anomaly and distance from focus:\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\n # r = self.a*(1 - self.e*cosE)\n #\n sinw = np.sin(self.w)\n cosw = np.cos(self.w)\n sinu = sinw * cosv + cosw * sinv\n cosu = cosw * cosv - sinw * sinv\n # position\n cosNode = np.cos(self.Node)\n sinNode = np.sin(self.Node)\n cosi = np.cos(self.i)\n sini = np.sin(self.i)\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\n z = r * sinu * sini\n # velocity\n p = self.a * (1.0 - self.e ** 2)\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\n vz = z * V_1 / r + cosu * sini * V_2\n\n state = np.array([x, y, z, vx, vy, vz])\n state = np.reshape(np.asarray(state), (3, 2), 'F')\n\n return state","def acceleration(self):\n return self.__accel","def get_rotationalAngularPosition(self, t): # returns [rad]\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\n return angle","def acceleration(data_array, time=1):\n speed = DataOperation.speed(data_array)\n acc_values = np.zeros(speed.size)\n count = 1\n acc_values[0] = 0\n for d in speed[1:]:\n acc_values[count] = (d - speed[count-1])/3.6/time\n count += 1\n return acc_values","def thetas (self,lag):\n tanthetas = [0,0,0]\n for k in range(3,self.n):\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\n tanthetas.append(tantheta_k)\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles","def _compute_solar_torque(self):\n pass","def acc(x: float, v: float, t: float) -> float:\n return -k*v - np.sin(x) + c*np.cos(omega*t)","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def compute_acceleration(self, x, y):\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\n return np.array([a_x, a_y])","def target_acceleration(self, time):\n pass","def target_acceleration(self, time):\n pass","def get_acceleration(self):\n return self.acceleration","def euler_cromer_approx(theta_0, omega_0, dt, T_i):\n theta=np.zeros(samples)\n omega=np.zeros(samples)\n t=np.zeros(samples)\n theta[0]=theta_0\n omega[0]=omega_0\n t[0]=T_i\n\n for n in range(1,samples):\n \"\"\"\n calculates new value for omega using old value of theta and omega\n \"\"\"\n omega[n]=omega[n-1]-g/l*theta[n-1]*dt\n \n \"\"\"\n Calculates new theta using new omega and old theta\n \"\"\"\n theta[n]=theta[n-1]+omega[n]*dt\n \n \"\"\"\n Time array in same dimension for ploting\n \"\"\"\n t[n]=t[n-1]+dt\n \n \n \"\"\"\n theta: array with values of angular displacement\n w: array with values of angular velocity\n t: array with time-values\n \"\"\"\n return theta,omega,t","def get_current_thrust_direction(self,\n time: float) -> np.array:\n # Interpolate with time\n angle = self.thrust_angle_interpolator.interpolate(time)\n # Set thrust in vertical frame and transpose it\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\n # Update flight conditions (this is needed to let tudat know to update all variables)\n self.vehicle_body.flight_conditions.update_conditions(time)\n # Get aerodynamic angle calculator\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\n frames.AerodynamicsReferenceFrames.vertical_frame,\n frames.AerodynamicsReferenceFrames.inertial_frame)\n # Compute the thrust in the inertial frame\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\n thrust_direction_vertical_frame)\n return thrust_inertial_frame","def advanceVelocity(self,time,acceleration):\n if not isinstance(acceleration,Cartesian3DVector):\n raise CoordinateException(\"Advancing particle momentum with the incorrect acceleration type.\")\n return self.v + time*acceleration","def calculate_acceleration(self) -> np.array:\n F = self.calculate_net_force()\n m = self.mass\n a = F / m\n\n return a","def position(x,v,t,a):\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)","def omega(x):\n # if ramp_start_time - ramp_constant_time <= x <= end_ramp_end_time + ramp_constant_time:\n # f_t0 = smooth_factor * (x - ramp_start_time)\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\n # if ramp_mode == 'with_end_acc':\n # f_t2 = smooth_factor * (x - steady_end_time)\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\n # elif ramp_mode == 'no_end_acc':\n # f_t2 = smooth_factor * ramp_start_time\n # f_t3 = smooth_factor * i_ramp_end_time\n\n # omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\n # else:\n # if bstroke == 'yes' and x <= 2 * (end_ramp_end_time +\n # ramp_constant_time):\n # x -= end_ramp_end_time + ramp_constant_time\n # f_t0 = smooth_factor * (x - ramp_start_time)\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\n # if ramp_mode == 'with_end_acc':\n # f_t2 = smooth_factor * (x - steady_end_time)\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\n # elif ramp_mode == 'no_end_acc':\n # f_t2 = smooth_factor * ramp_start_time\n # f_t3 = smooth_factor * i_ramp_end_time\n\n # omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\n # logcosh(f_t2))\n # else:\n # omegax = 0\n\n if bstroke == 'no':\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\n\n else:\n if x <= end_ramp_end_time + ramp_constant_time:\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = (ramp_stage_acceleration /\n 2) / smooth_factor * (logcosh(f_t0) - logcosh(f_t1) +\n logcosh(f_t3) - logcosh(f_t2))\n\n else:\n x -= end_ramp_end_time + ramp_constant_time\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\n logcosh(f_t2))\n\n return omegax","def acceleration(self):\n # speed is by formula: x axis speed: by cos of the heading and y\n # axis by sine of the heading\n self.x_speed += math.cos(math.radians(self.degrees))\n self.y_speed += math.sin(math.radians(self.degrees))","def analyticalLinearSol(self, t):\n return self.c*t + self.I","def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])","def speed(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.velocity(rf), t.velocity(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def get_D_C3H8_air(self, T):\n\n self.set_TempPres_dependents(T)\n\n self.D_C3H8_air = (\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\n )\n\n return self.D_C3H8_air","def _acceleration(data):\n\n # intermediate values\n sumcube_resids = ((data.mean() - data)**3).sum()\n\n # dodge the ZeroDivision error\n sumsqr_resids = max(((data.mean() - data)**2).sum(), 1e-12)\n\n # compute and return the acceleration\n return sumcube_resids / (6 * sumsqr_resids**1.5)","def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\r\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\r\n * c)) ** 2) - 1.0)\r\n self.xa_track.append(x)\r\n p = qe * self.t[i]\r\n self.pa.append(p)\r\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\r\n jv = self.t[i] * qe / (m * c)\r\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\r\n self.va.append(v)\r\n print 'Analytical solution of the differential equation of motion'","def robot_arm_acc(self):\n return self.sim.data.qacc[self.arm_index]","def thetacm(t):\n return np.array([\n 0,\n 0,\n self.wz * t\n ])","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def _get_alpha(self, m_t, v_t):\n return max(0, ((-m_t * self._psi \n + math.sqrt((m_t ** 2 * self._phi ** 4) \n / 4 + v_t * self._phi ** 2 * self._xi)) \n / (v_t * self._xi)))","def calc_accel(vel_data, dt):\n\n ax = np.gradient(vel_data[:, 0], dt)\n ay = np.gradient(vel_data[:, 1], dt)\n\n return np.c_[ax, ay]","def M31Accel(self,r):\n\n ### Call the previous functions for the halo, bulge and disk\n halo_acc = self.HernquistAccel(self.Mhalo,self.rhalo,r) #Calculating halo acceleration\n bulge_acc = self.HernquistAccel(self.Mbulge,self.rbulge,r) #\"\"\" bulge \"\"\"\n disk_acc = self.MiyamotoNagaiAccel(self.Mdisk,self.rdisk,r)#\"\"\" disk \"\"\"\n sum1 = np.add(halo_acc,bulge_acc) #summing halo and bulge first\n acc_sum = np.add(sum1,disk_acc) #then adding disk acceleration\n\n return acc_sum","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def clAlphaT(self):\n A = 2 * pi * self.aspectRatioT\n B = (self.aspectRatioT * self.betaT / self.airfoilEffT)**2\n C = 1 + ((tan(radians(self.sweep50T)))**2) / (self.betaT**2)\n return A / (2 + sqrt(4 + B * C))","def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation","def acceleration_double_pendulum(t, state, kwargs, g = 9.81):\n theta = [ state[0], state[1] ]\n omega = [ state[2], state[3] ]\n M, L = kwargs['M'], kwargs['L']\n Mt = M[0] + M[1]\n \n denominator = 2 * M[0] + M[1] - M[1] * cos( 2 * theta[0] - 2 * theta[1])\n sin_delta = sin( theta[0] - theta[1] )\n cos_delta = cos( theta[0] - theta[1] )\n d_state = [ 0, 0, 0, 0 ]\n \n d_state[2] = - g * (Mt + M[0]) * sin(theta[0]) + M[1] * g * sin(theta[0] - 2*theta[1])\n d_state[2] -= 2 * sin_delta * M[1] * (L[1]*omega[1]**2 + L[0] * cos_delta * omega[0]**2)\n d_state[2] /= L[0] * denominator \n \n d_state[3] = L[0] * Mt * omega[0]**2 + g * Mt * cos(theta[0])\n d_state[3] += L[1] * M[1] * cos_delta * omega[1]**2\n d_state[3] *= 2 * sin_delta / ( L[1] * denominator )\n \n d_state[0] = omega[0] \n d_state[1] = omega[1] \n \n return np.asarray(d_state)","def get_action(self):\n # Actual q and dq\n contacts = np.array(\n [(leg_state in (gait_generator_lib.LegState.STANCE,\n gait_generator_lib.LegState.EARLY_CONTACT))\n for leg_state in self._gait_generator.desired_leg_state],\n dtype=np.float64)\n foot_positions = self._robot.GetFootPositionsInBaseFrame()\n\n robot_com_height = self._estimate_robot_height(contacts, foot_positions)\n robot_com_velocity = self._state_estimator.com_velocity_body_frame\n robot_com_roll_pitch_yaw = np.array(self._robot.GetBaseRollPitchYaw())\n robot_com_roll_pitch_yaw[2] = 0. # To prevent yaw drifting\n robot_com_roll_pitch_yaw_rate = self._robot.GetBaseRollPitchYawRate()\n robot_q = np.hstack(([0., 0., robot_com_height], robot_com_roll_pitch_yaw))\n robot_dq = np.hstack((robot_com_velocity, robot_com_roll_pitch_yaw_rate))\n # Desired q and dq\n desired_com_position = np.array((0., 0., self._desired_body_height),\n dtype=np.float64)\n desired_com_velocity = np.array(\n (self.desired_speed[0], self.desired_speed[1], 0.), dtype=np.float64)\n desired_com_roll_pitch_yaw = np.array((0., 0., 0.), dtype=np.float64)\n desired_com_angular_velocity = np.array(\n (0., 0., self.desired_twisting_speed), dtype=np.float64)\n desired_q = np.hstack((desired_com_position, desired_com_roll_pitch_yaw))\n desired_dq = np.hstack(\n (desired_com_velocity, desired_com_angular_velocity))\n # Desired ddq\n desired_ddq = KP * (desired_q - robot_q) + KD * (desired_dq - robot_dq)\n desired_ddq = np.clip(desired_ddq, MIN_DDQ, MAX_DDQ)\n contact_forces = self._qp_torque_optimizer.compute_contact_force(\n foot_positions, desired_ddq, contacts=contacts)\n\n action = {}\n for leg_id, force in enumerate(contact_forces):\n # While \"Lose Contact\" is useful in simulation, in real environment it's\n # susceptible to sensor noise. Disabling for now.\n # if self._gait_generator.leg_state[\n # leg_id] == gait_generator_lib.LegState.LOSE_CONTACT:\n # force = (0, 0, 0)\n motor_torques = self._robot.MapContactForceToJointTorques(leg_id, force)\n for joint_id, torque in motor_torques.items():\n action[joint_id] = (0, 0, 0, 0, torque)\n return action, contact_forces","def OrbitPos(self, rv, t, m):\n \n params = np.array(rv)\n params = params.flatten()\n \n def GravityODE(rv,t):\n G = 6.67e-11\n m = 5.972e24\n x = rv[0]\n y = rv[1]\n vx = rv[2]\n vy = rv[3]\n \n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\n dxdt = vx\n dydt = vy\n\n pos_derivs = np.array([dxdt,dydt])\n v_deriv = np.array([dvxdt,dvydt])\n derivs = np.hstack((pos_derivs,v_deriv))\n \n return derivs \n \n satellite_orbit = integrate.odeint(GravityODE,params,t)\n \n return satellite_orbit[:,0],satellite_orbit[:,1]","def lerp(self, t):\n a = self.a0 + t * self.da\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))","def TimeEvolution(w: np.ndarray, t: float):\n # pylint: disable=expression-not-assigned\n n_modes = len(w)\n\n @operation(n_modes)\n def op(q):\n\n theta = -w * 100.0 * c * 1.0e-15 * t * (2.0 * pi)\n\n for i in range(n_modes):\n sf.ops.Rgate(theta[i]) | q[i]\n\n return op()","def rcm(t):\n x0 = 0 # initial position\n return np.array([\n 0,\n 0,\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\n ])","def rhs(x, t):\n\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))","def compute_acceleration(energy, sigma, r):\n return 0.5 * -LJForce(energy, sigma, magnitude(r)) * (r/magnitude(r))","def get_trajectory(h, launch_speed, launch_angle):\n\n v0 = launch_speed\n theta = mp.radians(launch_angle)\n\n N = 100000\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\n tr = np.empty((N,2))\n v = np.empty((N,2))\n # Initial rocket position, velocity and acceleration\n tr[0] = 0, R + h\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\n a = calc_a(tr[0])\n\n for i, t in enumerate(tgrid[1:]):\n # Calculate the rocket's next position based on its instantaneous velocity.\n \n r = tr[i] + v[i] * dt \n \n if np.hypot(*r) < R:\n # Our rocket crashed.\n break\n # Update the rocket's position, velocity and acceleration.\n tr[i+1] = r\n v[i+1] = v[i] + a*dt\n a = calc_a(tr[i+1])\n return tr[:i+1]","def integrate(self, t):\n t0 = self.t0\n if t-t0 <= self.max_step_size:\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \n \n else :\n n = (t-t0) / self.max_step_size\n dt = (t-t0)/int(n+1)\n \n while t0 < t :\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\n t0 += dt\n \n return self.y0","def path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def update_ab3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 2:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.set_old(kap, 2)\n\n self.time += delta_t\n\n else:\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\n\n try:\n tmp = [self.get_old(0)]\n except IndexError:\n tmp = []\n kap = update_ab2(self)\n if tmp:\n self._old = self._old + tmp\n\n return kap","def update_apc11(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n pos = self.pos+delta_t*self.vel\n vel = self.vel+delta_t*kap[1]\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n force = self.force(pos,\n vel,\n self.time+delta_t, drag=False)\n\n pos = self.pos+delta_t*vel\n vel = self.vel+delta_t*force\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n\n try:\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n vel = self.vel+col.delta_t*kap[1]\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest = True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n \n self.time += delta_t\n\n return (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)","def _k(self, T):\n RT = Rgas * T\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))","def objective_function(T_cr: np.ndarray) -> np.ndarray:\n \n Tm = (T_r + T_cr)/2.0\n ks = thermal_conductivity(Tm)\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\n \n return np.linalg.norm(T_cr_update - T_cr,ord = 1)","def update_apc23(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n if len(self._old) >= 1:\n\n\n try:\n\n kap = (self.vel, self.force(self.pos,\n self.vel,\n self.time, drag=False), self.time)\n\n beta = 0.5*self.delta_t/(self.time-self.get_old(0, 2))\n\n pos = self.pos+delta_t*((1+beta)*self.vel-beta*self.get_old(0, 0))\n vel = self.vel+delta_t*((1+beta)*kap[1]-beta*self.get_old(0, 1))\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\n\n\n beta1 = (3.0*(self.time-self.get_old(0,2))+delta_t)/(6.0*self.time-self.get_old(0,2))\n beta2 = -delta_t**2/(6.0*(self.time+delta_t-self.get_old(0,2))*(self.time-self.get_old(0,2)))\n\n print self.force(pos, vel, self.time+delta_t), kap[1], self.get_old(0,1)\n\n pos = self.pos+delta_t*((1.0-beta1-beta2)*vel+beta1*self.vel+beta2*self.get_old(0, 0))\n vel = self.vel+delta_t*((1.0-beta1-beta2)*self.force(pos, vel, self.time+delta_t,\n drag=False)+beta1*kap[1]+beta2*self.get_old(0,1))\n\n for cback in self.pos_callbacks:\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n for cback in self.vel_callbacks:\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=True)\n except Collision.CollisionException as col:\n beta = 0.5*col.delta_t/(self.time-self.get_old(0, 2))\n vel = self.vel+col.delta_t*(1+beta)*kap[1]-beta*self.get_old(0, 1)\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\n raise col\n\n self.time += delta_t\n\n else:\n ## reduced to using the Adams first order method for the first timestep:\n\n kap = update_apc1(self)\n\n self.set_old(kap, 1)\n\n return kap","def acceleration_sensor(axis):\n\n\tsensor_name = \"baseBoard\"\n\treg_addr = 24\n\tdata_len = 56\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t#get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Imu', Imu, 2)\n\tacceleration = data.linear_acceleration\n\tif axis == \"x\":\n\t\tresult = acceleration.x\n\telif axis == \"y\":\n\t\tresult = acceleration.y\n\telse:\n\t\tresult = acceleration.z\n\n\tdelete_sensor(sensor_name)\n\treturn result","def update(self, tfinal):\n t = 0; kk = 0\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\n self.omega = np.zeros((nstep,self.npts))\n self.theta = np.zeros((nstep,self.npts))\n\n while t <(tfinal+1e-10):\n self.return_map()\n self.omega[kk] = self.y[0]\n self.theta[kk] = self.y[1]\n\n self.y = RK4(self.y, self.dt, t, self.deri)\n kk += 1; t += self.dt\n\n return self","def t2x(self, t ):\n \n # Find time index\n i = (np.abs(self.t_sol - t)).argmin()\n \n # Find associated control input\n x = self.x_sol[i,:]\n \n return x","def euler_cromer_method(theta_0, omega_0, dt, T_i):\n theta=np.zeros(samples)\n omega=np.zeros(samples)\n t=np.zeros(samples)\n theta[0]=theta_0\n omega[0]=omega_0\n t[0]=T_i\n\n for n in range(1,samples):\n \"\"\"\n calculates new value for omega using old value of theta and omega\n \"\"\"\n omega[n]=omega[n-1]-g/l*np.sin(theta[n-1])*dt\n \n \"\"\"\n calculates new value of omega by new omega and old theta\n \"\"\"\n theta[n]=theta[n-1]+omega[n]*dt\n \n \"\"\"\n time erray of same dimenion as earlier arrays\n \"\"\"\n t[n]=t[n-1]+dt\n \n \n \"\"\"\n theta: array with values of angular displacement\n w: array with values of angular velocity\n t: array with time-values\n \"\"\"\n return theta,omega,t","def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\n\n #project forwards in time\n sim_interval = self.sim_interval\n sim_interval_sq = sim_interval*sim_interval\n cmd_vel = list(cmd_vel)\n current_speed = list(current_speed)\n\n max_acc_x = self.robot.max_acc_x\n max_acc_th = self.robot.max_acc_th\n max_decc_x = self.robot.max_dacc_x\n max_decc_th = self.robot.max_dacc_th\n\n\n code = \"\"\"\n double x, y, th;\n x = y = th = 0;\n\n double vx, vth;\n vx = current_speed[0];\n vth = current_speed[1];\n\n double cmd_x = cmd_vel[0];\n double cmd_th = cmd_vel[1];\n\n //are we accelerating or decelerating?\n double acc_x;\n double acc_th;\n\n bool b_ax = false;\n if (cmd_x > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = accs[2];\n acc_x = -1*acc_x;\n }\n\n bool b_ath = false;\n if (cmd_th > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1* (double) accs[3];\n\n }\n\n py::list traj;\n\n //delay at the beginning\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //application of the command\n for (double i=0; i<=time_applied; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //delay before decellerating\n for (double i=0; i<=delay_time; i+=sim_interval) {\n //check if we have already attained our velocity\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\n\n //check if we have exceeded our target\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\n\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n }\n\n //now we apply a stop\n b_ax = false;\n if (0 > vx) {\n acc_x = accs[0];\n b_ax = true;\n } else {\n acc_x = -1 * (double) accs[2];\n }\n\n b_ath = false;\n if (0 > vth) {\n acc_th = accs[1];\n b_ath = true;\n } else {\n acc_th = -1 * (double) accs[3];\n }\n\n for (double i=0; i<=time_decc; i+=sim_interval) {\n vx += acc_x*sim_interval;\n\n //check if we have already attained our velocity\n if (fabs(vx) < 1e-6) vx = 0;\n\n //check if we have exceeded our target\n if (b_ax && (vx > 0 )) vx = 0;\n if (!b_ax && (vx < 0 )) vx = 0;\n\n vth += acc_th*sim_interval;\n\n if (fabs(vth) < 1e-6) vth = 0;\n if (b_ath && (vth > 0 )) vth = 0;\n if (!b_ath && (vth < 0 )) vth = 0;\n\n x += vx*cos(th)*sim_interval;\n y += vx*sin(th)*sim_interval;\n th += vth*sim_interval;\n\n py::list new_pt;\n new_pt.append(x);\n new_pt.append(y);\n new_pt.append(th);\n traj.append(new_pt);\n\n\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\n if (stopped) break;\n\n }\n\n return_val = traj;\n \"\"\"\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\n 'time_decc'], type_converters=converters.blitz)\n\n return traj","def get_kappa (self, t):\n\n Omega, dOmega_dt = self.get_Omega(t)\n Delta, dDelta_dt = self.get_Delta(t)\n\n kappa = Delta/2 + self.sign * \\\n (sqrt(Delta**2 + 2*Omega**2) / 2 - sqrt(Delta**2 + Omega**2))\n\n return kappa","def tidal_acc(self, xyz):\r\n assert(xyz.shape[1] == 3)\r\n\r\n # create solar mass variable, if not already extant\r\n try:\r\n self.M\r\n except AttributeError:\r\n self.M = Constant(2e33) # solar mass in g\r\n\r\n # get the vector of x-values\r\n x = xyz[:, 0]\r\n\r\n # create an all-zero force vector\r\n acc = np.zeros_like(xyz)\r\n\r\n # get the heliocentric distance at the current time\r\n dist = self.trajectory(self.t)\r\n\r\n # get the acceleration as the difference between the acceleration at\r\n # the points and the acceleration at the c.o.m.\r\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\r\n return(acc)","def get_actual_air_conditioned_temperature(\n hc_period: np.ndarray,\n theta_ac: np.ndarray, v_supply: np.ndarray, theta_supply_h: np.ndarray, theta_supply_c: np.ndarray,\n l_d_h: np.ndarray, l_d_cs: np.ndarray,\n u_prt: float, a_prt: np.ndarray, a_hcz: np.ndarray, q: float) -> np.ndarray:\n\n rho = get_air_density()\n c = get_specific_heat()\n\n a_prt = a_prt.reshape(1, 5).T\n a_hcz = a_hcz[0:5].reshape(1, 5).T\n\n theta_ac_act_h = np.maximum(theta_ac + (c * rho * v_supply * (theta_supply_h - theta_ac) - l_d_h * 10 ** 6)\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\n\n theta_ac_act_c = np.minimum(theta_ac - (c * rho * v_supply * (theta_ac - theta_supply_c) - l_d_cs * 10 ** 6)\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\n\n return theta_ac_act_h * (hc_period == 'h') + theta_ac_act_c * (hc_period == 'c') + theta_ac * (hc_period == 'm')","def get_potential(self,t):\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\n grid_V += 200 * (self.grid_x < 0)\n return grid_V","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0],\n [0, c, -s],\n [0, s, c]])","def runge_integrator(self, t, y, dt, tau):\n\n k1 = self.plant.rhs(t, y, tau)\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\n return (k1 + 2 * (k2 + k3) + k4) / 6.0","def get_angular_velocity(r, T):\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\n # velocity = 2(pi)r/T\n return (2*math.pi*r)/T","def rotx(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])","def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\n global yaw\n global current_heading\n yawdot = 0.0\n pos = np.zeros(3)\n acc = np.zeros(3)\n vel = np.zeros(3)\n jerk = np.zeros(3)\n snap = np.zeros(3)\n yawddot = 0.0\n\n # distance vector array, represents each segment's distance\n distance = waypoints[0:-1] - waypoints[1:]\n # T is now each segment's travel time\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\n # accumulated time\n S = np.zeros(len(T) + 1)\n S[1:] = np.cumsum(T)\n\n # find which segment current t belongs to\n t_index = np.where(t >= S)[0][-1]\n\n # prepare the next desired state\n if t == 0:\n pos = waypoints[0]\n t0 = get_poly_cc(8, 1, 0)\n\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\n if(LA.norm(v_proj) == 0.0):\n # if velocity vector is of zero magnitude there should be no change in heading!\n pass\n else:\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\n \n\n # stay hover at the last waypoint position\n elif t > S[-1]:\n pos = waypoints[-1]\n else:\n # scaled time\n scale = (t - S[t_index]) / T[t_index]\n start = 8 * t_index\n end = 8 * (t_index + 1)\n\n t0 = get_poly_cc(8, 0, scale)\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\n\n t1 = get_poly_cc(8, 1, scale)\n # chain rule applied\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\n\n t2 = get_poly_cc(8, 2, scale)\n # chain rule applied\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\n\n t3 = get_poly_cc(8, 3, scale)\n # apply chain rule\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\n\n t4 = get_poly_cc(8, 4, scale)\n # apply chain rule\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\n\n # calculate desired yaw and yaw rate\n\n v_proj = np.array([vel[0], vel[1]])\n\n if( LA.norm(v_proj) == 0.0):\n # if velocity vector is zero, again there should be no change in heading\n next_heading = current_heading\n else:\n next_heading = v_proj/LA.norm(v_proj)\n\n \"\"\"\n try :\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\n next_heading = v_proj/LA.norm(v_proj)\n except ZeroDivisionError:\n # velocity vector magnitude was zero so there should be no change in heading!\n next_heading = current_heading\n \"\"\" \n\n # angle between current vector with the next heading vector\n # from a * b = |a|*|b|cos(angle)\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\n # cross product allow us to determine rotating direction\n norm_v = np.cross(current_heading,next_heading)\n\n if norm_v > 0:\n yaw += delta_psi\n elif norm_v < 0:\n yaw -= delta_psi\n else:\n # normv = 0! if there is no change in yaw, do not modify it!\n pass\n\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\n while yaw > np.pi:\n yaw = yaw - 2*np.pi\n\n # print next_heading, current_heading, \"yaw\", yaw*180/np.pi, 'pos', pos\n current_heading = next_heading\n #print(current_heading)\n yawdot = delta_psi / 0.005 # dt is control period\n max_yawdot = 5.0 #rad/s\n if(abs(yawdot) > max_yawdot):\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\n \n yaw = np.sin(2*t)*0.0\n yawdot = 2*np.cos(2*t)*0.0\n yawddot = -4*np.sin(2*t)*0.0\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)","def acceleration(R,M,G):\r\n N = R.shape[0]\r\n a = np.zeros((N,3)) # initialize accelerations\r\n for n in range(N):\r\n for nn in range(N):\r\n if n!=nn:\r\n a[n,:] += G*M[nn] * (R[nn,:]-R[n,:]) / util.enod(R[nn,:],R[n,:])**(3) \r\n return a","def __call__(self, t, y):\n # State vector is [T, Y_1, Y_2, ... Y_K]\n self.gas.set_unnormalized_mass_fractions(y[1:])\n self.gas.TP = y[0], self.P\n rho = self.gas.density\n\n wdot = self.gas.net_production_rates\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\n dTdt = (self.tin-self.gas.T)/self.tres + \\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\n return np.hstack((dTdt, dYdt))","def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\n z_pos = self.ar_tag_pos[2]\n # print(x_pos,y_pos)\n # raise NotImplementedError\n return np.array([x_pos,y_pos,z_pos])","def trajectory(self):\n traj = np.zeros((2, self.times.size))\n for t, time in enumerate(self.times):\n traj[:, t] = self.center_of_mass(time)\n return traj","def air_exchange(self, room: Room, time: float) -> _VectorisedFloat:\n return 0.","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def accelerometer(self):\n accel = [0,0,0]\n accel[X] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_X_H_A) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_X_L_A), 16)\n accel[Y] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Y_H_A) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_Y_L_A), 16)\n accel[Z] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Z_H_A) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_Z_L_A), 16)\n\n for i in range(X, Z+1):\n self._accel[i] = accel[i] / math.pow(2, 15) * ACCEL_SCALE\n\n return vector(self._accel)","def acceleration(degrees, finalSpeed, steering = 0, robot = MoveSteering(OUTPUT_A, OUTPUT_B), motorA = LargeMotor(OUTPUT_A)): # Function to accelerate while moving so the robot can get traction before moving fast\n\n motorA.reset() #reseting how many degrees the robot has moved\n motorA.position = 0 # setting how many degrees the robot has moved\n\n accelerateDegree = degrees * 0.8\n # declerationDegree = degrees * 0.2'\n speed = 0 #starting speed\n while motorA.position < degrees and False == Constants.STOP: #while the robot hasen't moved the target amount of degree's(distance)\n if motorA.position < accelerateDegree and False == Constants.STOP: \n if speed < finalSpeed: # while the robot hasen't accelerated to the target speed\n speed += 5 #speed up\n robot.on(steering = steering, speed = speed) # Start Moving\n sleep(0.1) #wait so that it doesn't accelerate immidiatly\n else:\n robot.on(steering = steering, speed = finalSpeed)# otherwise just keep moving\n sleep(0.01)\n elif False == Constants.STOP:\n if speed > 10:\n speed -= 5\n robot.on(steering = steering, speed = speed)\n sleep(0.05)\n else:\n robot.on(steering = steering, speed = speed)\n sleep(0.01)\n \n robot.off() # Stop Moving","def evaluate(self, _t):\n\n temp = self.init_temp - (self.decay*_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def forward_kinematics(self):\n temp_T = Matrix.eye(3)\n for i in range(len(self.lengths)):\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\n temp_T = temp_T * angle_mat * len_mat\n \n self.final_T = np.array(temp_T,dtype=float)\n \n return self.final_T","def est_am(t,y):\n ch=t>t_eq\n y1=y[ch]\n return y1[-1]-y1[0]","def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\n while theta_t_1 is None:\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\n while theta_t is None:\n theta_t = self.get_ik(self.target_position(t))\n \n # we said you shouldn't simply take a finite difference when creating\n # the path, why do you think we're doing that here?\n point.positions = theta_t\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\n\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\n vel_t_curr = (theta_t - theta_t_1) / delta_t\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\n\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\n # if t >= 3.:\n # import pdb; pdb.set_trace()\n else:\n point.positions = self.target_position(t)\n point.velocities = self.target_velocity(t)\n point.accelerations = self.target_acceleration(t)\n point.time_from_start = rospy.Duration.from_sec(t)\n return point","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def simulate_system(self, state, input, time_step = 0.01):\n\n #set arm position to x\n self.arm.reset(q=state[0:3],dq=state[3:6])\n\n #apply the control signal\n self.arm.apply_torque(input,time_step)\n\n #get the next step from the arm \n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\n\n return xnext","def predict(self, t : float) -> vector :\n '''@ Zstar : vector'''\n '''@ dt : float'''\n '''@ dtau : float'''\n '''@ F : array'''\n dt = t - self.t\n dtau = self._normalizeDeltaTime(dt)\n F = self.stateTransitionMatrix(self.order+1, dtau)\n Zstar = F @ self.Z;\n return Zstar;","def calculate_timestep(self, control_inputs):\r\n rcs_disp = [0, 0]\r\n if control_inputs[4]:\r\n if control_inputs[0]: rcs_disp[0] += 1\r\n if control_inputs[1]: rcs_disp[0] -= 1\r\n if control_inputs[2]: rcs_disp[1] += 1\r\n if control_inputs[3]: rcs_disp[1] -= 1\r\n else:\r\n if control_inputs[0]:\r\n self.delta_v += self.accel*0.1\r\n self.thrust_angle = self.heading\r\n if control_inputs[1]:\r\n self.delta_v -= self.accel*0.1\r\n self.thrust_angle = self.heading\r\n if control_inputs[3]: self.delta_omega += self.accel*0.1\r\n if control_inputs[2]: self.delta_omega -= self.accel*0.1\r\n if control_inputs[5]:\r\n self.delta_omega *= 0.5\r\n self.delta_v *= 0.5\r\n if control_inputs[0] == False and control_inputs[1] == False:\r\n self.delta_v = 0\r\n if control_inputs[3] == False and control_inputs[2] == False:\r\n self.delta_omega = 0\r\n \r\n self.vel += self.delta_v\r\n self.omega += self.delta_omega\r\n if self.vel > 5: self.vel = 5\r\n if self.vel < -5: self.vel = -5\r\n if self.omega > 5: self.omega = 5\r\n if self.omega < -5: self.omega = -5\r\n if abs(self.vel) < 0.1: self.vel = 0\r\n if abs(self.omega) < 0.1: self.omega = 0\r\n if control_inputs[6]:\r\n self.vel = self.vel*0.9\r\n self.omega = self.omega*0.9\r\n self.heading += self.omega*self.time_step\r\n self.position[0] += (\r\n self.vel*self.time_step*cos(-radians(self.thrust_angle))\r\n + rcs_disp[0]*cos(-radians(self.heading))\r\n - rcs_disp[1]*sin(-radians(self.heading)))\r\n self.position[1] += (\r\n self.vel*self.time_step*sin(-radians(self.thrust_angle))\r\n + rcs_disp[0]*sin(-radians(self.heading))\r\n -rcs_disp[1]*cos(-radians(self.heading)))\r\n return self.position, self.vel, self.heading, self.omega, self.thrust_angle","def integrate(self, dt):\n f = lambda t, y: self.Cm * (np.dot(self.phi, self.activation(y)) + np.dot(self.phi_input, self.activation(self.input)) - self.Gm * y)\n self.Vm = rk4(self.t, self.Vm, self.t + dt, f)","def UpdateCromer(self, deltaT):\n self.velocity += self.acceleration * deltaT\n self.position += self.velocity * deltaT","def rk4(self, t, h,G) :\r\n k1 = h*self.calc_diff_eqn(t, self.quant_vec,G,self.mass_vec)\r\n k2 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k1 ,G, self.mass_vec)\r\n k3 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k2 ,G, self.mass_vec)\r\n k4 = h*self.calc_diff_eqn(t + h , self.quant_vec + k3 ,G, self.mass_vec)\r\n y_new = self.quant_vec + ((k1 + 2*k2 + 2*k3 + k4)/6)\r\n return y_new","def update_rk3(self, delta_t=None):\n\n delta_t = delta_t or self.delta_t\n\n try:\n\n kap1 = (self.vel, self.force(self.pos,\n self.vel,\n self.time))\n\n pos = self.pos+0.5*delta_t*kap1[0]\n vel = self.vel+0.5*delta_t*kap1[1]\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n 0.5*delta_t, drag=False)\n\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\n\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\n\n self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\n\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\n\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\n vel, self.vel,\n delta_t, drag=False)\n\n except Collision.CollisionException as col:\n col.vel = self.vel+col.delta_t*kap1[0]\n raise col\n\n self.time += self.delta_t","def path(e,a,q,i,period, timediff, offset):\n b = a*np.sqrt(1-e**2)\n c=np.sqrt(a**2-b**2)\n #t = ((timediff*np.pi*b)/period)\n #t1 = ((timediff)*np.pi*b)/period\n #print(t1-t)\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\n #print(t)\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\n theta=0 #need a real theta value \n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\n \n \n return xcoord, ycoord, zcoord"],"string":"[\n \"def target_acceleration(self, time):\\n x_a = -self.w**2*self.r*sin(self.w*time)\\n y_a = -self.w**2*self.r*cos(self.w*time)\\n z_a = 0\\n # raise NotImplementedError\\n return np.array([x_a,y_a,z_a])\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def get_acceleration(self,v,el,T_s,T_i):\\n\\n rad = radiation.Radiation()\\n T_atm = rad.getTemp(el)\\n p_atm = rad.getPressure(el)\\n rho_atm = rad.getDensity(el)\\n g = rad.getGravity(el)\\n\\n\\n rho_int = p_atm/(self.Rsp_air*T_i) # Internal air density\\n\\n Cd = .5 # Drag Coefficient\\n F_b = (rho_atm - rho_int)*self.vol*g # Force due to buyoancy\\n F_d = Cd*(0.5*rho_atm*math.fabs(v)*v)*self.cs_area# Force due to Drag\\n\\n if F_d > 0:\\n F_d = F_d * self.Upsilon\\n vm = (self.massEnv + self.mp) + rho_atm*self.vol + self.vm_coeff*rho_atm*self.vol #Virtual Mass\\n accel = ((F_b - F_d - (self.massEnv + self.mp)*g)/vm)\\n\\n return accel\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def target_acceleration(self, time):\\n return self.target(time, self.accelerations, self.dt, self.num_way)\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def eval_accel(self,t,endBehavior='halt') -> Vector:\\n res = Trajectory.deriv_state(self,t,endBehavior)\\n return res[len(res)//2:]\",\n \"def target_acceleration(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_acceleration(path_time)\",\n \"def target_acceleration(self, time):\\n return np.array([0, 0, 0])\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def acceleration(self):\\n ux,uy = np.gradient(self._obj['u'],self._obj['x'],self._obj['y'],axis=(0,1))\\n vx,vy = np.gradient(self._obj['v'],self._obj['x'],self._obj['y'],axis=(0,1))\\n \\n ax = self._obj['u']*ux + self._obj['v']*uy\\n ay = self._obj['u']*vx + self._obj['v']*vy\\n\\n self._obj['w'] = xr.DataArray(np.sqrt(ax**2+ay**2), dims=['x', 'y','t'])\\n\\n if len(self._obj.attrs['units']) == 4:\\n vel_units = self._obj.attrs['units'][-1]\\n self._obj.attrs['units'].append(f'{vel_units}^2')\\n else:\\n vel_units = self._obj.attrs['units'][-2]\\n self._obj.attrs['units'][-1] = (f'{vel_units}^2')\\n\\n\\n return self._obj\",\n \"def to_cart(self, t):\\n # mean motion:\\n n = np.sqrt(self.GM / self.a / self.a / self.a) * 86400.0 # [rad/day]\\n # mean anomaly at t:\\n M = n * (t - self.t0) + self.M0\\n # print(np.fmod(M, 2*np.pi))\\n # solve Kepler equation, get eccentric anomaly:\\n E = self.kepler(self.e, M)\\n cosE = np.cos(E)\\n sinE = np.sin(E)\\n # get true anomaly and distance from focus:\\n sinv = np.sqrt(1.0 - self.e ** 2) * sinE / (1.0 - self.e * cosE)\\n cosv = (cosE - self.e) / (1.0 - self.e * cosE)\\n r = self.a * (1.0 - self.e ** 2) / (1.0 + self.e * cosv)\\n # r = self.a*(1 - self.e*cosE)\\n #\\n sinw = np.sin(self.w)\\n cosw = np.cos(self.w)\\n sinu = sinw * cosv + cosw * sinv\\n cosu = cosw * cosv - sinw * sinv\\n # position\\n cosNode = np.cos(self.Node)\\n sinNode = np.sin(self.Node)\\n cosi = np.cos(self.i)\\n sini = np.sin(self.i)\\n x = r * (cosu * cosNode - sinu * sinNode * cosi)\\n y = r * (cosu * sinNode + sinu * cosNode * cosi)\\n z = r * sinu * sini\\n # velocity\\n p = self.a * (1.0 - self.e ** 2)\\n V_1 = np.sqrt(self.GM / p) * self.e * sinv\\n V_2 = np.sqrt(self.GM / p) * (1.0 + self.e * cosv)\\n vx = x * V_1 / r + (-sinu * cosNode - cosu * sinNode * cosi) * V_2\\n vy = y * V_1 / r + (-sinu * sinNode + cosu * cosNode * cosi) * V_2\\n vz = z * V_1 / r + cosu * sini * V_2\\n\\n state = np.array([x, y, z, vx, vy, vz])\\n state = np.reshape(np.asarray(state), (3, 2), 'F')\\n\\n return state\",\n \"def acceleration(self):\\n return self.__accel\",\n \"def get_rotationalAngularPosition(self, t): # returns [rad]\\n angle = self.theta0 + self.rotationalAngularVelocity * t # angular position [rad]\\n return angle\",\n \"def acceleration(data_array, time=1):\\n speed = DataOperation.speed(data_array)\\n acc_values = np.zeros(speed.size)\\n count = 1\\n acc_values[0] = 0\\n for d in speed[1:]:\\n acc_values[count] = (d - speed[count-1])/3.6/time\\n count += 1\\n return acc_values\",\n \"def thetas (self,lag):\\n tanthetas = [0,0,0]\\n for k in range(3,self.n):\\n tantheta_k = (self.radii[k-3] - self.radii[k-1])/((self.v2+self.v1)/self.v2* lag[k-1] + (self.v1/self.v2-1)*lag[k])\\n tanthetas.append(tantheta_k)\\n return np.arctan(tanthetas) # maybe no need for arctan with such small angles\",\n \"def _compute_solar_torque(self):\\n pass\",\n \"def acc(x: float, v: float, t: float) -> float:\\n return -k*v - np.sin(x) + c*np.cos(omega*t)\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def compute_acceleration(self, x, y):\\n a_x = G * self.m / (x*x + y*y) * -x/(np.sqrt(x*x + y*y))\\n a_y = G * self.m / (x*x + y*y) * -y/(np.sqrt(x*x + y*y))\\n return np.array([a_x, a_y])\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def target_acceleration(self, time):\\n pass\",\n \"def get_acceleration(self):\\n return self.acceleration\",\n \"def euler_cromer_approx(theta_0, omega_0, dt, T_i):\\n theta=np.zeros(samples)\\n omega=np.zeros(samples)\\n t=np.zeros(samples)\\n theta[0]=theta_0\\n omega[0]=omega_0\\n t[0]=T_i\\n\\n for n in range(1,samples):\\n \\\"\\\"\\\"\\n calculates new value for omega using old value of theta and omega\\n \\\"\\\"\\\"\\n omega[n]=omega[n-1]-g/l*theta[n-1]*dt\\n \\n \\\"\\\"\\\"\\n Calculates new theta using new omega and old theta\\n \\\"\\\"\\\"\\n theta[n]=theta[n-1]+omega[n]*dt\\n \\n \\\"\\\"\\\"\\n Time array in same dimension for ploting\\n \\\"\\\"\\\"\\n t[n]=t[n-1]+dt\\n \\n \\n \\\"\\\"\\\"\\n theta: array with values of angular displacement\\n w: array with values of angular velocity\\n t: array with time-values\\n \\\"\\\"\\\"\\n return theta,omega,t\",\n \"def get_current_thrust_direction(self,\\n time: float) -> np.array:\\n # Interpolate with time\\n angle = self.thrust_angle_interpolator.interpolate(time)\\n # Set thrust in vertical frame and transpose it\\n thrust_direction_vertical_frame = np.array([[0, np.sin(angle), - np.cos(angle)]]).T\\n # Update flight conditions (this is needed to let tudat know to update all variables)\\n self.vehicle_body.flight_conditions.update_conditions(time)\\n # Get aerodynamic angle calculator\\n aerodynamic_angle_calculator = self.vehicle_body.flight_conditions.get_aerodynamic_angle_calculator()\\n # Retrieve rotation matrix from vertical to inertial frame from the aerodynamic angle calculator\\n vertical_to_inertial_frame = aerodynamic_angle_calculator.get_rotation_matrix_between_frames(\\n frames.AerodynamicsReferenceFrames.vertical_frame,\\n frames.AerodynamicsReferenceFrames.inertial_frame)\\n # Compute the thrust in the inertial frame\\n thrust_inertial_frame = np.dot(vertical_to_inertial_frame,\\n thrust_direction_vertical_frame)\\n return thrust_inertial_frame\",\n \"def advanceVelocity(self,time,acceleration):\\n if not isinstance(acceleration,Cartesian3DVector):\\n raise CoordinateException(\\\"Advancing particle momentum with the incorrect acceleration type.\\\")\\n return self.v + time*acceleration\",\n \"def calculate_acceleration(self) -> np.array:\\n F = self.calculate_net_force()\\n m = self.mass\\n a = F / m\\n\\n return a\",\n \"def position(x,v,t,a):\\n return x + v*t + 0.5*a*t**2 # pos = initial position + velocity*time + .5(acceleration)(time squared)\",\n \"def omega(x):\\n # if ramp_start_time - ramp_constant_time <= x <= end_ramp_end_time + ramp_constant_time:\\n # f_t0 = smooth_factor * (x - ramp_start_time)\\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\\n # if ramp_mode == 'with_end_acc':\\n # f_t2 = smooth_factor * (x - steady_end_time)\\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\\n # elif ramp_mode == 'no_end_acc':\\n # f_t2 = smooth_factor * ramp_start_time\\n # f_t3 = smooth_factor * i_ramp_end_time\\n\\n # omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\\n # else:\\n # if bstroke == 'yes' and x <= 2 * (end_ramp_end_time +\\n # ramp_constant_time):\\n # x -= end_ramp_end_time + ramp_constant_time\\n # f_t0 = smooth_factor * (x - ramp_start_time)\\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\\n # if ramp_mode == 'with_end_acc':\\n # f_t2 = smooth_factor * (x - steady_end_time)\\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\\n # elif ramp_mode == 'no_end_acc':\\n # f_t2 = smooth_factor * ramp_start_time\\n # f_t3 = smooth_factor * i_ramp_end_time\\n\\n # omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\\n # logcosh(f_t2))\\n # else:\\n # omegax = 0\\n\\n if bstroke == 'no':\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\\n\\n else:\\n if x <= end_ramp_end_time + ramp_constant_time:\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = (ramp_stage_acceleration /\\n 2) / smooth_factor * (logcosh(f_t0) - logcosh(f_t1) +\\n logcosh(f_t3) - logcosh(f_t2))\\n\\n else:\\n x -= end_ramp_end_time + ramp_constant_time\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\\n logcosh(f_t2))\\n\\n return omegax\",\n \"def acceleration(self):\\n # speed is by formula: x axis speed: by cos of the heading and y\\n # axis by sine of the heading\\n self.x_speed += math.cos(math.radians(self.degrees))\\n self.y_speed += math.sin(math.radians(self.degrees))\",\n \"def analyticalLinearSol(self, t):\\n return self.c*t + self.I\",\n \"def target_velocity(self, time):\\n\\n x_v = self.w*self.r*cos(self.w*time)\\n y_v = -self.w*self.r*sin(self.w*time)\\n z_v = 0\\n # raise NotImplementedError\\n return np.array([x_v,y_v,z_v])\",\n \"def speed(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.velocity(rf), t.velocity(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def get_D_C3H8_air(self, T):\\n\\n self.set_TempPres_dependents(T)\\n\\n self.D_C3H8_air = (\\n 2. / 3. * np.sqrt(const.k_B * T / np.pi * 0.5 * (1. /\\n self.air.m + 1. / self.fuel.m)) / (np.pi * (0.5 *\\n (self.air.d + self.fuel.d)) ** 2.) / self.air.n\\n )\\n\\n return self.D_C3H8_air\",\n \"def _acceleration(data):\\n\\n # intermediate values\\n sumcube_resids = ((data.mean() - data)**3).sum()\\n\\n # dodge the ZeroDivision error\\n sumsqr_resids = max(((data.mean() - data)**2).sum(), 1e-12)\\n\\n # compute and return the acceleration\\n return sumcube_resids / (6 * sumsqr_resids**1.5)\",\n \"def anl_solution(self):\\r\\n\\r\\n m = float(self.mass) / self.nu_m\\r\\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\\\\r\\n / float(self.size_tick * self.size_tick)\\r\\n print 'qE=', qe\\r\\n c = self.light_vel\\r\\n for i in range(0, len(self.obs.obt_g)):\\r\\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\\r\\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\\r\\n * c)) ** 2) - 1.0)\\r\\n self.xa_track.append(x)\\r\\n p = qe * self.t[i]\\r\\n self.pa.append(p)\\r\\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\\r\\n jv = self.t[i] * qe / (m * c)\\r\\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\\r\\n self.va.append(v)\\r\\n print 'Analytical solution of the differential equation of motion'\",\n \"def robot_arm_acc(self):\\n return self.sim.data.qacc[self.arm_index]\",\n \"def thetacm(t):\\n return np.array([\\n 0,\\n 0,\\n self.wz * t\\n ])\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def _get_alpha(self, m_t, v_t):\\n return max(0, ((-m_t * self._psi \\n + math.sqrt((m_t ** 2 * self._phi ** 4) \\n / 4 + v_t * self._phi ** 2 * self._xi)) \\n / (v_t * self._xi)))\",\n \"def calc_accel(vel_data, dt):\\n\\n ax = np.gradient(vel_data[:, 0], dt)\\n ay = np.gradient(vel_data[:, 1], dt)\\n\\n return np.c_[ax, ay]\",\n \"def M31Accel(self,r):\\n\\n ### Call the previous functions for the halo, bulge and disk\\n halo_acc = self.HernquistAccel(self.Mhalo,self.rhalo,r) #Calculating halo acceleration\\n bulge_acc = self.HernquistAccel(self.Mbulge,self.rbulge,r) #\\\"\\\"\\\" bulge \\\"\\\"\\\"\\n disk_acc = self.MiyamotoNagaiAccel(self.Mdisk,self.rdisk,r)#\\\"\\\"\\\" disk \\\"\\\"\\\"\\n sum1 = np.add(halo_acc,bulge_acc) #summing halo and bulge first\\n acc_sum = np.add(sum1,disk_acc) #then adding disk acceleration\\n\\n return acc_sum\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def clAlphaT(self):\\n A = 2 * pi * self.aspectRatioT\\n B = (self.aspectRatioT * self.betaT / self.airfoilEffT)**2\\n C = 1 + ((tan(radians(self.sweep50T)))**2) / (self.betaT**2)\\n return A / (2 + sqrt(4 + B * C))\",\n \"def get_rotation(self) -> np.array:\\n axis = self.get_arms()[1]\\n force = [self.d_x, self.d_y] # \\\"Force applied on the arm\\\"\\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\\n if torque == 1: # Anti clockwise rotation\\n rotation = np.array([[0, -1], [1, 0]])\\n if torque == -1: # Clockwise rotation\\n rotation = np.array([[0, 1], [-1, 0]])\\n if torque == 0: # No rotation\\n rotation = np.array([[0, 0], [0, 0]])\\n return rotation\",\n \"def acceleration_double_pendulum(t, state, kwargs, g = 9.81):\\n theta = [ state[0], state[1] ]\\n omega = [ state[2], state[3] ]\\n M, L = kwargs['M'], kwargs['L']\\n Mt = M[0] + M[1]\\n \\n denominator = 2 * M[0] + M[1] - M[1] * cos( 2 * theta[0] - 2 * theta[1])\\n sin_delta = sin( theta[0] - theta[1] )\\n cos_delta = cos( theta[0] - theta[1] )\\n d_state = [ 0, 0, 0, 0 ]\\n \\n d_state[2] = - g * (Mt + M[0]) * sin(theta[0]) + M[1] * g * sin(theta[0] - 2*theta[1])\\n d_state[2] -= 2 * sin_delta * M[1] * (L[1]*omega[1]**2 + L[0] * cos_delta * omega[0]**2)\\n d_state[2] /= L[0] * denominator \\n \\n d_state[3] = L[0] * Mt * omega[0]**2 + g * Mt * cos(theta[0])\\n d_state[3] += L[1] * M[1] * cos_delta * omega[1]**2\\n d_state[3] *= 2 * sin_delta / ( L[1] * denominator )\\n \\n d_state[0] = omega[0] \\n d_state[1] = omega[1] \\n \\n return np.asarray(d_state)\",\n \"def get_action(self):\\n # Actual q and dq\\n contacts = np.array(\\n [(leg_state in (gait_generator_lib.LegState.STANCE,\\n gait_generator_lib.LegState.EARLY_CONTACT))\\n for leg_state in self._gait_generator.desired_leg_state],\\n dtype=np.float64)\\n foot_positions = self._robot.GetFootPositionsInBaseFrame()\\n\\n robot_com_height = self._estimate_robot_height(contacts, foot_positions)\\n robot_com_velocity = self._state_estimator.com_velocity_body_frame\\n robot_com_roll_pitch_yaw = np.array(self._robot.GetBaseRollPitchYaw())\\n robot_com_roll_pitch_yaw[2] = 0. # To prevent yaw drifting\\n robot_com_roll_pitch_yaw_rate = self._robot.GetBaseRollPitchYawRate()\\n robot_q = np.hstack(([0., 0., robot_com_height], robot_com_roll_pitch_yaw))\\n robot_dq = np.hstack((robot_com_velocity, robot_com_roll_pitch_yaw_rate))\\n # Desired q and dq\\n desired_com_position = np.array((0., 0., self._desired_body_height),\\n dtype=np.float64)\\n desired_com_velocity = np.array(\\n (self.desired_speed[0], self.desired_speed[1], 0.), dtype=np.float64)\\n desired_com_roll_pitch_yaw = np.array((0., 0., 0.), dtype=np.float64)\\n desired_com_angular_velocity = np.array(\\n (0., 0., self.desired_twisting_speed), dtype=np.float64)\\n desired_q = np.hstack((desired_com_position, desired_com_roll_pitch_yaw))\\n desired_dq = np.hstack(\\n (desired_com_velocity, desired_com_angular_velocity))\\n # Desired ddq\\n desired_ddq = KP * (desired_q - robot_q) + KD * (desired_dq - robot_dq)\\n desired_ddq = np.clip(desired_ddq, MIN_DDQ, MAX_DDQ)\\n contact_forces = self._qp_torque_optimizer.compute_contact_force(\\n foot_positions, desired_ddq, contacts=contacts)\\n\\n action = {}\\n for leg_id, force in enumerate(contact_forces):\\n # While \\\"Lose Contact\\\" is useful in simulation, in real environment it's\\n # susceptible to sensor noise. Disabling for now.\\n # if self._gait_generator.leg_state[\\n # leg_id] == gait_generator_lib.LegState.LOSE_CONTACT:\\n # force = (0, 0, 0)\\n motor_torques = self._robot.MapContactForceToJointTorques(leg_id, force)\\n for joint_id, torque in motor_torques.items():\\n action[joint_id] = (0, 0, 0, 0, torque)\\n return action, contact_forces\",\n \"def OrbitPos(self, rv, t, m):\\n \\n params = np.array(rv)\\n params = params.flatten()\\n \\n def GravityODE(rv,t):\\n G = 6.67e-11\\n m = 5.972e24\\n x = rv[0]\\n y = rv[1]\\n vx = rv[2]\\n vy = rv[3]\\n \\n dvydt = -((G*m*y)/((x**2+y**2)**(3/2)))\\n dvxdt = -((G*m*x)/((x**2+y**2)**(3/2)))\\n dxdt = vx\\n dydt = vy\\n\\n pos_derivs = np.array([dxdt,dydt])\\n v_deriv = np.array([dvxdt,dvydt])\\n derivs = np.hstack((pos_derivs,v_deriv))\\n \\n return derivs \\n \\n satellite_orbit = integrate.odeint(GravityODE,params,t)\\n \\n return satellite_orbit[:,0],satellite_orbit[:,1]\",\n \"def lerp(self, t):\\n a = self.a0 + t * self.da\\n return self.c + Vector((self.r * cos(a), self.r * sin(a)))\",\n \"def TimeEvolution(w: np.ndarray, t: float):\\n # pylint: disable=expression-not-assigned\\n n_modes = len(w)\\n\\n @operation(n_modes)\\n def op(q):\\n\\n theta = -w * 100.0 * c * 1.0e-15 * t * (2.0 * pi)\\n\\n for i in range(n_modes):\\n sf.ops.Rgate(theta[i]) | q[i]\\n\\n return op()\",\n \"def rcm(t):\\n x0 = 0 # initial position\\n return np.array([\\n 0,\\n 0,\\n x0 + self.v0x * t + 1 / 2 * self.ax * t ** 2\\n ])\",\n \"def rhs(x, t):\\n\\n return - np.sin(np.pi * x) * (np.sin(t) - 1 * np.pi ** 2 * np.cos(t))\",\n \"def compute_acceleration(energy, sigma, r):\\n return 0.5 * -LJForce(energy, sigma, magnitude(r)) * (r/magnitude(r))\",\n \"def get_trajectory(h, launch_speed, launch_angle):\\n\\n v0 = launch_speed\\n theta = mp.radians(launch_angle)\\n\\n N = 100000\\n tgrid, dt = np.linspace(0, 15000, N, retstep=True)\\n tr = np.empty((N,2))\\n v = np.empty((N,2))\\n # Initial rocket position, velocity and acceleration\\n tr[0] = 0, R + h\\n v[0] = v0 * np.sin(theta), v0 * np.cos(theta)\\n a = calc_a(tr[0])\\n\\n for i, t in enumerate(tgrid[1:]):\\n # Calculate the rocket's next position based on its instantaneous velocity.\\n \\n r = tr[i] + v[i] * dt \\n \\n if np.hypot(*r) < R:\\n # Our rocket crashed.\\n break\\n # Update the rocket's position, velocity and acceleration.\\n tr[i+1] = r\\n v[i+1] = v[i] + a*dt\\n a = calc_a(tr[i+1])\\n return tr[:i+1]\",\n \"def integrate(self, t):\\n t0 = self.t0\\n if t-t0 <= self.max_step_size:\\n self.y0 = self.y0 + (t-t0)*self.f(t0,self.y0) \\n \\n else :\\n n = (t-t0) / self.max_step_size\\n dt = (t-t0)/int(n+1)\\n \\n while t0 < t :\\n self.y0 = self.y0 + dt*self.f(t0,self.y0)\\n t0 += dt\\n \\n return self.y0\",\n \"def path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def update_ab3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 2:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = -(1.0/6.0)*delta_t*(delta_t*(5.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*delta_t*(delta_t*(2.0*delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n\\n pos = self.pos+(delta_t-beta-gamma)*self.vel+beta*self.get_old(0, 0)+gamma*self.get_old(1, 0)\\n vel = self.vel+(delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(1, 1)\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = -(1.0/6.0)*col.delta_t*(col.delta_t*(5.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(0, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n gamma = (1.0/6.0)*col.delta_t*(col.delta_t*(2.0*col.delta_t+3.0*(self.time-self.get_old(0, 2)))\\n /((self.time-self.get_old(1, 2))*(self.get_old(0, 2)-self.get_old(1, 2))))\\n vel = self.vel+(col.delta_t-beta-gamma)*kap[1]+beta*self.get_old(0, 1)+gamma*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.set_old(kap, 2)\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using Adams Bashforth 2nd order method for the second timestep:\\n\\n try:\\n tmp = [self.get_old(0)]\\n except IndexError:\\n tmp = []\\n kap = update_ab2(self)\\n if tmp:\\n self._old = self._old + tmp\\n\\n return kap\",\n \"def update_apc11(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n pos = self.pos+delta_t*self.vel\\n vel = self.vel+delta_t*kap[1]\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n force = self.force(pos,\\n vel,\\n self.time+delta_t, drag=False)\\n\\n pos = self.pos+delta_t*vel\\n vel = self.vel+delta_t*force\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n\\n try:\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n vel = self.vel+col.delta_t*kap[1]\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest = True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n \\n self.time += delta_t\\n\\n return (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\",\n \"def _k(self, T):\\n RT = Rgas * T\\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))\",\n \"def objective_function(T_cr: np.ndarray) -> np.ndarray:\\n \\n Tm = (T_r + T_cr)/2.0\\n ks = thermal_conductivity(Tm)\\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\\n \\n return np.linalg.norm(T_cr_update - T_cr,ord = 1)\",\n \"def update_apc23(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n if len(self._old) >= 1:\\n\\n\\n try:\\n\\n kap = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time, drag=False), self.time)\\n\\n beta = 0.5*self.delta_t/(self.time-self.get_old(0, 2))\\n\\n pos = self.pos+delta_t*((1+beta)*self.vel-beta*self.get_old(0, 0))\\n vel = self.vel+delta_t*((1+beta)*kap[1]-beta*self.get_old(0, 1))\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(self.pos, self.vel, self.time, delta_t)\\n\\n\\n beta1 = (3.0*(self.time-self.get_old(0,2))+delta_t)/(6.0*self.time-self.get_old(0,2))\\n beta2 = -delta_t**2/(6.0*(self.time+delta_t-self.get_old(0,2))*(self.time-self.get_old(0,2)))\\n\\n print self.force(pos, vel, self.time+delta_t), kap[1], self.get_old(0,1)\\n\\n pos = self.pos+delta_t*((1.0-beta1-beta2)*vel+beta1*self.vel+beta2*self.get_old(0, 0))\\n vel = self.vel+delta_t*((1.0-beta1-beta2)*self.force(pos, vel, self.time+delta_t,\\n drag=False)+beta1*kap[1]+beta2*self.get_old(0,1))\\n\\n for cback in self.pos_callbacks:\\n pos += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n for cback in self.vel_callbacks:\\n vel += delta_t*cback(pos, vel, self.time+delta_t, delta_t)\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=True)\\n except Collision.CollisionException as col:\\n beta = 0.5*col.delta_t/(self.time-self.get_old(0, 2))\\n vel = self.vel+col.delta_t*(1+beta)*kap[1]-beta*self.get_old(0, 1)\\n C, fvel = self.drag_coefficient(col.pos, vel, self.time+col.delta_t, nearest=True)\\n col.vel = (self.vel+col.delta_t*(kap[1]+C*fvel))/(1.0+col.delta_t*C)\\n raise col\\n\\n self.time += delta_t\\n\\n else:\\n ## reduced to using the Adams first order method for the first timestep:\\n\\n kap = update_apc1(self)\\n\\n self.set_old(kap, 1)\\n\\n return kap\",\n \"def acceleration_sensor(axis):\\n\\n\\tsensor_name = \\\"baseBoard\\\"\\n\\treg_addr = 24\\n\\tdata_len = 56\\n\\tregist_sensor(sensor_name, reg_addr, data_len)\\n\\n\\t#get sensor data\\n\\tdata = rospy.wait_for_message('MediumSize/SensorHub/Imu', Imu, 2)\\n\\tacceleration = data.linear_acceleration\\n\\tif axis == \\\"x\\\":\\n\\t\\tresult = acceleration.x\\n\\telif axis == \\\"y\\\":\\n\\t\\tresult = acceleration.y\\n\\telse:\\n\\t\\tresult = acceleration.z\\n\\n\\tdelete_sensor(sensor_name)\\n\\treturn result\",\n \"def update(self, tfinal):\\n t = 0; kk = 0\\n nstep = int(np.round(tfinal/self.dt))+1 # number of time steps\\n self.omega = np.zeros((nstep,self.npts))\\n self.theta = np.zeros((nstep,self.npts))\\n\\n while t <(tfinal+1e-10):\\n self.return_map()\\n self.omega[kk] = self.y[0]\\n self.theta[kk] = self.y[1]\\n\\n self.y = RK4(self.y, self.dt, t, self.deri)\\n kk += 1; t += self.dt\\n\\n return self\",\n \"def t2x(self, t ):\\n \\n # Find time index\\n i = (np.abs(self.t_sol - t)).argmin()\\n \\n # Find associated control input\\n x = self.x_sol[i,:]\\n \\n return x\",\n \"def euler_cromer_method(theta_0, omega_0, dt, T_i):\\n theta=np.zeros(samples)\\n omega=np.zeros(samples)\\n t=np.zeros(samples)\\n theta[0]=theta_0\\n omega[0]=omega_0\\n t[0]=T_i\\n\\n for n in range(1,samples):\\n \\\"\\\"\\\"\\n calculates new value for omega using old value of theta and omega\\n \\\"\\\"\\\"\\n omega[n]=omega[n-1]-g/l*np.sin(theta[n-1])*dt\\n \\n \\\"\\\"\\\"\\n calculates new value of omega by new omega and old theta\\n \\\"\\\"\\\"\\n theta[n]=theta[n-1]+omega[n]*dt\\n \\n \\\"\\\"\\\"\\n time erray of same dimenion as earlier arrays\\n \\\"\\\"\\\"\\n t[n]=t[n-1]+dt\\n \\n \\n \\\"\\\"\\\"\\n theta: array with values of angular displacement\\n w: array with values of angular velocity\\n t: array with time-values\\n \\\"\\\"\\\"\\n return theta,omega,t\",\n \"def computeTrajectoryWithDecceleration(self, cmd_vel, current_speed, delay_time, time_applied, time_decc):\\n accs = [self.robot.acc_x, self.robot.acc_th, self.robot.dacc_x,self.robot.dacc_th ]\\n\\n #project forwards in time\\n sim_interval = self.sim_interval\\n sim_interval_sq = sim_interval*sim_interval\\n cmd_vel = list(cmd_vel)\\n current_speed = list(current_speed)\\n\\n max_acc_x = self.robot.max_acc_x\\n max_acc_th = self.robot.max_acc_th\\n max_decc_x = self.robot.max_dacc_x\\n max_decc_th = self.robot.max_dacc_th\\n\\n\\n code = \\\"\\\"\\\"\\n double x, y, th;\\n x = y = th = 0;\\n\\n double vx, vth;\\n vx = current_speed[0];\\n vth = current_speed[1];\\n\\n double cmd_x = cmd_vel[0];\\n double cmd_th = cmd_vel[1];\\n\\n //are we accelerating or decelerating?\\n double acc_x;\\n double acc_th;\\n\\n bool b_ax = false;\\n if (cmd_x > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = accs[2];\\n acc_x = -1*acc_x;\\n }\\n\\n bool b_ath = false;\\n if (cmd_th > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1* (double) accs[3];\\n\\n }\\n\\n py::list traj;\\n\\n //delay at the beginning\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //application of the command\\n for (double i=0; i<=time_applied; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //delay before decellerating\\n for (double i=0; i<=delay_time; i+=sim_interval) {\\n //check if we have already attained our velocity\\n if (fabs(vx - (double) cmd_x) < 1e-6) vx = cmd_x;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > cmd_x )) vx = cmd_x;\\n if (!b_ax && (vx < cmd_x )) vx = cmd_x;\\n\\n if (fabs(vth - (double) cmd_th) < 1e-6) vth = cmd_th;\\n if (b_ath && (vth > cmd_th )) vth = cmd_th;\\n if (!b_ath && (vth < cmd_th )) vth = cmd_th;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n }\\n\\n //now we apply a stop\\n b_ax = false;\\n if (0 > vx) {\\n acc_x = accs[0];\\n b_ax = true;\\n } else {\\n acc_x = -1 * (double) accs[2];\\n }\\n\\n b_ath = false;\\n if (0 > vth) {\\n acc_th = accs[1];\\n b_ath = true;\\n } else {\\n acc_th = -1 * (double) accs[3];\\n }\\n\\n for (double i=0; i<=time_decc; i+=sim_interval) {\\n vx += acc_x*sim_interval;\\n\\n //check if we have already attained our velocity\\n if (fabs(vx) < 1e-6) vx = 0;\\n\\n //check if we have exceeded our target\\n if (b_ax && (vx > 0 )) vx = 0;\\n if (!b_ax && (vx < 0 )) vx = 0;\\n\\n vth += acc_th*sim_interval;\\n\\n if (fabs(vth) < 1e-6) vth = 0;\\n if (b_ath && (vth > 0 )) vth = 0;\\n if (!b_ath && (vth < 0 )) vth = 0;\\n\\n x += vx*cos(th)*sim_interval;\\n y += vx*sin(th)*sim_interval;\\n th += vth*sim_interval;\\n\\n py::list new_pt;\\n new_pt.append(x);\\n new_pt.append(y);\\n new_pt.append(th);\\n traj.append(new_pt);\\n\\n\\n bool stopped = (fabs(vth) < 1e-2) && (fabs(vx) < 1e-2);\\n if (stopped) break;\\n\\n }\\n\\n return_val = traj;\\n \\\"\\\"\\\"\\n traj = weave.inline(code, ['cmd_vel', 'current_speed', 'accs','sim_interval', 'delay_time', 'sim_interval_sq',\\n 'time_applied', 'max_acc_x', 'max_acc_th', 'max_decc_x', 'max_decc_th',\\n 'time_decc'], type_converters=converters.blitz)\\n\\n return traj\",\n \"def get_kappa (self, t):\\n\\n Omega, dOmega_dt = self.get_Omega(t)\\n Delta, dDelta_dt = self.get_Delta(t)\\n\\n kappa = Delta/2 + self.sign * \\\\\\n (sqrt(Delta**2 + 2*Omega**2) / 2 - sqrt(Delta**2 + Omega**2))\\n\\n return kappa\",\n \"def tidal_acc(self, xyz):\\r\\n assert(xyz.shape[1] == 3)\\r\\n\\r\\n # create solar mass variable, if not already extant\\r\\n try:\\r\\n self.M\\r\\n except AttributeError:\\r\\n self.M = Constant(2e33) # solar mass in g\\r\\n\\r\\n # get the vector of x-values\\r\\n x = xyz[:, 0]\\r\\n\\r\\n # create an all-zero force vector\\r\\n acc = np.zeros_like(xyz)\\r\\n\\r\\n # get the heliocentric distance at the current time\\r\\n dist = self.trajectory(self.t)\\r\\n\\r\\n # get the acceleration as the difference between the acceleration at\\r\\n # the points and the acceleration at the c.o.m.\\r\\n acc[:, 0] = float(self.G)*float(self.M)*(1/(dist-x)**2-1/(dist)**2)\\r\\n return(acc)\",\n \"def get_actual_air_conditioned_temperature(\\n hc_period: np.ndarray,\\n theta_ac: np.ndarray, v_supply: np.ndarray, theta_supply_h: np.ndarray, theta_supply_c: np.ndarray,\\n l_d_h: np.ndarray, l_d_cs: np.ndarray,\\n u_prt: float, a_prt: np.ndarray, a_hcz: np.ndarray, q: float) -> np.ndarray:\\n\\n rho = get_air_density()\\n c = get_specific_heat()\\n\\n a_prt = a_prt.reshape(1, 5).T\\n a_hcz = a_hcz[0:5].reshape(1, 5).T\\n\\n theta_ac_act_h = np.maximum(theta_ac + (c * rho * v_supply * (theta_supply_h - theta_ac) - l_d_h * 10 ** 6)\\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\\n\\n theta_ac_act_c = np.minimum(theta_ac - (c * rho * v_supply * (theta_ac - theta_supply_c) - l_d_cs * 10 ** 6)\\n / (c * rho * v_supply + (u_prt * a_prt + q * a_hcz) * 3600), theta_ac)\\n\\n return theta_ac_act_h * (hc_period == 'h') + theta_ac_act_c * (hc_period == 'c') + theta_ac * (hc_period == 'm')\",\n \"def get_potential(self,t):\\n grid_V = self.grid_x * (1 + self.Lambda*np.cos(self.omega*t)) * (self.grid_x >= 0)\\n grid_V += 200 * (self.grid_x < 0)\\n return grid_V\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0],\\n [0, c, -s],\\n [0, s, c]])\",\n \"def runge_integrator(self, t, y, dt, tau):\\n\\n k1 = self.plant.rhs(t, y, tau)\\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\\n return (k1 + 2 * (k2 + k3) + k4) / 6.0\",\n \"def get_angular_velocity(r, T):\\n # http://www.hep.fsu.edu/~berg/teach/phy2048/0918.pdf\\n # velocity = 2(pi)r/T\\n return (2*math.pi*r)/T\",\n \"def rotx(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])\",\n \"def generate_trajectory(t, v, waypoints, coeff_x, coeff_y, coeff_z):\\n global yaw\\n global current_heading\\n yawdot = 0.0\\n pos = np.zeros(3)\\n acc = np.zeros(3)\\n vel = np.zeros(3)\\n jerk = np.zeros(3)\\n snap = np.zeros(3)\\n yawddot = 0.0\\n\\n # distance vector array, represents each segment's distance\\n distance = waypoints[0:-1] - waypoints[1:]\\n # T is now each segment's travel time\\n T = (1.0 / v) * np.sqrt(distance[:,0]**2 + distance[:,1]**2 + distance[:,2]**2)\\n # accumulated time\\n S = np.zeros(len(T) + 1)\\n S[1:] = np.cumsum(T)\\n\\n # find which segment current t belongs to\\n t_index = np.where(t >= S)[0][-1]\\n\\n # prepare the next desired state\\n if t == 0:\\n pos = waypoints[0]\\n t0 = get_poly_cc(8, 1, 0)\\n\\n # get X-Y plane project of velocity vector ( this vector is tangent to curve )\\n v_proj = np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)])\\n if(LA.norm(v_proj) == 0.0):\\n # if velocity vector is of zero magnitude there should be no change in heading!\\n pass\\n else:\\n current_heading = v_proj/LA.norm(v_proj) * (1.0 / T[0])\\n \\n\\n # stay hover at the last waypoint position\\n elif t > S[-1]:\\n pos = waypoints[-1]\\n else:\\n # scaled time\\n scale = (t - S[t_index]) / T[t_index]\\n start = 8 * t_index\\n end = 8 * (t_index + 1)\\n\\n t0 = get_poly_cc(8, 0, scale)\\n pos = np.array([coeff_x[start:end].dot(t0), coeff_y[start:end].dot(t0), coeff_z[start:end].dot(t0)])\\n\\n t1 = get_poly_cc(8, 1, scale)\\n # chain rule applied\\n vel = np.array([coeff_x[start:end].dot(t1), coeff_y[start:end].dot(t1), coeff_z[start:end].dot(t1)]) * (1.0 / T[t_index])\\n\\n t2 = get_poly_cc(8, 2, scale)\\n # chain rule applied\\n acc = np.array([coeff_x[start:end].dot(t2), coeff_y[start:end].dot(t2), coeff_z[start:end].dot(t2)]) * (1.0 / T[t_index]**2)\\n\\n t3 = get_poly_cc(8, 3, scale)\\n # apply chain rule\\n jerk = np.array([coeff_x[start:end].dot(t3), coeff_y[start:end].dot(t3), coeff_z[start:end].dot(t3)]) * (1.0 / T[t_index]**3)\\n\\n t4 = get_poly_cc(8, 4, scale)\\n # apply chain rule\\n snap = np.array([coeff_x[start:end].dot(t4), coeff_y[start:end].dot(t4), coeff_z[start:end].dot(t4)]) * (1.0 / T[t_index]**4)\\n\\n # calculate desired yaw and yaw rate\\n\\n v_proj = np.array([vel[0], vel[1]])\\n\\n if( LA.norm(v_proj) == 0.0):\\n # if velocity vector is zero, again there should be no change in heading\\n next_heading = current_heading\\n else:\\n next_heading = v_proj/LA.norm(v_proj)\\n\\n \\\"\\\"\\\"\\n try :\\n #current_heading = v_proj/LA.norm(v_proj) #* (1.0 / T[0]) #np.array([coeff_x[0:8].dot(t0), coeff_y[0:8].dot(t0)]) * (1.0 / T[0])\\n next_heading = v_proj/LA.norm(v_proj)\\n except ZeroDivisionError:\\n # velocity vector magnitude was zero so there should be no change in heading!\\n next_heading = current_heading\\n \\\"\\\"\\\" \\n\\n # angle between current vector with the next heading vector\\n # from a * b = |a|*|b|cos(angle)\\n delta_psi = np.arccos(np.dot(current_heading, next_heading) / (LA.norm(current_heading)*LA.norm(next_heading)))\\n # cross product allow us to determine rotating direction\\n norm_v = np.cross(current_heading,next_heading)\\n\\n if norm_v > 0:\\n yaw += delta_psi\\n elif norm_v < 0:\\n yaw -= delta_psi\\n else:\\n # normv = 0! if there is no change in yaw, do not modify it!\\n pass\\n\\n # dirty hack, quadcopter's yaw range represented by quaternion is [-pi, pi]\\n while yaw > np.pi:\\n yaw = yaw - 2*np.pi\\n\\n # print next_heading, current_heading, \\\"yaw\\\", yaw*180/np.pi, 'pos', pos\\n current_heading = next_heading\\n #print(current_heading)\\n yawdot = delta_psi / 0.005 # dt is control period\\n max_yawdot = 5.0 #rad/s\\n if(abs(yawdot) > max_yawdot):\\n yawdot = (yawdot/abs(yawdot))*max_yawdot # make it 5rad/s with appropriate direction\\n \\n yaw = np.sin(2*t)*0.0\\n yawdot = 2*np.cos(2*t)*0.0\\n yawddot = -4*np.sin(2*t)*0.0\\n return DesiredState(pos, vel, acc, jerk, snap, yaw, yawdot, yawddot)\",\n \"def acceleration(R,M,G):\\r\\n N = R.shape[0]\\r\\n a = np.zeros((N,3)) # initialize accelerations\\r\\n for n in range(N):\\r\\n for nn in range(N):\\r\\n if n!=nn:\\r\\n a[n,:] += G*M[nn] * (R[nn,:]-R[n,:]) / util.enod(R[nn,:],R[n,:])**(3) \\r\\n return a\",\n \"def __call__(self, t, y):\\n # State vector is [T, Y_1, Y_2, ... Y_K]\\n self.gas.set_unnormalized_mass_fractions(y[1:])\\n self.gas.TP = y[0], self.P\\n rho = self.gas.density\\n\\n wdot = self.gas.net_production_rates\\n dYdt = (self.yin-self.gas.Y)/self.tres + wdot*self.gas.molecular_weights/rho\\n dTdt = (self.tin-self.gas.T)/self.tres + \\\\\\n self.Q*(self.ta-self.gas.T)/(rho*self.gas.cp) - \\\\\\n (np.dot(self.gas.partial_molar_enthalpies,wdot)/(rho*self.gas.cp))\\n return np.hstack((dTdt, dYdt))\",\n \"def target_position(self, time):\\n\\n x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]\\n y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]\\n z_pos = self.ar_tag_pos[2]\\n # print(x_pos,y_pos)\\n # raise NotImplementedError\\n return np.array([x_pos,y_pos,z_pos])\",\n \"def trajectory(self):\\n traj = np.zeros((2, self.times.size))\\n for t, time in enumerate(self.times):\\n traj[:, t] = self.center_of_mass(time)\\n return traj\",\n \"def air_exchange(self, room: Room, time: float) -> _VectorisedFloat:\\n return 0.\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def accelerometer(self):\\n accel = [0,0,0]\\n accel[X] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_X_H_A) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_X_L_A), 16)\\n accel[Y] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Y_H_A) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_Y_L_A), 16)\\n accel[Z] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Z_H_A) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_Z_L_A), 16)\\n\\n for i in range(X, Z+1):\\n self._accel[i] = accel[i] / math.pow(2, 15) * ACCEL_SCALE\\n\\n return vector(self._accel)\",\n \"def acceleration(degrees, finalSpeed, steering = 0, robot = MoveSteering(OUTPUT_A, OUTPUT_B), motorA = LargeMotor(OUTPUT_A)): # Function to accelerate while moving so the robot can get traction before moving fast\\n\\n motorA.reset() #reseting how many degrees the robot has moved\\n motorA.position = 0 # setting how many degrees the robot has moved\\n\\n accelerateDegree = degrees * 0.8\\n # declerationDegree = degrees * 0.2'\\n speed = 0 #starting speed\\n while motorA.position < degrees and False == Constants.STOP: #while the robot hasen't moved the target amount of degree's(distance)\\n if motorA.position < accelerateDegree and False == Constants.STOP: \\n if speed < finalSpeed: # while the robot hasen't accelerated to the target speed\\n speed += 5 #speed up\\n robot.on(steering = steering, speed = speed) # Start Moving\\n sleep(0.1) #wait so that it doesn't accelerate immidiatly\\n else:\\n robot.on(steering = steering, speed = finalSpeed)# otherwise just keep moving\\n sleep(0.01)\\n elif False == Constants.STOP:\\n if speed > 10:\\n speed -= 5\\n robot.on(steering = steering, speed = speed)\\n sleep(0.05)\\n else:\\n robot.on(steering = steering, speed = speed)\\n sleep(0.01)\\n \\n robot.off() # Stop Moving\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp - (self.decay*_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def forward_kinematics(self):\\n temp_T = Matrix.eye(3)\\n for i in range(len(self.lengths)):\\n angle_mat = self.T_a.subs(self.q,self.angles[i]).evalf()\\n len_mat = self.T_x.subs(self.l,self.lengths[i]).evalf()\\n temp_T = temp_T * angle_mat * len_mat\\n \\n self.final_T = np.array(temp_T,dtype=float)\\n \\n return self.final_T\",\n \"def est_am(t,y):\\n ch=t>t_eq\\n y1=y[ch]\\n return y1[-1]-y1[0]\",\n \"def trajectory_point(self, t, jointspace):\\n point = JointTrajectoryPoint()\\n delta_t = .01\\n if jointspace:\\n x_t, x_t_1, x_t_2 = None, None, None\\n ik_attempts = 0\\n theta_t = theta_t_1 = theta_t_2 = None\\n while theta_t_2 is None:\\n theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))\\n while theta_t_1 is None:\\n theta_t_1 = self.get_ik(self.target_position(t-delta_t))\\n while theta_t is None:\\n theta_t = self.get_ik(self.target_position(t))\\n \\n # we said you shouldn't simply take a finite difference when creating\\n # the path, why do you think we're doing that here?\\n point.positions = theta_t\\n # print 'theta_t: {0}, {1}'.format(theta_t.shape, theta_t)\\n # print 'theta_t_1: {0}, {1}'.format(theta_t_1.shape, theta_t_1)\\n\\n vel_t_prev = (theta_t_1 - theta_t_2) / delta_t\\n vel_t_curr = (theta_t - theta_t_1) / delta_t\\n vel_t_avg = (vel_t_prev + vel_t_curr) / 2.\\n\\n point.velocities = vel_t_avg #(theta_t - theta_t_1) / delta_t\\n point.accelerations = (theta_t - 2*theta_t_1 + theta_t_2) / (2*delta_t)\\n # if t >= 3.:\\n # import pdb; pdb.set_trace()\\n else:\\n point.positions = self.target_position(t)\\n point.velocities = self.target_velocity(t)\\n point.accelerations = self.target_acceleration(t)\\n point.time_from_start = rospy.Duration.from_sec(t)\\n return point\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def simulate_system(self, state, input, time_step = 0.01):\\n\\n #set arm position to x\\n self.arm.reset(q=state[0:3],dq=state[3:6])\\n\\n #apply the control signal\\n self.arm.apply_torque(input,time_step)\\n\\n #get the next step from the arm \\n xnext = np.append(np.copy(self.arm.q),np.copy(self.arm.dq))\\n\\n return xnext\",\n \"def predict(self, t : float) -> vector :\\n '''@ Zstar : vector'''\\n '''@ dt : float'''\\n '''@ dtau : float'''\\n '''@ F : array'''\\n dt = t - self.t\\n dtau = self._normalizeDeltaTime(dt)\\n F = self.stateTransitionMatrix(self.order+1, dtau)\\n Zstar = F @ self.Z;\\n return Zstar;\",\n \"def calculate_timestep(self, control_inputs):\\r\\n rcs_disp = [0, 0]\\r\\n if control_inputs[4]:\\r\\n if control_inputs[0]: rcs_disp[0] += 1\\r\\n if control_inputs[1]: rcs_disp[0] -= 1\\r\\n if control_inputs[2]: rcs_disp[1] += 1\\r\\n if control_inputs[3]: rcs_disp[1] -= 1\\r\\n else:\\r\\n if control_inputs[0]:\\r\\n self.delta_v += self.accel*0.1\\r\\n self.thrust_angle = self.heading\\r\\n if control_inputs[1]:\\r\\n self.delta_v -= self.accel*0.1\\r\\n self.thrust_angle = self.heading\\r\\n if control_inputs[3]: self.delta_omega += self.accel*0.1\\r\\n if control_inputs[2]: self.delta_omega -= self.accel*0.1\\r\\n if control_inputs[5]:\\r\\n self.delta_omega *= 0.5\\r\\n self.delta_v *= 0.5\\r\\n if control_inputs[0] == False and control_inputs[1] == False:\\r\\n self.delta_v = 0\\r\\n if control_inputs[3] == False and control_inputs[2] == False:\\r\\n self.delta_omega = 0\\r\\n \\r\\n self.vel += self.delta_v\\r\\n self.omega += self.delta_omega\\r\\n if self.vel > 5: self.vel = 5\\r\\n if self.vel < -5: self.vel = -5\\r\\n if self.omega > 5: self.omega = 5\\r\\n if self.omega < -5: self.omega = -5\\r\\n if abs(self.vel) < 0.1: self.vel = 0\\r\\n if abs(self.omega) < 0.1: self.omega = 0\\r\\n if control_inputs[6]:\\r\\n self.vel = self.vel*0.9\\r\\n self.omega = self.omega*0.9\\r\\n self.heading += self.omega*self.time_step\\r\\n self.position[0] += (\\r\\n self.vel*self.time_step*cos(-radians(self.thrust_angle))\\r\\n + rcs_disp[0]*cos(-radians(self.heading))\\r\\n - rcs_disp[1]*sin(-radians(self.heading)))\\r\\n self.position[1] += (\\r\\n self.vel*self.time_step*sin(-radians(self.thrust_angle))\\r\\n + rcs_disp[0]*sin(-radians(self.heading))\\r\\n -rcs_disp[1]*cos(-radians(self.heading)))\\r\\n return self.position, self.vel, self.heading, self.omega, self.thrust_angle\",\n \"def integrate(self, dt):\\n f = lambda t, y: self.Cm * (np.dot(self.phi, self.activation(y)) + np.dot(self.phi_input, self.activation(self.input)) - self.Gm * y)\\n self.Vm = rk4(self.t, self.Vm, self.t + dt, f)\",\n \"def UpdateCromer(self, deltaT):\\n self.velocity += self.acceleration * deltaT\\n self.position += self.velocity * deltaT\",\n \"def rk4(self, t, h,G) :\\r\\n k1 = h*self.calc_diff_eqn(t, self.quant_vec,G,self.mass_vec)\\r\\n k2 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k1 ,G, self.mass_vec)\\r\\n k3 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k2 ,G, self.mass_vec)\\r\\n k4 = h*self.calc_diff_eqn(t + h , self.quant_vec + k3 ,G, self.mass_vec)\\r\\n y_new = self.quant_vec + ((k1 + 2*k2 + 2*k3 + k4)/6)\\r\\n return y_new\",\n \"def update_rk3(self, delta_t=None):\\n\\n delta_t = delta_t or self.delta_t\\n\\n try:\\n\\n kap1 = (self.vel, self.force(self.pos,\\n self.vel,\\n self.time))\\n\\n pos = self.pos+0.5*delta_t*kap1[0]\\n vel = self.vel+0.5*delta_t*kap1[1]\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n 0.5*delta_t, drag=False)\\n\\n kap2 = (vel, self.force(pos, vel, self.time+0.5*delta_t))\\n\\n pos = self.pos+delta_t*(2.0*kap2[0]-kap1[0])\\n vel = self.vel+delta_t*(2.0*kap2[1]-kap1[1])\\n\\n self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n kap3 = (vel, self.force(pos, vel, self.time+delta_t))\\n\\n pos = self.pos+delta_t*(kap1[0]+4.0*kap2[0]+kap3[0])/6.0\\n vel = self.vel+delta_t*(kap1[1]+4.0*kap2[1]+kap3[1])/6.0\\n\\n self.pos, self.vel = self.check_collision_full(pos, self.pos,\\n vel, self.vel,\\n delta_t, drag=False)\\n\\n except Collision.CollisionException as col:\\n col.vel = self.vel+col.delta_t*kap1[0]\\n raise col\\n\\n self.time += self.delta_t\",\n \"def path(e,a,q,i,period, timediff, offset):\\n b = a*np.sqrt(1-e**2)\\n c=np.sqrt(a**2-b**2)\\n #t = ((timediff*np.pi*b)/period)\\n #t1 = ((timediff)*np.pi*b)/period\\n #print(t1-t)\\n #t1 = (((timediff*np.pi*b)/period) + e*np.sin(t))%(2*np.pi)\\n #print(t)\\n t1= angle_helper(((timediff % period)/period)*2*np.pi,e)\\n theta=0 #need a real theta value \\n xcoord = a*np.cos(t1+offset)*np.cos(theta)-b*np.sin(t1+offset)*np.sin(theta)-c*np.cos(theta) #c term is to adjust for the focus\\n ycoord = a*np.cos(t1+offset)*np.sin(theta)*np.cos(i)+b*np.sin(t1+offset)*np.cos(theta)*np.cos(i)-c*np.sin(theta)*np.cos(i)\\n zcoord = a*np.cos(t1+offset)*np.sin(theta)*np.sin(i)+b*np.sin(t1+offset)*np.cos(theta)*np.sin(i)-c*np.sin(theta)*np.sin(i)\\n \\n \\n return xcoord, ycoord, zcoord\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7151567","0.69269055","0.6620792","0.6604044","0.6604044","0.64903134","0.6474762","0.6448839","0.642742","0.6288047","0.6253032","0.62328714","0.62094814","0.61376417","0.6014507","0.6013373","0.59907395","0.5975713","0.5963832","0.5947619","0.5936622","0.5936622","0.59100264","0.5859001","0.5836712","0.5833334","0.58295643","0.58230615","0.5811249","0.5798874","0.5787475","0.5783993","0.57819694","0.57804096","0.57754743","0.57742065","0.57486796","0.5742699","0.57349324","0.5733285","0.5694556","0.5682514","0.56484556","0.5647005","0.56305766","0.5624419","0.5623938","0.56188613","0.56148815","0.56103796","0.5610364","0.56089705","0.56047916","0.5604008","0.5602954","0.5591551","0.5576322","0.55725753","0.55694807","0.5564235","0.55637634","0.5556733","0.55560374","0.55510026","0.55500716","0.5548615","0.5543194","0.55415","0.5539491","0.55342233","0.5533414","0.55237556","0.55237556","0.55237556","0.55237556","0.55200267","0.55197287","0.55150986","0.5503478","0.5497162","0.5492523","0.54914564","0.5490474","0.5489547","0.5486871","0.54839665","0.5480307","0.54796886","0.5478063","0.5477395","0.54771364","0.5467587","0.5467587","0.5462285","0.54513377","0.54499257","0.5449182","0.54327685","0.5432709","0.54286593"],"string":"[\n \"0.7151567\",\n \"0.69269055\",\n \"0.6620792\",\n \"0.6604044\",\n \"0.6604044\",\n \"0.64903134\",\n \"0.6474762\",\n \"0.6448839\",\n \"0.642742\",\n \"0.6288047\",\n \"0.6253032\",\n \"0.62328714\",\n \"0.62094814\",\n \"0.61376417\",\n \"0.6014507\",\n \"0.6013373\",\n \"0.59907395\",\n \"0.5975713\",\n \"0.5963832\",\n \"0.5947619\",\n \"0.5936622\",\n \"0.5936622\",\n \"0.59100264\",\n \"0.5859001\",\n \"0.5836712\",\n \"0.5833334\",\n \"0.58295643\",\n \"0.58230615\",\n \"0.5811249\",\n \"0.5798874\",\n \"0.5787475\",\n \"0.5783993\",\n \"0.57819694\",\n \"0.57804096\",\n \"0.57754743\",\n \"0.57742065\",\n \"0.57486796\",\n \"0.5742699\",\n \"0.57349324\",\n \"0.5733285\",\n \"0.5694556\",\n \"0.5682514\",\n \"0.56484556\",\n \"0.5647005\",\n \"0.56305766\",\n \"0.5624419\",\n \"0.5623938\",\n \"0.56188613\",\n \"0.56148815\",\n \"0.56103796\",\n \"0.5610364\",\n \"0.56089705\",\n \"0.56047916\",\n \"0.5604008\",\n \"0.5602954\",\n \"0.5591551\",\n \"0.5576322\",\n \"0.55725753\",\n \"0.55694807\",\n \"0.5564235\",\n \"0.55637634\",\n \"0.5556733\",\n \"0.55560374\",\n \"0.55510026\",\n \"0.55500716\",\n \"0.5548615\",\n \"0.5543194\",\n \"0.55415\",\n \"0.5539491\",\n \"0.55342233\",\n \"0.5533414\",\n \"0.55237556\",\n \"0.55237556\",\n \"0.55237556\",\n \"0.55237556\",\n \"0.55200267\",\n \"0.55197287\",\n \"0.55150986\",\n \"0.5503478\",\n \"0.5497162\",\n \"0.5492523\",\n \"0.54914564\",\n \"0.5490474\",\n \"0.5489547\",\n \"0.5486871\",\n \"0.54839665\",\n \"0.5480307\",\n \"0.54796886\",\n \"0.5478063\",\n \"0.5477395\",\n \"0.54771364\",\n \"0.5467587\",\n \"0.5467587\",\n \"0.5462285\",\n \"0.54513377\",\n \"0.54499257\",\n \"0.5449182\",\n \"0.54327685\",\n \"0.5432709\",\n \"0.54286593\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65715986"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":20297,"cells":{"query":{"kind":"string","value":"Add tables to update."},"document":{"kind":"string","value":"def table(self, list_or_name):\n if not isinstance(list_or_name, basestring):\n for c in list_or_name:\n self.table(c)\n else:\n self._table_names.append(list_or_name)\n\n return self"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __new_tables_statement(self):\n new_tables = self.__new_tables()\n for table in new_tables:\n with open('./update/create_tables.sql', 'a') as f:\n create_statement = self.source.query_create_table_statement(table.name)\n f.write(create_statement)\n f.write('\\n')","def create_tables(self):\n for query in table_create_sql:\n self.cursor.execute(query)\n\n self.commit()","def create_all_tables(self):\n pass","def make_tables(self):\n for t in self.tables:\n self.add_table(groupname=t['groupname'],\n tablename=t['tablename'],\n description=t['description'],\n tabletitle=t['tabletitle'])","def create_tables(self):\n con = self.connect()\n cursor = con.cursor()\n queries = self.tables()\n for query in queries:\n cursor.execute(query)\n cursor.close()\n con.commit()\n con.close()","def migrateTables(self):\n tables = self.client_from.tables.list(['columns'])\n if len(tables) > 0:\n for table in tables:\n self.client_to.tables.update(table['tableId'], json.dumps(table))\n else:\n print(\"No tables to migrate!\")\n return\n print(len(tables) + \" Tables migrated!\")","def createTables():\n conn = getConnection()\n try:\n cur = conn.cursor()\n for table, query in tables.items():\n cur.execute(query)\n conn.commit()\n except Exception as ex:\n print(\"Failed to create tables:\" )\n print(ex)\n sys.exit(1)","def create_tables_and_apply_patches(self):\n\n if self.authorized and not self.db_tables_initiated:\n with self.connection.cursor() as cursor:\n for statement in self.parse_mysql_sql_file():\n cursor.execute(statement)\n\n PyFunceble.LOGGER.info(\n \"Created the missing tables. Applied all patched\"\n )\n\n self.db_tables_initiated = True","def create_tables():\n db.create_all()","def create_tables():\n db.create_all()","def init_tables(self) -> None:\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\n # it to be?\n # \"How to know that schema changes?\"\n # logger.warning(\"some message\")\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n with conn:\n c = conn.cursor()\n c.execute(CREATE_PROJECTS_TABLE)\n c.execute(CREATE_TASKS_TABLE)\n c.execute(CREATE_REQUESTERS_TABLE)\n c.execute(CREATE_TASK_RUNS_TABLE)\n c.execute(CREATE_ASSIGNMENTS_TABLE)\n c.execute(CREATE_UNITS_TABLE)\n c.execute(CREATE_WORKERS_TABLE)\n c.execute(CREATE_AGENTS_TABLE)\n c.execute(CREATE_QUALIFICATIONS_TABLE)\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)","def create_tables(self, tables=None):\n LOG.debug(f\"Creating table subset {tables}\")\n Base.metadata.create_all(self.engine, tables, checkfirst=False)","def collect_table_names(self):\n try:\n for migrate_table in self.migration_tables:\n tabel_name = migrate_table.migrationTable.DestinationTable.name\n self.table_list.add(tabel_name)\n self.tables.update(self.table_list)\n except Exception as err:\n logger.error(\"collect_table_names [error] -> %s\" % err)","def create_all_tables():\n\tcommon_db.create_all_tables()","def create_tables():\n db.create_all()","def append_table(self, table):\n\n self._db_manager.register_table(table)","def createTables(self):\n metadata = Base.metadata\n metadata.create_all(self._engine)\n return","def insert_tables(cur, conn):\n logger.debug(\"Insert tables ...\")\n for query in insert_table_queries:\n logger.debug(f'RUN query: {query}')\n cur.execute(query)\n conn.commit()\n\n print('All files INSERTED OK.')","def create_tables(cur, conn): \n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def insert_tables(cur, conn):\n for query in insert_table_queries:\n cur.execute(query)\n conn.commit()","def insert_tables(cur, conn):\n for query in insert_table_queries:\n cur.execute(query)\n conn.commit()","def insert_tables(cur, conn):\n for query in insert_table_queries:\n cur.execute(query)\n conn.commit()","def insert_tables(cur, conn):\n for query in insert_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n \n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def add_tables(self, *tables):\n \n for t in tables:\n # if table contains actual aperture magnitudes\n if \"mag_calib_unc\" in t.colnames:\n LightCurve.__mag_table_append(self, t.copy())\n # if table contains limiting magnitudes\n else: \n LightCurve.__limmag_table_append(self, t.copy())","def create_tables(cur, conn) -> None:\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_db_tables():\n\n try:\n webapp.dbsql.create_all()\n webapp.dbsql.session.commit()\n except Exception as e:\n # TODO: melhorar o informe do erro\n raise e","async def _create_tables_declarative(self, base, engine):\n if hasattr(base, 'metadata'):\n base.metadata.create_all(bind=engine, checkfirst=True)\n return","def update(self):\n current = LazyRegister(self.db)\n current.render()\n cur = self.db.cursor()\n for table in self.tables:\n if table in current.tables:\n additions, removals = current.tables[table].migrate(self.tables[table])\n for addition in additions:\n cur.execute(\"\"\"ALTER TABLE %s ADD COLUMN %s\"\"\" % (\n table, addition[1].get_sql()\n ))\n print('Added column: ', addition[0])\n for removal in removals:\n #cur.execute(\"\"\"ALTER TABLE %s DROP COLUMN %s\"\"\" % (\n # table, removal[0]\n #))\n #print('Removed column: ', removal[0])\n print('Did not removed column: ', removal[0])\n else:\n schema = self.tables[table].get_create_table_sql()\n cur.execute(schema)\n print('Added table %s' % table)","def AddTable(self, table):\n self.tables.append(table)","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()\n \n print('Tables created.')","def init_tables(self):\n\n settings.Base.metadata.tables[\n 'session_master'].drop(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\n\n settings.Base.metadata.tables[\n 'session_master'].create(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\n\n logging.info(\"Sessionization Tables created\")","def set_tables(self):\n with sql.connect('./{}.db'.format(self.name)) as conn:\n conn.execute(\"\"\"CREATE TABLE IF NOT EXISTS tweets(\n id INTEGER PRIMARY KEY,\n tweet_id INTEGER,\n insert_date TEXT,\n created_at TEXT,\n hashtag TEXT)\n \"\"\")\n\n conn.execute(\"\"\"CREATE TABLE tweet_peaks(\n peak_datetime TEXT NOT NULL,\n hashtag TEXT NOT NULL,\n time_frame TEXT,\n mean REAL,\n std REAL,\n sensibility REAL,\n freq_limit REAL,\n qt_tweets INTEGER,\n id TEXT PRIMARY KEY,\n probability REAL);\n \"\"\")","def create_tables(self):\n users_tb = \"\"\"CREATE TABLE IF NOT EXISTS Users(\n user_id serial PRIMARY KEY,\n email varchar(30) NOT NULL,\n username varchar(15) NOT NULL,\n password varchar(250) NOT NULL,\n role varchar(10) DEFAULT 'User'\n );\"\"\"\n\n meals_tb = \"\"\"CREATE TABLE IF NOT EXISTS Meals(\n meal_id serial PRIMARY KEY,\n meal_name varchar(25) NOT NULL,\n image varchar(150) NOT NULL,\n description varchar(250) NOT NULL,\n unit_price decimal(5,2) NOT NULL\n );\"\"\"\n\n orders_tb = \"\"\"CREATE TABLE IF NOT EXISTS Orders(\n order_id serial PRIMARY KEY,\n user_id integer NOT NULL,\n meal_id integer NOT NULL,\n address varchar(50),\n quantity int NOT NULL,\n order_date timestamp NOT NULL,\n status varchar(15),\n FOREIGN KEY (user_id) REFERENCES users(user_id)\n ON DELETE CASCADE ON UPDATE CASCADE,\n FOREIGN KEY (meal_id) REFERENCES meals(meal_id)\n ON DELETE CASCADE ON UPDATE CASCADE\n );\"\"\"\n return [users_tb, meals_tb, orders_tb]","def sync_tables():\n sync_table(ShoppingList)\n sync_table(User)\n sync_table(Category)\n sync_table(Feed)\n sync_table(News)\n sync_table(Photo)\n sync_table(Profile)\n sync_table(Video)\n sync_type(FeedPhoto)\n sync_type(NewsPhoto)","def create_db_tables(self):\n self.releases = Table(\n RELEASES,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"tag_name\", String),\n Column(\"release_name\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n self.commits = Table(\n COMMITS,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"branch\", String),\n Column(\"sha\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n self.tags = Table(\n TAGS,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"tag_name\", String),\n Column(\"sha\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n try:\n self.metadata.create_all()\n log.info(\"Tables created\")\n except Exception as e:\n log.error(\"Error occurred during Table creation!\")\n log.exception(e)","def create_tables (cls, env=os.environ):\n\n cur = cls.pri_table_read_cursor (env=env)\n cur.execute ('SPECIALCASE gettablelist')\n ret = cur.fetchall ()\n \n existingtables = set ([x[0].lower() for x in ret])\n\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\n sql, lsd = cls.table_desc[tabname]\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\n\n conn = get_labeled_conn (epls, desls)\n cur = conn.cursor ()\n cur.execute (sql)\n conn.close ()\n lsd.pop_labelset ()\n\n \n import psycopg2\n for sql in cls.sql_createindex:\n conn = get_labeled_conn ()\n cur = conn.cursor ()\n # XXX It would be better to check which indices exist as we do for tables.\n try:\n cur.execute (sql)\n except psycopg2.ProgrammingError, e: \n pass\n conn.close ()","def create_tables(self, script):\n for query in script:\n try:\n self.cursor.execute(query)\n except:\n print(\"\\n Une erreur s'est produite lors \"\n \"de la création des tables \\n\")\n print(\"\\n Les tables ont bien été créées \"\n f\"dans la base de données |{DB_NAME}| \\n\")","def create_tables(self):\n for name, attribute in self.__dict__.items():\n if hasattr(attribute, 'create_table_in_sqlite_db'):\n attribute.create_table_in_sqlite_db()","def init_tables(self) -> None:\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n c = conn.cursor()\n c.execute(tables.CREATE_STUDIES_TABLE)\n c.execute(tables.CREATE_SUBMISSIONS_TABLE)\n c.execute(tables.CREATE_REQUESTERS_TABLE)\n c.execute(tables.CREATE_UNITS_TABLE)\n c.execute(tables.CREATE_WORKERS_TABLE)\n c.execute(tables.CREATE_RUNS_TABLE)\n c.execute(tables.CREATE_RUN_MAP_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUPS_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUP_QUALIFICATIONS_MAPPING_TABLE)\n conn.commit()","def _create_tables():\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\n db.create_tables([SubjectType, SubjectRegion, Subject])","def create_tables(self):\n\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\n (\n id SERIAL PRIMARY KEY,\n url_yes_no boolean,\n url TEXT,\n phone_yes_no boolean,\n phone TEXT,\n rating TEXT,\n nr_of_ratings TEXT,\n myBusiness boolean,\n company TEXT\n );''')\n\n self.connection.commit()","def table(self, *tables):\n self._tables.append(', '.join(tables))\n return self","def create_tables(self):\n if not self.is_enabled(Subsystem.database):\n raise RuntimeError(\"Database subsystem was not enabled\")\n\n Base.metadata.create_all(self.engine)","def _create_tables(self):\n\n print(\"\\n ** Creating DynamoDB Tables\")\n\n # Create Tables\n for table_config in self.table_list:\n with open(os.path.join(self.config_dir, table_config), \"rt\") as handle:\n config_data = json.load(handle)\n story_table = DynamoDB(DynamoTable.STACK_NAME, config_data[self.stack_name])\n story_table.create()","def __create_tables(self):\n self.__cur.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS federations(\n id INTEGER PRIMARY KEY UNIQUE,\n name TEXT,\n category TEXT\n )\n \"\"\")\n self.__cur.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS clubs(\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n code_fede INT,\n dpt TEXT,\n nb_clubs INT,\n year INT,\n FOREIGN KEY(code_fede) REFERENCES federations(i)\n )\n \"\"\")\n self.__cur.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS by_age(\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n code_fede INT,\n age TEXT,\n sex TEXT,\n nb INT,\n year INT,\n FOREIGN KEY(code_fede) REFERENCES federations(id)\n )\n \"\"\")\n self.__cur.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS by_dpt(\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n code_fede INT,\n dpt TEXT,\n nb INT,\n sex TEXT,\n year INT,\n FOREIGN KEY(code_fede) REFERENCES federations(id)\n )\n \"\"\")\n\n # Save all the changes\n self.save()","def _do_action_tables_create(self):\n\n schema_shell = os.path.join(self.bento_home, \"schema-shell\", \"bin\", \"kiji-schema-shell\")\n assert os.path.isfile(schema_shell), schema_shell\n\n # Delete the table first!\n cmd = (\n \"kiji delete --target={kiji_uri} --interactive=false; \" +\n \"kiji install --kiji={kiji_uri}\" ).format(kiji_uri=self.kiji_uri)\n self._run_kiji_job(cmd)\n\n for ddl in self.ddls:\n ddl_full_path = os.path.join(self.movie_advisor_home, ddl)\n assert os.path.isfile(ddl_full_path)\n cmd = \"{schema_shell} --kiji={kiji_uri} --file={ddl_full_path}\".format(\n schema_shell=schema_shell,\n kiji_uri=self.kiji_uri,\n ddl_full_path=ddl_full_path)\n self._run_kiji_job(cmd)","def _load_tables(neo4j_session: neo4j.Session, tables: List[Dict], update_tag: int) -> None:\n ingest_tables = \"\"\"\n UNWIND $tables_list as table\n MERGE (t:AzureStorageTable{id: table.id})\n ON CREATE SET t.firstseen = timestamp(), t.type = table.type\n SET t.name = table.name,\n t.tablename = table.table_name,\n t.lastupdated = $azure_update_tag\n WITH t, table\n MATCH (ts:AzureStorageTableService{id: table.service_id})\n MERGE (ts)-[r:CONTAINS]->(t)\n ON CREATE SET r.firstseen = timestamp()\n SET r.lastupdated = $azure_update_tag\n \"\"\"\n\n neo4j_session.run(\n ingest_tables,\n tables_list=tables,\n azure_update_tag=update_tag,\n )","async def create_sys_tables(self) -> None:\n await self.conn.execute(\"\"\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\n table_name TEXT,\n level INTEGER\n )\"\"\")","def insert_db():\n populate_tables()","def create_tables() -> None:\n print(\"Creating database tables using SQLAlchemy ORM\")\n Base.metadata.create_all(engine)\n print(\"Done creating tables\")","def create_tables(session):\n for query in create_table_queries:\n session.execute(query)","def create_tables(cur, conn):\n for query in create_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except Exception as e:\n print(e)","def fill_target_table(new_data, curs, conn, overwrite=False):\n for i in new_data:\n connect_database.add_target_to_database(list(i), curs, conn, overwrite_exsiting = overwrite)\n conn.commit()","def pack_for_create_table(tables: tuple):\n\n all_tables = {'product': \"\"\"CREATE TABLE IF NOT EXISTS product (\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\n PRODUCT_ID CHAR(50),\n GLOBAL_ID CHAR(50),\n TITLE TEXT,\n COUNTRY CHAR(50),\n RETURNS_ACCEPTED CHAR(50),\n IS_MULTI_VARIATION_LISTING CHAR(50),\n CONDITION_ID CHAR(50),\n CONDITION_DISPLAY_NAME CHAR(50),\n CATEGORY_ID CHAR(50),\n CATEGORY_NAME CHAR(100),\n AUTO_PAY CHAR(50),\n LOCATION CHAR(50),\n PAYMENT_METHOD CHAR(50),\n TOP_RATED_LISTING CHAR(50),\n VIEW_ITEM_URL TEXT\n )\"\"\",\n 'listing_info': \"\"\"CREATE TABLE IF NOT EXISTS listing_info (\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\n BEST_OFFER_ENABLED CHAR(20),\n END_TIME CHAR(50),\n GIFT CHAR(20),\n BUY_IT_NOW_AVAILABLE CHAR(20),\n START_TIME CHAR(50),\n FIXED_PRICE CHAR(20)\n )\"\"\",\n 'selling_status': \"\"\"CREATE TABLE IF NOT EXISTS selling_status (\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\n CONVERTED_CURRENT_PRICE_CURRENCY_ID CHAR(20),\n CONVERTED_CURRENT_PRICE_VALUE CHAR(50),\n CURRENT_PRICE_CURRENCY_ID CHAR(20),\n CURRENT_PRICE_VALUE CHAR(50),\n TIME_LEFT CHAR(50),\n SELLING_STATE CHAR(20)\n )\"\"\",\n 'shipping_info': \"\"\"CREATE TABLE IF NOT EXISTS shipping_info (\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\n SHIP_TO_LOCATIONS CHAR(20),\n SHIPPING_TYPE CHAR(100),\n ONE_DAY_SHIPPING_AVAILABLE CHAR(20),\n EXPEDITED_SHIPPING CHAR(20),\n SHIPPING_SERVICE_COST_CURRENCY_ID CHAR(50),\n SHIPPING_SERVICE_COST_VALUE CHAR(50),\n HANDLING_TIME CHAR(50)\n )\"\"\"\n }\n\n # If table was not specified, put all tables in line\n tables = all_tables.keys() if tables is None else tables\n\n return ';'.join([\"{}\".format(all_tables[i]) for i in tables])","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()\n print(f\"\\nRunning: {query}\")","def add_table(self, name):\n self.puml_tables[name] = {\n 'default': OrderedDict(),\n 'foreign': OrderedDict(),\n 'primary': OrderedDict()\n }\n # Set current table name.\n self.current_table = name","def insert_tables(cur, conn):\n for query in insert_table_queries:\n print('insert', query)\n cur.execute(query)\n conn.commit()","def create_tables(session):\n\n for query in create_table_queries:\n session.execute(query)","async def _create_tables(self):\n\n await self.bot.db.execute(\n \"\"\"\n CREATE TABLE IF NOT EXISTS giveaways_game(\n game_id INTEGER NOT NULL PRIMARY KEY,\n given INTEGER DEFAULT 0,\n key TEXT NOT NULL,\n title TEXT NOT NULL,\n url TEXT NOT NULL,\n UNIQUE (key)\n )\n \"\"\"\n )\n\n await self.bot.db.execute(\n \"\"\"\n CREATE TABLE IF NOT EXISTS giveaways_giveaway(\n giveaway_id INTEGER NOT NULL PRIMARY KEY,\n channel_id INTEGER,\n created_at TIMESTAMP,\n is_done INTEGER DEFAULT 0,\n game_id INTEGER NOT NULL,\n message_id INTEGER,\n trigger_at TIMESTAMP NOT NULL,\n FOREIGN KEY (game_id)\n REFERENCES giveaways_game (game_id)\n )\n \"\"\"\n )\n\n await self.bot.db.execute(\n \"\"\"\n CREATE TABLE IF NOT EXISTS giveaways_entry(\n giveaway_id INTEGER NOT NULL,\n user_id INTEGER NOT NULL,\n FOREIGN KEY (giveaway_id)\n REFERENCES giveaways_giveaway (giveaway_id)\n UNIQUE (giveaway_id, user_id)\n )\n \"\"\"\n )\n\n await self.bot.db.commit()","def create_tables(self):\n\n conn = sqlite3.connect(self.db_name)\n c = conn.cursor()\n\n c.execute(\"DROP TABLE IF EXISTS Installation;\")\n c.execute(\"DROP TABLE IF EXISTS Equipment;\")\n c.execute(\"DROP TABLE IF EXISTS Activity;\")\n c.execute(\"DROP TABLE IF EXISTS EquipmentActivity;\")\n\n c.execute(\"CREATE TABLE Installation (Id INTEGER PRIMARY KEY, Name TEXT, Address TEXT, \"\n \"PostalCode INTEGER, City TEXT, Latitude REAL, Longitude Real);\")\n\n c.execute(\"CREATE TABLE Equipment (Id INTEGER PRIMARY KEY, Name TEXT, \"\n \"IdInstallation INTEGER, FOREIGN KEY(IdInstallation) REFERENCES Installation(Id));\")\n\n c.execute(\"CREATE TABLE Activity (Id INTEGER PRIMARY KEY, Name TEXT);\")\n\n c.execute(\n \"CREATE TABLE EquipmentActivity (IdEquipment INTEGER, IdActivity INTEGER, PRIMARY KEY (IdEquipment, \"\n \"IdActivity));\")\n\n conn.commit()\n conn.close()","def create_all_schemas_and_tables(self):\n for schema, tables in self.schemas.items():\n self.create_schema(schema)\n for table in tables.keys():\n self.create_table(schema, table)","def create_tables():\n with db.connect() as conn:\n conn.execute(\n \"CREATE TABLE IF NOT EXISTS url_list \"\n \"(url_id VARCHAR(20) NOT NULL UNIQUE, url_data VARCHAR(2083) NOT NULL);\"\n )","def insert_tables(cur, conn):\n for query in insert_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except Exception as e:\n print(e)","def merge_tables(self):\r\n\r\n table_params = pd.read_json(os.path.join(self.config_path, self.db_config_file),\r\n orient='records')[self.report_type]['table']\r\n\r\n self.trees = create_tree(table_params)\r\n\r\n for tree in self.trees:\r\n self._recursive_merge(tree=tree)\r\n self.merged_table.append(self._get_table(self.master_table[0]))\r\n\r\n # Drop table from list_of_tables, table_indexes and master_table\r\n del self.list_of_tables[self.table_indexes.index(self.master_table[0])]\r\n self.table_indexes.remove(self.master_table[0])\r\n del self.master_table[0]","def test_add_table(self):\n name_column = Varchar()\n name_column._meta.name = \"name\"\n schema: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\", tablename=\"band\", columns=[name_column]\n )\n ]\n schema_snapshot: t.List[DiffableTable] = []\n schema_differ = SchemaDiffer(\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\"y\"\n )\n\n create_tables = schema_differ.create_tables\n self.assertTrue(len(create_tables.statements) == 1)\n self.assertEqual(\n create_tables.statements[0],\n \"manager.add_table('Band', tablename='band')\",\n )\n\n new_table_columns = schema_differ.new_table_columns\n self.assertTrue(len(new_table_columns.statements) == 1)\n self.assertEqual(\n new_table_columns.statements[0],\n \"manager.add_column(table_class_name='Band', tablename='band', column_name='name', db_column_name='name', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\", # noqa\n )","async def create_tables():\n text_create_citizens_table = queries.CREATE_CITIZENS\n text_create_relative_table = queries.CREATE_RELATIVES\n text_create_consts_table = queries.CREATE_CONSTS\n text_insert_base_import_id = queries.INSERT_IMPORT_ID_0\n text_create_index_citizens = queries.CREATE_INDEX_CITIZENS\n text_create_index_relatives = queries.CREATE_INDEX_RELATIVES\n\n queries_list = [text_create_citizens_table, text_create_relative_table,\n text_create_consts_table, text_insert_base_import_id,\n text_create_index_citizens,text_create_index_relatives]\n\n connection = await sql.connect()\n async with connection.transaction():\n for query in queries_list:\n await sql.execute_query(connection, query)\n await sql.close(connection)","def create_tables():\n\tlog_msg4(\"No hay tablas para el año \" + txt_year + \". Creando\")\n\n\tcreate_table('visited')\n\tcreate_table('saved')\n\tcreate_table('actions')\n\n\tglobal new_tables_created\n\tnew_tables_created = True\n\n\tlog_msg_ok4()","def create_tables():\n # Depending on your local settings, you may need to specify a user and password, e.g.\n # conn = psycopg2.connect(dbname=DBNAME, user=\"postgres\", password=\"password\")\n conn = psycopg2.connect(dbname=DBNAME)\n\n create_train_table(conn)\n create_questions_table(conn)\n create_lectures_table(conn)\n create_example_test_table(conn)\n create_example_test_table(conn)\n\n conn.close()","def create_tables(hpo_id, drop_existing=False):\n for table_name in ACHILLES_HEEL_TABLES:\n table_id = bq_utils.get_table_id(hpo_id, table_name)\n bq_utils.create_standard_table(table_name, table_id, drop_existing)","def make_new_tbl(self):\n debug = False\n default_dd = getdata.get_default_db_dets()\n con, cur = default_dd.con, default_dd.cur\n oth_name_types = getdata.get_oth_name_types(self.settings_data)\n tblname = self.tblname_lst[0]\n if debug: print(f'DBE in make_new_tbl is: {default_dd.dbe}')\n getdata.make_sofa_tbl(\n con, cur, tblname, oth_name_types, headless=False)\n wx.MessageBox(\n _('Your new table has been added to the default SOFA database'))","def insert_into_tables(cur, conn):\n for query in insert_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(engine):\n BASE.metadata.create_all(engine)","def create_tables(self):\n\n cur = self.conn.cursor()\n cur.execute('CREATE TABLE blog(blog_id INTEGER PRIMARY KEY, '\n ' title TEXT, subtitle TEXT, content TEXT, date TEXT, '\n ' author_id INTEGER, '\n 'FOREIGN KEY (author_id) REFERENCES author(author_id)) ')\n\n cur.execute('CREATE TABLE author(author_id INTEGER PRIMARY KEY, '\n ' name TEXT UNIQUE) ')\n\n cur.execute('CREATE TABLE password(password_id INTEGER PRIMARY KEY,'\n ' author_id INTEGER, '\n ' password TEXT, '\n 'FOREIGN KEY (author_id) REFERENCES author(author_id)) ')\n\n self.conn.commit()","def create_database_tables():\n with APP.app_context():\n DB.create_all()","def create_tables(session):\n \n for query in create_table_queries:\n try:\n session.execute(query)\n except Exception as e:\n print(e)","def add_table(self, name):\n raise NotImplementedError(\n \"Please implement the 'add_table' method in a derived class.\")","def create_tables(c, drop_all = False):\n\tprint \"create_tables [status]: create tables triggered.\"\n\tautoincrement = \" autoincrement\"\n\tglobal Options, Database\n\tif drop_all:\n\t\tprint \"create_tables [status]: dropping tables initiated.\"\n\t\tif Database.type == DatabaseTypes.SQLITE:\n\t\t\tdrop_sql = open(mk_drop(\"sqlite\")).read()\n\t\telif Database.type == DatabaseTypes.MYSQL:\n\t\t\tdrop_sql = open(mk_drop(\"mysql\")).read()\n\t\telif Database.type == DatabaseTypes.POSTGRES:\n\t\t\tdrop_sql = open(mk_drop(\"postgres\")).read()\n\t\tdrop_list = drop_sql.split(\";\")\n\t\tfor line in drop_list:\n\t\t\tquery = line.strip()\n\t\t\tif query:\n\t\t\t\tc.execute(line)\n\t\tprint \"create_tables [status]: dropping tables complete.\"\n\tif Database.type == DatabaseTypes.SQLITE:\n\t\tdbf = open(mk_schema(\"sqlite\", Options.use_dict))\n\t\tquery_list = dbf.read()\n\t\tc.executescript(query_list)\n\telif Database.type == DatabaseTypes.MYSQL:\n\t\tdbf = open(mk_schema(\"mysql\", Options.use_dict))\n\t\texecutescript(c, dbf)\n\telif Database.type == DatabaseTypes.POSTGRES:\n\t\tdbf = open(mk_schema(\"postgres\", Options.use_dict))\n\t\texecutescript(c, dbf)","def create_tables(self):\n\n # Uses methods from class DbAuth\n cursor = self.connect.create_cursor()\n cursor.execute(\"USE `dbPurBeurre`\")\n\n cursor.execute(\n \"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Categories` (\"\n \" `num` INT UNSIGNED AUTO_INCREMENT,\"\n \" `id` VARCHAR(80) NOT NULL UNIQUE,\"\n \" `name` VARCHAR(80) NOT NULL,\"\n \" `url` VARCHAR(255) NOT NULL,\"\n \" `products` INT NULL,\"\n \" PRIMARY KEY (`num`))\"\n \" ENGINE = InnoDB\"\n )\n\n cursor.execute(\n \"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Produits` (\"\n \" `num` INT UNSIGNED AUTO_INCREMENT,\"\n \" `id` VARCHAR(80) NOT NULL UNIQUE,\"\n \" `product_name` VARCHAR(80) NOT NULL,\"\n \" `nutrition_grade_fr` CHAR(1) NOT NULL,\"\n \" `brands` VARCHAR(80) NULL,\"\n \" `stores` VARCHAR(80) NOT NULL,\"\n \" `url` VARCHAR(255) NOT NULL,\"\n \" `watchlist` DATE NULL,\"\n \" PRIMARY KEY (`num`, `id`))\"\n \" ENGINE = InnoDB\"\n )\n\n cursor.execute(\n \"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Asso_Prod_Cat` (\"\n \" `id_categories` VARCHAR(80) NOT NULL,\"\n \" `id_produits` VARCHAR(80) NOT NULL,\"\n \" PRIMARY KEY (`id_categories`, `id_produits`),\"\n \" CONSTRAINT `fk_id_categories`\"\n \" FOREIGN KEY (`id_categories`)\"\n \" REFERENCES `Categories` (`id`),\"\n \" CONSTRAINT `fk_id_produits`\"\n \" FOREIGN KEY (`id_produits`)\"\n \" REFERENCES `Produits` (`id`))\"\n \" ENGINE = InnoDB\"\n )","def load_db_tables(self):\r\n\r\n self.list_of_tables = pd.read_json(os.path.join(self.config_path, self.db_config_file),\r\n orient='records')[self.report_type]['table']\r\n\r\n # Loading tables from database\r\n for aux_index, table in enumerate(self.list_of_tables):\r\n \"\"\"\r\n table_indexes: position in which each table is located in the list variable 'list_of_tables'.\r\n list_of_tables: list data structure used to allocate the database tables in DataFrame format.\r\n \"\"\"\r\n self.table_indexes.append(table['name'])\r\n self.list_of_tables[aux_index] = pd.read_sql_table(table_name=table['name'],\r\n con=self.mariadb_engine,\r\n columns=table['columns'],\r\n parse_dates=table['parse_dates'])\r\n\r\n if table['master_table']:\r\n self.master_table.append(table['name'])","def create_tables(): \n \n pk_contraint = \"CONSTRAINT {}_pk PRIMARY KEY ({})\"\n uq_contraint = \"CONSTRAINT {}_uq UNIQUE ({})\"\n fk_query = \"\"\"CONSTRAINT {}_fk_{} \n FOREIGN KEY ({}) \n REFERENCES {}({}) \n ON UPDATE CASCADE \n ON DELETE RESTRICT\n \"\"\"\n \n create_dict = {}\n index = 1\n\n\n ############################## public SCHEMA ##############################\n \n schema = 'public'\n create_schema(schema)\n\n #################### site ####################\n table_name = 'site'\n pk_id = 'site_id'\n uq_list = ['site_code']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_code CHAR(3),\n purok VARCHAR,\n sitio VARCHAR,\n barangay VARCHAR,\n municipality VARCHAR,\n province VARCHAR,\n region VARCHAR,\n psgc INTEGER,\n active BOOLEAN NOT NULL DEFAULT TRUE,\n season SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################## spatial SCHEMA ##############################\n \n schema = 'spatial'\n create_schema(schema)\n \n #################### exposure ####################\n table_name = 'exposure'\n pk_id = 'exp_id'\n uq_list = ['exp_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n exp_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### site_exposure ####################\n table_name = 'site_exposure'\n pk_id = 'se_id'\n uq_list = ['site_id', 'exp_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n exp_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### feature ####################\n table_name = 'feature'\n pk_id = 'feat_id'\n uq_list = ['feat_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n feat_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_feature ####################\n table_name = 'site_feature'\n pk_id = 'sf_id'\n uq_list = ['site_id', 'feat_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n feat_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### hazard_zone ####################\n table_name = 'hazard_zone'\n pk_id = 'hz_id'\n uq_list = ['site_id, geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### monitoring ####################\n table_name = 'monitoring'\n pk_id = 'mon_id'\n uq_list = ['mon_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n mon_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_monitoring ####################\n table_name = 'site_monitoring'\n pk_id = 'sm_id'\n uq_list = ['site_id', 'mon_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n mon_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################### comm SCHEMA ###############################\n \n schema = 'comm'\n create_schema(schema)\n\n #################### gsm_server ####################\n table_name = 'gsm_server'\n pk_id = 'server_id'\n uq_list = ['server_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_name VARCHAR,\n platform_type VARCHAR,\n version SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### server_port ####################\n table_name = 'server_port'\n pk_id = 'port_id'\n uq_list = ['server_id', 'port']\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_id INTEGER,\n port BOOLEAN,\n ser_port VARCHAR,\n pwr_on_pin SMALLINT,\n ring_pin SMALLINT,\n module_type SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- left\n 1- right'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### network_type ####################\n table_name = 'network_type'\n pk_id = 'prefix'\n uq_list = ['prefix']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} VARCHAR(3), \n carrier SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '1- globe\n 2- smart\n 3- landline'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### gsm_module ####################\n table_name = 'gsm_module'\n pk_id = 'gsm_id'\n uq_list = ['prefix', 'num', 'activated']\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n prefix VARCHAR(3),\n num CHAR(7),\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n port_id INTEGER,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################# temporal SCHEMA #############################\n \n schema = 'temporal'\n create_schema(schema)\n\n #################### marker_observation ####################\n table_name = 'marker_observation'\n pk_id = 'mo_id'\n uq_list = ['site_id', 'ts']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n ts TIMESTAMP,\n meas_type VARCHAR(7),\n weather VARCHAR,\n observer_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_history ####################\n table_name = 'marker_history'\n pk_id = 'hist_id'\n uq_list = ['sm_id', 'ts', 'event']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n sm_id BIGINT,\n ts TIMESTAMP,\n event BOOLEAN,\n label_name VARCHAR,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- rename\n 1- reposition'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_data ####################\n table_name = 'marker_data'\n pk_id = 'data_id'\n uq_list = ['sm_id', 'mo_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n mo_id BIGINT,\n sm_id BIGINT,\n measurement NUMERIC(5,1),\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_alert ####################\n table_name = 'marker_alert'\n pk_id = 'alert_id'\n uq_list = ['data_id']\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n data_id BIGINT,\n displacement NUMERIC(4,1),\n time_delta FLOAT,\n alert_level SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger_model ####################\n table_name = 'logger_model'\n pk_id = 'model_id'\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n has_tilt BOOLEAN,\n has_rain BOOLEAN,\n has_piezo BOOLEAN,\n has_soms BOOLEAN,\n logger_type SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger ####################\n table_name = 'logger'\n pk_id = 'logger_id'\n uq_list = ['sm_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n sm_id BIGINT,\n model_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### logger_mobile ####################\n table_name = 'logger_mobile'\n pk_id = 'mobile_id'\n uq_list = ['logger_id', 'activated']\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n logger_id INTEGER,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n sim_num VARCHAR(12),\n gsm_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n #################### EXECUTE QUERY TO CREATE TABLES ####################\n for index in create_dict.keys():\n dct = create_dict[index]\n schema = dct['schema']\n table_name = dct['table_name']\n query = dct['query']\n pk_id = dct['pk_id']\n uq_list = dct['uq_list']\n fk_dict = dct['fk_dict']\n if len(fk_dict.keys()) == 0:\n fk_constraint = ''\n else:\n fk_constraint_list = ['']\n for fk_id in fk_dict.keys():\n ref_schema = fk_dict.get(fk_id)['ref_schema']\n ref_table = fk_dict.get(fk_id)['ref_table']\n fk_part = fk_query.format(table_name, ref_table, fk_id,\n \"{}.{}\".format(ref_schema, ref_table),\n fk_id)\n fk_constraint_list.append(fk_part)\n fk_constraint = ', '.join(fk_constraint_list)\n \n query = query.format(schema, table_name, pk_id, \n pk_contraint.format(table_name, pk_id),\n uq_contraint.format(table_name, ', '.join(uq_list)),\n \"{}\".format(fk_constraint))\n qdb.execute(query)","def _alter_table(self, names, types) :\n\n cur = self.con.cursor()\n for i in range(min(len(names), len(types))) :\n alter_sql = 'ALTER TABLE \"%s\" ADD COLUMN \"%s\" %s' % (self.name, names[i], types[i])\n cur.execute(alter_sql)","def set_up_tables(self):\n tables = []\n tables.append({'groupname': 'metadata',\n 'tablename': 'sim_info',\n 'description': desc.SimInfoRow,\n 'tabletitle': 'Simulation Information'})\n tables.append({'groupname': 'metadata',\n 'tablename': 'sim_timeseries',\n 'description': desc.SimTimeseriesRow,\n 'tabletitle': 'Simulation Power Data'})\n tables.append({'groupname': 'th',\n 'tablename': 'th_params',\n 'description': desc.ThMetadataRow,\n 'tabletitle': 'TH Component Parameters'})\n tables.append({'groupname': 'th',\n 'tablename': 'th_timeseries',\n 'description': desc.ThTimeseriesRow,\n 'tabletitle': 'TH Timeseries'})\n tables.append({'groupname': 'neutronics',\n 'tablename': 'neutronics_timeseries',\n 'description': desc.NeutronicsTimeseriesRow,\n 'tabletitle': 'Neutronics Timeseries'})\n tables.append({'groupname': 'neutronics',\n 'tablename': 'neutronics_params',\n 'description': desc.NeutronicsParamsRow,\n 'tabletitle': 'Neutronics Metadata'})\n tables.append({'groupname': 'neutronics',\n 'tablename': 'zetas',\n 'description': desc.ZetasTimestepRow,\n 'tabletitle': 'Neutron Precursor Concentrations'})\n tables.append({'groupname': 'neutronics',\n 'tablename': 'omegas',\n 'description': desc.OmegasTimestepRow,\n 'tabletitle': 'Decay Heat Fractions'})\n return tables","def create_tables(args):\n\n from bob.db.base.utils import create_engine_try_nolock\n\n engine = create_engine_try_nolock(args.type, args.files[0], echo=(args.verbose >= 2));\n Client.metadata.create_all(engine)\n File.metadata.create_all(engine) \n Annotation.metadata.create_all(engine)\n #Protocol_File_Association.metadata.create_all(engine)","def create_tables(self):\n if self.mock:\n mock_dynamodb2(self._create_tables())\n else:\n self._create_tables()","def create_tables( self ) :\n return self._create_tables","def create_tables():\n inf(\"Creating tables\")\n \n pinners = Table('pinners', metadata,\n Column('pinner_id', Integer, primary_key=True),\n Column('name', String(40)),\n Column('email', String(40))\n )\n pinners.create()\n \n contents = Table('contents', metadata,\n Column('content_id', Integer, primary_key=True),\n Column('url', String(80)),\n Column('display_status', String(20)), # good, objectionable, copyright\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id'))\n )\n contents.create()\n\n reviewers = Table('reviewers', metadata,\n Column('reviewer_id', Integer, primary_key=True),\n Column('name', String(40)),\n Column('email', String(40))\n )\n reviewers.create()\n\n complaints = Table('complaints', metadata,\n Column('complaint_id', Integer, primary_key=True),\n Column('complaint_timestamp', DateTime), # when the complaint was filed\n Column('complaint_type', String(80)), # objectionable, copyright\n Column('process_status', String(20)), # complaint, review, done\n Column('display_status', String(20)), # good, objectionable, copyright\n Column('review_timestamp', DateTime), # when the compliant was resolved\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id')),\n Column('reviewer_id', Integer, ForeignKey('reviewers.reviewer_id')),\n Column('content_id', Integer, ForeignKey('contents.content_id'))\n )\n complaints.create()\n \n # could create a table of \"near by\" images and/or near by features and \n # include these in the review","def setup_table(self):\n\n self.setup.create_basic_table_in_dev()\n self.setup.insert_random_records_into_dev()","async def add_table(self, table: TableSchema) -> None:\n name = table['name']\n if not self._schema_valid_prod(table):\n if self.update_schema: # Interactively create or upgrade table schema\n stored_schema = self._get_stored_schema(name)\n if stored_schema: # Generate migrations from previous schema\n table, requests = update_table_schema(stored_schema, table)\n self._create_migration(table, requests)\n self._schema_write(table) # Write new schema to disk\n elif self.prod_mode: # Crash if production mode is on\n raise MigrationException(f\"in prod, and table {name} has outdated schema\")\n\n current_level = await self._get_migration_level(name)\n if current_level is None: # New table\n self._new_table_queue.append(table)\n elif self._needs_migrations(name, current_level): # Needs migration\n self._migration_queue.append(table)\n # else: no need to do anything for this table","def setup_table(self):\n self.interface.start_transaction()\n self.interface.drop_table(_history_table)\n self.interface.drop_table(_history_stats_table)\n self.interface.create_table(_history_table)\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\n self.interface.create_table(_history_stats_table)\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\n self.interface.commit_transaction()","def CheckTables():\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table'\")\n tables = [row[0] for row in cursor.fetchall()]\n if not tables or not \"master\" in tables:\n cursor.execute('''CREATE TABLE master (\n hit TEXT,\n logfile TEXT,\n count INTEGER,\n date TEXT)''')\n con.commit()\n if not tables or not \"rotate\" in tables:\n cursor.execute('''CREATE TABLE rotate (\n logfile TEXT,\n hash TEXT,\n date TEXT)''')\n con.commit()","def imp_create_tables():\n config = configparser.ConfigParser()\n config.read('dwh.cfg')\n\n conn = psycopg2.connect(\"host={} dbname={} user={} password={} port={}\".format(*config['CLUSTER'].values()))\n cur = conn.cursor()\n \n # Drop the tables (uncomment if necessary)\n #drop_tables(cur, conn)\n\n # Create the tables\n create_tables(cur, conn)\n\n conn.close()"],"string":"[\n \"def __new_tables_statement(self):\\n new_tables = self.__new_tables()\\n for table in new_tables:\\n with open('./update/create_tables.sql', 'a') as f:\\n create_statement = self.source.query_create_table_statement(table.name)\\n f.write(create_statement)\\n f.write('\\\\n')\",\n \"def create_tables(self):\\n for query in table_create_sql:\\n self.cursor.execute(query)\\n\\n self.commit()\",\n \"def create_all_tables(self):\\n pass\",\n \"def make_tables(self):\\n for t in self.tables:\\n self.add_table(groupname=t['groupname'],\\n tablename=t['tablename'],\\n description=t['description'],\\n tabletitle=t['tabletitle'])\",\n \"def create_tables(self):\\n con = self.connect()\\n cursor = con.cursor()\\n queries = self.tables()\\n for query in queries:\\n cursor.execute(query)\\n cursor.close()\\n con.commit()\\n con.close()\",\n \"def migrateTables(self):\\n tables = self.client_from.tables.list(['columns'])\\n if len(tables) > 0:\\n for table in tables:\\n self.client_to.tables.update(table['tableId'], json.dumps(table))\\n else:\\n print(\\\"No tables to migrate!\\\")\\n return\\n print(len(tables) + \\\" Tables migrated!\\\")\",\n \"def createTables():\\n conn = getConnection()\\n try:\\n cur = conn.cursor()\\n for table, query in tables.items():\\n cur.execute(query)\\n conn.commit()\\n except Exception as ex:\\n print(\\\"Failed to create tables:\\\" )\\n print(ex)\\n sys.exit(1)\",\n \"def create_tables_and_apply_patches(self):\\n\\n if self.authorized and not self.db_tables_initiated:\\n with self.connection.cursor() as cursor:\\n for statement in self.parse_mysql_sql_file():\\n cursor.execute(statement)\\n\\n PyFunceble.LOGGER.info(\\n \\\"Created the missing tables. Applied all patched\\\"\\n )\\n\\n self.db_tables_initiated = True\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_tables():\\n db.create_all()\",\n \"def init_tables(self) -> None:\\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\\n # it to be?\\n # \\\"How to know that schema changes?\\\"\\n # logger.warning(\\\"some message\\\")\\n with self.table_access_condition:\\n conn = self._get_connection()\\n conn.execute(\\\"PRAGMA foreign_keys = 1\\\")\\n with conn:\\n c = conn.cursor()\\n c.execute(CREATE_PROJECTS_TABLE)\\n c.execute(CREATE_TASKS_TABLE)\\n c.execute(CREATE_REQUESTERS_TABLE)\\n c.execute(CREATE_TASK_RUNS_TABLE)\\n c.execute(CREATE_ASSIGNMENTS_TABLE)\\n c.execute(CREATE_UNITS_TABLE)\\n c.execute(CREATE_WORKERS_TABLE)\\n c.execute(CREATE_AGENTS_TABLE)\\n c.execute(CREATE_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)\",\n \"def create_tables(self, tables=None):\\n LOG.debug(f\\\"Creating table subset {tables}\\\")\\n Base.metadata.create_all(self.engine, tables, checkfirst=False)\",\n \"def collect_table_names(self):\\n try:\\n for migrate_table in self.migration_tables:\\n tabel_name = migrate_table.migrationTable.DestinationTable.name\\n self.table_list.add(tabel_name)\\n self.tables.update(self.table_list)\\n except Exception as err:\\n logger.error(\\\"collect_table_names [error] -> %s\\\" % err)\",\n \"def create_all_tables():\\n\\tcommon_db.create_all_tables()\",\n \"def create_tables():\\n db.create_all()\",\n \"def append_table(self, table):\\n\\n self._db_manager.register_table(table)\",\n \"def createTables(self):\\n metadata = Base.metadata\\n metadata.create_all(self._engine)\\n return\",\n \"def insert_tables(cur, conn):\\n logger.debug(\\\"Insert tables ...\\\")\\n for query in insert_table_queries:\\n logger.debug(f'RUN query: {query}')\\n cur.execute(query)\\n conn.commit()\\n\\n print('All files INSERTED OK.')\",\n \"def create_tables(cur, conn): \\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n \\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def add_tables(self, *tables):\\n \\n for t in tables:\\n # if table contains actual aperture magnitudes\\n if \\\"mag_calib_unc\\\" in t.colnames:\\n LightCurve.__mag_table_append(self, t.copy())\\n # if table contains limiting magnitudes\\n else: \\n LightCurve.__limmag_table_append(self, t.copy())\",\n \"def create_tables(cur, conn) -> None:\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_db_tables():\\n\\n try:\\n webapp.dbsql.create_all()\\n webapp.dbsql.session.commit()\\n except Exception as e:\\n # TODO: melhorar o informe do erro\\n raise e\",\n \"async def _create_tables_declarative(self, base, engine):\\n if hasattr(base, 'metadata'):\\n base.metadata.create_all(bind=engine, checkfirst=True)\\n return\",\n \"def update(self):\\n current = LazyRegister(self.db)\\n current.render()\\n cur = self.db.cursor()\\n for table in self.tables:\\n if table in current.tables:\\n additions, removals = current.tables[table].migrate(self.tables[table])\\n for addition in additions:\\n cur.execute(\\\"\\\"\\\"ALTER TABLE %s ADD COLUMN %s\\\"\\\"\\\" % (\\n table, addition[1].get_sql()\\n ))\\n print('Added column: ', addition[0])\\n for removal in removals:\\n #cur.execute(\\\"\\\"\\\"ALTER TABLE %s DROP COLUMN %s\\\"\\\"\\\" % (\\n # table, removal[0]\\n #))\\n #print('Removed column: ', removal[0])\\n print('Did not removed column: ', removal[0])\\n else:\\n schema = self.tables[table].get_create_table_sql()\\n cur.execute(schema)\\n print('Added table %s' % table)\",\n \"def AddTable(self, table):\\n self.tables.append(table)\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\\n \\n print('Tables created.')\",\n \"def init_tables(self):\\n\\n settings.Base.metadata.tables[\\n 'session_master'].drop(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\\n\\n settings.Base.metadata.tables[\\n 'session_master'].create(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\\n\\n logging.info(\\\"Sessionization Tables created\\\")\",\n \"def set_tables(self):\\n with sql.connect('./{}.db'.format(self.name)) as conn:\\n conn.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS tweets(\\n id INTEGER PRIMARY KEY,\\n tweet_id INTEGER,\\n insert_date TEXT,\\n created_at TEXT,\\n hashtag TEXT)\\n \\\"\\\"\\\")\\n\\n conn.execute(\\\"\\\"\\\"CREATE TABLE tweet_peaks(\\n peak_datetime TEXT NOT NULL,\\n hashtag TEXT NOT NULL,\\n time_frame TEXT,\\n mean REAL,\\n std REAL,\\n sensibility REAL,\\n freq_limit REAL,\\n qt_tweets INTEGER,\\n id TEXT PRIMARY KEY,\\n probability REAL);\\n \\\"\\\"\\\")\",\n \"def create_tables(self):\\n users_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Users(\\n user_id serial PRIMARY KEY,\\n email varchar(30) NOT NULL,\\n username varchar(15) NOT NULL,\\n password varchar(250) NOT NULL,\\n role varchar(10) DEFAULT 'User'\\n );\\\"\\\"\\\"\\n\\n meals_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Meals(\\n meal_id serial PRIMARY KEY,\\n meal_name varchar(25) NOT NULL,\\n image varchar(150) NOT NULL,\\n description varchar(250) NOT NULL,\\n unit_price decimal(5,2) NOT NULL\\n );\\\"\\\"\\\"\\n\\n orders_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Orders(\\n order_id serial PRIMARY KEY,\\n user_id integer NOT NULL,\\n meal_id integer NOT NULL,\\n address varchar(50),\\n quantity int NOT NULL,\\n order_date timestamp NOT NULL,\\n status varchar(15),\\n FOREIGN KEY (user_id) REFERENCES users(user_id)\\n ON DELETE CASCADE ON UPDATE CASCADE,\\n FOREIGN KEY (meal_id) REFERENCES meals(meal_id)\\n ON DELETE CASCADE ON UPDATE CASCADE\\n );\\\"\\\"\\\"\\n return [users_tb, meals_tb, orders_tb]\",\n \"def sync_tables():\\n sync_table(ShoppingList)\\n sync_table(User)\\n sync_table(Category)\\n sync_table(Feed)\\n sync_table(News)\\n sync_table(Photo)\\n sync_table(Profile)\\n sync_table(Video)\\n sync_type(FeedPhoto)\\n sync_type(NewsPhoto)\",\n \"def create_db_tables(self):\\n self.releases = Table(\\n RELEASES,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"tag_name\\\", String),\\n Column(\\\"release_name\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n self.commits = Table(\\n COMMITS,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"branch\\\", String),\\n Column(\\\"sha\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n self.tags = Table(\\n TAGS,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"tag_name\\\", String),\\n Column(\\\"sha\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n try:\\n self.metadata.create_all()\\n log.info(\\\"Tables created\\\")\\n except Exception as e:\\n log.error(\\\"Error occurred during Table creation!\\\")\\n log.exception(e)\",\n \"def create_tables (cls, env=os.environ):\\n\\n cur = cls.pri_table_read_cursor (env=env)\\n cur.execute ('SPECIALCASE gettablelist')\\n ret = cur.fetchall ()\\n \\n existingtables = set ([x[0].lower() for x in ret])\\n\\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\\n sql, lsd = cls.table_desc[tabname]\\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\\n\\n conn = get_labeled_conn (epls, desls)\\n cur = conn.cursor ()\\n cur.execute (sql)\\n conn.close ()\\n lsd.pop_labelset ()\\n\\n \\n import psycopg2\\n for sql in cls.sql_createindex:\\n conn = get_labeled_conn ()\\n cur = conn.cursor ()\\n # XXX It would be better to check which indices exist as we do for tables.\\n try:\\n cur.execute (sql)\\n except psycopg2.ProgrammingError, e: \\n pass\\n conn.close ()\",\n \"def create_tables(self, script):\\n for query in script:\\n try:\\n self.cursor.execute(query)\\n except:\\n print(\\\"\\\\n Une erreur s'est produite lors \\\"\\n \\\"de la création des tables \\\\n\\\")\\n print(\\\"\\\\n Les tables ont bien été créées \\\"\\n f\\\"dans la base de données |{DB_NAME}| \\\\n\\\")\",\n \"def create_tables(self):\\n for name, attribute in self.__dict__.items():\\n if hasattr(attribute, 'create_table_in_sqlite_db'):\\n attribute.create_table_in_sqlite_db()\",\n \"def init_tables(self) -> None:\\n with self.table_access_condition:\\n conn = self._get_connection()\\n conn.execute(\\\"PRAGMA foreign_keys = 1\\\")\\n c = conn.cursor()\\n c.execute(tables.CREATE_STUDIES_TABLE)\\n c.execute(tables.CREATE_SUBMISSIONS_TABLE)\\n c.execute(tables.CREATE_REQUESTERS_TABLE)\\n c.execute(tables.CREATE_UNITS_TABLE)\\n c.execute(tables.CREATE_WORKERS_TABLE)\\n c.execute(tables.CREATE_RUNS_TABLE)\\n c.execute(tables.CREATE_RUN_MAP_TABLE)\\n c.execute(tables.CREATE_PARTICIPANT_GROUPS_TABLE)\\n c.execute(tables.CREATE_PARTICIPANT_GROUP_QUALIFICATIONS_MAPPING_TABLE)\\n conn.commit()\",\n \"def _create_tables():\\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\\n db.create_tables([SubjectType, SubjectRegion, Subject])\",\n \"def create_tables(self):\\n\\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\\n (\\n id SERIAL PRIMARY KEY,\\n url_yes_no boolean,\\n url TEXT,\\n phone_yes_no boolean,\\n phone TEXT,\\n rating TEXT,\\n nr_of_ratings TEXT,\\n myBusiness boolean,\\n company TEXT\\n );''')\\n\\n self.connection.commit()\",\n \"def table(self, *tables):\\n self._tables.append(', '.join(tables))\\n return self\",\n \"def create_tables(self):\\n if not self.is_enabled(Subsystem.database):\\n raise RuntimeError(\\\"Database subsystem was not enabled\\\")\\n\\n Base.metadata.create_all(self.engine)\",\n \"def _create_tables(self):\\n\\n print(\\\"\\\\n ** Creating DynamoDB Tables\\\")\\n\\n # Create Tables\\n for table_config in self.table_list:\\n with open(os.path.join(self.config_dir, table_config), \\\"rt\\\") as handle:\\n config_data = json.load(handle)\\n story_table = DynamoDB(DynamoTable.STACK_NAME, config_data[self.stack_name])\\n story_table.create()\",\n \"def __create_tables(self):\\n self.__cur.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS federations(\\n id INTEGER PRIMARY KEY UNIQUE,\\n name TEXT,\\n category TEXT\\n )\\n \\\"\\\"\\\")\\n self.__cur.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS clubs(\\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\\n code_fede INT,\\n dpt TEXT,\\n nb_clubs INT,\\n year INT,\\n FOREIGN KEY(code_fede) REFERENCES federations(i)\\n )\\n \\\"\\\"\\\")\\n self.__cur.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS by_age(\\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\\n code_fede INT,\\n age TEXT,\\n sex TEXT,\\n nb INT,\\n year INT,\\n FOREIGN KEY(code_fede) REFERENCES federations(id)\\n )\\n \\\"\\\"\\\")\\n self.__cur.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS by_dpt(\\n id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\\n code_fede INT,\\n dpt TEXT,\\n nb INT,\\n sex TEXT,\\n year INT,\\n FOREIGN KEY(code_fede) REFERENCES federations(id)\\n )\\n \\\"\\\"\\\")\\n\\n # Save all the changes\\n self.save()\",\n \"def _do_action_tables_create(self):\\n\\n schema_shell = os.path.join(self.bento_home, \\\"schema-shell\\\", \\\"bin\\\", \\\"kiji-schema-shell\\\")\\n assert os.path.isfile(schema_shell), schema_shell\\n\\n # Delete the table first!\\n cmd = (\\n \\\"kiji delete --target={kiji_uri} --interactive=false; \\\" +\\n \\\"kiji install --kiji={kiji_uri}\\\" ).format(kiji_uri=self.kiji_uri)\\n self._run_kiji_job(cmd)\\n\\n for ddl in self.ddls:\\n ddl_full_path = os.path.join(self.movie_advisor_home, ddl)\\n assert os.path.isfile(ddl_full_path)\\n cmd = \\\"{schema_shell} --kiji={kiji_uri} --file={ddl_full_path}\\\".format(\\n schema_shell=schema_shell,\\n kiji_uri=self.kiji_uri,\\n ddl_full_path=ddl_full_path)\\n self._run_kiji_job(cmd)\",\n \"def _load_tables(neo4j_session: neo4j.Session, tables: List[Dict], update_tag: int) -> None:\\n ingest_tables = \\\"\\\"\\\"\\n UNWIND $tables_list as table\\n MERGE (t:AzureStorageTable{id: table.id})\\n ON CREATE SET t.firstseen = timestamp(), t.type = table.type\\n SET t.name = table.name,\\n t.tablename = table.table_name,\\n t.lastupdated = $azure_update_tag\\n WITH t, table\\n MATCH (ts:AzureStorageTableService{id: table.service_id})\\n MERGE (ts)-[r:CONTAINS]->(t)\\n ON CREATE SET r.firstseen = timestamp()\\n SET r.lastupdated = $azure_update_tag\\n \\\"\\\"\\\"\\n\\n neo4j_session.run(\\n ingest_tables,\\n tables_list=tables,\\n azure_update_tag=update_tag,\\n )\",\n \"async def create_sys_tables(self) -> None:\\n await self.conn.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\\n table_name TEXT,\\n level INTEGER\\n )\\\"\\\"\\\")\",\n \"def insert_db():\\n populate_tables()\",\n \"def create_tables() -> None:\\n print(\\\"Creating database tables using SQLAlchemy ORM\\\")\\n Base.metadata.create_all(engine)\\n print(\\\"Done creating tables\\\")\",\n \"def create_tables(session):\\n for query in create_table_queries:\\n session.execute(query)\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except Exception as e:\\n print(e)\",\n \"def fill_target_table(new_data, curs, conn, overwrite=False):\\n for i in new_data:\\n connect_database.add_target_to_database(list(i), curs, conn, overwrite_exsiting = overwrite)\\n conn.commit()\",\n \"def pack_for_create_table(tables: tuple):\\n\\n all_tables = {'product': \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS product (\\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\\n PRODUCT_ID CHAR(50),\\n GLOBAL_ID CHAR(50),\\n TITLE TEXT,\\n COUNTRY CHAR(50),\\n RETURNS_ACCEPTED CHAR(50),\\n IS_MULTI_VARIATION_LISTING CHAR(50),\\n CONDITION_ID CHAR(50),\\n CONDITION_DISPLAY_NAME CHAR(50),\\n CATEGORY_ID CHAR(50),\\n CATEGORY_NAME CHAR(100),\\n AUTO_PAY CHAR(50),\\n LOCATION CHAR(50),\\n PAYMENT_METHOD CHAR(50),\\n TOP_RATED_LISTING CHAR(50),\\n VIEW_ITEM_URL TEXT\\n )\\\"\\\"\\\",\\n 'listing_info': \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS listing_info (\\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\\n BEST_OFFER_ENABLED CHAR(20),\\n END_TIME CHAR(50),\\n GIFT CHAR(20),\\n BUY_IT_NOW_AVAILABLE CHAR(20),\\n START_TIME CHAR(50),\\n FIXED_PRICE CHAR(20)\\n )\\\"\\\"\\\",\\n 'selling_status': \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS selling_status (\\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\\n CONVERTED_CURRENT_PRICE_CURRENCY_ID CHAR(20),\\n CONVERTED_CURRENT_PRICE_VALUE CHAR(50),\\n CURRENT_PRICE_CURRENCY_ID CHAR(20),\\n CURRENT_PRICE_VALUE CHAR(50),\\n TIME_LEFT CHAR(50),\\n SELLING_STATE CHAR(20)\\n )\\\"\\\"\\\",\\n 'shipping_info': \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS shipping_info (\\n ITEM_ID CHAR(50) NOT NULL UNIQUE,\\n SHIP_TO_LOCATIONS CHAR(20),\\n SHIPPING_TYPE CHAR(100),\\n ONE_DAY_SHIPPING_AVAILABLE CHAR(20),\\n EXPEDITED_SHIPPING CHAR(20),\\n SHIPPING_SERVICE_COST_CURRENCY_ID CHAR(50),\\n SHIPPING_SERVICE_COST_VALUE CHAR(50),\\n HANDLING_TIME CHAR(50)\\n )\\\"\\\"\\\"\\n }\\n\\n # If table was not specified, put all tables in line\\n tables = all_tables.keys() if tables is None else tables\\n\\n return ';'.join([\\\"{}\\\".format(all_tables[i]) for i in tables])\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\\n print(f\\\"\\\\nRunning: {query}\\\")\",\n \"def add_table(self, name):\\n self.puml_tables[name] = {\\n 'default': OrderedDict(),\\n 'foreign': OrderedDict(),\\n 'primary': OrderedDict()\\n }\\n # Set current table name.\\n self.current_table = name\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n print('insert', query)\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(session):\\n\\n for query in create_table_queries:\\n session.execute(query)\",\n \"async def _create_tables(self):\\n\\n await self.bot.db.execute(\\n \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS giveaways_game(\\n game_id INTEGER NOT NULL PRIMARY KEY,\\n given INTEGER DEFAULT 0,\\n key TEXT NOT NULL,\\n title TEXT NOT NULL,\\n url TEXT NOT NULL,\\n UNIQUE (key)\\n )\\n \\\"\\\"\\\"\\n )\\n\\n await self.bot.db.execute(\\n \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS giveaways_giveaway(\\n giveaway_id INTEGER NOT NULL PRIMARY KEY,\\n channel_id INTEGER,\\n created_at TIMESTAMP,\\n is_done INTEGER DEFAULT 0,\\n game_id INTEGER NOT NULL,\\n message_id INTEGER,\\n trigger_at TIMESTAMP NOT NULL,\\n FOREIGN KEY (game_id)\\n REFERENCES giveaways_game (game_id)\\n )\\n \\\"\\\"\\\"\\n )\\n\\n await self.bot.db.execute(\\n \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS giveaways_entry(\\n giveaway_id INTEGER NOT NULL,\\n user_id INTEGER NOT NULL,\\n FOREIGN KEY (giveaway_id)\\n REFERENCES giveaways_giveaway (giveaway_id)\\n UNIQUE (giveaway_id, user_id)\\n )\\n \\\"\\\"\\\"\\n )\\n\\n await self.bot.db.commit()\",\n \"def create_tables(self):\\n\\n conn = sqlite3.connect(self.db_name)\\n c = conn.cursor()\\n\\n c.execute(\\\"DROP TABLE IF EXISTS Installation;\\\")\\n c.execute(\\\"DROP TABLE IF EXISTS Equipment;\\\")\\n c.execute(\\\"DROP TABLE IF EXISTS Activity;\\\")\\n c.execute(\\\"DROP TABLE IF EXISTS EquipmentActivity;\\\")\\n\\n c.execute(\\\"CREATE TABLE Installation (Id INTEGER PRIMARY KEY, Name TEXT, Address TEXT, \\\"\\n \\\"PostalCode INTEGER, City TEXT, Latitude REAL, Longitude Real);\\\")\\n\\n c.execute(\\\"CREATE TABLE Equipment (Id INTEGER PRIMARY KEY, Name TEXT, \\\"\\n \\\"IdInstallation INTEGER, FOREIGN KEY(IdInstallation) REFERENCES Installation(Id));\\\")\\n\\n c.execute(\\\"CREATE TABLE Activity (Id INTEGER PRIMARY KEY, Name TEXT);\\\")\\n\\n c.execute(\\n \\\"CREATE TABLE EquipmentActivity (IdEquipment INTEGER, IdActivity INTEGER, PRIMARY KEY (IdEquipment, \\\"\\n \\\"IdActivity));\\\")\\n\\n conn.commit()\\n conn.close()\",\n \"def create_all_schemas_and_tables(self):\\n for schema, tables in self.schemas.items():\\n self.create_schema(schema)\\n for table in tables.keys():\\n self.create_table(schema, table)\",\n \"def create_tables():\\n with db.connect() as conn:\\n conn.execute(\\n \\\"CREATE TABLE IF NOT EXISTS url_list \\\"\\n \\\"(url_id VARCHAR(20) NOT NULL UNIQUE, url_data VARCHAR(2083) NOT NULL);\\\"\\n )\",\n \"def insert_tables(cur, conn):\\n for query in insert_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except Exception as e:\\n print(e)\",\n \"def merge_tables(self):\\r\\n\\r\\n table_params = pd.read_json(os.path.join(self.config_path, self.db_config_file),\\r\\n orient='records')[self.report_type]['table']\\r\\n\\r\\n self.trees = create_tree(table_params)\\r\\n\\r\\n for tree in self.trees:\\r\\n self._recursive_merge(tree=tree)\\r\\n self.merged_table.append(self._get_table(self.master_table[0]))\\r\\n\\r\\n # Drop table from list_of_tables, table_indexes and master_table\\r\\n del self.list_of_tables[self.table_indexes.index(self.master_table[0])]\\r\\n self.table_indexes.remove(self.master_table[0])\\r\\n del self.master_table[0]\",\n \"def test_add_table(self):\\n name_column = Varchar()\\n name_column._meta.name = \\\"name\\\"\\n schema: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\", tablename=\\\"band\\\", columns=[name_column]\\n )\\n ]\\n schema_snapshot: t.List[DiffableTable] = []\\n schema_differ = SchemaDiffer(\\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\\\"y\\\"\\n )\\n\\n create_tables = schema_differ.create_tables\\n self.assertTrue(len(create_tables.statements) == 1)\\n self.assertEqual(\\n create_tables.statements[0],\\n \\\"manager.add_table('Band', tablename='band')\\\",\\n )\\n\\n new_table_columns = schema_differ.new_table_columns\\n self.assertTrue(len(new_table_columns.statements) == 1)\\n self.assertEqual(\\n new_table_columns.statements[0],\\n \\\"manager.add_column(table_class_name='Band', tablename='band', column_name='name', db_column_name='name', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\\\", # noqa\\n )\",\n \"async def create_tables():\\n text_create_citizens_table = queries.CREATE_CITIZENS\\n text_create_relative_table = queries.CREATE_RELATIVES\\n text_create_consts_table = queries.CREATE_CONSTS\\n text_insert_base_import_id = queries.INSERT_IMPORT_ID_0\\n text_create_index_citizens = queries.CREATE_INDEX_CITIZENS\\n text_create_index_relatives = queries.CREATE_INDEX_RELATIVES\\n\\n queries_list = [text_create_citizens_table, text_create_relative_table,\\n text_create_consts_table, text_insert_base_import_id,\\n text_create_index_citizens,text_create_index_relatives]\\n\\n connection = await sql.connect()\\n async with connection.transaction():\\n for query in queries_list:\\n await sql.execute_query(connection, query)\\n await sql.close(connection)\",\n \"def create_tables():\\n\\tlog_msg4(\\\"No hay tablas para el año \\\" + txt_year + \\\". Creando\\\")\\n\\n\\tcreate_table('visited')\\n\\tcreate_table('saved')\\n\\tcreate_table('actions')\\n\\n\\tglobal new_tables_created\\n\\tnew_tables_created = True\\n\\n\\tlog_msg_ok4()\",\n \"def create_tables():\\n # Depending on your local settings, you may need to specify a user and password, e.g.\\n # conn = psycopg2.connect(dbname=DBNAME, user=\\\"postgres\\\", password=\\\"password\\\")\\n conn = psycopg2.connect(dbname=DBNAME)\\n\\n create_train_table(conn)\\n create_questions_table(conn)\\n create_lectures_table(conn)\\n create_example_test_table(conn)\\n create_example_test_table(conn)\\n\\n conn.close()\",\n \"def create_tables(hpo_id, drop_existing=False):\\n for table_name in ACHILLES_HEEL_TABLES:\\n table_id = bq_utils.get_table_id(hpo_id, table_name)\\n bq_utils.create_standard_table(table_name, table_id, drop_existing)\",\n \"def make_new_tbl(self):\\n debug = False\\n default_dd = getdata.get_default_db_dets()\\n con, cur = default_dd.con, default_dd.cur\\n oth_name_types = getdata.get_oth_name_types(self.settings_data)\\n tblname = self.tblname_lst[0]\\n if debug: print(f'DBE in make_new_tbl is: {default_dd.dbe}')\\n getdata.make_sofa_tbl(\\n con, cur, tblname, oth_name_types, headless=False)\\n wx.MessageBox(\\n _('Your new table has been added to the default SOFA database'))\",\n \"def insert_into_tables(cur, conn):\\n for query in insert_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(engine):\\n BASE.metadata.create_all(engine)\",\n \"def create_tables(self):\\n\\n cur = self.conn.cursor()\\n cur.execute('CREATE TABLE blog(blog_id INTEGER PRIMARY KEY, '\\n ' title TEXT, subtitle TEXT, content TEXT, date TEXT, '\\n ' author_id INTEGER, '\\n 'FOREIGN KEY (author_id) REFERENCES author(author_id)) ')\\n\\n cur.execute('CREATE TABLE author(author_id INTEGER PRIMARY KEY, '\\n ' name TEXT UNIQUE) ')\\n\\n cur.execute('CREATE TABLE password(password_id INTEGER PRIMARY KEY,'\\n ' author_id INTEGER, '\\n ' password TEXT, '\\n 'FOREIGN KEY (author_id) REFERENCES author(author_id)) ')\\n\\n self.conn.commit()\",\n \"def create_database_tables():\\n with APP.app_context():\\n DB.create_all()\",\n \"def create_tables(session):\\n \\n for query in create_table_queries:\\n try:\\n session.execute(query)\\n except Exception as e:\\n print(e)\",\n \"def add_table(self, name):\\n raise NotImplementedError(\\n \\\"Please implement the 'add_table' method in a derived class.\\\")\",\n \"def create_tables(c, drop_all = False):\\n\\tprint \\\"create_tables [status]: create tables triggered.\\\"\\n\\tautoincrement = \\\" autoincrement\\\"\\n\\tglobal Options, Database\\n\\tif drop_all:\\n\\t\\tprint \\\"create_tables [status]: dropping tables initiated.\\\"\\n\\t\\tif Database.type == DatabaseTypes.SQLITE:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"sqlite\\\")).read()\\n\\t\\telif Database.type == DatabaseTypes.MYSQL:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"mysql\\\")).read()\\n\\t\\telif Database.type == DatabaseTypes.POSTGRES:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"postgres\\\")).read()\\n\\t\\tdrop_list = drop_sql.split(\\\";\\\")\\n\\t\\tfor line in drop_list:\\n\\t\\t\\tquery = line.strip()\\n\\t\\t\\tif query:\\n\\t\\t\\t\\tc.execute(line)\\n\\t\\tprint \\\"create_tables [status]: dropping tables complete.\\\"\\n\\tif Database.type == DatabaseTypes.SQLITE:\\n\\t\\tdbf = open(mk_schema(\\\"sqlite\\\", Options.use_dict))\\n\\t\\tquery_list = dbf.read()\\n\\t\\tc.executescript(query_list)\\n\\telif Database.type == DatabaseTypes.MYSQL:\\n\\t\\tdbf = open(mk_schema(\\\"mysql\\\", Options.use_dict))\\n\\t\\texecutescript(c, dbf)\\n\\telif Database.type == DatabaseTypes.POSTGRES:\\n\\t\\tdbf = open(mk_schema(\\\"postgres\\\", Options.use_dict))\\n\\t\\texecutescript(c, dbf)\",\n \"def create_tables(self):\\n\\n # Uses methods from class DbAuth\\n cursor = self.connect.create_cursor()\\n cursor.execute(\\\"USE `dbPurBeurre`\\\")\\n\\n cursor.execute(\\n \\\"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Categories` (\\\"\\n \\\" `num` INT UNSIGNED AUTO_INCREMENT,\\\"\\n \\\" `id` VARCHAR(80) NOT NULL UNIQUE,\\\"\\n \\\" `name` VARCHAR(80) NOT NULL,\\\"\\n \\\" `url` VARCHAR(255) NOT NULL,\\\"\\n \\\" `products` INT NULL,\\\"\\n \\\" PRIMARY KEY (`num`))\\\"\\n \\\" ENGINE = InnoDB\\\"\\n )\\n\\n cursor.execute(\\n \\\"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Produits` (\\\"\\n \\\" `num` INT UNSIGNED AUTO_INCREMENT,\\\"\\n \\\" `id` VARCHAR(80) NOT NULL UNIQUE,\\\"\\n \\\" `product_name` VARCHAR(80) NOT NULL,\\\"\\n \\\" `nutrition_grade_fr` CHAR(1) NOT NULL,\\\"\\n \\\" `brands` VARCHAR(80) NULL,\\\"\\n \\\" `stores` VARCHAR(80) NOT NULL,\\\"\\n \\\" `url` VARCHAR(255) NOT NULL,\\\"\\n \\\" `watchlist` DATE NULL,\\\"\\n \\\" PRIMARY KEY (`num`, `id`))\\\"\\n \\\" ENGINE = InnoDB\\\"\\n )\\n\\n cursor.execute(\\n \\\"CREATE TABLE IF NOT EXISTS `dbPurBeurre`.`Asso_Prod_Cat` (\\\"\\n \\\" `id_categories` VARCHAR(80) NOT NULL,\\\"\\n \\\" `id_produits` VARCHAR(80) NOT NULL,\\\"\\n \\\" PRIMARY KEY (`id_categories`, `id_produits`),\\\"\\n \\\" CONSTRAINT `fk_id_categories`\\\"\\n \\\" FOREIGN KEY (`id_categories`)\\\"\\n \\\" REFERENCES `Categories` (`id`),\\\"\\n \\\" CONSTRAINT `fk_id_produits`\\\"\\n \\\" FOREIGN KEY (`id_produits`)\\\"\\n \\\" REFERENCES `Produits` (`id`))\\\"\\n \\\" ENGINE = InnoDB\\\"\\n )\",\n \"def load_db_tables(self):\\r\\n\\r\\n self.list_of_tables = pd.read_json(os.path.join(self.config_path, self.db_config_file),\\r\\n orient='records')[self.report_type]['table']\\r\\n\\r\\n # Loading tables from database\\r\\n for aux_index, table in enumerate(self.list_of_tables):\\r\\n \\\"\\\"\\\"\\r\\n table_indexes: position in which each table is located in the list variable 'list_of_tables'.\\r\\n list_of_tables: list data structure used to allocate the database tables in DataFrame format.\\r\\n \\\"\\\"\\\"\\r\\n self.table_indexes.append(table['name'])\\r\\n self.list_of_tables[aux_index] = pd.read_sql_table(table_name=table['name'],\\r\\n con=self.mariadb_engine,\\r\\n columns=table['columns'],\\r\\n parse_dates=table['parse_dates'])\\r\\n\\r\\n if table['master_table']:\\r\\n self.master_table.append(table['name'])\",\n \"def create_tables(): \\n \\n pk_contraint = \\\"CONSTRAINT {}_pk PRIMARY KEY ({})\\\"\\n uq_contraint = \\\"CONSTRAINT {}_uq UNIQUE ({})\\\"\\n fk_query = \\\"\\\"\\\"CONSTRAINT {}_fk_{} \\n FOREIGN KEY ({}) \\n REFERENCES {}({}) \\n ON UPDATE CASCADE \\n ON DELETE RESTRICT\\n \\\"\\\"\\\"\\n \\n create_dict = {}\\n index = 1\\n\\n\\n ############################## public SCHEMA ##############################\\n \\n schema = 'public'\\n create_schema(schema)\\n\\n #################### site ####################\\n table_name = 'site'\\n pk_id = 'site_id'\\n uq_list = ['site_code']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_code CHAR(3),\\n purok VARCHAR,\\n sitio VARCHAR,\\n barangay VARCHAR,\\n municipality VARCHAR,\\n province VARCHAR,\\n region VARCHAR,\\n psgc INTEGER,\\n active BOOLEAN NOT NULL DEFAULT TRUE,\\n season SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################## spatial SCHEMA ##############################\\n \\n schema = 'spatial'\\n create_schema(schema)\\n \\n #################### exposure ####################\\n table_name = 'exposure'\\n pk_id = 'exp_id'\\n uq_list = ['exp_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n exp_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### site_exposure ####################\\n table_name = 'site_exposure'\\n pk_id = 'se_id'\\n uq_list = ['site_id', 'exp_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n exp_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### feature ####################\\n table_name = 'feature'\\n pk_id = 'feat_id'\\n uq_list = ['feat_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n feat_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_feature ####################\\n table_name = 'site_feature'\\n pk_id = 'sf_id'\\n uq_list = ['site_id', 'feat_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n feat_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### hazard_zone ####################\\n table_name = 'hazard_zone'\\n pk_id = 'hz_id'\\n uq_list = ['site_id, geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### monitoring ####################\\n table_name = 'monitoring'\\n pk_id = 'mon_id'\\n uq_list = ['mon_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n mon_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_monitoring ####################\\n table_name = 'site_monitoring'\\n pk_id = 'sm_id'\\n uq_list = ['site_id', 'mon_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n mon_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################### comm SCHEMA ###############################\\n \\n schema = 'comm'\\n create_schema(schema)\\n\\n #################### gsm_server ####################\\n table_name = 'gsm_server'\\n pk_id = 'server_id'\\n uq_list = ['server_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_name VARCHAR,\\n platform_type VARCHAR,\\n version SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### server_port ####################\\n table_name = 'server_port'\\n pk_id = 'port_id'\\n uq_list = ['server_id', 'port']\\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_id INTEGER,\\n port BOOLEAN,\\n ser_port VARCHAR,\\n pwr_on_pin SMALLINT,\\n ring_pin SMALLINT,\\n module_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- left\\n 1- right'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### network_type ####################\\n table_name = 'network_type'\\n pk_id = 'prefix'\\n uq_list = ['prefix']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} VARCHAR(3), \\n carrier SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '1- globe\\n 2- smart\\n 3- landline'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### gsm_module ####################\\n table_name = 'gsm_module'\\n pk_id = 'gsm_id'\\n uq_list = ['prefix', 'num', 'activated']\\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n prefix VARCHAR(3),\\n num CHAR(7),\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n port_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################# temporal SCHEMA #############################\\n \\n schema = 'temporal'\\n create_schema(schema)\\n\\n #################### marker_observation ####################\\n table_name = 'marker_observation'\\n pk_id = 'mo_id'\\n uq_list = ['site_id', 'ts']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n ts TIMESTAMP,\\n meas_type VARCHAR(7),\\n weather VARCHAR,\\n observer_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_history ####################\\n table_name = 'marker_history'\\n pk_id = 'hist_id'\\n uq_list = ['sm_id', 'ts', 'event']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n sm_id BIGINT,\\n ts TIMESTAMP,\\n event BOOLEAN,\\n label_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- rename\\n 1- reposition'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_data ####################\\n table_name = 'marker_data'\\n pk_id = 'data_id'\\n uq_list = ['sm_id', 'mo_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n mo_id BIGINT,\\n sm_id BIGINT,\\n measurement NUMERIC(5,1),\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_alert ####################\\n table_name = 'marker_alert'\\n pk_id = 'alert_id'\\n uq_list = ['data_id']\\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n data_id BIGINT,\\n displacement NUMERIC(4,1),\\n time_delta FLOAT,\\n alert_level SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger_model ####################\\n table_name = 'logger_model'\\n pk_id = 'model_id'\\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n has_tilt BOOLEAN,\\n has_rain BOOLEAN,\\n has_piezo BOOLEAN,\\n has_soms BOOLEAN,\\n logger_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger ####################\\n table_name = 'logger'\\n pk_id = 'logger_id'\\n uq_list = ['sm_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n sm_id BIGINT,\\n model_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### logger_mobile ####################\\n table_name = 'logger_mobile'\\n pk_id = 'mobile_id'\\n uq_list = ['logger_id', 'activated']\\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n logger_id INTEGER,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n sim_num VARCHAR(12),\\n gsm_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n #################### EXECUTE QUERY TO CREATE TABLES ####################\\n for index in create_dict.keys():\\n dct = create_dict[index]\\n schema = dct['schema']\\n table_name = dct['table_name']\\n query = dct['query']\\n pk_id = dct['pk_id']\\n uq_list = dct['uq_list']\\n fk_dict = dct['fk_dict']\\n if len(fk_dict.keys()) == 0:\\n fk_constraint = ''\\n else:\\n fk_constraint_list = ['']\\n for fk_id in fk_dict.keys():\\n ref_schema = fk_dict.get(fk_id)['ref_schema']\\n ref_table = fk_dict.get(fk_id)['ref_table']\\n fk_part = fk_query.format(table_name, ref_table, fk_id,\\n \\\"{}.{}\\\".format(ref_schema, ref_table),\\n fk_id)\\n fk_constraint_list.append(fk_part)\\n fk_constraint = ', '.join(fk_constraint_list)\\n \\n query = query.format(schema, table_name, pk_id, \\n pk_contraint.format(table_name, pk_id),\\n uq_contraint.format(table_name, ', '.join(uq_list)),\\n \\\"{}\\\".format(fk_constraint))\\n qdb.execute(query)\",\n \"def _alter_table(self, names, types) :\\n\\n cur = self.con.cursor()\\n for i in range(min(len(names), len(types))) :\\n alter_sql = 'ALTER TABLE \\\"%s\\\" ADD COLUMN \\\"%s\\\" %s' % (self.name, names[i], types[i])\\n cur.execute(alter_sql)\",\n \"def set_up_tables(self):\\n tables = []\\n tables.append({'groupname': 'metadata',\\n 'tablename': 'sim_info',\\n 'description': desc.SimInfoRow,\\n 'tabletitle': 'Simulation Information'})\\n tables.append({'groupname': 'metadata',\\n 'tablename': 'sim_timeseries',\\n 'description': desc.SimTimeseriesRow,\\n 'tabletitle': 'Simulation Power Data'})\\n tables.append({'groupname': 'th',\\n 'tablename': 'th_params',\\n 'description': desc.ThMetadataRow,\\n 'tabletitle': 'TH Component Parameters'})\\n tables.append({'groupname': 'th',\\n 'tablename': 'th_timeseries',\\n 'description': desc.ThTimeseriesRow,\\n 'tabletitle': 'TH Timeseries'})\\n tables.append({'groupname': 'neutronics',\\n 'tablename': 'neutronics_timeseries',\\n 'description': desc.NeutronicsTimeseriesRow,\\n 'tabletitle': 'Neutronics Timeseries'})\\n tables.append({'groupname': 'neutronics',\\n 'tablename': 'neutronics_params',\\n 'description': desc.NeutronicsParamsRow,\\n 'tabletitle': 'Neutronics Metadata'})\\n tables.append({'groupname': 'neutronics',\\n 'tablename': 'zetas',\\n 'description': desc.ZetasTimestepRow,\\n 'tabletitle': 'Neutron Precursor Concentrations'})\\n tables.append({'groupname': 'neutronics',\\n 'tablename': 'omegas',\\n 'description': desc.OmegasTimestepRow,\\n 'tabletitle': 'Decay Heat Fractions'})\\n return tables\",\n \"def create_tables(args):\\n\\n from bob.db.base.utils import create_engine_try_nolock\\n\\n engine = create_engine_try_nolock(args.type, args.files[0], echo=(args.verbose >= 2));\\n Client.metadata.create_all(engine)\\n File.metadata.create_all(engine) \\n Annotation.metadata.create_all(engine)\\n #Protocol_File_Association.metadata.create_all(engine)\",\n \"def create_tables(self):\\n if self.mock:\\n mock_dynamodb2(self._create_tables())\\n else:\\n self._create_tables()\",\n \"def create_tables( self ) :\\n return self._create_tables\",\n \"def create_tables():\\n inf(\\\"Creating tables\\\")\\n \\n pinners = Table('pinners', metadata,\\n Column('pinner_id', Integer, primary_key=True),\\n Column('name', String(40)),\\n Column('email', String(40))\\n )\\n pinners.create()\\n \\n contents = Table('contents', metadata,\\n Column('content_id', Integer, primary_key=True),\\n Column('url', String(80)),\\n Column('display_status', String(20)), # good, objectionable, copyright\\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id'))\\n )\\n contents.create()\\n\\n reviewers = Table('reviewers', metadata,\\n Column('reviewer_id', Integer, primary_key=True),\\n Column('name', String(40)),\\n Column('email', String(40))\\n )\\n reviewers.create()\\n\\n complaints = Table('complaints', metadata,\\n Column('complaint_id', Integer, primary_key=True),\\n Column('complaint_timestamp', DateTime), # when the complaint was filed\\n Column('complaint_type', String(80)), # objectionable, copyright\\n Column('process_status', String(20)), # complaint, review, done\\n Column('display_status', String(20)), # good, objectionable, copyright\\n Column('review_timestamp', DateTime), # when the compliant was resolved\\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id')),\\n Column('reviewer_id', Integer, ForeignKey('reviewers.reviewer_id')),\\n Column('content_id', Integer, ForeignKey('contents.content_id'))\\n )\\n complaints.create()\\n \\n # could create a table of \\\"near by\\\" images and/or near by features and \\n # include these in the review\",\n \"def setup_table(self):\\n\\n self.setup.create_basic_table_in_dev()\\n self.setup.insert_random_records_into_dev()\",\n \"async def add_table(self, table: TableSchema) -> None:\\n name = table['name']\\n if not self._schema_valid_prod(table):\\n if self.update_schema: # Interactively create or upgrade table schema\\n stored_schema = self._get_stored_schema(name)\\n if stored_schema: # Generate migrations from previous schema\\n table, requests = update_table_schema(stored_schema, table)\\n self._create_migration(table, requests)\\n self._schema_write(table) # Write new schema to disk\\n elif self.prod_mode: # Crash if production mode is on\\n raise MigrationException(f\\\"in prod, and table {name} has outdated schema\\\")\\n\\n current_level = await self._get_migration_level(name)\\n if current_level is None: # New table\\n self._new_table_queue.append(table)\\n elif self._needs_migrations(name, current_level): # Needs migration\\n self._migration_queue.append(table)\\n # else: no need to do anything for this table\",\n \"def setup_table(self):\\n self.interface.start_transaction()\\n self.interface.drop_table(_history_table)\\n self.interface.drop_table(_history_stats_table)\\n self.interface.create_table(_history_table)\\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\\n self.interface.create_table(_history_stats_table)\\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\\n self.interface.commit_transaction()\",\n \"def CheckTables():\\n cursor.execute(\\\"SELECT name FROM sqlite_master WHERE type='table'\\\")\\n tables = [row[0] for row in cursor.fetchall()]\\n if not tables or not \\\"master\\\" in tables:\\n cursor.execute('''CREATE TABLE master (\\n hit TEXT,\\n logfile TEXT,\\n count INTEGER,\\n date TEXT)''')\\n con.commit()\\n if not tables or not \\\"rotate\\\" in tables:\\n cursor.execute('''CREATE TABLE rotate (\\n logfile TEXT,\\n hash TEXT,\\n date TEXT)''')\\n con.commit()\",\n \"def imp_create_tables():\\n config = configparser.ConfigParser()\\n config.read('dwh.cfg')\\n\\n conn = psycopg2.connect(\\\"host={} dbname={} user={} password={} port={}\\\".format(*config['CLUSTER'].values()))\\n cur = conn.cursor()\\n \\n # Drop the tables (uncomment if necessary)\\n #drop_tables(cur, conn)\\n\\n # Create the tables\\n create_tables(cur, conn)\\n\\n conn.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71956253","0.7121374","0.7104306","0.71029955","0.6936429","0.689795","0.68570906","0.6833193","0.68265414","0.68265414","0.6670361","0.66690147","0.65515643","0.65446407","0.65392756","0.6525563","0.64799553","0.6468853","0.6457003","0.645229","0.645229","0.645229","0.645229","0.64509773","0.6444706","0.6438407","0.64341664","0.6431421","0.6431406","0.64281434","0.6407347","0.6407347","0.6407347","0.6407347","0.6407347","0.6407347","0.6407347","0.6407347","0.6407347","0.639469","0.6384171","0.63715297","0.6362046","0.63579786","0.6346429","0.6345305","0.6332997","0.6330251","0.63090134","0.63020176","0.6290966","0.6279055","0.62710553","0.6260281","0.62513435","0.6223561","0.62034535","0.62010336","0.61704355","0.6162233","0.61596537","0.6152085","0.61462617","0.6145421","0.61453724","0.6120208","0.610552","0.60885745","0.60862565","0.6040819","0.6020633","0.60150784","0.6004701","0.59810483","0.5971342","0.59700906","0.5966279","0.59657544","0.5961194","0.59555495","0.5953265","0.59504527","0.5939534","0.5926679","0.59015226","0.58862835","0.5882462","0.58813095","0.5870096","0.5855055","0.5852449","0.5846737","0.584081","0.58403516","0.58347017","0.5826348","0.5815182","0.58090645","0.58049977","0.5803563","0.5777392"],"string":"[\n \"0.71956253\",\n \"0.7121374\",\n \"0.7104306\",\n \"0.71029955\",\n \"0.6936429\",\n \"0.689795\",\n \"0.68570906\",\n \"0.6833193\",\n \"0.68265414\",\n \"0.68265414\",\n \"0.6670361\",\n \"0.66690147\",\n \"0.65515643\",\n \"0.65446407\",\n \"0.65392756\",\n \"0.6525563\",\n \"0.64799553\",\n \"0.6468853\",\n \"0.6457003\",\n \"0.645229\",\n \"0.645229\",\n \"0.645229\",\n \"0.645229\",\n \"0.64509773\",\n \"0.6444706\",\n \"0.6438407\",\n \"0.64341664\",\n \"0.6431421\",\n \"0.6431406\",\n \"0.64281434\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.6407347\",\n \"0.639469\",\n \"0.6384171\",\n \"0.63715297\",\n \"0.6362046\",\n \"0.63579786\",\n \"0.6346429\",\n \"0.6345305\",\n \"0.6332997\",\n \"0.6330251\",\n \"0.63090134\",\n \"0.63020176\",\n \"0.6290966\",\n \"0.6279055\",\n \"0.62710553\",\n \"0.6260281\",\n \"0.62513435\",\n \"0.6223561\",\n \"0.62034535\",\n \"0.62010336\",\n \"0.61704355\",\n \"0.6162233\",\n \"0.61596537\",\n \"0.6152085\",\n \"0.61462617\",\n \"0.6145421\",\n \"0.61453724\",\n \"0.6120208\",\n \"0.610552\",\n \"0.60885745\",\n \"0.60862565\",\n \"0.6040819\",\n \"0.6020633\",\n \"0.60150784\",\n \"0.6004701\",\n \"0.59810483\",\n \"0.5971342\",\n \"0.59700906\",\n \"0.5966279\",\n \"0.59657544\",\n \"0.5961194\",\n \"0.59555495\",\n \"0.5953265\",\n \"0.59504527\",\n \"0.5939534\",\n \"0.5926679\",\n \"0.59015226\",\n \"0.58862835\",\n \"0.5882462\",\n \"0.58813095\",\n \"0.5870096\",\n \"0.5855055\",\n \"0.5852449\",\n \"0.5846737\",\n \"0.584081\",\n \"0.58403516\",\n \"0.58347017\",\n \"0.5826348\",\n \"0.5815182\",\n \"0.58090645\",\n \"0.58049977\",\n \"0.5803563\",\n \"0.5777392\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20298,"cells":{"query":{"kind":"string","value":"Add expressions to order by."},"document":{"kind":"string","value":"def order_by(self, list_or_name):\n if not isinstance(list_or_name, basestring):\n for c in list_or_name:\n self.order_by(c)\n else:\n self._orderby_conds.append(list_or_name)\n\n return self"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _orderby_expression(self):\n return ''","def order_by(self, *fields):\n self._evaluated = False\n if self._order is None:\n self._order = []\n\n for field in fields:\n direction = \"asc\"\n if field.startswith('-'):\n direction = \"desc\"\n field = field[1:]\n\n self._order.append({ field : direction })\n\n return self","def order_by(columns):\r\n def col(cd):\r\n return f\"{cd[0]} ASC\" if cd[1] else f\"{cd[0]} DESC\"\r\n return '' if len(columns) == 0 else f\"ORDER BY {', '.join(map(col, columns.items()))}\"","def order_by(self, *args):\n order_clauses = self.order_clauses[:]\n related_clauses = self.related_clauses[:]\n model = self.proxy.model\n for arg in args:\n if isinstance(arg, str):\n # Convert django-style to sqlalchemy ordering column\n if arg[0] == '-':\n field = arg[1:]\n ascending = False\n else:\n field = arg\n ascending = True\n\n col = resolve_member_column(model, field, related_clauses)\n\n if ascending:\n clause = col.asc()\n else:\n clause = col.desc()\n else:\n clause = arg\n if clause not in order_clauses:\n order_clauses.append(clause)\n return self.clone(order_clauses=order_clauses,\n related_clauses=related_clauses)","def _augment_order(self, stmt, key, reverse):\n sqlstmt = stmt + \" ORDER BY %s\" % key\n if reverse:\n sqlstmt += \" DESC\"\n else:\n sqlstmt += \" ASC\"\n return sqlstmt","def order_by(self, *fields):\n self.query = self.query.sort(self._parse_order_spec(fields))\n return self","def collect(transform: dict, expr: ibis.Expr) -> ibis.Expr:\n fields = promote_list(transform[\"sort\"][\"field\"])\n orders = promote_list(transform[\"sort\"].get(\"order\", [\"ascending\"] * len(fields)))\n assert len(fields) == len(orders)\n\n rules = [\n (field, (True if order == \"ascending\" else False))\n for field, order in zip(fields, orders)\n ]\n return expr.sort_by(rules)","def order_by(self, field_paths, order=None):\n raise NotImplementedError(\"This should have been implemented.\")","def order_by(self, *colnames):\r\n if len(colnames) == 0:\r\n clone = copy.deepcopy(self)\r\n clone._order = []\r\n return clone\r\n\r\n conditions = []\r\n for colname in colnames:\r\n conditions.append('\"{}\" {}'.format(*self._get_ordering_condition(colname)))\r\n\r\n clone = copy.deepcopy(self)\r\n clone._order.extend(conditions)\r\n return clone","def orderby():\n pass","def order_by(self):\r\n if self.column.order_by is not None:\r\n order_by = self.column.order_by\r\n else:\r\n # default to using column accessor as data source sort key\r\n order_by = OrderByTuple((self.accessor, ))\r\n return order_by.opposite if self.order_by_alias.is_descending else order_by","def _convert_sort_expressions(gae_sort_expressions, index_schema):\n solr_sort_expressions = []\n if gae_sort_expressions:\n for sort_expression, direction in gae_sort_expressions:\n try:\n # Date fields are indexes as two fields. DATE_FIELD should be ignored.\n fields_group = [\n solr_field\n for solr_field in index_schema.grouped_fields[sort_expression]\n if solr_field.type != SolrSchemaFieldInfo.Type.DATE_FIELD\n ]\n except KeyError:\n if EXPRESSION_SIGN.search(sort_expression):\n raise InvalidRequest(\n 'Sort expression currently supports only field names, '\n 'can not sort by expression \"{}\"'.format(sort_expression)\n )\n else:\n logger.warning('Unknown field \"{}\" in sort expression'\n .format(sort_expression))\n continue\n if len(fields_group) > 1:\n # Multiple field types are used for field with the same GAE name [*1],\n # so let's pick most \"popular\" field of those.\n field_types = ', '.join(\n '{}: {} docs'.format(field.type, field.docs_number)\n for field in fields_group\n )\n logger.warning(\n 'Multiple field types are used for field {} ({}). Sorting by {}.'\n .format(sort_expression, field_types, fields_group[0].type)\n )\n solr_field = fields_group[0]\n solr_name = solr_field.solr_name\n if solr_field.type == SolrSchemaFieldInfo.Type.TEXT_FIELD:\n solr_sort_expr = 'field({}) {}'.format(solr_name, direction)\n solr_sort_expressions.append(solr_sort_expr)\n elif solr_field.type == SolrSchemaFieldInfo.Type.ATOM_FIELD:\n solr_sort_expr = 'field({}) {}'.format(solr_name, direction)\n solr_sort_expressions.append(solr_sort_expr)\n else:\n solr_sort_expr = '{} {}'.format(solr_name, direction)\n solr_sort_expressions.append(solr_sort_expr)\n if not solr_sort_expressions:\n solr_sort_expressions = ['rank desc']\n return solr_sort_expressions","def iter_sort_items(self, expr: str) -> Iterable[str]:\n\n def format_op(s: str) -> str:\n s_exp = self.sort_ops.get(s)\n if s_exp:\n return s_exp\n raise HTTPException(\n status_code=HTTPStatus.BAD_REQUEST, detail=f\"Invalid sort field: {s}\"\n )\n\n if not expr:\n yield self.default_sort_op\n else:\n for item in expr.split(\",\"):\n item = item.strip()\n if item.startswith(\"-\"):\n yield f\"-{format_op(item[1:])}\"\n elif item.startswith(\"+\"):\n yield format_op(item[1:])\n else:\n yield format_op(item)","def order_by(self, aliases):\r\n accessors = []\r\n for alias in aliases:\r\n bound_column = self.table.columns[OrderBy(alias).bare]\r\n # bound_column.order_by reflects the current ordering applied to\r\n # the table. As such we need to check the current ordering on the\r\n # column and use the opposite if it doesn't match the alias prefix.\r\n if alias[0] != bound_column.order_by_alias[0]:\r\n accessors += bound_column.order_by.opposite\r\n else:\r\n accessors += bound_column.order_by\r\n if hasattr(self, \"queryset\"):\r\n translate = lambda accessor: accessor.replace(Accessor.SEPARATOR, QUERYSET_ACCESSOR_SEPARATOR)\r\n self.queryset = self.queryset.order_by(*(translate(a) for a in accessors))\r\n else:\r\n self.list.sort(key=OrderByTuple(accessors).key)","def order_by(self, *orderings):\n return OrderedQuery(self, orderings)","def order_by_as_sql(self):\n return comma_join([\n '%s DESC' % field[1:] if isinstance(field, str) and field[0] == '-' else str(field)\n for field in self._order_by\n ])","def sort(self, exprs):\n self._sort_exprs = exprs\n return self","def order_by(cls, *args):\n return cls.query.order_by(*args)","def order_by_alias(self):\r\n order_by = OrderBy((self.table.order_by or {}).get(self.name, self.name))\r\n order_by.next = order_by.opposite if self.is_ordered else order_by\r\n return order_by","def order_queryset(self, queryset):\n if ordering := self.request.query_params.get(\"ordering\"):\n order_by = []\n regex = re.compile(r\"-?annotations__(?P<field_id>\\d+)\")\n fields = [field.strip() for field in ordering.split(\",\")]\n for match in filter(None, map(regex.match, fields)):\n field_id = match.group(\"field_id\")\n annotation_value = AnnotationValue.objects.filter(\n entity_id=OuterRef(\"pk\"), field_id=field_id\n ).values(\"_value__value\")\n annotate = {f\"_order_{field_id}\": Subquery(annotation_value)}\n queryset = queryset.annotate(**annotate)\n sign = \"-\" if match.string.startswith(\"-\") else \"\"\n order_by.append(f\"{sign}_order_{field_id}\")\n if order_by:\n queryset = queryset.order_by(*order_by)\n return queryset","def filter_and_order(cls, *args, **kwargs):\n return cls.query.filter_by(**kwargs).order_by(*args)","def _display_operators(operators):\n def sort_name(o): return o.name\n def filter_op(o): return any([o.email, o.address, o.website, o.twitter])\n\n return sorted(filter(filter_op, operators), key=sort_name)","def order_by(self, value):\r\n # collapse empty values to ()\r\n order_by = () if not value else value\r\n # accept string\r\n order_by = order_by.split(',') if isinstance(order_by, six.string_types) else order_by\r\n valid = []\r\n # everything's been converted to a iterable, accept iterable!\r\n for alias in order_by:\r\n name = OrderBy(alias).bare\r\n if name in self.columns and self.columns[name].orderable:\r\n valid.append(alias)\r\n self._order_by = OrderByTuple(valid)\r\n self.data.order_by(self._order_by)","def order_by(self, columns, reverse=False):\n\n return self._get(\"order\", (columns, reverse), Table)","def test_order_by(self):\n self.Person(name=\"User B\", age=40).save()\n self.Person(name=\"User A\", age=20).save()\n self.Person(name=\"User C\", age=30).save()\n\n names = [p.name for p in self.Person.objects.order_by(\"-age\")]\n assert names == [\"User B\", \"User C\", \"User A\"]\n\n names = [p.name for p in self.Person.objects.order_by(\"+age\")]\n assert names == [\"User A\", \"User C\", \"User B\"]\n\n names = [p.name for p in self.Person.objects.order_by(\"age\")]\n assert names == [\"User A\", \"User C\", \"User B\"]\n\n ages = [p.age for p in self.Person.objects.order_by(\"-name\")]\n assert ages == [30, 40, 20]\n\n ages = [p.age for p in self.Person.objects.order_by()]\n assert ages == [40, 20, 30]\n\n ages = [p.age for p in self.Person.objects.order_by(\"\")]\n assert ages == [40, 20, 30]","def _asc_op(attr_name):","def _compile_order(self, orderings):\n to_apply = []\n for o in orderings:\n descending = False\n if o.startswith(\"-\"):\n descending = True\n o = o[1:]\n to_apply.append((o, descending))\n\n def compare(res1, res2):\n # res1 and res2 are attribute dictionaries\n # Apply each comparison in order\n # Note that we consider None to be bigger than anything else (i.e.\n # in an ascending sort, None comes after everything else)\n for attr, descending in to_apply:\n if descending:\n x, y = res2.get(attr, []), res1.get(attr, [])\n else:\n x, y = res1.get(attr, []), res2.get(attr, [])\n if x < y:\n return -1\n elif x > y:\n return 1\n return 0\n\n return compare","def order_by(self, *field_names):\n assert self.query.can_filter(), \\\n \"Cannot reorder a query once a slice has been taken.\"\n\n clone = self._clone()\n for field_name in field_names:\n clone.query.order_by.append(field_name)\n return clone","def _get_order_by(order, orderby, order_by_fields):\n try:\n # Find the actual database fieldnames for the keyword.\n db_fieldnames = order_by_fields[orderby]\n except KeyError:\n raise ValueError(\n \"Invalid value for 'orderby': '{}', supported values are: {}\".format(\n orderby, \", \".join(sorted(order_by_fields.keys()))\n )\n )\n\n # Default to descending for some fields, otherwise be ascending\n is_desc = (not order and orderby in ORDER_BY_DESC) or (order or \"asc\").lower() in (\n \"desc\",\n \"descending\",\n )\n\n if is_desc:\n return map(lambda name: \"-\" + name, db_fieldnames)\n else:\n return db_fieldnames","def get_random_order_by_clause(columns: List[str]) -> str:\n\n random_columns = choose_random_columns(columns)\n return f\"ORDER BY {','.join(random_columns)}\"","def order_by(self, *field_names):\n qs = copy(self)\n qs._order_by = field_names\n return qs","def order_by_raw(self, sql, bindings=None):\n if bindings is None:\n bindings = []\n\n type = 'raw'\n\n self.orders.append({\n 'type': type,\n 'sql': sql\n })\n\n self.add_binding(bindings, 'order')\n\n return self","def AddOrderByTerms(self, order_by_pairs):\n for term, args in order_by_pairs:\n assert _IsValidOrderByTerm(term), term\n assert term.count('%s') == len(args), term\n self.order_by_terms.append(term)\n self.order_by_args.extend(args)","def resolve_orderby(self, orderby: Optional[Union[List[str], str]]) -> List[OrderBy]:\n validated: List[OrderBy] = []\n\n if orderby is None:\n return validated\n\n if isinstance(orderby, str):\n if not orderby:\n return validated\n\n orderby = [orderby]\n\n orderby_columns: List[str] = orderby if orderby else []\n\n resolved_orderby: Union[str, SelectType, None]\n for orderby in orderby_columns:\n bare_orderby = orderby.lstrip(\"-\")\n bare_orderby = self.tag_to_prefixed_map.get(bare_orderby, bare_orderby)\n try:\n # Allow ordering equations with the calculated alias (ie. equation[0])\n if is_equation_alias(bare_orderby):\n resolved_orderby = bare_orderby\n # Allow ordering equations directly with the raw alias (ie. equation|a + b)\n elif is_equation(bare_orderby):\n resolved_orderby = self.equation_alias_map[strip_equation(bare_orderby)]\n bare_orderby = resolved_orderby.alias\n else:\n resolved_orderby = self.resolve_column(bare_orderby)\n except (NotImplementedError, IncompatibleMetricsQuery):\n resolved_orderby = None\n\n direction = Direction.DESC if orderby.startswith(\"-\") else Direction.ASC\n\n if fields.is_function(bare_orderby) and (\n isinstance(resolved_orderby, Function)\n or isinstance(resolved_orderby, CurriedFunction)\n or isinstance(resolved_orderby, AliasedExpression)\n ):\n bare_orderby = resolved_orderby.alias\n\n for selected_column in self.columns:\n if isinstance(selected_column, Column) and selected_column == resolved_orderby:\n validated.append(OrderBy(selected_column, direction))\n break\n elif (\n isinstance(selected_column, AliasedExpression)\n and selected_column.alias == bare_orderby\n ):\n if bare_orderby in self.orderby_converter:\n validated.append(self.orderby_converter[bare_orderby](direction))\n break\n # We cannot directly order by an `AliasedExpression`.\n # Instead, we order by the column inside.\n validated.append(OrderBy(selected_column.exp, direction))\n break\n\n elif (\n isinstance(selected_column, CurriedFunction)\n and selected_column.alias == bare_orderby\n ):\n if bare_orderby in self.orderby_converter:\n validated.append(self.orderby_converter[bare_orderby](direction))\n validated.append(OrderBy(selected_column, direction))\n break\n\n if len(validated) == len(orderby_columns):\n return validated\n\n # TODO: This is no longer true, can order by fields that aren't selected, keeping\n # for now so we're consistent with the existing functionality\n raise InvalidSearchQuery(\"Cannot sort by a field that is not selected.\")","def apply_sorts(self, query, sorts, convert_key_names_func=str):\n if len(query.column_descriptions) == 1:\n record_class = query.column_descriptions[0][\"expr\"]\n order_bys = self._get_order_bys(\n record_class, sorts, convert_key_names_func)\n for order_by in order_bys:\n query = query.order_by(order_by)\n else:\n raise ValueError\n return query","def order_by(self, name, *selectors) :\n\n temp = []\n for row in self :\n r = row.as_dict()\n keys = tuple([s(r) for s in selectors])\n temp.append((keys, r))\n\n temp.sort(key=lambda x : x[0])\n\n ct = [(s.get_name(), s.get_type()) for s in selectors]\n new_table = self.factory.new_table(name, ct)\n new_table.add_rows([x[1] for x in temp])\n return new_table","def order_by(self, column, direction=\"ASC\"):\n self._order_by += ((column, direction),)\n return self","def order_by(self, column: Union[str, List[str], List[Tuple], Any], order: str = 'ASC') -> B[B, E]:","def _get_order_bys(self, record_class, sorts, convert_key_names_func):\n result = list()\n for sort in sorts:\n attr_name = convert_key_names_func(sort.attr)\n if attr_name is not None and hasattr(record_class, attr_name):\n if sort.direction == \"ASC\":\n result.append(getattr(record_class, attr_name).asc())\n else:\n result.append(getattr(record_class, attr_name).desc())\n else:\n raise AttributeError(\"Invalid attribute.\")\n return result","def _create_order_by_list(cls, search: Search):\n\n cls.__class_validation()\n order_by_list = []\n for searchBy in search.OrderBy.split(\",\"):\n order_by = cls._get_column_from_name(searchBy)\n if search.OrderDesc and order_by is not None:\n order_by = order_by.desc()\n order_by_list.append(order_by)\n\n return order_by_list","def order_by(self, *field_names):\n if self.query.is_sliced:\n raise TypeError(\"Cannot reorder a query once a slice has been taken.\")\n obj = self._chain()\n obj.query.clear_ordering(force=True, clear_default=False)\n obj.query.add_ordering(*field_names)\n return obj","def sortby(self):\n ...","def _apply_order_by_and_limit(objects, order_by=None, limit=None):\n if order_by:\n try:\n # Note: currently we sort only by the first column from the list\n order_by = order_by[0]\n order_field = order_by[\"name\"]\n order_desc = order_by.get(\"desc\", False)\n objects = sorted(\n objects,\n key=lambda obj: getattr(obj, order_field),\n reverse=order_desc,\n )\n except:\n raise BadQueryException(\"Bad query: Invalid 'order_by' parameter\")\n\n if limit:\n try:\n from_, to_ = limit\n objects = objects[from_: to_]\n except:\n raise BadQueryException(\"Bad query: Invalid 'limit' parameter.\")\n\n return objects","def order_by(self, field, descending=False):\n self._order_by.append((field, descending))\n return self","def ordering(self, qs):\n request = self.request\n # Number of columns that are used in sorting\n try:\n i_sorting_cols = int(request.REQUEST.get('iSortingCols', 0))\n except ValueError:\n i_sorting_cols = 0\n\n order = []\n order_columns = self.get_order_columns()\n for i in range(i_sorting_cols):\n # sorting column\n try:\n i_sort_col = int(request.REQUEST.get('iSortCol_%s' % i))\n except ValueError:\n i_sort_col = 0\n # sorting order\n s_sort_dir = request.REQUEST.get('sSortDir_%s' % i)\n\n sdir = '-' if s_sort_dir == 'desc' else ''\n\n sortcol = order_columns[i_sort_col]\n if isinstance(sortcol, list):\n for sc in sortcol:\n order.append('%s%s' % (sdir, sc))\n else:\n order.append('%s%s' % (sdir, sortcol))\n if order:\n return qs.order_by(*order)\n return qs","def order_query(self, query):\n\n direction = desc if self.direction == 'desc' else asc\n if self.order in inspect(self.model_class).columns.keys():\n attribute = getattr(self.model_class, self.order)\n elif self.order == 'group.name':\n attribute = func.coalesce(UserGroup.name, '')\n elif self.order == 'user.realname':\n attribute = func.coalesce(User.realname, '')\n elif self.order == 'user.username':\n attribute = func.coalesce(User.username, '')\n elif self.order == 'user.name':\n attribute = func.coalesce(User.realname, User.username, '')\n else:\n attribute = self.model_class.first_issue\n\n return query.order_by(None).order_by(direction(attribute))","def Order(self, *orderings):\n orderings = list(orderings)\n\n for (order, i) in zip(orderings, range(len(orderings))):\n if not (isinstance(order, basestring) or\n (isinstance(order, tuple) and len(order) in [2, 3])):\n raise datastore_errors.BadArgumentError(\n 'Order() expects strings or 2- or 3-tuples; received %s (a %s). ' %\n (order, typename(order)))\n\n if isinstance(order, basestring):\n order = (order,)\n\n datastore_types.ValidateString(order[0], 'sort order property',\n datastore_errors.BadArgumentError)\n property = order[0]\n\n direction = order[-1]\n if direction not in (Query.ASCENDING, Query.DESCENDING):\n if len(order) == 3:\n raise datastore_errors.BadArgumentError(\n 'Order() expects Query.ASCENDING or DESCENDING; received %s' %\n str(direction))\n direction = Query.ASCENDING\n\n if (self.__kind is None and\n (property != datastore_types._KEY_SPECIAL_PROPERTY or\n direction != Query.ASCENDING)):\n raise datastore_errors.BadArgumentError(\n 'Only %s ascending orders are supported on kindless queries' %\n datastore_types._KEY_SPECIAL_PROPERTY)\n\n orderings[i] = (property, direction)\n\n if (orderings and self.__inequality_prop and\n orderings[0][0] != self.__inequality_prop):\n raise datastore_errors.BadArgumentError(\n 'First ordering property must be the same as inequality filter '\n 'property, if specified for this query; received %s, expected %s' %\n (orderings[0][0], self.__inequality_prop))\n\n self.__orderings = orderings\n return self","def ordering(self):\r\n if hasattr(self, \"queryset\"):\r\n aliases = {}\r\n for bound_column in self.table.columns:\r\n aliases[bound_column.order_by_alias] = bound_column.order_by\r\n try:\r\n return next(segment(self.queryset.query.order_by, aliases))\r\n except StopIteration:\r\n pass","def get_sort_query(self, kind, order, is_number):\n pass","def format_order(order):\n if order is None:\n return ''\n else:\n return 'Ordered by ' + ORDER[order]","def order_by(self, order_by):\n\n self._order_by = order_by","def order_by(self, *fields):\n doc = []\n for field in fields:\n if field.startswith('-'):\n doc.append((field.strip('-'), pymongo.DESCENDING))\n else:\n doc.append((field, pymongo.ASCENDING))\n return self.sort(doc)","def test_ordering_with_overridden_field_name(self):\n class F(FilterSet):\n class Meta:\n model = User\n fields = ['username', 'status']\n order_by = ['status']\n order_by_field = 'order'\n\n f = F({'order': 'status'}, queryset=self.qs)\n self.assertQuerysetEqual(\n f.qs, ['carl', 'alex', 'jacob', 'aaron'], lambda o: o.username)","def orderBy(\n self,\n *cols: t.Union[str, Column],\n ascending: t.Optional[t.Union[t.Any, t.List[t.Any]]] = None,\n ) -> DataFrame:\n columns = self._ensure_and_normalize_cols(cols)\n pre_ordered_col_indexes = [\n x\n for x in [\n i if isinstance(col.expression, exp.Ordered) else None\n for i, col in enumerate(columns)\n ]\n if x is not None\n ]\n if ascending is None:\n ascending = [True] * len(columns)\n elif not isinstance(ascending, list):\n ascending = [ascending] * len(columns)\n ascending = [bool(x) for i, x in enumerate(ascending)]\n assert len(columns) == len(\n ascending\n ), \"The length of items in ascending must equal the number of columns provided\"\n col_and_ascending = list(zip(columns, ascending))\n order_by_columns = [\n exp.Ordered(this=col.expression, desc=not asc)\n if i not in pre_ordered_col_indexes\n else columns[i].column_expression\n for i, (col, asc) in enumerate(col_and_ascending)\n ]\n return self.copy(expression=self.expression.order_by(*order_by_columns))","def orderby(cls, field, desc=False):\n cls.runtime.set_orderby((field, desc))\n return cls","def test_orderby(self):\n\n # TODO: make a unit test out of these various combinations\n #m = mapper(User, users, order_by=desc(users.c.user_name))\n mapper(User, users, order_by=None)\n #mapper(User, users)\n\n #l = create_session().query(User).select(order_by=[desc(users.c.user_name), asc(users.c.user_id)])\n l = create_session().query(User).all()\n #l = create_session().query(User).select(order_by=[])\n #l = create_session().query(User).select(order_by=None)","def order_by(self, column, direction='asc'):\n if self.unions:\n prop = 'union_orders'\n else:\n prop = 'orders'\n\n if direction.lower() == 'asc':\n direction = 'asc'\n else:\n direction = 'desc'\n\n getattr(self, prop).append({\n 'column': column,\n 'direction': direction\n })\n\n return self","def make_clause(exprs, orderby=None, limit=None, offset=None):\n exprs = flatten_exprs(exprs)\n assert exprs, 'Must supply exprs to make_clause! (got: %r)' % (exprs,)\n assert all(isinstance(expr, ttypes.Comparison) for expr in exprs)\n\n kwargs = {'exprs': exprs}\n if orderby is not None:\n if isinstance(orderby, (list, tuple)):\n kwargs['orderby'] = [mapserv.query.util.make_orderby(o) for o in orderby]\n else:\n kwargs['orderby'] = [mapserv.query.util.make_orderby(orderby)]\n if limit is not None:\n kwargs['limit'] = limit\n if offset:\n kwargs['offset'] = offset\n\n return ttypes.QueryClause(**kwargs)","def test_get_tag_order_by(self):\n tag = \"pod_labels__key\"\n expected_param = (tag.split(\"__\")[1],)\n\n url = \"?\"\n query_params = self.mocked_query_params(url, OCPCpuView)\n handler = OCPReportQueryHandler(query_params)\n result = handler.get_tag_order_by(tag)\n expression = result.expression\n\n self.assertIsInstance(result, OrderBy)\n self.assertEqual(expression.sql, \"pod_labels -> %s\")\n self.assertEqual(expression.params, expected_param)","def user_order_by(self, field):\n # Get ordering model.\n model_label = order.utils.resolve_labels('.'.join(\\\n [self.model._meta.app_label, self.model._meta.object_name]))\n orderitem_set = getattr(self.model, \\\n order.utils.resolve_order_item_related_set_name(model_label))\n order_model = orderitem_set.related.model\n\n # Resolve ordering model table name.\n db_table = order_model._meta.db_table\n\n # Add ordering field as extra queryset fields.\n pk_name = self.model._meta.pk.attname\n\n # If we have a descending query remove '-' from field name when quering.\n sanitized_field = field.lstrip('-')\n\n extra_select = {\n sanitized_field: '(SELECT %s from %s WHERE item_id=%s.%s)' % \\\n (sanitized_field, db_table, self.model._meta.db_table, pk_name)\n }\n\n # Use original field name when ordering to allow for descending.\n return self.extra(select=extra_select).all().order_by(field)","def get_sort_string(sort_column, sort_descending):\n if sort_column:\n sort_descending_string = \"desc\" if sort_descending else \"\"\n return \" ORDER BY %s %s\" % (sort_column, sort_descending_string) \n return \"\"","def order_by_col_from_union(self):\n return exclusions.open()","def order_by(self, order):\n new_table = self.select()\n new_table.rows.sort(key=order)\n return new_table","def maybe_order_by(sql_dict, table_list, idx, start_index, next_sql_type, sql_type_now, table_json, args):\n\n if (idx == start_index and sql_type_now != SQL_TOP) or (\n next_sql_type == SQL_SUBSUB and idx > 0 and sql_dict['where'][idx - 1] == 'sub'):\n return ''\n\n # print(len(sql_dict['where']))\n if (sql_dict['where'][idx][3][0] == 1 or sql_dict['where'][idx][3][0] == 2) and sql_dict['where'][idx][2][1][1] == \\\n sql_dict['where'][idx][3][1] and sql_dict['where'][idx][1] == 2: # sql_dict['where'][idx][1] == 2 means '='\n break_idx, next_type = (idx, SQL_SUB) if (idx > start_index and not next_sql_type) or (\n sql_type_now == SQL_TOP and not next_sql_type) else (idx, next_sql_type)\n break_idx, table_list, next_sql, sql_where, sql_having, orderby_sql_, next_table_list = get_where_column(\n sql_dict, table_list, break_idx + 1, next_type, table_json, args)\n if (not next_sql and len(sql_dict['where']) == idx + 1) or (\n next_sql and break_idx <= idx + 2): # the end of the sql or sub sql.\n if next_sql_type: # make it pass for next if check in get_where_column\n return ' '\n\n if args.keep_top_order_by and sql_type_now == SQL_TOP:\n return ''\n\n order_by_sql = \" ORDER BY \" + sql_dict['where'][idx][2][1][1] + (\n \" DESC LIMIT 1 \" if sql_dict['where'][idx][3][0] == 1 else \" ASC LIMIT 1 \")\n return order_by_sql\n return ''","def order(self, column, type):\n self._order = (column, type)\n return self","def order_filter(self,elements):","def sort(self, *keys):\n s = self._clone()\n s._sort = []\n for k in keys:\n if isinstance(k, str) and k.startswith('-'):\n k = {k[1:]: {\"order\": \"desc\"}}\n s._sort.append(k)\n return s","def add_sort(self, field_name, ascending=True):\n if not self._query_is_empty():\n self.query.AND()\n if ascending:\n logger.info(\"Sorting records by {} in ascending order.\".format(field_name))\n self.query.field(field_name.lower()).order_ascending() # lowercase for convenience\n logger.debug(\"sysparm_query contains: {q}\".format(q=self.query._query))\n else:\n logger.info(\"Sorting records by {} in descending order.\".format(field_name))\n self.query.field(field_name.lower()).order_descending()\n logger.debug(\"sysparm_query contains: {q}\".format(q=self.query._query))","def sort(self, *order_fields):\n return MockSearch(\n self, self._query, self.nested_filter_calls, order_fields,\n self._script_fields\n )","def sort(self, trans, query, ascending, column_name=None):\n return grids.GridColumn.sort(self, trans, query, ascending, column_name=\"history_id\")","def sql(self, tabtype, only_limit=False, prefix=None):\n if only_limit and self.limit < 1:\n return ''\n\n exprs = self.exprs\n if tabtype is not None:\n exprs = [(f, o) for f, o in exprs if f in tabtype._sql_fields]\n if len(exprs) == 0:\n return ''\n\n as_sql = lambda f: tabtype._as_sql(f, prefix=prefix)\n s = ' ORDER BY '\n s += ', '.join('%s %s' % (as_sql(f), o) for f, o in exprs)\n if self.limit > 0:\n s += ' LIMIT %d' % self.limit\n return s","def _add_column_and_sort_table(sources, pointing_position):\n sources = sources.copy()\n source_pos = SkyCoord(sources[\"RA\"], sources[\"DEC\"], unit=\"deg\")\n sources[\"separation\"] = pointing_position.separation(source_pos)\n sources[\"phi\"] = pointing_position.position_angle(source_pos)\n sources.sort(\"separation\")\n return sources","def order_report():","def pre_sort(self, qs):\n return qs","def add_sort_filter(source, args, index):\n tags = hxl.TagPattern.parse_list(args.get('sort-tags%02d' % index, ''))\n reverse = (args.get('sort-reverse%02d' % index) == 'on')\n return source.sort(tags, reverse)","def test_ordering_with_overridden_field_name_and_descending(self):\n class F(FilterSet):\n class Meta:\n model = User\n fields = ['username', 'status']\n order_by = ['status', '-status']\n order_by_field = 'order'\n\n f = F().form\n self.assertNotIn('o', f.fields)\n self.assertIn('order', f.fields)\n self.assertEqual(f.fields['order'].choices, [('status', 'Status'), ('-status', 'Status (descending)')])","def get_queryset(self):\n queryset = super().get_queryset()\n today = datetime.datetime.today()\n return queryset.annotate(\n relevance=models.Case(\n models.When(date__gte=today, then=1),\n models.When(date__lt=today, then=2),\n output_field=models.IntegerField(),\n )).order_by('relevance', 'date')","def _build_expression(self, exp, object_class, fields):\n if \"op\" not in exp:\n return None\n\n def autocast(o_key, value):\n \"\"\"Try to guess the type of `value` and parse it from the string.\"\"\"\n if not isinstance(o_key, (str, unicode)):\n return value\n key, _ = self.attr_name_map[object_class].get(o_key, (o_key, None))\n # handle dates\n if (\"date\" in key and \"relative\" not in key) or \\\n key in [\"end_date\", \"start_date\"]:\n if isinstance(value, datetime.date):\n return value\n try:\n month, day, year = [int(part) for part in value.split(\"/\")]\n return datetime.date(year, month, day)\n except Exception:\n raise BadQueryException(\"Field \\\"{}\\\" expects a MM/DD/YYYY date\"\n .format(o_key))\n # fallback\n return value\n\n def relevant():\n \"\"\"Filter by relevant object.\"\"\"\n query = (self.query[exp[\"ids\"][0]]\n if exp[\"object_name\"] == \"__previous__\" else exp)\n return object_class.id.in_(\n RelationshipHelper.get_ids_related_to(\n object_class.__name__,\n query[\"object_name\"],\n query[\"ids\"],\n )\n )\n\n def unknown():\n raise BadQueryException(\"Unknown operator \\\"{}\\\"\"\n .format(exp[\"op\"][\"name\"]))\n\n def with_key(key, p):\n key = key.lower()\n key, filter_by = self.attr_name_map[\n object_class].get(key, (key, None))\n if hasattr(filter_by, \"__call__\"):\n return filter_by(p)\n else:\n attr = getattr(object_class, key, None)\n if attr is None:\n raise BadQueryException(\"Bad query: object '{}' does \"\n \"not have attribute '{}'.\"\n .format(object_class.__name__, key))\n return p(attr)\n\n with_left = lambda p: with_key(exp[\"left\"], p)\n\n lift_bin = lambda f: f(self._build_expression(exp[\"left\"], object_class,\n fields),\n self._build_expression(exp[\"right\"], object_class,\n fields))\n\n def text_search():\n \"\"\"Filter by text search.\n\n The search is done only in fields listed in external `fields` var.\n \"\"\"\n existing_fields = self.attr_name_map[object_class]\n text = \"%{}%\".format(exp[\"text\"])\n p = lambda f: f.ilike(text)\n return or_(*(\n with_key(field, p)\n for field in fields\n if field in existing_fields\n ))\n\n rhs = lambda: autocast(exp[\"left\"], exp[\"right\"])\n\n ops = {\n \"AND\": lambda: lift_bin(and_),\n \"OR\": lambda: lift_bin(or_),\n \"=\": lambda: with_left(lambda l: l == rhs()),\n \"!=\": lambda: not_(with_left(\n lambda l: l == rhs())),\n \"~\": lambda: with_left(lambda l:\n l.ilike(\"%{}%\".format(rhs()))),\n \"!~\": lambda: not_(with_left(\n lambda l: l.ilike(\"%{}%\".format(rhs())))),\n \"<\": lambda: with_left(lambda l: l < rhs()),\n \">\": lambda: with_left(lambda l: l > rhs()),\n \"relevant\": relevant,\n \"text_search\": text_search\n }\n\n return ops.get(exp[\"op\"][\"name\"], unknown)()","def build_query_clauses(\n where: str = \"\", order: str = \"\", limit: int = 0, offset: int = 0\n ) -> str:\n return SqliteQueryBuilder.build_query_clauses(where, order, limit, offset)","def order_answers(self, queryset):\n if self.answer_order == 'content':\n return queryset.order_by('content')\n if self.answer_order == 'random':\n return queryset.order_by('?')\n if self.answer_order == 'none':\n return queryset.order_by('None')","def _parse_order_spec(self, spec):\n if not isinstance(spec, (list, tuple)):\n spec = [spec]\n \n res = []\n for field in spec:\n direction = pymongo.ASCENDING\n if field.startswith('-'):\n direction = pymongo.DESCENDING\n field = field[1:]\n \n field = self.document._meta.get_field_by_name(field).db_name\n res.append((field, direction))\n \n return res","def get_ordering(self):\n self.ordering = \"-fecha_vista\"\n return self.ordering","def sort_by(function):\n f = partial(sorted, key=function)\n f.attrs = {'descending': _descending_sort_by(function)}\n return f","def visit_expression(self, node, children):\n if self.debug:\n print(\"Expression {}\".format(children))\n expr = 0\n start = 0\n # Check for unary + or - operator\n if text(children[0]) in \"+-\":\n start = 1\n\n for i in range(start, len(children), 2):\n if i and children[i - 1] == \"-\":\n expr -= children[i]\n else:\n expr += children[i]\n\n if self.debug:\n print(\"Expression = {}\".format(expr))\n\n return expr","def __sort_orders_by_price(self):\n self.orders = sorted(self.orders, key=lambda o: o.price, reverse=True)","def get_sort_field(self, kind, order, is_number):\n pass","def apply_sorting(tasks, *conditions):\n return tasks.sort(conditions)","def get_ordering(self, request, queryset, view):\n ordering = []\n params = get_datatables_ordering(request.query_params)\n if params:\n fields = [param.strip() for param in params.split(',')]\n ordering = self.remove_invalid_fields(queryset, fields, view, request)\n if ordering:\n return ordering\n\n # No ordering was included, or all the ordering fields were invalid\n return self.get_default_ordering(view)","def create_expression(ex_names, stat_types):\n expression = ''\n if not isinstance(ex_names, list):\n ex_names = list(ex_names)\n\n if not isinstance(stat_types, list):\n stat_types = list(stat_types)\n\n expression = expression_maker(ex_names, stat_types.pop(0))\n for stat_type in stat_types:\n expression = expression + ',' + expression_maker(ex_names, stat_types)","def _sort_by_query_string_param(self, songs):\n orderable_fields_dict = {\n 'name': Lower('name'),\n 'artist': Lower('artist__name'),\n 'avgRating': 'average_rating',\n 'year': 'year'\n }\n\n order_by = self.request.query_params.get('orderBy', None)\n\n if order_by is not None and order_by in orderable_fields_dict:\n order_field = orderable_fields_dict[order_by]\n\n # sort in direction indicated by `direction` query string param\n # or ascending, by default\n direction = self.request.query_params.get('direction', 'asc')\n if direction == 'desc':\n if order_by == 'name' or order_by == 'artist':\n order_field = order_field.desc()\n else:\n order_field = '-' + order_field\n\n # add annotation for average_rating to sort by computed property\n if order_by == 'avgRating':\n songs = songs.annotate(\n average_rating=Avg('ratings__rating')\n )\n\n songs = songs.order_by(order_field)\n\n return songs","def order(self):\n raise NotImplementedError()","def get_sort_columns_raw(self):\n col_sort_orders = self.gridpreference_sort.all().select_related()\n \n return [x.sort_display for x in col_sort_orders]","def _sort_columns(self, order):\n unknown = set(self._columns) - set(order)\n if unknown:\n names = \", \".join(str(name) for name in unknown)\n raise ValueError(f\"Unknown columns: {names}\")\n\n cols = [self.column_location(column) for column in order]\n\n self._columns = [self._columns[col] for col in cols]\n self._data = [[row[col] for col in cols] for row in self._data]","def _append_conds(conds, tabtype, kwargs):\n keys = tabtype._sql_fields\n trim = _no_comp_suffix\n for k, v in ((k, v) for k, v in kwargs.items() if trim(k) in keys):\n conds.append(Comparison(tabtype, k, v))","def object_list(self):\n\n def _sort(ob, ol):\n reverse = ob.startswith(\"-\")\n ob = ob[1:] if reverse else ob\n for column in self.columns:\n if column.sort_key_fn is not None and column.name == ob:\n return sorted(ol, key=column.sort_key_fn, reverse=reverse)\n if self._meta.order_by and hasattr(ol, \"order_by\"):\n return ol.order_by(*self._meta.order_by.split(\"|\"))\n return ol\n\n ol = self._object_list\n ob = self._meta.order_by\n if not ob: return ol\n if isinstance(ob, basestring):\n return _sort(ob, ol)\n elif isinstance(ob, list):\n ob.reverse()\n for fn in ob:\n ol = _sort(fn, ol)\n return ol","def argsort(self, **kwargs): # noqa: PR02\n return SeriesDefault.register(pandas.Series.argsort)(self, **kwargs)","def construct_SELECT_AS(self, exp):\n display_names = self.get_display_names(exp)\n db_colnames = self.get_colnames(exp.measurementmodel)\n \n AS_stmt = ', '.join('%s AS %s' % (db_col, display_col) \n for db_col, display_col in zip(db_colnames, display_names))\n return AS_stmt","def _total_ordering(cls):\n convert = {\n '__lt__': [('__gt__', lambda self, other: not (self < other or self == other)),\n ('__le__', lambda self, other: self < other or self == other),\n ('__ge__', lambda self, other: not self < other)],\n '__le__': [('__ge__', lambda self, other: not self <= other or self == other),\n ('__lt__', lambda self, other: self <= other and not self == other),\n ('__gt__', lambda self, other: not self <= other)],\n '__gt__': [('__lt__', lambda self, other: not (self > other or self == other)),\n ('__ge__', lambda self, other: self > other or self == other),\n ('__le__', lambda self, other: not self > other)],\n '__ge__': [('__le__', lambda self, other: (not self >= other) or self == other),\n ('__gt__', lambda self, other: self >= other and not self == other),\n ('__lt__', lambda self, other: not self >= other)]\n }\n roots = set(dir(cls)) & set(convert)\n if not roots:\n raise ValueError('must define at least one ordering operation: < > <= >=')\n root = max(roots) # prefer __lt__ to __le__ to __gt__ to __ge__\n for opname, opfunc in convert[root]:\n if opname not in roots:\n opfunc.__name__ = opname\n opfunc.__doc__ = getattr(int, opname).__doc__\n setattr(cls, opname, opfunc)\n return cls","def order(self, order_id, symbol, **kwargs):\n pass"],"string":"[\n \"def _orderby_expression(self):\\n return ''\",\n \"def order_by(self, *fields):\\n self._evaluated = False\\n if self._order is None:\\n self._order = []\\n\\n for field in fields:\\n direction = \\\"asc\\\"\\n if field.startswith('-'):\\n direction = \\\"desc\\\"\\n field = field[1:]\\n\\n self._order.append({ field : direction })\\n\\n return self\",\n \"def order_by(columns):\\r\\n def col(cd):\\r\\n return f\\\"{cd[0]} ASC\\\" if cd[1] else f\\\"{cd[0]} DESC\\\"\\r\\n return '' if len(columns) == 0 else f\\\"ORDER BY {', '.join(map(col, columns.items()))}\\\"\",\n \"def order_by(self, *args):\\n order_clauses = self.order_clauses[:]\\n related_clauses = self.related_clauses[:]\\n model = self.proxy.model\\n for arg in args:\\n if isinstance(arg, str):\\n # Convert django-style to sqlalchemy ordering column\\n if arg[0] == '-':\\n field = arg[1:]\\n ascending = False\\n else:\\n field = arg\\n ascending = True\\n\\n col = resolve_member_column(model, field, related_clauses)\\n\\n if ascending:\\n clause = col.asc()\\n else:\\n clause = col.desc()\\n else:\\n clause = arg\\n if clause not in order_clauses:\\n order_clauses.append(clause)\\n return self.clone(order_clauses=order_clauses,\\n related_clauses=related_clauses)\",\n \"def _augment_order(self, stmt, key, reverse):\\n sqlstmt = stmt + \\\" ORDER BY %s\\\" % key\\n if reverse:\\n sqlstmt += \\\" DESC\\\"\\n else:\\n sqlstmt += \\\" ASC\\\"\\n return sqlstmt\",\n \"def order_by(self, *fields):\\n self.query = self.query.sort(self._parse_order_spec(fields))\\n return self\",\n \"def collect(transform: dict, expr: ibis.Expr) -> ibis.Expr:\\n fields = promote_list(transform[\\\"sort\\\"][\\\"field\\\"])\\n orders = promote_list(transform[\\\"sort\\\"].get(\\\"order\\\", [\\\"ascending\\\"] * len(fields)))\\n assert len(fields) == len(orders)\\n\\n rules = [\\n (field, (True if order == \\\"ascending\\\" else False))\\n for field, order in zip(fields, orders)\\n ]\\n return expr.sort_by(rules)\",\n \"def order_by(self, field_paths, order=None):\\n raise NotImplementedError(\\\"This should have been implemented.\\\")\",\n \"def order_by(self, *colnames):\\r\\n if len(colnames) == 0:\\r\\n clone = copy.deepcopy(self)\\r\\n clone._order = []\\r\\n return clone\\r\\n\\r\\n conditions = []\\r\\n for colname in colnames:\\r\\n conditions.append('\\\"{}\\\" {}'.format(*self._get_ordering_condition(colname)))\\r\\n\\r\\n clone = copy.deepcopy(self)\\r\\n clone._order.extend(conditions)\\r\\n return clone\",\n \"def orderby():\\n pass\",\n \"def order_by(self):\\r\\n if self.column.order_by is not None:\\r\\n order_by = self.column.order_by\\r\\n else:\\r\\n # default to using column accessor as data source sort key\\r\\n order_by = OrderByTuple((self.accessor, ))\\r\\n return order_by.opposite if self.order_by_alias.is_descending else order_by\",\n \"def _convert_sort_expressions(gae_sort_expressions, index_schema):\\n solr_sort_expressions = []\\n if gae_sort_expressions:\\n for sort_expression, direction in gae_sort_expressions:\\n try:\\n # Date fields are indexes as two fields. DATE_FIELD should be ignored.\\n fields_group = [\\n solr_field\\n for solr_field in index_schema.grouped_fields[sort_expression]\\n if solr_field.type != SolrSchemaFieldInfo.Type.DATE_FIELD\\n ]\\n except KeyError:\\n if EXPRESSION_SIGN.search(sort_expression):\\n raise InvalidRequest(\\n 'Sort expression currently supports only field names, '\\n 'can not sort by expression \\\"{}\\\"'.format(sort_expression)\\n )\\n else:\\n logger.warning('Unknown field \\\"{}\\\" in sort expression'\\n .format(sort_expression))\\n continue\\n if len(fields_group) > 1:\\n # Multiple field types are used for field with the same GAE name [*1],\\n # so let's pick most \\\"popular\\\" field of those.\\n field_types = ', '.join(\\n '{}: {} docs'.format(field.type, field.docs_number)\\n for field in fields_group\\n )\\n logger.warning(\\n 'Multiple field types are used for field {} ({}). Sorting by {}.'\\n .format(sort_expression, field_types, fields_group[0].type)\\n )\\n solr_field = fields_group[0]\\n solr_name = solr_field.solr_name\\n if solr_field.type == SolrSchemaFieldInfo.Type.TEXT_FIELD:\\n solr_sort_expr = 'field({}) {}'.format(solr_name, direction)\\n solr_sort_expressions.append(solr_sort_expr)\\n elif solr_field.type == SolrSchemaFieldInfo.Type.ATOM_FIELD:\\n solr_sort_expr = 'field({}) {}'.format(solr_name, direction)\\n solr_sort_expressions.append(solr_sort_expr)\\n else:\\n solr_sort_expr = '{} {}'.format(solr_name, direction)\\n solr_sort_expressions.append(solr_sort_expr)\\n if not solr_sort_expressions:\\n solr_sort_expressions = ['rank desc']\\n return solr_sort_expressions\",\n \"def iter_sort_items(self, expr: str) -> Iterable[str]:\\n\\n def format_op(s: str) -> str:\\n s_exp = self.sort_ops.get(s)\\n if s_exp:\\n return s_exp\\n raise HTTPException(\\n status_code=HTTPStatus.BAD_REQUEST, detail=f\\\"Invalid sort field: {s}\\\"\\n )\\n\\n if not expr:\\n yield self.default_sort_op\\n else:\\n for item in expr.split(\\\",\\\"):\\n item = item.strip()\\n if item.startswith(\\\"-\\\"):\\n yield f\\\"-{format_op(item[1:])}\\\"\\n elif item.startswith(\\\"+\\\"):\\n yield format_op(item[1:])\\n else:\\n yield format_op(item)\",\n \"def order_by(self, aliases):\\r\\n accessors = []\\r\\n for alias in aliases:\\r\\n bound_column = self.table.columns[OrderBy(alias).bare]\\r\\n # bound_column.order_by reflects the current ordering applied to\\r\\n # the table. As such we need to check the current ordering on the\\r\\n # column and use the opposite if it doesn't match the alias prefix.\\r\\n if alias[0] != bound_column.order_by_alias[0]:\\r\\n accessors += bound_column.order_by.opposite\\r\\n else:\\r\\n accessors += bound_column.order_by\\r\\n if hasattr(self, \\\"queryset\\\"):\\r\\n translate = lambda accessor: accessor.replace(Accessor.SEPARATOR, QUERYSET_ACCESSOR_SEPARATOR)\\r\\n self.queryset = self.queryset.order_by(*(translate(a) for a in accessors))\\r\\n else:\\r\\n self.list.sort(key=OrderByTuple(accessors).key)\",\n \"def order_by(self, *orderings):\\n return OrderedQuery(self, orderings)\",\n \"def order_by_as_sql(self):\\n return comma_join([\\n '%s DESC' % field[1:] if isinstance(field, str) and field[0] == '-' else str(field)\\n for field in self._order_by\\n ])\",\n \"def sort(self, exprs):\\n self._sort_exprs = exprs\\n return self\",\n \"def order_by(cls, *args):\\n return cls.query.order_by(*args)\",\n \"def order_by_alias(self):\\r\\n order_by = OrderBy((self.table.order_by or {}).get(self.name, self.name))\\r\\n order_by.next = order_by.opposite if self.is_ordered else order_by\\r\\n return order_by\",\n \"def order_queryset(self, queryset):\\n if ordering := self.request.query_params.get(\\\"ordering\\\"):\\n order_by = []\\n regex = re.compile(r\\\"-?annotations__(?P<field_id>\\\\d+)\\\")\\n fields = [field.strip() for field in ordering.split(\\\",\\\")]\\n for match in filter(None, map(regex.match, fields)):\\n field_id = match.group(\\\"field_id\\\")\\n annotation_value = AnnotationValue.objects.filter(\\n entity_id=OuterRef(\\\"pk\\\"), field_id=field_id\\n ).values(\\\"_value__value\\\")\\n annotate = {f\\\"_order_{field_id}\\\": Subquery(annotation_value)}\\n queryset = queryset.annotate(**annotate)\\n sign = \\\"-\\\" if match.string.startswith(\\\"-\\\") else \\\"\\\"\\n order_by.append(f\\\"{sign}_order_{field_id}\\\")\\n if order_by:\\n queryset = queryset.order_by(*order_by)\\n return queryset\",\n \"def filter_and_order(cls, *args, **kwargs):\\n return cls.query.filter_by(**kwargs).order_by(*args)\",\n \"def _display_operators(operators):\\n def sort_name(o): return o.name\\n def filter_op(o): return any([o.email, o.address, o.website, o.twitter])\\n\\n return sorted(filter(filter_op, operators), key=sort_name)\",\n \"def order_by(self, value):\\r\\n # collapse empty values to ()\\r\\n order_by = () if not value else value\\r\\n # accept string\\r\\n order_by = order_by.split(',') if isinstance(order_by, six.string_types) else order_by\\r\\n valid = []\\r\\n # everything's been converted to a iterable, accept iterable!\\r\\n for alias in order_by:\\r\\n name = OrderBy(alias).bare\\r\\n if name in self.columns and self.columns[name].orderable:\\r\\n valid.append(alias)\\r\\n self._order_by = OrderByTuple(valid)\\r\\n self.data.order_by(self._order_by)\",\n \"def order_by(self, columns, reverse=False):\\n\\n return self._get(\\\"order\\\", (columns, reverse), Table)\",\n \"def test_order_by(self):\\n self.Person(name=\\\"User B\\\", age=40).save()\\n self.Person(name=\\\"User A\\\", age=20).save()\\n self.Person(name=\\\"User C\\\", age=30).save()\\n\\n names = [p.name for p in self.Person.objects.order_by(\\\"-age\\\")]\\n assert names == [\\\"User B\\\", \\\"User C\\\", \\\"User A\\\"]\\n\\n names = [p.name for p in self.Person.objects.order_by(\\\"+age\\\")]\\n assert names == [\\\"User A\\\", \\\"User C\\\", \\\"User B\\\"]\\n\\n names = [p.name for p in self.Person.objects.order_by(\\\"age\\\")]\\n assert names == [\\\"User A\\\", \\\"User C\\\", \\\"User B\\\"]\\n\\n ages = [p.age for p in self.Person.objects.order_by(\\\"-name\\\")]\\n assert ages == [30, 40, 20]\\n\\n ages = [p.age for p in self.Person.objects.order_by()]\\n assert ages == [40, 20, 30]\\n\\n ages = [p.age for p in self.Person.objects.order_by(\\\"\\\")]\\n assert ages == [40, 20, 30]\",\n \"def _asc_op(attr_name):\",\n \"def _compile_order(self, orderings):\\n to_apply = []\\n for o in orderings:\\n descending = False\\n if o.startswith(\\\"-\\\"):\\n descending = True\\n o = o[1:]\\n to_apply.append((o, descending))\\n\\n def compare(res1, res2):\\n # res1 and res2 are attribute dictionaries\\n # Apply each comparison in order\\n # Note that we consider None to be bigger than anything else (i.e.\\n # in an ascending sort, None comes after everything else)\\n for attr, descending in to_apply:\\n if descending:\\n x, y = res2.get(attr, []), res1.get(attr, [])\\n else:\\n x, y = res1.get(attr, []), res2.get(attr, [])\\n if x < y:\\n return -1\\n elif x > y:\\n return 1\\n return 0\\n\\n return compare\",\n \"def order_by(self, *field_names):\\n assert self.query.can_filter(), \\\\\\n \\\"Cannot reorder a query once a slice has been taken.\\\"\\n\\n clone = self._clone()\\n for field_name in field_names:\\n clone.query.order_by.append(field_name)\\n return clone\",\n \"def _get_order_by(order, orderby, order_by_fields):\\n try:\\n # Find the actual database fieldnames for the keyword.\\n db_fieldnames = order_by_fields[orderby]\\n except KeyError:\\n raise ValueError(\\n \\\"Invalid value for 'orderby': '{}', supported values are: {}\\\".format(\\n orderby, \\\", \\\".join(sorted(order_by_fields.keys()))\\n )\\n )\\n\\n # Default to descending for some fields, otherwise be ascending\\n is_desc = (not order and orderby in ORDER_BY_DESC) or (order or \\\"asc\\\").lower() in (\\n \\\"desc\\\",\\n \\\"descending\\\",\\n )\\n\\n if is_desc:\\n return map(lambda name: \\\"-\\\" + name, db_fieldnames)\\n else:\\n return db_fieldnames\",\n \"def get_random_order_by_clause(columns: List[str]) -> str:\\n\\n random_columns = choose_random_columns(columns)\\n return f\\\"ORDER BY {','.join(random_columns)}\\\"\",\n \"def order_by(self, *field_names):\\n qs = copy(self)\\n qs._order_by = field_names\\n return qs\",\n \"def order_by_raw(self, sql, bindings=None):\\n if bindings is None:\\n bindings = []\\n\\n type = 'raw'\\n\\n self.orders.append({\\n 'type': type,\\n 'sql': sql\\n })\\n\\n self.add_binding(bindings, 'order')\\n\\n return self\",\n \"def AddOrderByTerms(self, order_by_pairs):\\n for term, args in order_by_pairs:\\n assert _IsValidOrderByTerm(term), term\\n assert term.count('%s') == len(args), term\\n self.order_by_terms.append(term)\\n self.order_by_args.extend(args)\",\n \"def resolve_orderby(self, orderby: Optional[Union[List[str], str]]) -> List[OrderBy]:\\n validated: List[OrderBy] = []\\n\\n if orderby is None:\\n return validated\\n\\n if isinstance(orderby, str):\\n if not orderby:\\n return validated\\n\\n orderby = [orderby]\\n\\n orderby_columns: List[str] = orderby if orderby else []\\n\\n resolved_orderby: Union[str, SelectType, None]\\n for orderby in orderby_columns:\\n bare_orderby = orderby.lstrip(\\\"-\\\")\\n bare_orderby = self.tag_to_prefixed_map.get(bare_orderby, bare_orderby)\\n try:\\n # Allow ordering equations with the calculated alias (ie. equation[0])\\n if is_equation_alias(bare_orderby):\\n resolved_orderby = bare_orderby\\n # Allow ordering equations directly with the raw alias (ie. equation|a + b)\\n elif is_equation(bare_orderby):\\n resolved_orderby = self.equation_alias_map[strip_equation(bare_orderby)]\\n bare_orderby = resolved_orderby.alias\\n else:\\n resolved_orderby = self.resolve_column(bare_orderby)\\n except (NotImplementedError, IncompatibleMetricsQuery):\\n resolved_orderby = None\\n\\n direction = Direction.DESC if orderby.startswith(\\\"-\\\") else Direction.ASC\\n\\n if fields.is_function(bare_orderby) and (\\n isinstance(resolved_orderby, Function)\\n or isinstance(resolved_orderby, CurriedFunction)\\n or isinstance(resolved_orderby, AliasedExpression)\\n ):\\n bare_orderby = resolved_orderby.alias\\n\\n for selected_column in self.columns:\\n if isinstance(selected_column, Column) and selected_column == resolved_orderby:\\n validated.append(OrderBy(selected_column, direction))\\n break\\n elif (\\n isinstance(selected_column, AliasedExpression)\\n and selected_column.alias == bare_orderby\\n ):\\n if bare_orderby in self.orderby_converter:\\n validated.append(self.orderby_converter[bare_orderby](direction))\\n break\\n # We cannot directly order by an `AliasedExpression`.\\n # Instead, we order by the column inside.\\n validated.append(OrderBy(selected_column.exp, direction))\\n break\\n\\n elif (\\n isinstance(selected_column, CurriedFunction)\\n and selected_column.alias == bare_orderby\\n ):\\n if bare_orderby in self.orderby_converter:\\n validated.append(self.orderby_converter[bare_orderby](direction))\\n validated.append(OrderBy(selected_column, direction))\\n break\\n\\n if len(validated) == len(orderby_columns):\\n return validated\\n\\n # TODO: This is no longer true, can order by fields that aren't selected, keeping\\n # for now so we're consistent with the existing functionality\\n raise InvalidSearchQuery(\\\"Cannot sort by a field that is not selected.\\\")\",\n \"def apply_sorts(self, query, sorts, convert_key_names_func=str):\\n if len(query.column_descriptions) == 1:\\n record_class = query.column_descriptions[0][\\\"expr\\\"]\\n order_bys = self._get_order_bys(\\n record_class, sorts, convert_key_names_func)\\n for order_by in order_bys:\\n query = query.order_by(order_by)\\n else:\\n raise ValueError\\n return query\",\n \"def order_by(self, name, *selectors) :\\n\\n temp = []\\n for row in self :\\n r = row.as_dict()\\n keys = tuple([s(r) for s in selectors])\\n temp.append((keys, r))\\n\\n temp.sort(key=lambda x : x[0])\\n\\n ct = [(s.get_name(), s.get_type()) for s in selectors]\\n new_table = self.factory.new_table(name, ct)\\n new_table.add_rows([x[1] for x in temp])\\n return new_table\",\n \"def order_by(self, column, direction=\\\"ASC\\\"):\\n self._order_by += ((column, direction),)\\n return self\",\n \"def order_by(self, column: Union[str, List[str], List[Tuple], Any], order: str = 'ASC') -> B[B, E]:\",\n \"def _get_order_bys(self, record_class, sorts, convert_key_names_func):\\n result = list()\\n for sort in sorts:\\n attr_name = convert_key_names_func(sort.attr)\\n if attr_name is not None and hasattr(record_class, attr_name):\\n if sort.direction == \\\"ASC\\\":\\n result.append(getattr(record_class, attr_name).asc())\\n else:\\n result.append(getattr(record_class, attr_name).desc())\\n else:\\n raise AttributeError(\\\"Invalid attribute.\\\")\\n return result\",\n \"def _create_order_by_list(cls, search: Search):\\n\\n cls.__class_validation()\\n order_by_list = []\\n for searchBy in search.OrderBy.split(\\\",\\\"):\\n order_by = cls._get_column_from_name(searchBy)\\n if search.OrderDesc and order_by is not None:\\n order_by = order_by.desc()\\n order_by_list.append(order_by)\\n\\n return order_by_list\",\n \"def order_by(self, *field_names):\\n if self.query.is_sliced:\\n raise TypeError(\\\"Cannot reorder a query once a slice has been taken.\\\")\\n obj = self._chain()\\n obj.query.clear_ordering(force=True, clear_default=False)\\n obj.query.add_ordering(*field_names)\\n return obj\",\n \"def sortby(self):\\n ...\",\n \"def _apply_order_by_and_limit(objects, order_by=None, limit=None):\\n if order_by:\\n try:\\n # Note: currently we sort only by the first column from the list\\n order_by = order_by[0]\\n order_field = order_by[\\\"name\\\"]\\n order_desc = order_by.get(\\\"desc\\\", False)\\n objects = sorted(\\n objects,\\n key=lambda obj: getattr(obj, order_field),\\n reverse=order_desc,\\n )\\n except:\\n raise BadQueryException(\\\"Bad query: Invalid 'order_by' parameter\\\")\\n\\n if limit:\\n try:\\n from_, to_ = limit\\n objects = objects[from_: to_]\\n except:\\n raise BadQueryException(\\\"Bad query: Invalid 'limit' parameter.\\\")\\n\\n return objects\",\n \"def order_by(self, field, descending=False):\\n self._order_by.append((field, descending))\\n return self\",\n \"def ordering(self, qs):\\n request = self.request\\n # Number of columns that are used in sorting\\n try:\\n i_sorting_cols = int(request.REQUEST.get('iSortingCols', 0))\\n except ValueError:\\n i_sorting_cols = 0\\n\\n order = []\\n order_columns = self.get_order_columns()\\n for i in range(i_sorting_cols):\\n # sorting column\\n try:\\n i_sort_col = int(request.REQUEST.get('iSortCol_%s' % i))\\n except ValueError:\\n i_sort_col = 0\\n # sorting order\\n s_sort_dir = request.REQUEST.get('sSortDir_%s' % i)\\n\\n sdir = '-' if s_sort_dir == 'desc' else ''\\n\\n sortcol = order_columns[i_sort_col]\\n if isinstance(sortcol, list):\\n for sc in sortcol:\\n order.append('%s%s' % (sdir, sc))\\n else:\\n order.append('%s%s' % (sdir, sortcol))\\n if order:\\n return qs.order_by(*order)\\n return qs\",\n \"def order_query(self, query):\\n\\n direction = desc if self.direction == 'desc' else asc\\n if self.order in inspect(self.model_class).columns.keys():\\n attribute = getattr(self.model_class, self.order)\\n elif self.order == 'group.name':\\n attribute = func.coalesce(UserGroup.name, '')\\n elif self.order == 'user.realname':\\n attribute = func.coalesce(User.realname, '')\\n elif self.order == 'user.username':\\n attribute = func.coalesce(User.username, '')\\n elif self.order == 'user.name':\\n attribute = func.coalesce(User.realname, User.username, '')\\n else:\\n attribute = self.model_class.first_issue\\n\\n return query.order_by(None).order_by(direction(attribute))\",\n \"def Order(self, *orderings):\\n orderings = list(orderings)\\n\\n for (order, i) in zip(orderings, range(len(orderings))):\\n if not (isinstance(order, basestring) or\\n (isinstance(order, tuple) and len(order) in [2, 3])):\\n raise datastore_errors.BadArgumentError(\\n 'Order() expects strings or 2- or 3-tuples; received %s (a %s). ' %\\n (order, typename(order)))\\n\\n if isinstance(order, basestring):\\n order = (order,)\\n\\n datastore_types.ValidateString(order[0], 'sort order property',\\n datastore_errors.BadArgumentError)\\n property = order[0]\\n\\n direction = order[-1]\\n if direction not in (Query.ASCENDING, Query.DESCENDING):\\n if len(order) == 3:\\n raise datastore_errors.BadArgumentError(\\n 'Order() expects Query.ASCENDING or DESCENDING; received %s' %\\n str(direction))\\n direction = Query.ASCENDING\\n\\n if (self.__kind is None and\\n (property != datastore_types._KEY_SPECIAL_PROPERTY or\\n direction != Query.ASCENDING)):\\n raise datastore_errors.BadArgumentError(\\n 'Only %s ascending orders are supported on kindless queries' %\\n datastore_types._KEY_SPECIAL_PROPERTY)\\n\\n orderings[i] = (property, direction)\\n\\n if (orderings and self.__inequality_prop and\\n orderings[0][0] != self.__inequality_prop):\\n raise datastore_errors.BadArgumentError(\\n 'First ordering property must be the same as inequality filter '\\n 'property, if specified for this query; received %s, expected %s' %\\n (orderings[0][0], self.__inequality_prop))\\n\\n self.__orderings = orderings\\n return self\",\n \"def ordering(self):\\r\\n if hasattr(self, \\\"queryset\\\"):\\r\\n aliases = {}\\r\\n for bound_column in self.table.columns:\\r\\n aliases[bound_column.order_by_alias] = bound_column.order_by\\r\\n try:\\r\\n return next(segment(self.queryset.query.order_by, aliases))\\r\\n except StopIteration:\\r\\n pass\",\n \"def get_sort_query(self, kind, order, is_number):\\n pass\",\n \"def format_order(order):\\n if order is None:\\n return ''\\n else:\\n return 'Ordered by ' + ORDER[order]\",\n \"def order_by(self, order_by):\\n\\n self._order_by = order_by\",\n \"def order_by(self, *fields):\\n doc = []\\n for field in fields:\\n if field.startswith('-'):\\n doc.append((field.strip('-'), pymongo.DESCENDING))\\n else:\\n doc.append((field, pymongo.ASCENDING))\\n return self.sort(doc)\",\n \"def test_ordering_with_overridden_field_name(self):\\n class F(FilterSet):\\n class Meta:\\n model = User\\n fields = ['username', 'status']\\n order_by = ['status']\\n order_by_field = 'order'\\n\\n f = F({'order': 'status'}, queryset=self.qs)\\n self.assertQuerysetEqual(\\n f.qs, ['carl', 'alex', 'jacob', 'aaron'], lambda o: o.username)\",\n \"def orderBy(\\n self,\\n *cols: t.Union[str, Column],\\n ascending: t.Optional[t.Union[t.Any, t.List[t.Any]]] = None,\\n ) -> DataFrame:\\n columns = self._ensure_and_normalize_cols(cols)\\n pre_ordered_col_indexes = [\\n x\\n for x in [\\n i if isinstance(col.expression, exp.Ordered) else None\\n for i, col in enumerate(columns)\\n ]\\n if x is not None\\n ]\\n if ascending is None:\\n ascending = [True] * len(columns)\\n elif not isinstance(ascending, list):\\n ascending = [ascending] * len(columns)\\n ascending = [bool(x) for i, x in enumerate(ascending)]\\n assert len(columns) == len(\\n ascending\\n ), \\\"The length of items in ascending must equal the number of columns provided\\\"\\n col_and_ascending = list(zip(columns, ascending))\\n order_by_columns = [\\n exp.Ordered(this=col.expression, desc=not asc)\\n if i not in pre_ordered_col_indexes\\n else columns[i].column_expression\\n for i, (col, asc) in enumerate(col_and_ascending)\\n ]\\n return self.copy(expression=self.expression.order_by(*order_by_columns))\",\n \"def orderby(cls, field, desc=False):\\n cls.runtime.set_orderby((field, desc))\\n return cls\",\n \"def test_orderby(self):\\n\\n # TODO: make a unit test out of these various combinations\\n #m = mapper(User, users, order_by=desc(users.c.user_name))\\n mapper(User, users, order_by=None)\\n #mapper(User, users)\\n\\n #l = create_session().query(User).select(order_by=[desc(users.c.user_name), asc(users.c.user_id)])\\n l = create_session().query(User).all()\\n #l = create_session().query(User).select(order_by=[])\\n #l = create_session().query(User).select(order_by=None)\",\n \"def order_by(self, column, direction='asc'):\\n if self.unions:\\n prop = 'union_orders'\\n else:\\n prop = 'orders'\\n\\n if direction.lower() == 'asc':\\n direction = 'asc'\\n else:\\n direction = 'desc'\\n\\n getattr(self, prop).append({\\n 'column': column,\\n 'direction': direction\\n })\\n\\n return self\",\n \"def make_clause(exprs, orderby=None, limit=None, offset=None):\\n exprs = flatten_exprs(exprs)\\n assert exprs, 'Must supply exprs to make_clause! (got: %r)' % (exprs,)\\n assert all(isinstance(expr, ttypes.Comparison) for expr in exprs)\\n\\n kwargs = {'exprs': exprs}\\n if orderby is not None:\\n if isinstance(orderby, (list, tuple)):\\n kwargs['orderby'] = [mapserv.query.util.make_orderby(o) for o in orderby]\\n else:\\n kwargs['orderby'] = [mapserv.query.util.make_orderby(orderby)]\\n if limit is not None:\\n kwargs['limit'] = limit\\n if offset:\\n kwargs['offset'] = offset\\n\\n return ttypes.QueryClause(**kwargs)\",\n \"def test_get_tag_order_by(self):\\n tag = \\\"pod_labels__key\\\"\\n expected_param = (tag.split(\\\"__\\\")[1],)\\n\\n url = \\\"?\\\"\\n query_params = self.mocked_query_params(url, OCPCpuView)\\n handler = OCPReportQueryHandler(query_params)\\n result = handler.get_tag_order_by(tag)\\n expression = result.expression\\n\\n self.assertIsInstance(result, OrderBy)\\n self.assertEqual(expression.sql, \\\"pod_labels -> %s\\\")\\n self.assertEqual(expression.params, expected_param)\",\n \"def user_order_by(self, field):\\n # Get ordering model.\\n model_label = order.utils.resolve_labels('.'.join(\\\\\\n [self.model._meta.app_label, self.model._meta.object_name]))\\n orderitem_set = getattr(self.model, \\\\\\n order.utils.resolve_order_item_related_set_name(model_label))\\n order_model = orderitem_set.related.model\\n\\n # Resolve ordering model table name.\\n db_table = order_model._meta.db_table\\n\\n # Add ordering field as extra queryset fields.\\n pk_name = self.model._meta.pk.attname\\n\\n # If we have a descending query remove '-' from field name when quering.\\n sanitized_field = field.lstrip('-')\\n\\n extra_select = {\\n sanitized_field: '(SELECT %s from %s WHERE item_id=%s.%s)' % \\\\\\n (sanitized_field, db_table, self.model._meta.db_table, pk_name)\\n }\\n\\n # Use original field name when ordering to allow for descending.\\n return self.extra(select=extra_select).all().order_by(field)\",\n \"def get_sort_string(sort_column, sort_descending):\\n if sort_column:\\n sort_descending_string = \\\"desc\\\" if sort_descending else \\\"\\\"\\n return \\\" ORDER BY %s %s\\\" % (sort_column, sort_descending_string) \\n return \\\"\\\"\",\n \"def order_by_col_from_union(self):\\n return exclusions.open()\",\n \"def order_by(self, order):\\n new_table = self.select()\\n new_table.rows.sort(key=order)\\n return new_table\",\n \"def maybe_order_by(sql_dict, table_list, idx, start_index, next_sql_type, sql_type_now, table_json, args):\\n\\n if (idx == start_index and sql_type_now != SQL_TOP) or (\\n next_sql_type == SQL_SUBSUB and idx > 0 and sql_dict['where'][idx - 1] == 'sub'):\\n return ''\\n\\n # print(len(sql_dict['where']))\\n if (sql_dict['where'][idx][3][0] == 1 or sql_dict['where'][idx][3][0] == 2) and sql_dict['where'][idx][2][1][1] == \\\\\\n sql_dict['where'][idx][3][1] and sql_dict['where'][idx][1] == 2: # sql_dict['where'][idx][1] == 2 means '='\\n break_idx, next_type = (idx, SQL_SUB) if (idx > start_index and not next_sql_type) or (\\n sql_type_now == SQL_TOP and not next_sql_type) else (idx, next_sql_type)\\n break_idx, table_list, next_sql, sql_where, sql_having, orderby_sql_, next_table_list = get_where_column(\\n sql_dict, table_list, break_idx + 1, next_type, table_json, args)\\n if (not next_sql and len(sql_dict['where']) == idx + 1) or (\\n next_sql and break_idx <= idx + 2): # the end of the sql or sub sql.\\n if next_sql_type: # make it pass for next if check in get_where_column\\n return ' '\\n\\n if args.keep_top_order_by and sql_type_now == SQL_TOP:\\n return ''\\n\\n order_by_sql = \\\" ORDER BY \\\" + sql_dict['where'][idx][2][1][1] + (\\n \\\" DESC LIMIT 1 \\\" if sql_dict['where'][idx][3][0] == 1 else \\\" ASC LIMIT 1 \\\")\\n return order_by_sql\\n return ''\",\n \"def order(self, column, type):\\n self._order = (column, type)\\n return self\",\n \"def order_filter(self,elements):\",\n \"def sort(self, *keys):\\n s = self._clone()\\n s._sort = []\\n for k in keys:\\n if isinstance(k, str) and k.startswith('-'):\\n k = {k[1:]: {\\\"order\\\": \\\"desc\\\"}}\\n s._sort.append(k)\\n return s\",\n \"def add_sort(self, field_name, ascending=True):\\n if not self._query_is_empty():\\n self.query.AND()\\n if ascending:\\n logger.info(\\\"Sorting records by {} in ascending order.\\\".format(field_name))\\n self.query.field(field_name.lower()).order_ascending() # lowercase for convenience\\n logger.debug(\\\"sysparm_query contains: {q}\\\".format(q=self.query._query))\\n else:\\n logger.info(\\\"Sorting records by {} in descending order.\\\".format(field_name))\\n self.query.field(field_name.lower()).order_descending()\\n logger.debug(\\\"sysparm_query contains: {q}\\\".format(q=self.query._query))\",\n \"def sort(self, *order_fields):\\n return MockSearch(\\n self, self._query, self.nested_filter_calls, order_fields,\\n self._script_fields\\n )\",\n \"def sort(self, trans, query, ascending, column_name=None):\\n return grids.GridColumn.sort(self, trans, query, ascending, column_name=\\\"history_id\\\")\",\n \"def sql(self, tabtype, only_limit=False, prefix=None):\\n if only_limit and self.limit < 1:\\n return ''\\n\\n exprs = self.exprs\\n if tabtype is not None:\\n exprs = [(f, o) for f, o in exprs if f in tabtype._sql_fields]\\n if len(exprs) == 0:\\n return ''\\n\\n as_sql = lambda f: tabtype._as_sql(f, prefix=prefix)\\n s = ' ORDER BY '\\n s += ', '.join('%s %s' % (as_sql(f), o) for f, o in exprs)\\n if self.limit > 0:\\n s += ' LIMIT %d' % self.limit\\n return s\",\n \"def _add_column_and_sort_table(sources, pointing_position):\\n sources = sources.copy()\\n source_pos = SkyCoord(sources[\\\"RA\\\"], sources[\\\"DEC\\\"], unit=\\\"deg\\\")\\n sources[\\\"separation\\\"] = pointing_position.separation(source_pos)\\n sources[\\\"phi\\\"] = pointing_position.position_angle(source_pos)\\n sources.sort(\\\"separation\\\")\\n return sources\",\n \"def order_report():\",\n \"def pre_sort(self, qs):\\n return qs\",\n \"def add_sort_filter(source, args, index):\\n tags = hxl.TagPattern.parse_list(args.get('sort-tags%02d' % index, ''))\\n reverse = (args.get('sort-reverse%02d' % index) == 'on')\\n return source.sort(tags, reverse)\",\n \"def test_ordering_with_overridden_field_name_and_descending(self):\\n class F(FilterSet):\\n class Meta:\\n model = User\\n fields = ['username', 'status']\\n order_by = ['status', '-status']\\n order_by_field = 'order'\\n\\n f = F().form\\n self.assertNotIn('o', f.fields)\\n self.assertIn('order', f.fields)\\n self.assertEqual(f.fields['order'].choices, [('status', 'Status'), ('-status', 'Status (descending)')])\",\n \"def get_queryset(self):\\n queryset = super().get_queryset()\\n today = datetime.datetime.today()\\n return queryset.annotate(\\n relevance=models.Case(\\n models.When(date__gte=today, then=1),\\n models.When(date__lt=today, then=2),\\n output_field=models.IntegerField(),\\n )).order_by('relevance', 'date')\",\n \"def _build_expression(self, exp, object_class, fields):\\n if \\\"op\\\" not in exp:\\n return None\\n\\n def autocast(o_key, value):\\n \\\"\\\"\\\"Try to guess the type of `value` and parse it from the string.\\\"\\\"\\\"\\n if not isinstance(o_key, (str, unicode)):\\n return value\\n key, _ = self.attr_name_map[object_class].get(o_key, (o_key, None))\\n # handle dates\\n if (\\\"date\\\" in key and \\\"relative\\\" not in key) or \\\\\\n key in [\\\"end_date\\\", \\\"start_date\\\"]:\\n if isinstance(value, datetime.date):\\n return value\\n try:\\n month, day, year = [int(part) for part in value.split(\\\"/\\\")]\\n return datetime.date(year, month, day)\\n except Exception:\\n raise BadQueryException(\\\"Field \\\\\\\"{}\\\\\\\" expects a MM/DD/YYYY date\\\"\\n .format(o_key))\\n # fallback\\n return value\\n\\n def relevant():\\n \\\"\\\"\\\"Filter by relevant object.\\\"\\\"\\\"\\n query = (self.query[exp[\\\"ids\\\"][0]]\\n if exp[\\\"object_name\\\"] == \\\"__previous__\\\" else exp)\\n return object_class.id.in_(\\n RelationshipHelper.get_ids_related_to(\\n object_class.__name__,\\n query[\\\"object_name\\\"],\\n query[\\\"ids\\\"],\\n )\\n )\\n\\n def unknown():\\n raise BadQueryException(\\\"Unknown operator \\\\\\\"{}\\\\\\\"\\\"\\n .format(exp[\\\"op\\\"][\\\"name\\\"]))\\n\\n def with_key(key, p):\\n key = key.lower()\\n key, filter_by = self.attr_name_map[\\n object_class].get(key, (key, None))\\n if hasattr(filter_by, \\\"__call__\\\"):\\n return filter_by(p)\\n else:\\n attr = getattr(object_class, key, None)\\n if attr is None:\\n raise BadQueryException(\\\"Bad query: object '{}' does \\\"\\n \\\"not have attribute '{}'.\\\"\\n .format(object_class.__name__, key))\\n return p(attr)\\n\\n with_left = lambda p: with_key(exp[\\\"left\\\"], p)\\n\\n lift_bin = lambda f: f(self._build_expression(exp[\\\"left\\\"], object_class,\\n fields),\\n self._build_expression(exp[\\\"right\\\"], object_class,\\n fields))\\n\\n def text_search():\\n \\\"\\\"\\\"Filter by text search.\\n\\n The search is done only in fields listed in external `fields` var.\\n \\\"\\\"\\\"\\n existing_fields = self.attr_name_map[object_class]\\n text = \\\"%{}%\\\".format(exp[\\\"text\\\"])\\n p = lambda f: f.ilike(text)\\n return or_(*(\\n with_key(field, p)\\n for field in fields\\n if field in existing_fields\\n ))\\n\\n rhs = lambda: autocast(exp[\\\"left\\\"], exp[\\\"right\\\"])\\n\\n ops = {\\n \\\"AND\\\": lambda: lift_bin(and_),\\n \\\"OR\\\": lambda: lift_bin(or_),\\n \\\"=\\\": lambda: with_left(lambda l: l == rhs()),\\n \\\"!=\\\": lambda: not_(with_left(\\n lambda l: l == rhs())),\\n \\\"~\\\": lambda: with_left(lambda l:\\n l.ilike(\\\"%{}%\\\".format(rhs()))),\\n \\\"!~\\\": lambda: not_(with_left(\\n lambda l: l.ilike(\\\"%{}%\\\".format(rhs())))),\\n \\\"<\\\": lambda: with_left(lambda l: l < rhs()),\\n \\\">\\\": lambda: with_left(lambda l: l > rhs()),\\n \\\"relevant\\\": relevant,\\n \\\"text_search\\\": text_search\\n }\\n\\n return ops.get(exp[\\\"op\\\"][\\\"name\\\"], unknown)()\",\n \"def build_query_clauses(\\n where: str = \\\"\\\", order: str = \\\"\\\", limit: int = 0, offset: int = 0\\n ) -> str:\\n return SqliteQueryBuilder.build_query_clauses(where, order, limit, offset)\",\n \"def order_answers(self, queryset):\\n if self.answer_order == 'content':\\n return queryset.order_by('content')\\n if self.answer_order == 'random':\\n return queryset.order_by('?')\\n if self.answer_order == 'none':\\n return queryset.order_by('None')\",\n \"def _parse_order_spec(self, spec):\\n if not isinstance(spec, (list, tuple)):\\n spec = [spec]\\n \\n res = []\\n for field in spec:\\n direction = pymongo.ASCENDING\\n if field.startswith('-'):\\n direction = pymongo.DESCENDING\\n field = field[1:]\\n \\n field = self.document._meta.get_field_by_name(field).db_name\\n res.append((field, direction))\\n \\n return res\",\n \"def get_ordering(self):\\n self.ordering = \\\"-fecha_vista\\\"\\n return self.ordering\",\n \"def sort_by(function):\\n f = partial(sorted, key=function)\\n f.attrs = {'descending': _descending_sort_by(function)}\\n return f\",\n \"def visit_expression(self, node, children):\\n if self.debug:\\n print(\\\"Expression {}\\\".format(children))\\n expr = 0\\n start = 0\\n # Check for unary + or - operator\\n if text(children[0]) in \\\"+-\\\":\\n start = 1\\n\\n for i in range(start, len(children), 2):\\n if i and children[i - 1] == \\\"-\\\":\\n expr -= children[i]\\n else:\\n expr += children[i]\\n\\n if self.debug:\\n print(\\\"Expression = {}\\\".format(expr))\\n\\n return expr\",\n \"def __sort_orders_by_price(self):\\n self.orders = sorted(self.orders, key=lambda o: o.price, reverse=True)\",\n \"def get_sort_field(self, kind, order, is_number):\\n pass\",\n \"def apply_sorting(tasks, *conditions):\\n return tasks.sort(conditions)\",\n \"def get_ordering(self, request, queryset, view):\\n ordering = []\\n params = get_datatables_ordering(request.query_params)\\n if params:\\n fields = [param.strip() for param in params.split(',')]\\n ordering = self.remove_invalid_fields(queryset, fields, view, request)\\n if ordering:\\n return ordering\\n\\n # No ordering was included, or all the ordering fields were invalid\\n return self.get_default_ordering(view)\",\n \"def create_expression(ex_names, stat_types):\\n expression = ''\\n if not isinstance(ex_names, list):\\n ex_names = list(ex_names)\\n\\n if not isinstance(stat_types, list):\\n stat_types = list(stat_types)\\n\\n expression = expression_maker(ex_names, stat_types.pop(0))\\n for stat_type in stat_types:\\n expression = expression + ',' + expression_maker(ex_names, stat_types)\",\n \"def _sort_by_query_string_param(self, songs):\\n orderable_fields_dict = {\\n 'name': Lower('name'),\\n 'artist': Lower('artist__name'),\\n 'avgRating': 'average_rating',\\n 'year': 'year'\\n }\\n\\n order_by = self.request.query_params.get('orderBy', None)\\n\\n if order_by is not None and order_by in orderable_fields_dict:\\n order_field = orderable_fields_dict[order_by]\\n\\n # sort in direction indicated by `direction` query string param\\n # or ascending, by default\\n direction = self.request.query_params.get('direction', 'asc')\\n if direction == 'desc':\\n if order_by == 'name' or order_by == 'artist':\\n order_field = order_field.desc()\\n else:\\n order_field = '-' + order_field\\n\\n # add annotation for average_rating to sort by computed property\\n if order_by == 'avgRating':\\n songs = songs.annotate(\\n average_rating=Avg('ratings__rating')\\n )\\n\\n songs = songs.order_by(order_field)\\n\\n return songs\",\n \"def order(self):\\n raise NotImplementedError()\",\n \"def get_sort_columns_raw(self):\\n col_sort_orders = self.gridpreference_sort.all().select_related()\\n \\n return [x.sort_display for x in col_sort_orders]\",\n \"def _sort_columns(self, order):\\n unknown = set(self._columns) - set(order)\\n if unknown:\\n names = \\\", \\\".join(str(name) for name in unknown)\\n raise ValueError(f\\\"Unknown columns: {names}\\\")\\n\\n cols = [self.column_location(column) for column in order]\\n\\n self._columns = [self._columns[col] for col in cols]\\n self._data = [[row[col] for col in cols] for row in self._data]\",\n \"def _append_conds(conds, tabtype, kwargs):\\n keys = tabtype._sql_fields\\n trim = _no_comp_suffix\\n for k, v in ((k, v) for k, v in kwargs.items() if trim(k) in keys):\\n conds.append(Comparison(tabtype, k, v))\",\n \"def object_list(self):\\n\\n def _sort(ob, ol):\\n reverse = ob.startswith(\\\"-\\\")\\n ob = ob[1:] if reverse else ob\\n for column in self.columns:\\n if column.sort_key_fn is not None and column.name == ob:\\n return sorted(ol, key=column.sort_key_fn, reverse=reverse)\\n if self._meta.order_by and hasattr(ol, \\\"order_by\\\"):\\n return ol.order_by(*self._meta.order_by.split(\\\"|\\\"))\\n return ol\\n\\n ol = self._object_list\\n ob = self._meta.order_by\\n if not ob: return ol\\n if isinstance(ob, basestring):\\n return _sort(ob, ol)\\n elif isinstance(ob, list):\\n ob.reverse()\\n for fn in ob:\\n ol = _sort(fn, ol)\\n return ol\",\n \"def argsort(self, **kwargs): # noqa: PR02\\n return SeriesDefault.register(pandas.Series.argsort)(self, **kwargs)\",\n \"def construct_SELECT_AS(self, exp):\\n display_names = self.get_display_names(exp)\\n db_colnames = self.get_colnames(exp.measurementmodel)\\n \\n AS_stmt = ', '.join('%s AS %s' % (db_col, display_col) \\n for db_col, display_col in zip(db_colnames, display_names))\\n return AS_stmt\",\n \"def _total_ordering(cls):\\n convert = {\\n '__lt__': [('__gt__', lambda self, other: not (self < other or self == other)),\\n ('__le__', lambda self, other: self < other or self == other),\\n ('__ge__', lambda self, other: not self < other)],\\n '__le__': [('__ge__', lambda self, other: not self <= other or self == other),\\n ('__lt__', lambda self, other: self <= other and not self == other),\\n ('__gt__', lambda self, other: not self <= other)],\\n '__gt__': [('__lt__', lambda self, other: not (self > other or self == other)),\\n ('__ge__', lambda self, other: self > other or self == other),\\n ('__le__', lambda self, other: not self > other)],\\n '__ge__': [('__le__', lambda self, other: (not self >= other) or self == other),\\n ('__gt__', lambda self, other: self >= other and not self == other),\\n ('__lt__', lambda self, other: not self >= other)]\\n }\\n roots = set(dir(cls)) & set(convert)\\n if not roots:\\n raise ValueError('must define at least one ordering operation: < > <= >=')\\n root = max(roots) # prefer __lt__ to __le__ to __gt__ to __ge__\\n for opname, opfunc in convert[root]:\\n if opname not in roots:\\n opfunc.__name__ = opname\\n opfunc.__doc__ = getattr(int, opname).__doc__\\n setattr(cls, opname, opfunc)\\n return cls\",\n \"def order(self, order_id, symbol, **kwargs):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7325629","0.68086284","0.6290014","0.6235323","0.6235261","0.62039375","0.6151792","0.61361706","0.6074596","0.6058576","0.60491574","0.6035678","0.60100913","0.59463125","0.59335196","0.5930086","0.5926631","0.57996154","0.5741835","0.5740553","0.5668141","0.5663232","0.5620014","0.5607871","0.56057626","0.56040555","0.56006104","0.55983186","0.5582817","0.5546667","0.5536159","0.5476154","0.5453394","0.54456353","0.543973","0.54294926","0.54245347","0.54216605","0.54192805","0.54143685","0.5410479","0.5383828","0.53602016","0.5352398","0.533294","0.5330685","0.5315077","0.5268531","0.52614367","0.52510846","0.52293026","0.5201411","0.5191226","0.5182872","0.51711655","0.5166471","0.5100968","0.5096566","0.5081079","0.49919584","0.49847084","0.49790034","0.4939508","0.48955244","0.4880243","0.48776704","0.48740926","0.4864606","0.48597905","0.4840661","0.48337048","0.48285723","0.48207894","0.47788814","0.47695425","0.47646627","0.47558498","0.47547114","0.47398263","0.47325274","0.47320846","0.47227666","0.4717425","0.47075704","0.4700414","0.46991277","0.46920514","0.4683826","0.46745837","0.46614245","0.4659812","0.46301425","0.46207753","0.46166816","0.4607658","0.45899186","0.45868865","0.45811275","0.45804006"],"string":"[\n \"0.7325629\",\n \"0.68086284\",\n \"0.6290014\",\n \"0.6235323\",\n \"0.6235261\",\n \"0.62039375\",\n \"0.6151792\",\n \"0.61361706\",\n \"0.6074596\",\n \"0.6058576\",\n \"0.60491574\",\n \"0.6035678\",\n \"0.60100913\",\n \"0.59463125\",\n \"0.59335196\",\n \"0.5930086\",\n \"0.5926631\",\n \"0.57996154\",\n \"0.5741835\",\n \"0.5740553\",\n \"0.5668141\",\n \"0.5663232\",\n \"0.5620014\",\n \"0.5607871\",\n \"0.56057626\",\n \"0.56040555\",\n \"0.56006104\",\n \"0.55983186\",\n \"0.5582817\",\n \"0.5546667\",\n \"0.5536159\",\n \"0.5476154\",\n \"0.5453394\",\n \"0.54456353\",\n \"0.543973\",\n \"0.54294926\",\n \"0.54245347\",\n \"0.54216605\",\n \"0.54192805\",\n \"0.54143685\",\n \"0.5410479\",\n \"0.5383828\",\n \"0.53602016\",\n \"0.5352398\",\n \"0.533294\",\n \"0.5330685\",\n \"0.5315077\",\n \"0.5268531\",\n \"0.52614367\",\n \"0.52510846\",\n \"0.52293026\",\n \"0.5201411\",\n \"0.5191226\",\n \"0.5182872\",\n \"0.51711655\",\n \"0.5166471\",\n \"0.5100968\",\n \"0.5096566\",\n \"0.5081079\",\n \"0.49919584\",\n \"0.49847084\",\n \"0.49790034\",\n \"0.4939508\",\n \"0.48955244\",\n \"0.4880243\",\n \"0.48776704\",\n \"0.48740926\",\n \"0.4864606\",\n \"0.48597905\",\n \"0.4840661\",\n \"0.48337048\",\n \"0.48285723\",\n \"0.48207894\",\n \"0.47788814\",\n \"0.47695425\",\n \"0.47646627\",\n \"0.47558498\",\n \"0.47547114\",\n \"0.47398263\",\n \"0.47325274\",\n \"0.47320846\",\n \"0.47227666\",\n \"0.4717425\",\n \"0.47075704\",\n \"0.4700414\",\n \"0.46991277\",\n \"0.46920514\",\n \"0.4683826\",\n \"0.46745837\",\n \"0.46614245\",\n \"0.4659812\",\n \"0.46301425\",\n \"0.46207753\",\n \"0.46166816\",\n \"0.4607658\",\n \"0.45899186\",\n \"0.45868865\",\n \"0.45811275\",\n \"0.45804006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5119484"},"document_rank":{"kind":"string","value":"57"}}},{"rowIdx":20299,"cells":{"query":{"kind":"string","value":"Add limit clause expression."},"document":{"kind":"string","value":"def limit(self, row_count):\n self._limit = row_count\n return self"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def limit_clause(self, select):\n return \"\"","def apply_limit(self, query, limit):\n if limit is not None:\n limit = int(limit)\n if limit < 0:\n raise ValueError(\"limit can not be a negative integer.\")\n query = query.limit(limit)\n return query","def limit(self, limit):\n if limit is None:\n return self\n\n self.query = self.query.limit(limit)\n self._has_limit = True\n return self","def limit(self, limit):\n raise NotImplementedError(\"This should have been implemented.\")","def limit(self, limit: int) -> 'Query':\n self.limit_index = max(1, limit)\n return self","def limit(self, limit):\n\n return self._get(\"limit\", limit, Table)","def _query_set_limit(query: str, limit: int) -> str:\n if limit < 0:\n return query\n\n # the query has the structure of \"section | section | section ...\"\n query_list = query.split('|')\n\n # split the query to sections and find limit sections\n changed = False\n for i, section in enumerate(query_list):\n section_list = section.split()\n # 'take' and 'limit' are synonyms.\n if section_list and section_list[0] == 'limit' or section_list[0] == 'take':\n query_list[i] = f\" limit {limit} \"\n changed = True\n\n # if the query have not been changed than limit is added to the query\n if not changed:\n query_list.append(f\" limit {limit} \")\n\n fixed_query = '|'.join(query_list)\n return fixed_query","def limit(self, limit):\n self._evaluated = False\n self._limit = limit\n return self","def limit(self, limit):\n params = join_params(self.parameters, {\"limit\": limit,\n \"url_domain\": self.url_domain,\n \"proxies\": self.proxies})\n\n return self.__class__(**params)","def limit_by(self, offset_limit, *fields_or_expr):\n if isinstance(offset_limit, int):\n # Single limit\n offset_limit = (0, offset_limit)\n offset = offset_limit[0]\n limit = offset_limit[1]\n assert offset >= 0 and limit >= 0, 'negative limits are not supported'\n qs = copy(self)\n qs._limit_by = (offset, limit)\n qs._limit_by_fields = fields_or_expr\n return qs","def limit(self, limit):\n self._limit = limit\n return self","def limit(self, limit: int) -> MongoDBQuerySet:\n\n self.cursor = self.cursor.limit(limit)\n return self","def limit(self, limit):\n self._limit = limit\n\n return self","def limit(self, limit):\n\n self._limit = limit\n return self","def limit(self, limit):\n self._limit = limit","def limit(self, row_count, offset=0):\n self._limit = (row_count, offset)\n return self","def limit(self, limit):\n\n self._limit = limit","def limit(self, limit):\n\n self._limit = limit","def limit(self, limit):\n\n self._limit = limit","def limit(self, v):\r\n if not (v is None or isinstance(v, (int, long))):\r\n raise TypeError\r\n if v == self._limit:\r\n return self\r\n\r\n if v < 0:\r\n raise QueryException(\"Negative limit is not allowed\")\r\n\r\n clone = copy.deepcopy(self)\r\n clone._limit = v\r\n return clone","def add_time_limit(query, today=datetime.today(), lapse='month'):\n if lapse == 'month':\n this_year = today.year\n this_month = today.month\n if this_month == 1:\n limit_year = this_year - 1\n limit_month = 12\n else:\n limit_year = this_year\n limit_month = this_month - 1\n limit_string = \" and extract(year from created_at)=%s\" % limit_year\n limit_string += \" and extract(month from created_at)=%s\" % limit_month\n query += limit_string\n\n return query","def limit(self, lim):\n limit_table = Table(self.columns)\n limit_table.rows = self.rows[:lim]\n return limit_table","def _limit(self, row):\n if 'counter' not in self._state:\n init_value = -1 if self._args.head else 0\n self._state['counter'] = init_value\n self._state['counter'] += 1\n if self._state['counter'] >= self._args.limit:\n self._leave = True\n return row","def limit(self, limit):\n odm_cursor = ODMCursor(self.session, self.cls,\n self.ming_cursor.limit(limit))\n _call_hook(self, 'cursor_created', odm_cursor, 'limit', self, limit)\n return odm_cursor","def set_limit(self, limit):\n self.limit = limit\n self._prune()","def set_Limit(self, value):\n super(DescribeEvaluationsInputSet, self)._set_input('Limit', value)","def limit(self, amount):\n self._limit = amount\n return self","def SetLimit(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_SetLimit(self, *args)","def limit(self, limit_value, key_func=None, per_method=False):\n return self.__limit_decorator(limit_value, key_func, per_method=per_method)","def test_limit(self):\n user_a = self.Person.objects.create(name=\"User A\", age=20)\n _ = self.Person.objects.create(name=\"User B\", age=30)\n\n # Test limit on a new queryset\n people = list(self.Person.objects.limit(1))\n assert len(people) == 1\n assert people[0] == user_a\n\n # Test limit on an existing queryset\n people = self.Person.objects\n assert len(people) == 2\n people2 = people.limit(1)\n assert len(people) == 2\n assert len(people2) == 1\n assert people2[0] == user_a\n\n # Test limit with 0 as parameter\n people = self.Person.objects.limit(0)\n assert people.count(with_limit_and_skip=True) == 2\n assert len(people) == 2\n\n # Test chaining of only after limit\n person = self.Person.objects().limit(1).only(\"name\").first()\n assert person == user_a\n assert person.name == \"User A\"\n assert person.age is None","def limit(cls, rows, offset=None):\n cls.runtime.set_limit((offset, rows))\n return cls","def calculate(self, limit):\n pass","def calculate(self, limit):\r\n pass","def set_limit(self, limit, truncated=False):\n self.limit = {'limit': limit, 'type': 'limit', 'truncated': truncated}","def get_random_limit_clause(k: int = 10) -> str:\n\n return f\"LIMIT {random.randint(1, k)}\"","def ranged_by(marker, limit = None, offset = None):\r\n clause, params = [], []\r\n if limit is not None:\r\n clause.append(f\"LIMIT {marker()}\")\r\n params.append(limit)\r\n if offset is not None:\r\n clause.append(f\"OFFSET {marker()}\")\r\n params.append(offset)\r\n return ' '.join(clause), params","def limit(self, count):\n self._limit = count\n return self","def SetLimitAndOffset(self, limit, offset):\n self.limit = limit\n self.offset = offset","def limit(self, limit):\n\n # Return between 1 and 250 results, defaults to 10\n return max(1, min(250, int(limit) if limit else 10))","def test_statement_expression_limit(self):\n case = self.__gen_huge_case(\"int_col\", 66, 2, \" \")\n query = \"select {0} as huge_case from functional.alltypes\".format(case)\n assert len(query) < 16 * 1024 * 1024\n expected_err_re = (\"Exceeded the statement expression limit \\({0}\\)\\n\"\n \"Statement has .* expressions.\").format(250000)\n err = self.execute_query_expect_failure(self.client, query)\n assert re.search(expected_err_re, str(err))","def set_limit(limit_name, value):\n LIMITS[limit_name] = value","def apply_limit(tasks, limit):\n return tasks.limit(limit)","def limit(requestContext, seriesList, n):\n return seriesList[0:n]","def __init__(self, c, limit, offset=0):\n super(Limit, self).__init__(c)\n self.limit = limit\n if isinstance(self.limit, numbers.Number):\n self.limit = Literal(self.limit)\n\n self._limit = int(self.limit(None).as_py())\n if self._limit < 0:\n raise Exception(\"LIMIT must not be negative: %d\" % l)\n\n self.offset = offset or 0\n if isinstance(self.offset, numbers.Number):\n self.offset = Literal(self.offset)\n\n self._offset = int(self.offset(None).as_py())\n if self._offset < 0:\n raise Exception(\"OFFSET must not be negative: %d\" % o)","def findLimit(name):\n return Limit(Cuebot.getStub('limit').Find(\n limit_pb2.LimitFindRequest(name=name), timeout=Cuebot.Timeout).limit)","def set_limit_offset(query_params, query):\n if query_params.get('limit') is not None:\n query = query.limit(int(request.args.get('limit')))\n else:\n query = query.limit(12)\n\n if query_params.get('offset') is not None:\n query = query.offset(int(request.args.get('offset')))\n else:\n query = query.offset(0)\n return query","def test_limit(self):\n\t\tfor lim in [1, '234', -100, '-200']:\n\t\t\tself.filter.set_limit(lim)\n\t\t\tself.assertEqual(int(lim), self.filter.get_limit(), \"Limit mismatch: %s!=%s\" % (lim, self.filter.get_limit()))\n\t\tself.filter.set_limit('test')\n\t\tself.assertEqual('test', self.filter.get_limit(), \"String set failed for Filter limit.\")","def limit(self, side, order_id, quantity, price):\n Library.functions.limit(self._book, side, order_id, quantity, price)","def limit(self, custom_limit):\n # NOTE(gibi): this operation needs escalated privileges (e.g. admin)\n # as the owner of the app cannot set its own app's limits. But\n # authorization is out of scope.\n self._limit = custom_limit","def limit(self, max_num):\n return QuerySet(itertools.islice(self, max_num))","async def cclimit(self, ctx, limit_amount: int = None):\n if limit_amount is None:\n return await ctx.send_help()\n if limit_amount < 0:\n return await ctx.send(\"You need to use a number larger than 0.\")\n await self.config.limit.set(limit_amount)\n await ctx.send(f\"Chatchart is now limited to {limit_amount} messages.\")","def get_limit(self):\n return self.limit","def limit(self):\n return self._limit","def limit(self):\n return self._limit","def limit_and_offset_select_query(self, query, limit, offset):\n return self.user_con.limit_and_offset_select_query(\n query=query, limit=limit, offset=offset)","def limit(self):\n return self._owner.plan","def set_max_record_limit(self, limit):\n self.max_record_limit = limit","def limit(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"limit\")","def calculate(self, limit: int) -> None:\n raise NotImplementedError()","def per_page(self,limit):\n params = join_params(self.parameters,\n {\"per_page\": set_limit(limit),\n \"limit\": self._limit,\n \"url_domain\": self.url_domain,\n \"proxies\": self.proxies\n }\n )\n\n return self.__class__(**params)","def limit(self, num_rows: int) -> 'Table':\n limit_table = Table(self.columns, self.types)\n for i, row in enumerate(self.rows):\n if i >= num_rows:\n break\n values = [row[column] for column in self.columns]\n limit_table.insert(values)\n return limit_table","def limit(self, lim: float):\n if self.mag() > lim:\n self.values = tuple(self.norm()*lim)\n return self","def set_result_limit(self, data):\n self.add_payload('resultLimit', data)\n self._result_limit = self._uni(data)","def set_limit(self, errors):\n self.limit = errors","def setPTLimits(*args):\n args[0].Limit.PTLimit.pt_limit = args[1]","def where_above(lst, limit):\n return [x for x in lst if x > limit]","def _determine_limit(self, limit):\n\n # Note: +1 is allowed here because it allows\n # the user to fetch one beyond to see if they\n # are at the end of the list\n if not limit:\n res = conf.api_configuration.max_returned_num + 1\n else:\n res = min(conf.api_configuration.max_returned_num + 1, limit)\n\n return res","def setRevisionLimit(self, limit):\n return self.client.put(self.name +\"/_revs_limit\", None, limit).getBodyData()","def adb_video_limit(given_limit):\n return given_limit","def limit_path_query(self, limit_path_query):\n\n self._limit_path_query = limit_path_query","def _create_limit(self, price_limit):\n if self.price_limit is not None:\n return(order(self.symbol, -self.volume, style=LimitOrder(self.price_limit)))\n else:\n return","def limit(self):\n if self._limit:\n return self._limit\n else: # no custom limit, go with the default\n return PublicAppPlan","def test_limit(db_session):\n query_params = {\"limit\": \"1\"}\n parser = ModelQueryParamParser(query_params)\n album_resource = AlbumResource(session=db_session)\n offset_limit_info = parser.parse_offset_limit(page_max_size=30)\n offset = offset_limit_info.offset\n limit = offset_limit_info.limit\n result = album_resource.get_collection(\n filters=parser.parse_filters(album_resource.model),\n sorts=parser.parse_sorts(),\n limit=limit,\n offset=offset\n )\n assert len(result) == 1","def allowedLimit(self, number, msg=None):\n return allowed_limit(number, msg)","def get_limit(self):\n return self._limit","def get_limit(self):\n return self._limit","def run_query(where_clause, limit=1000):\n sql = \"SELECT * FROM catalog WHERE {} ORDER BY creators, title LIMIT {}\"\\\n .format(where_clause, limit)\n with sqlite3.connect(db_name) as db:\n results = pd.read_sql_query(sql, db)\n print_results(results)","def fetch(self, limit, offset=0):\r\n self.limit = limit\r\n self.offset = offset\r\n return self","def createLimit(name, maxValue):\n return Limit(Cuebot.getStub('limit').Create(\n limit_pb2.LimitCreateRequest(name=name, max_value=maxValue), timeout=Cuebot.Timeout))","def set_custom_readings_persistence_limit(self, limit: int): # type: ignore\n self.readings_limit = limit\n return self","def __str__(self):\n return self.limit","def test_limit(self):\n\n mapper(Item, items)\n mapper(Order, orders, properties={\n 'items':relation(Item, secondary=order_items, lazy=False, order_by=items.c.id)\n })\n mapper(User, users, properties={\n 'addresses':relation(mapper(Address, addresses), lazy=False, order_by=addresses.c.id),\n 'orders':relation(Order, lazy=True)\n })\n\n sess = create_session()\n q = sess.query(User)\n\n if testing.against('mysql'):\n l = q.limit(2).all()\n assert fixtures.user_all_result[:2] == l\n else:\n l = q.limit(2).offset(1).order_by(User.id).all()\n print fixtures.user_all_result[1:3]\n print l\n assert fixtures.user_all_result[1:3] == l","def set_deriv_limit(axis_number, limit_type):\n robots = get_robot_roots()\n\n if not robots:\n raise MimicError('Nothing Selected; Select a valid robot')\n return\n\n try: # If there is not a float input in the UI box, do nothing\n val = float(pm.textField('t_A{}{}'.format(axis_number, limit_type),\n query=True,\n text=True))\n robot_list_str = ''\n for robot in robots:\n target_ctrl_path = get_target_ctrl_path(robot)\n\n # Check if the rig has attributes for the input limit type\n # If not, add the corresponding limit attributes\n # This is mostly used for backwards-compatibility\n if not pm.attributeQuery('axis{}Limits'.format(limit_type),\n n=target_ctrl_path, ex=True):\n add_limits_to_robot(robot, limit_type)\n\n # Set the axis' limit to the user-input value\n pm.setAttr(target_ctrl_path + '.axis{}{}Limit'.format(axis_number, limit_type), val)\n\n robot_list_str += robot + ' '\n except:\n pass","def strict_limit(self, strict_limit):\n\n self._strict_limit = strict_limit","def shared_limit(self, limit_value, scope, key_func=None):\n return self.__limit_decorator(limit_value, key_func, True, scope)","def test_limit_0(self):\n self.Person.objects.create(name=\"User A\", age=20)\n\n # Test limit with 0 as parameter\n qs = self.Person.objects.limit(0)\n assert qs.count() == 0","def limit_package_query(self, limit_package_query):\n\n self._limit_package_query = limit_package_query","def limit(self, max_size):\n return self.__class__(itertools.islice(self, max_size))","def set_LevelLimit(self, value):\n super(GetCategoriesInputSet, self)._set_input('LevelLimit', value)","def get_limits(self):\n raise NotImplementedError(\"Limits are not available for Cloud Databases\")","def gt(value, limit):\n return value > limit","def test_queryset_limit_immutability(self):\r\n query1 = TestModel.objects(test_id=5).limit(1)\r\n assert query1._limit == 1\r\n\r\n query2 = query1.filter(expected_result__gte=1)\r\n assert query2._limit == 1\r\n\r\n query3 = query1.filter(expected_result__gte=1).limit(2)\r\n assert query1._limit == 1\r\n assert query3._limit == 2","def _get_limit(self, req):\n try:\n limit = int(req.str_params.get('limit', MAX_ITEM_LIMIT))\n except ValueError:\n raise exc.HTTPBadRequest(\"limit param must be an integer\")\n\n if limit < 0:\n raise exc.HTTPBadRequest(\"limit param must be positive\")\n\n return min(MAX_ITEM_LIMIT, limit)","def limit_string(self) -> str:\n return f\"{self.action}={self.amount}/{self.per}\"","def sql(self, tabtype, only_limit=False, prefix=None):\n if only_limit and self.limit < 1:\n return ''\n\n exprs = self.exprs\n if tabtype is not None:\n exprs = [(f, o) for f, o in exprs if f in tabtype._sql_fields]\n if len(exprs) == 0:\n return ''\n\n as_sql = lambda f: tabtype._as_sql(f, prefix=prefix)\n s = ' ORDER BY '\n s += ', '.join('%s %s' % (as_sql(f), o) for f, o in exprs)\n if self.limit > 0:\n s += ' LIMIT %d' % self.limit\n return s","def limit_package_query(self):\n return self._limit_package_query","def test_identify_limit(limit, all, expected):\n assert identify_limit(limit, all) == expected","def check_limit(limit):\n if limit:\n limit = int(limit)\n if limit > settings.MAX_LISTING_LIMIT or \\\n limit < settings.MIN_LISTING_LIMIT:\n # SuspiciousOperation raises 400 bad request in Django 1.11.\n # https://docs.djangoproject.com/en/1.11/ref/views/#the-400-bad-request-view\n raise SuspiciousOperation()\n return limit\n return settings.DEFAULT_LISTING_LIMIT","def le(value, limit):\n return value <= limit","def charge_limit(self, limit=None):\n if limit is None:\n done, data = self._request('GH')\n if done:\n return int(data[0])\n else:\n if self._request('SH', str(int(limit)))[0]:\n return limit\n\n raise EvseError"],"string":"[\n \"def limit_clause(self, select):\\n return \\\"\\\"\",\n \"def apply_limit(self, query, limit):\\n if limit is not None:\\n limit = int(limit)\\n if limit < 0:\\n raise ValueError(\\\"limit can not be a negative integer.\\\")\\n query = query.limit(limit)\\n return query\",\n \"def limit(self, limit):\\n if limit is None:\\n return self\\n\\n self.query = self.query.limit(limit)\\n self._has_limit = True\\n return self\",\n \"def limit(self, limit):\\n raise NotImplementedError(\\\"This should have been implemented.\\\")\",\n \"def limit(self, limit: int) -> 'Query':\\n self.limit_index = max(1, limit)\\n return self\",\n \"def limit(self, limit):\\n\\n return self._get(\\\"limit\\\", limit, Table)\",\n \"def _query_set_limit(query: str, limit: int) -> str:\\n if limit < 0:\\n return query\\n\\n # the query has the structure of \\\"section | section | section ...\\\"\\n query_list = query.split('|')\\n\\n # split the query to sections and find limit sections\\n changed = False\\n for i, section in enumerate(query_list):\\n section_list = section.split()\\n # 'take' and 'limit' are synonyms.\\n if section_list and section_list[0] == 'limit' or section_list[0] == 'take':\\n query_list[i] = f\\\" limit {limit} \\\"\\n changed = True\\n\\n # if the query have not been changed than limit is added to the query\\n if not changed:\\n query_list.append(f\\\" limit {limit} \\\")\\n\\n fixed_query = '|'.join(query_list)\\n return fixed_query\",\n \"def limit(self, limit):\\n self._evaluated = False\\n self._limit = limit\\n return self\",\n \"def limit(self, limit):\\n params = join_params(self.parameters, {\\\"limit\\\": limit,\\n \\\"url_domain\\\": self.url_domain,\\n \\\"proxies\\\": self.proxies})\\n\\n return self.__class__(**params)\",\n \"def limit_by(self, offset_limit, *fields_or_expr):\\n if isinstance(offset_limit, int):\\n # Single limit\\n offset_limit = (0, offset_limit)\\n offset = offset_limit[0]\\n limit = offset_limit[1]\\n assert offset >= 0 and limit >= 0, 'negative limits are not supported'\\n qs = copy(self)\\n qs._limit_by = (offset, limit)\\n qs._limit_by_fields = fields_or_expr\\n return qs\",\n \"def limit(self, limit):\\n self._limit = limit\\n return self\",\n \"def limit(self, limit: int) -> MongoDBQuerySet:\\n\\n self.cursor = self.cursor.limit(limit)\\n return self\",\n \"def limit(self, limit):\\n self._limit = limit\\n\\n return self\",\n \"def limit(self, limit):\\n\\n self._limit = limit\\n return self\",\n \"def limit(self, limit):\\n self._limit = limit\",\n \"def limit(self, row_count, offset=0):\\n self._limit = (row_count, offset)\\n return self\",\n \"def limit(self, limit):\\n\\n self._limit = limit\",\n \"def limit(self, limit):\\n\\n self._limit = limit\",\n \"def limit(self, limit):\\n\\n self._limit = limit\",\n \"def limit(self, v):\\r\\n if not (v is None or isinstance(v, (int, long))):\\r\\n raise TypeError\\r\\n if v == self._limit:\\r\\n return self\\r\\n\\r\\n if v < 0:\\r\\n raise QueryException(\\\"Negative limit is not allowed\\\")\\r\\n\\r\\n clone = copy.deepcopy(self)\\r\\n clone._limit = v\\r\\n return clone\",\n \"def add_time_limit(query, today=datetime.today(), lapse='month'):\\n if lapse == 'month':\\n this_year = today.year\\n this_month = today.month\\n if this_month == 1:\\n limit_year = this_year - 1\\n limit_month = 12\\n else:\\n limit_year = this_year\\n limit_month = this_month - 1\\n limit_string = \\\" and extract(year from created_at)=%s\\\" % limit_year\\n limit_string += \\\" and extract(month from created_at)=%s\\\" % limit_month\\n query += limit_string\\n\\n return query\",\n \"def limit(self, lim):\\n limit_table = Table(self.columns)\\n limit_table.rows = self.rows[:lim]\\n return limit_table\",\n \"def _limit(self, row):\\n if 'counter' not in self._state:\\n init_value = -1 if self._args.head else 0\\n self._state['counter'] = init_value\\n self._state['counter'] += 1\\n if self._state['counter'] >= self._args.limit:\\n self._leave = True\\n return row\",\n \"def limit(self, limit):\\n odm_cursor = ODMCursor(self.session, self.cls,\\n self.ming_cursor.limit(limit))\\n _call_hook(self, 'cursor_created', odm_cursor, 'limit', self, limit)\\n return odm_cursor\",\n \"def set_limit(self, limit):\\n self.limit = limit\\n self._prune()\",\n \"def set_Limit(self, value):\\n super(DescribeEvaluationsInputSet, self)._set_input('Limit', value)\",\n \"def limit(self, amount):\\n self._limit = amount\\n return self\",\n \"def SetLimit(self, *args):\\n return _BRepAlgo.BRepAlgo_NormalProjection_SetLimit(self, *args)\",\n \"def limit(self, limit_value, key_func=None, per_method=False):\\n return self.__limit_decorator(limit_value, key_func, per_method=per_method)\",\n \"def test_limit(self):\\n user_a = self.Person.objects.create(name=\\\"User A\\\", age=20)\\n _ = self.Person.objects.create(name=\\\"User B\\\", age=30)\\n\\n # Test limit on a new queryset\\n people = list(self.Person.objects.limit(1))\\n assert len(people) == 1\\n assert people[0] == user_a\\n\\n # Test limit on an existing queryset\\n people = self.Person.objects\\n assert len(people) == 2\\n people2 = people.limit(1)\\n assert len(people) == 2\\n assert len(people2) == 1\\n assert people2[0] == user_a\\n\\n # Test limit with 0 as parameter\\n people = self.Person.objects.limit(0)\\n assert people.count(with_limit_and_skip=True) == 2\\n assert len(people) == 2\\n\\n # Test chaining of only after limit\\n person = self.Person.objects().limit(1).only(\\\"name\\\").first()\\n assert person == user_a\\n assert person.name == \\\"User A\\\"\\n assert person.age is None\",\n \"def limit(cls, rows, offset=None):\\n cls.runtime.set_limit((offset, rows))\\n return cls\",\n \"def calculate(self, limit):\\n pass\",\n \"def calculate(self, limit):\\r\\n pass\",\n \"def set_limit(self, limit, truncated=False):\\n self.limit = {'limit': limit, 'type': 'limit', 'truncated': truncated}\",\n \"def get_random_limit_clause(k: int = 10) -> str:\\n\\n return f\\\"LIMIT {random.randint(1, k)}\\\"\",\n \"def ranged_by(marker, limit = None, offset = None):\\r\\n clause, params = [], []\\r\\n if limit is not None:\\r\\n clause.append(f\\\"LIMIT {marker()}\\\")\\r\\n params.append(limit)\\r\\n if offset is not None:\\r\\n clause.append(f\\\"OFFSET {marker()}\\\")\\r\\n params.append(offset)\\r\\n return ' '.join(clause), params\",\n \"def limit(self, count):\\n self._limit = count\\n return self\",\n \"def SetLimitAndOffset(self, limit, offset):\\n self.limit = limit\\n self.offset = offset\",\n \"def limit(self, limit):\\n\\n # Return between 1 and 250 results, defaults to 10\\n return max(1, min(250, int(limit) if limit else 10))\",\n \"def test_statement_expression_limit(self):\\n case = self.__gen_huge_case(\\\"int_col\\\", 66, 2, \\\" \\\")\\n query = \\\"select {0} as huge_case from functional.alltypes\\\".format(case)\\n assert len(query) < 16 * 1024 * 1024\\n expected_err_re = (\\\"Exceeded the statement expression limit \\\\({0}\\\\)\\\\n\\\"\\n \\\"Statement has .* expressions.\\\").format(250000)\\n err = self.execute_query_expect_failure(self.client, query)\\n assert re.search(expected_err_re, str(err))\",\n \"def set_limit(limit_name, value):\\n LIMITS[limit_name] = value\",\n \"def apply_limit(tasks, limit):\\n return tasks.limit(limit)\",\n \"def limit(requestContext, seriesList, n):\\n return seriesList[0:n]\",\n \"def __init__(self, c, limit, offset=0):\\n super(Limit, self).__init__(c)\\n self.limit = limit\\n if isinstance(self.limit, numbers.Number):\\n self.limit = Literal(self.limit)\\n\\n self._limit = int(self.limit(None).as_py())\\n if self._limit < 0:\\n raise Exception(\\\"LIMIT must not be negative: %d\\\" % l)\\n\\n self.offset = offset or 0\\n if isinstance(self.offset, numbers.Number):\\n self.offset = Literal(self.offset)\\n\\n self._offset = int(self.offset(None).as_py())\\n if self._offset < 0:\\n raise Exception(\\\"OFFSET must not be negative: %d\\\" % o)\",\n \"def findLimit(name):\\n return Limit(Cuebot.getStub('limit').Find(\\n limit_pb2.LimitFindRequest(name=name), timeout=Cuebot.Timeout).limit)\",\n \"def set_limit_offset(query_params, query):\\n if query_params.get('limit') is not None:\\n query = query.limit(int(request.args.get('limit')))\\n else:\\n query = query.limit(12)\\n\\n if query_params.get('offset') is not None:\\n query = query.offset(int(request.args.get('offset')))\\n else:\\n query = query.offset(0)\\n return query\",\n \"def test_limit(self):\\n\\t\\tfor lim in [1, '234', -100, '-200']:\\n\\t\\t\\tself.filter.set_limit(lim)\\n\\t\\t\\tself.assertEqual(int(lim), self.filter.get_limit(), \\\"Limit mismatch: %s!=%s\\\" % (lim, self.filter.get_limit()))\\n\\t\\tself.filter.set_limit('test')\\n\\t\\tself.assertEqual('test', self.filter.get_limit(), \\\"String set failed for Filter limit.\\\")\",\n \"def limit(self, side, order_id, quantity, price):\\n Library.functions.limit(self._book, side, order_id, quantity, price)\",\n \"def limit(self, custom_limit):\\n # NOTE(gibi): this operation needs escalated privileges (e.g. admin)\\n # as the owner of the app cannot set its own app's limits. But\\n # authorization is out of scope.\\n self._limit = custom_limit\",\n \"def limit(self, max_num):\\n return QuerySet(itertools.islice(self, max_num))\",\n \"async def cclimit(self, ctx, limit_amount: int = None):\\n if limit_amount is None:\\n return await ctx.send_help()\\n if limit_amount < 0:\\n return await ctx.send(\\\"You need to use a number larger than 0.\\\")\\n await self.config.limit.set(limit_amount)\\n await ctx.send(f\\\"Chatchart is now limited to {limit_amount} messages.\\\")\",\n \"def get_limit(self):\\n return self.limit\",\n \"def limit(self):\\n return self._limit\",\n \"def limit(self):\\n return self._limit\",\n \"def limit_and_offset_select_query(self, query, limit, offset):\\n return self.user_con.limit_and_offset_select_query(\\n query=query, limit=limit, offset=offset)\",\n \"def limit(self):\\n return self._owner.plan\",\n \"def set_max_record_limit(self, limit):\\n self.max_record_limit = limit\",\n \"def limit(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"limit\\\")\",\n \"def calculate(self, limit: int) -> None:\\n raise NotImplementedError()\",\n \"def per_page(self,limit):\\n params = join_params(self.parameters,\\n {\\\"per_page\\\": set_limit(limit),\\n \\\"limit\\\": self._limit,\\n \\\"url_domain\\\": self.url_domain,\\n \\\"proxies\\\": self.proxies\\n }\\n )\\n\\n return self.__class__(**params)\",\n \"def limit(self, num_rows: int) -> 'Table':\\n limit_table = Table(self.columns, self.types)\\n for i, row in enumerate(self.rows):\\n if i >= num_rows:\\n break\\n values = [row[column] for column in self.columns]\\n limit_table.insert(values)\\n return limit_table\",\n \"def limit(self, lim: float):\\n if self.mag() > lim:\\n self.values = tuple(self.norm()*lim)\\n return self\",\n \"def set_result_limit(self, data):\\n self.add_payload('resultLimit', data)\\n self._result_limit = self._uni(data)\",\n \"def set_limit(self, errors):\\n self.limit = errors\",\n \"def setPTLimits(*args):\\n args[0].Limit.PTLimit.pt_limit = args[1]\",\n \"def where_above(lst, limit):\\n return [x for x in lst if x > limit]\",\n \"def _determine_limit(self, limit):\\n\\n # Note: +1 is allowed here because it allows\\n # the user to fetch one beyond to see if they\\n # are at the end of the list\\n if not limit:\\n res = conf.api_configuration.max_returned_num + 1\\n else:\\n res = min(conf.api_configuration.max_returned_num + 1, limit)\\n\\n return res\",\n \"def setRevisionLimit(self, limit):\\n return self.client.put(self.name +\\\"/_revs_limit\\\", None, limit).getBodyData()\",\n \"def adb_video_limit(given_limit):\\n return given_limit\",\n \"def limit_path_query(self, limit_path_query):\\n\\n self._limit_path_query = limit_path_query\",\n \"def _create_limit(self, price_limit):\\n if self.price_limit is not None:\\n return(order(self.symbol, -self.volume, style=LimitOrder(self.price_limit)))\\n else:\\n return\",\n \"def limit(self):\\n if self._limit:\\n return self._limit\\n else: # no custom limit, go with the default\\n return PublicAppPlan\",\n \"def test_limit(db_session):\\n query_params = {\\\"limit\\\": \\\"1\\\"}\\n parser = ModelQueryParamParser(query_params)\\n album_resource = AlbumResource(session=db_session)\\n offset_limit_info = parser.parse_offset_limit(page_max_size=30)\\n offset = offset_limit_info.offset\\n limit = offset_limit_info.limit\\n result = album_resource.get_collection(\\n filters=parser.parse_filters(album_resource.model),\\n sorts=parser.parse_sorts(),\\n limit=limit,\\n offset=offset\\n )\\n assert len(result) == 1\",\n \"def allowedLimit(self, number, msg=None):\\n return allowed_limit(number, msg)\",\n \"def get_limit(self):\\n return self._limit\",\n \"def get_limit(self):\\n return self._limit\",\n \"def run_query(where_clause, limit=1000):\\n sql = \\\"SELECT * FROM catalog WHERE {} ORDER BY creators, title LIMIT {}\\\"\\\\\\n .format(where_clause, limit)\\n with sqlite3.connect(db_name) as db:\\n results = pd.read_sql_query(sql, db)\\n print_results(results)\",\n \"def fetch(self, limit, offset=0):\\r\\n self.limit = limit\\r\\n self.offset = offset\\r\\n return self\",\n \"def createLimit(name, maxValue):\\n return Limit(Cuebot.getStub('limit').Create(\\n limit_pb2.LimitCreateRequest(name=name, max_value=maxValue), timeout=Cuebot.Timeout))\",\n \"def set_custom_readings_persistence_limit(self, limit: int): # type: ignore\\n self.readings_limit = limit\\n return self\",\n \"def __str__(self):\\n return self.limit\",\n \"def test_limit(self):\\n\\n mapper(Item, items)\\n mapper(Order, orders, properties={\\n 'items':relation(Item, secondary=order_items, lazy=False, order_by=items.c.id)\\n })\\n mapper(User, users, properties={\\n 'addresses':relation(mapper(Address, addresses), lazy=False, order_by=addresses.c.id),\\n 'orders':relation(Order, lazy=True)\\n })\\n\\n sess = create_session()\\n q = sess.query(User)\\n\\n if testing.against('mysql'):\\n l = q.limit(2).all()\\n assert fixtures.user_all_result[:2] == l\\n else:\\n l = q.limit(2).offset(1).order_by(User.id).all()\\n print fixtures.user_all_result[1:3]\\n print l\\n assert fixtures.user_all_result[1:3] == l\",\n \"def set_deriv_limit(axis_number, limit_type):\\n robots = get_robot_roots()\\n\\n if not robots:\\n raise MimicError('Nothing Selected; Select a valid robot')\\n return\\n\\n try: # If there is not a float input in the UI box, do nothing\\n val = float(pm.textField('t_A{}{}'.format(axis_number, limit_type),\\n query=True,\\n text=True))\\n robot_list_str = ''\\n for robot in robots:\\n target_ctrl_path = get_target_ctrl_path(robot)\\n\\n # Check if the rig has attributes for the input limit type\\n # If not, add the corresponding limit attributes\\n # This is mostly used for backwards-compatibility\\n if not pm.attributeQuery('axis{}Limits'.format(limit_type),\\n n=target_ctrl_path, ex=True):\\n add_limits_to_robot(robot, limit_type)\\n\\n # Set the axis' limit to the user-input value\\n pm.setAttr(target_ctrl_path + '.axis{}{}Limit'.format(axis_number, limit_type), val)\\n\\n robot_list_str += robot + ' '\\n except:\\n pass\",\n \"def strict_limit(self, strict_limit):\\n\\n self._strict_limit = strict_limit\",\n \"def shared_limit(self, limit_value, scope, key_func=None):\\n return self.__limit_decorator(limit_value, key_func, True, scope)\",\n \"def test_limit_0(self):\\n self.Person.objects.create(name=\\\"User A\\\", age=20)\\n\\n # Test limit with 0 as parameter\\n qs = self.Person.objects.limit(0)\\n assert qs.count() == 0\",\n \"def limit_package_query(self, limit_package_query):\\n\\n self._limit_package_query = limit_package_query\",\n \"def limit(self, max_size):\\n return self.__class__(itertools.islice(self, max_size))\",\n \"def set_LevelLimit(self, value):\\n super(GetCategoriesInputSet, self)._set_input('LevelLimit', value)\",\n \"def get_limits(self):\\n raise NotImplementedError(\\\"Limits are not available for Cloud Databases\\\")\",\n \"def gt(value, limit):\\n return value > limit\",\n \"def test_queryset_limit_immutability(self):\\r\\n query1 = TestModel.objects(test_id=5).limit(1)\\r\\n assert query1._limit == 1\\r\\n\\r\\n query2 = query1.filter(expected_result__gte=1)\\r\\n assert query2._limit == 1\\r\\n\\r\\n query3 = query1.filter(expected_result__gte=1).limit(2)\\r\\n assert query1._limit == 1\\r\\n assert query3._limit == 2\",\n \"def _get_limit(self, req):\\n try:\\n limit = int(req.str_params.get('limit', MAX_ITEM_LIMIT))\\n except ValueError:\\n raise exc.HTTPBadRequest(\\\"limit param must be an integer\\\")\\n\\n if limit < 0:\\n raise exc.HTTPBadRequest(\\\"limit param must be positive\\\")\\n\\n return min(MAX_ITEM_LIMIT, limit)\",\n \"def limit_string(self) -> str:\\n return f\\\"{self.action}={self.amount}/{self.per}\\\"\",\n \"def sql(self, tabtype, only_limit=False, prefix=None):\\n if only_limit and self.limit < 1:\\n return ''\\n\\n exprs = self.exprs\\n if tabtype is not None:\\n exprs = [(f, o) for f, o in exprs if f in tabtype._sql_fields]\\n if len(exprs) == 0:\\n return ''\\n\\n as_sql = lambda f: tabtype._as_sql(f, prefix=prefix)\\n s = ' ORDER BY '\\n s += ', '.join('%s %s' % (as_sql(f), o) for f, o in exprs)\\n if self.limit > 0:\\n s += ' LIMIT %d' % self.limit\\n return s\",\n \"def limit_package_query(self):\\n return self._limit_package_query\",\n \"def test_identify_limit(limit, all, expected):\\n assert identify_limit(limit, all) == expected\",\n \"def check_limit(limit):\\n if limit:\\n limit = int(limit)\\n if limit > settings.MAX_LISTING_LIMIT or \\\\\\n limit < settings.MIN_LISTING_LIMIT:\\n # SuspiciousOperation raises 400 bad request in Django 1.11.\\n # https://docs.djangoproject.com/en/1.11/ref/views/#the-400-bad-request-view\\n raise SuspiciousOperation()\\n return limit\\n return settings.DEFAULT_LISTING_LIMIT\",\n \"def le(value, limit):\\n return value <= limit\",\n \"def charge_limit(self, limit=None):\\n if limit is None:\\n done, data = self._request('GH')\\n if done:\\n return int(data[0])\\n else:\\n if self._request('SH', str(int(limit)))[0]:\\n return limit\\n\\n raise EvseError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7404516","0.72155404","0.69859445","0.67413896","0.6662522","0.6627026","0.65691817","0.6537712","0.6416191","0.6371152","0.62403226","0.62190896","0.6199445","0.61692774","0.61400425","0.60801107","0.6063965","0.6063965","0.6063965","0.60438126","0.5997827","0.59951425","0.5979558","0.5952374","0.59388196","0.5901955","0.589314","0.5887076","0.5820409","0.5813387","0.5812368","0.5719548","0.5712326","0.569212","0.5683463","0.5677762","0.56674254","0.5654367","0.5642226","0.55622417","0.55078447","0.5481173","0.54661226","0.5437468","0.54270047","0.5378798","0.5377965","0.5358477","0.53405553","0.5308933","0.5301422","0.52742743","0.52615285","0.52615285","0.52567375","0.52558035","0.52527636","0.5235512","0.5198128","0.51942456","0.5183929","0.5181821","0.5164261","0.51506615","0.51420635","0.51284915","0.5127686","0.5121049","0.51179236","0.5111663","0.50961465","0.5095995","0.50847876","0.5063201","0.5056623","0.5056623","0.5047668","0.5043701","0.5009673","0.49807504","0.49114558","0.48671052","0.484279","0.48119032","0.47978437","0.47903427","0.47747067","0.47608304","0.47587463","0.47490874","0.47478727","0.4729828","0.47238824","0.47164285","0.47160074","0.47111142","0.4701328","0.4698688","0.46816614","0.4678657"],"string":"[\n \"0.7404516\",\n \"0.72155404\",\n \"0.69859445\",\n \"0.67413896\",\n \"0.6662522\",\n \"0.6627026\",\n \"0.65691817\",\n \"0.6537712\",\n \"0.6416191\",\n \"0.6371152\",\n \"0.62403226\",\n \"0.62190896\",\n \"0.6199445\",\n \"0.61692774\",\n \"0.61400425\",\n \"0.60801107\",\n \"0.6063965\",\n \"0.6063965\",\n \"0.6063965\",\n \"0.60438126\",\n \"0.5997827\",\n \"0.59951425\",\n \"0.5979558\",\n \"0.5952374\",\n \"0.59388196\",\n \"0.5901955\",\n \"0.589314\",\n \"0.5887076\",\n \"0.5820409\",\n \"0.5813387\",\n \"0.5812368\",\n \"0.5719548\",\n \"0.5712326\",\n \"0.569212\",\n \"0.5683463\",\n \"0.5677762\",\n \"0.56674254\",\n \"0.5654367\",\n \"0.5642226\",\n \"0.55622417\",\n \"0.55078447\",\n \"0.5481173\",\n \"0.54661226\",\n \"0.5437468\",\n \"0.54270047\",\n \"0.5378798\",\n \"0.5377965\",\n \"0.5358477\",\n \"0.53405553\",\n \"0.5308933\",\n \"0.5301422\",\n \"0.52742743\",\n \"0.52615285\",\n \"0.52615285\",\n \"0.52567375\",\n \"0.52558035\",\n \"0.52527636\",\n \"0.5235512\",\n \"0.5198128\",\n \"0.51942456\",\n \"0.5183929\",\n \"0.5181821\",\n \"0.5164261\",\n \"0.51506615\",\n \"0.51420635\",\n \"0.51284915\",\n \"0.5127686\",\n \"0.5121049\",\n \"0.51179236\",\n \"0.5111663\",\n \"0.50961465\",\n \"0.5095995\",\n \"0.50847876\",\n \"0.5063201\",\n \"0.5056623\",\n \"0.5056623\",\n \"0.5047668\",\n \"0.5043701\",\n \"0.5009673\",\n \"0.49807504\",\n \"0.49114558\",\n \"0.48671052\",\n \"0.484279\",\n \"0.48119032\",\n \"0.47978437\",\n \"0.47903427\",\n \"0.47747067\",\n \"0.47608304\",\n \"0.47587463\",\n \"0.47490874\",\n \"0.47478727\",\n \"0.4729828\",\n \"0.47238824\",\n \"0.47164285\",\n \"0.47160074\",\n \"0.47111142\",\n \"0.4701328\",\n \"0.4698688\",\n \"0.46816614\",\n \"0.4678657\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57001954"},"document_rank":{"kind":"string","value":"33"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":202,"numItemsPerPage":100,"numTotalItems":95772,"offset":20200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjM0NjM4NSwianRpIjoiZTNkZDg1MTEtZTZjZC00MjRjLWFlNjQtMmM2OTU3MjgwNzgwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzNDk5ODUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.apzUmoRSrSbRhaXr5nPrzXFMmcccZtvMqpL6Nse5XYH20IYPKZr_pbSbAUwn1uIe1jgnbhhDGfFrq4TgKS--DA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Gets the db connection. | def get_connection(self):
current_platform = platform.system().lower()
if current_platform != "windows":
raise Exception("MS Access can only be used in Windows.")
import pypyodbc as dbapi # pylint: disable=E0401
self.get_input()
file_name = self.opts["file"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_connection(self):\n\n\t\treturn dbapi.connect(credentials.SERVER,\\\n\t\t\t\t\t\t\t credentials.PORT,\\\n\t\t\t\t\t\t\t credentials.USER,\\\n\t\t\t\t\t\t\t credentials.PASSWORD)",
"def get_connection(cls):\n return cls.database.connection",
"def get_db():\n if not hasattr(g, 'db_connectio... | [
"0.8684576",
"0.86277896",
"0.8552817",
"0.8545873",
"0.8271116",
"0.8254641",
"0.81228167",
"0.80504644",
"0.80504644",
"0.8048555",
"0.8040573",
"0.8039187",
"0.802962",
"0.8026118",
"0.8026118",
"0.8006939",
"0.80013317",
"0.7990245",
"0.7976455",
"0.7968377",
"0.79032737"... | 0.0 | -1 |
This function connects to the device provided when called (dev) in the instantiated testbed (testbed_obj) and executes the provided show command (if none was provided, 'show version' is executed by default. If the Save option = True (s in the command line) was provided then the output will be saved to a JSON file in th... | def device_info(dev, testbed_obj, showcmd='show version', save_to_json=False, logstdout=True):
device = testbed_obj.devices[dev]
device.connect(log_stdout=logstdout)
response = device.parse(showcmd)
print(f"Response from {dev} is of type {type(response)} and length {len(response)}")
print(f"RAW res... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def executeShow(self,\n rsrcType,\n showAdditionalParams=[],\n rsrcAdditionalParams=[]):\n\n args = [\"show\",\n \"--wavefrontHost\", util.wavefrontHostName,\n \"--apiToken\", util.wavefrontApiToken] \\\n + sho... | [
"0.6001754",
"0.56841195",
"0.566696",
"0.54662395",
"0.54120153",
"0.5365674",
"0.5250371",
"0.523401",
"0.52098423",
"0.5194957",
"0.51602536",
"0.51479226",
"0.5107748",
"0.5103756",
"0.50766176",
"0.5072563",
"0.50322425",
"0.5027172",
"0.50200206",
"0.5005128",
"0.500112... | 0.72180516 | 0 |
initialize your data structure here. | def __init__(self):
self.max_heap = MaxHeap()
self.min_heap = MinHeap() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self.data = []\n self.record = {}",
"def __init__(self):\n self.structure = {}",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self... | [
"0.7761043",
"0.76102185",
"0.7555967",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.752797",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.743338",
"0.743338",
"0.7408609",
"0.7385719",
"0.737986",
"0.737986",
"0.73... | 0.0 | -1 |
The set of arguments for constructing a BucketLifecycleConfigurationV2 resource. | def __init__(__self__, *,
bucket: pulumi.Input[str],
rules: pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]],
expected_bucket_owner: Optional[pulumi.Input[str]] = None):
pulumi.set(__self__, "bucket", bucket)
pulumi.set(__s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__, *,\n bucket: Optional[pulumi.Input[str]] = None,\n expected_bucket_owner: Optional[pulumi.Input[str]] = None,\n rules: Optional[pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]]] = None):\n if bucket is not N... | [
"0.5992038",
"0.5966955",
"0.5840128",
"0.564464",
"0.5369499",
"0.5274274",
"0.5194183",
"0.5058795",
"0.5053266",
"0.5050231",
"0.5019062",
"0.5004931",
"0.49637008",
"0.49507582",
"0.49400494",
"0.48740724",
"0.48440862",
"0.4800399",
"0.47935998",
"0.47795483",
"0.4777908... | 0.57040656 | 3 |
Name of the source S3 bucket you want Amazon S3 to monitor. | def bucket(self) -> pulumi.Input[str]:
return pulumi.get(self, "bucket") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s3_bucket_name(self):\n return self._get_param(\"ResourcesS3Bucket\")",
"def bucket_name(self) -> str:\n ...",
"def bucket_name(self) -> str:\n return pulumi.get(self, \"bucket_name\")",
"def s3_bucket(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"s3_bucket\")",
"d... | [
"0.7696654",
"0.7252698",
"0.7064286",
"0.70079666",
"0.6968253",
"0.6968253",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.67862225",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.676... | 0.6067084 | 47 |
List of configuration blocks describing the rules managing the replication. See below. | def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]]:
return pulumi.get(self, "rules") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config_rules(self) -> Sequence['outputs.GetCompliancePacksPackConfigRuleResult']:\n return pulumi.get(self, \"config_rules\")",
"def rules(self) -> List['outputs.PreventionInspectTemplateInspectConfigRuleSetRule']:\n return pulumi.get(self, \"rules\")",
"def rules(cls):\n rules_Citysca... | [
"0.60906136",
"0.6038157",
"0.59134495",
"0.5897179",
"0.5889369",
"0.5826266",
"0.5803657",
"0.5783454",
"0.574287",
"0.5704244",
"0.5654648",
"0.5601011",
"0.55975515",
"0.5552346",
"0.55122215",
"0.5479335",
"0.54434586",
"0.5440965",
"0.54113096",
"0.5402494",
"0.5401443"... | 0.5440727 | 18 |
Account ID of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error. | def expected_bucket_owner(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "expected_bucket_owner") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expected_bucket_owner(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"expected_bucket_owner\")",
"def owner_account_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"owner_account_id\")",
"def owner_account_id(self) -> Optional[pulumi.Input[str]]:\n return ... | [
"0.7146499",
"0.6446139",
"0.6384591",
"0.6065642",
"0.5860553",
"0.5854814",
"0.58411705",
"0.581899",
"0.57273",
"0.57180434",
"0.5700793",
"0.5700793",
"0.5690769",
"0.5674292",
"0.5650694",
"0.56504285",
"0.5646915",
"0.5642213",
"0.5625961",
"0.5623262",
"0.56102705",
... | 0.70394754 | 1 |
Input properties used for looking up and filtering BucketLifecycleConfigurationV2 resources. | def __init__(__self__, *,
bucket: Optional[pulumi.Input[str]] = None,
expected_bucket_owner: Optional[pulumi.Input[str]] = None,
rules: Optional[pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]]] = None):
if bucket is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]]:\n return pulumi.get(self, \"rules\")",
"def get_bucket_lifecycle_configuration(Bucket=None):\n pass",
"def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleA... | [
"0.6019637",
"0.5962815",
"0.57765776",
"0.5525546",
"0.5406651",
"0.53766525",
"0.52367",
"0.4996396",
"0.48929548",
"0.48800376",
"0.48694855",
"0.48114437",
"0.48030028",
"0.47656834",
"0.46710703",
"0.46434137",
"0.4614874",
"0.4606839",
"0.46032488",
"0.45911995",
"0.458... | 0.55417687 | 3 |
Name of the source S3 bucket you want Amazon S3 to monitor. | def bucket(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "bucket") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s3_bucket_name(self):\n return self._get_param(\"ResourcesS3Bucket\")",
"def bucket_name(self) -> str:\n ...",
"def bucket_name(self) -> str:\n return pulumi.get(self, \"bucket_name\")",
"def s3_bucket(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"s3_bucket\")",
"d... | [
"0.7696654",
"0.7252698",
"0.7064286",
"0.70079666",
"0.6968253",
"0.6968253",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.67862225",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.676... | 0.5758498 | 98 |
Account ID of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error. | def expected_bucket_owner(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "expected_bucket_owner") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expected_bucket_owner(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"expected_bucket_owner\")",
"def owner_account_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"owner_account_id\")",
"def owner_account_id(self) -> Optional[pulumi.Input[str]]:\n return ... | [
"0.7147683",
"0.6445131",
"0.63837475",
"0.6061159",
"0.5858455",
"0.5852843",
"0.583966",
"0.5817529",
"0.5723972",
"0.5716804",
"0.5698139",
"0.5698139",
"0.5686788",
"0.5675481",
"0.5651604",
"0.565157",
"0.564837",
"0.5641776",
"0.562609",
"0.5620628",
"0.5610478",
"0.5... | 0.7040738 | 2 |
List of configuration blocks describing the rules managing the replication. See below. | def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketLifecycleConfigurationV2RuleArgs']]]]:
return pulumi.get(self, "rules") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config_rules(self) -> Sequence['outputs.GetCompliancePacksPackConfigRuleResult']:\n return pulumi.get(self, \"config_rules\")",
"def rules(self) -> List['outputs.PreventionInspectTemplateInspectConfigRuleSetRule']:\n return pulumi.get(self, \"rules\")",
"def rules(cls):\n rules_Citysca... | [
"0.60906136",
"0.6038157",
"0.59134495",
"0.5897179",
"0.5889369",
"0.5826266",
"0.5803657",
"0.5783454",
"0.574287",
"0.5704244",
"0.5654648",
"0.5601011",
"0.55975515",
"0.5552346",
"0.55122215",
"0.5479335",
"0.54434586",
"0.5440965",
"0.5440727",
"0.54113096",
"0.5402494"... | 0.52318865 | 40 |
Get an existing BucketLifecycleConfigurationV2 resource's state with the given name, id, and optional extra properties used to qualify the lookup. | def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
bucket: Optional[pulumi.Input[str]] = None,
expected_bucket_owner: Optional[pulumi.Input[str]] = None,
rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.I... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n minimal_action: Optional[pulumi.Input[str]] = None,\n most_disruptive_allowed_action: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]... | [
"0.58018064",
"0.5353829",
"0.5117951",
"0.51060236",
"0.50312877",
"0.49301392",
"0.48632613",
"0.4778881",
"0.47655228",
"0.47473097",
"0.4707761",
"0.4704642",
"0.46908763",
"0.46863323",
"0.4678712",
"0.46439952",
"0.46264488",
"0.46231508",
"0.46105427",
"0.455522",
"0.4... | 0.7716009 | 0 |
Name of the source S3 bucket you want Amazon S3 to monitor. | def bucket(self) -> pulumi.Output[str]:
return pulumi.get(self, "bucket") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s3_bucket_name(self):\n return self._get_param(\"ResourcesS3Bucket\")",
"def bucket_name(self) -> str:\n ...",
"def bucket_name(self) -> str:\n return pulumi.get(self, \"bucket_name\")",
"def s3_bucket(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"s3_bucket\")",
"d... | [
"0.7696654",
"0.7252698",
"0.7064286",
"0.70079666",
"0.6968253",
"0.6968253",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.6959447",
"0.67862225",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.67652977",
"0.676... | 0.5934818 | 73 |
Account ID of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error. | def expected_bucket_owner(self) -> pulumi.Output[Optional[str]]:
return pulumi.get(self, "expected_bucket_owner") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expected_bucket_owner(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"expected_bucket_owner\")",
"def expected_bucket_owner(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"expected_bucket_owner\")",
"def owner_account_id(self) -> pulumi.Output[str]:\n ... | [
"0.7040738",
"0.7040738",
"0.6445131",
"0.63837475",
"0.6061159",
"0.5858455",
"0.5852843",
"0.583966",
"0.5817529",
"0.5723972",
"0.5716804",
"0.5698139",
"0.5698139",
"0.5686788",
"0.5675481",
"0.5651604",
"0.565157",
"0.564837",
"0.5641776",
"0.562609",
"0.5620628",
"0.5... | 0.7147683 | 0 |
List of configuration blocks describing the rules managing the replication. See below. | def rules(self) -> pulumi.Output[Sequence['outputs.BucketLifecycleConfigurationV2Rule']]:
return pulumi.get(self, "rules") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config_rules(self) -> Sequence['outputs.GetCompliancePacksPackConfigRuleResult']:\n return pulumi.get(self, \"config_rules\")",
"def rules(self) -> List['outputs.PreventionInspectTemplateInspectConfigRuleSetRule']:\n return pulumi.get(self, \"rules\")",
"def rules(cls):\n rules_Citysca... | [
"0.60906136",
"0.6038157",
"0.59134495",
"0.5897179",
"0.5889369",
"0.5826266",
"0.5803657",
"0.574287",
"0.5704244",
"0.5654648",
"0.5601011",
"0.55975515",
"0.5552346",
"0.55122215",
"0.5479335",
"0.54434586",
"0.5440965",
"0.5440727",
"0.54113096",
"0.5402494",
"0.5401443"... | 0.5783454 | 7 |
Test the object construction. | def test_construction(self, search, expected, provider_string):
cws = Cws(False, provider_string, search, 25)
assert cws.searchtext == expected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_constructor(self):\n pass",
"def test_constructors(self, name, obj):\n assert getattr(forge, name) == obj",
"def test_constructors(self, name, obj):\n assert getattr(forge, name) == obj",
"def test_constructor(self):\n # Args\n name = 'Mathew'\n age = 13\n ... | [
"0.84078884",
"0.7803084",
"0.7803084",
"0.77192414",
"0.7586731",
"0.7398419",
"0.7353136",
"0.71540725",
"0.71333116",
"0.71261495",
"0.71220094",
"0.70800287",
"0.70170707",
"0.70005536",
"0.6983822",
"0.6973698",
"0.6966851",
"0.69559306",
"0.69241315",
"0.69136184",
"0.6... | 0.0 | -1 |
Get original model if the input model is a model wrapper. | def get_ori_model(model: nn.Module) -> nn.Module:
if is_model_wrapper(model):
return model.module
else:
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_non_wrapped_model(model: nn.Module) -> nn.Module:\n from torch.nn import DataParallel\n from torch.nn.parallel import DistributedDataParallel\n\n if not isinstance(model, nn.Module):\n raise RuntimeError(\"Input model must be a subclass of nn.Module.\")\n\n if isinstance(model, (DataPara... | [
"0.6501197",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.6491106",
"0.64641833",
"0.64641833",
"0.6462358",
"0.64084584",
"0.63638914",
"0.6319201",
"0.6311763",
"0.6279905",
"0.6277195",
"0.6266046",... | 0.7013369 | 0 |
Local file path relative to root | def _filepath(self, filename):
return os.path.join(self.root, self.version, filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _localfile(name):\n return os.path.abspath(resource_filename(__name__, name))",
"def _LocalDataPath(local_file):\n return data.ResourcePath(local_file)",
"def _get_path(): # THIS IS JUST FOR GETTING THE FILE\n return os.path.dirname(os.path.abspath(__file__)) + '/'",
"def localdir():\n root = __... | [
"0.76177573",
"0.73733217",
"0.72739893",
"0.7249159",
"0.7245917",
"0.72200906",
"0.7189738",
"0.7156527",
"0.7129785",
"0.7078425",
"0.7075425",
"0.70750046",
"0.70476395",
"0.7032672",
"0.7020124",
"0.69282275",
"0.69266427",
"0.69164157",
"0.6915657",
"0.69052947",
"0.689... | 0.67992586 | 39 |
Download dataset from Public HTTP URL. | def _download_http(source_uri, dest_path, version):
try:
logger.info("Downloading the dataset.")
download_file(source_uri=source_uri, dest_path=dest_path)
except DownloadError as e:
logger.info(
f"The request download from {source_uri} -> {dest_path} ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_dataset(url=DATASET_URL):\n # disable insecure https warning\n urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\n\n c = urllib3.PoolManager()\n with c.request(\"GET\", url, preload_content=False) as res, open(\n LOCAL_FILE_NAME, \"wb\"\n ) as out_file:\n ... | [
"0.80386454",
"0.7523211",
"0.7261655",
"0.7186977",
"0.70576763",
"0.7033056",
"0.6983279",
"0.6979918",
"0.6965372",
"0.69583726",
"0.69454134",
"0.6910798",
"0.6874054",
"0.6850715",
"0.68237364",
"0.6804672",
"0.67878693",
"0.6755197",
"0.6751866",
"0.67461944",
"0.674292... | 0.6942501 | 11 |
Unzip the downloaded file. | def _extract_file(dest_path, root_dir):
logger.info("Unzipping the dataset file.")
with zipfile.ZipFile(dest_path, "r") as zip_dir:
zip_dir.extractall(root_dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unzip() -> None:\n logger = logging.getLogger(__name__)\n logger.info('Download the dataset')\n\n # define the destination\n destination = project_dir / 'data' / 'raw'\n\n # extract zip\n zip_file = ZipFile(destination / \"original.zip\")\n zip_file.extractall(destination)",
"def unzip(z... | [
"0.7120566",
"0.68945885",
"0.68283784",
"0.67834395",
"0.6745126",
"0.66927487",
"0.6636815",
"0.6607741",
"0.6572298",
"0.65560687",
"0.65266436",
"0.6512526",
"0.6462456",
"0.64529145",
"0.64505756",
"0.64146626",
"0.641037",
"0.640688",
"0.63944346",
"0.6388501",
"0.63870... | 0.6222795 | 32 |
Download dataset from Public HTTP URL. If the file already exists and the checksum matches, it will skip the download step. If not, it would delete the previous file and download it again. If the file doesn't exist, it would download the file. | def download(data_root, version):
if version not in GroceriesReal.GROCERIES_REAL_DATASET_TABLES.keys():
raise ValueError(
f"A valid dataset version is required. Available versions are:"
f"{GroceriesReal.GROCERIES_REAL_DATASET_TABLES.keys()}"
)
dest... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _download_http(source_uri, dest_path, version):\n\n try:\n logger.info(\"Downloading the dataset.\")\n download_file(source_uri=source_uri, dest_path=dest_path)\n except DownloadError as e:\n logger.info(\n f\"The request download from {source_uri} ... | [
"0.73288465",
"0.7237144",
"0.70823073",
"0.6893158",
"0.686726",
"0.6793318",
"0.6786019",
"0.6761416",
"0.66435325",
"0.6617243",
"0.66126984",
"0.6610634",
"0.6591112",
"0.65789825",
"0.6554",
"0.6554",
"0.6553654",
"0.65531015",
"0.65490633",
"0.65347546",
"0.65282995",
... | 0.6844599 | 5 |
Load annotation from annotations.json file | def _load_annotations(self):
annotation_file = self._filepath(self.ANNOTATION_FILE)
with open(annotation_file) as f:
json_data = json.load(f)
return json_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_annotation(json_path):\n # Open the file containing the annotation\n with open(json_path) as annotation_file:\n\n # Parse the AI2D annotation from the JSON file into a dictionary\n annotation = json.load(annotation_file)\n\n # Return the annotation\n retu... | [
"0.7888858",
"0.7325585",
"0.7084303",
"0.6923192",
"0.687097",
"0.68155825",
"0.66877896",
"0.6673177",
"0.65827876",
"0.6560132",
"0.6559868",
"0.6558796",
"0.65527225",
"0.64227253",
"0.63591856",
"0.6338805",
"0.6284784",
"0.6264161",
"0.62268883",
"0.62000585",
"0.618474... | 0.8038193 | 0 |
Load the data indices txt file. | def _load_split_indices(self):
split_file = self.SPLITS.get(self.split)
indices_file = self._filepath(split_file)
with open(indices_file) as txt_file:
idx_data = [int(i) for i in txt_file.readline().split()]
return idx_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_index_data(data_path):\n index_keywords = []\n with open(data_path) as data:\n for line in data:\n index_keywords.append(line.rstrip())\n return index_keywords",
"def load_info():\n data = np.loadtxt(\"u_sol_meta.txt\", dtype=int)\n return data",
"def load_labels_index... | [
"0.67228645",
"0.64503235",
"0.6270136",
"0.62359387",
"0.62125915",
"0.6206149",
"0.61973083",
"0.6185728",
"0.61774135",
"0.61695915",
"0.61617666",
"0.61599284",
"0.61492556",
"0.61449534",
"0.61161757",
"0.6100025",
"0.60692877",
"0.602712",
"0.6014525",
"0.60091174",
"0.... | 0.68765545 | 0 |
Convert the bbox record to BBox2D objects. | def _convert_to_bbox2d(single_bbox):
label = single_bbox["label_id"]
bbox = single_bbox["bbox"]
canonical_bbox = BBox2D(
x=bbox[0], y=bbox[1], w=bbox[2], h=bbox[3], label=label
)
return canonical_bbox | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bbox2fields():\n bbox2label = {\n 'gt_bboxes': 'gt_labels',\n 'gt_bboxes_ignore': 'gt_labels_ignore'\n }\n bbox2mask = {\n 'gt_bboxes': 'gt_masks',\n 'gt_bboxes_ignore': 'gt_masks_ignore'\n }\n bbox2seg = {\n 'gt_bboxes': 'gt_semantic_seg',\n }\n return b... | [
"0.6832664",
"0.6783777",
"0.6691991",
"0.63218105",
"0.6319875",
"0.6284736",
"0.6246083",
"0.6223461",
"0.61668444",
"0.6120401",
"0.6079261",
"0.6019865",
"0.6007134",
"0.59077746",
"0.5902924",
"0.5898657",
"0.58965296",
"0.5879593",
"0.5847342",
"0.58367205",
"0.58200914... | 0.75232357 | 0 |
Download dataset from GCS | def download(self):
cloud_path = f"gs://{const.GCS_BUCKET}/{self.GCS_PATH}"
# download label file
label_zip = download_file_from_gcs(
cloud_path, self.root, self.LABEL_ZIP
)
with zipfile.ZipFile(label_zip, "r") as zip_dir:
zip_dir.extractall(self.root)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_dataset(self):\n raise NotImplementedError",
"def download_dataset(url=DATASET_URL):\n # disable insecure https warning\n urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\n\n c = urllib3.PoolManager()\n with c.request(\"GET\", url, preload_content=False) as res,... | [
"0.7185856",
"0.68503934",
"0.6714282",
"0.67088765",
"0.66851914",
"0.6538648",
"0.6525635",
"0.6497461",
"0.64432293",
"0.6433408",
"0.6422011",
"0.639159",
"0.63663715",
"0.6344865",
"0.6338407",
"0.62408376",
"0.6234367",
"0.62312293",
"0.6227992",
"0.6183774",
"0.6181906... | 0.75893414 | 0 |
Finds number of documents in the Tweet collection matching a given search_term (and location, if provided). | def count_tweets(search_term, location=None):
if location:
return len(Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location)))
else:
return len(Tweet.objects(keyword_search_term=search_term)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _count(self):\n if self._count_valid:\n return self._total_results\n\n url = self._build_url(\"/_search\")\n request = self._build_request(0, -1)\n resp = self._cb.post_object(url, body=request)\n result = resp.json()\n\n self._total_results = result[\"num_f... | [
"0.67774284",
"0.67774284",
"0.64773935",
"0.6338761",
"0.63320786",
"0.6253776",
"0.61553955",
"0.6143456",
"0.6119857",
"0.605183",
"0.60442805",
"0.6041794",
"0.6023299",
"0.60119075",
"0.59792614",
"0.59583217",
"0.5956584",
"0.59333336",
"0.59300566",
"0.5897961",
"0.585... | 0.81229687 | 0 |
Calculates a keyword's historical sentiment (restricted within a location, if provided). | def get_historical_sentiment(search_term, location=None):
if location:
positive = len(Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location) & Q(sentiment_type="positive")))
negative = len(Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location) &... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_historical_sentiment_avg(search_term, location=None):\r\n\r\n total = 0\r\n\r\n if location:\r\n tweets = Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location))\r\n count = len(tweets)\r\n else:\r\n tweets = Tweet.objects(Q(keyword_search_term=search_... | [
"0.67188215",
"0.67036396",
"0.6334149",
"0.6167096",
"0.59021384",
"0.5850361",
"0.5808837",
"0.57456166",
"0.55691725",
"0.55315197",
"0.55021304",
"0.5500344",
"0.5474109",
"0.54653317",
"0.5465105",
"0.5422208",
"0.5408632",
"0.5408632",
"0.54046506",
"0.5381399",
"0.5356... | 0.704126 | 0 |
Calculates the average sentiment score for a given keyword (restricted within a location, if provided). | def get_historical_sentiment_avg(search_term, location=None):
total = 0
if location:
tweets = Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location))
count = len(tweets)
else:
tweets = Tweet.objects(Q(keyword_search_term=search_term))
count... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sentiment_overtime(keyword, location=None):\r\n\r\n # Get date 10 days ago\r\n ten_days_ago = datetime.now() - timedelta(days=10)\r\n\r\n # Get raw PyMongo collection\r\n collection = Tweet._get_collection()\r\n\r\n if location:\r\n match = {\r\n \"$match\":\r\n ... | [
"0.70859677",
"0.63445497",
"0.615348",
"0.6074",
"0.607026",
"0.6054127",
"0.60071707",
"0.59709895",
"0.58449465",
"0.58252454",
"0.5823854",
"0.58144957",
"0.57648957",
"0.57458204",
"0.5664769",
"0.5651309",
"0.56352067",
"0.56242144",
"0.56193566",
"0.5584524",
"0.558051... | 0.74165547 | 0 |
Calculates the average sentiment score in a given query set of Tweets. | def get_query_sentiment_avg(tweets):
total = 0
count = len(tweets)
for tweet in tweets:
total += tweet.sentiment_score
# Calculate average
avg = total / count
avg = float("{0:.2f}".format((float(avg))))
return avg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_query_statistics(tweets, sentiment_aggregate_list):\r\n\r\n total = len(tweets)\r\n positive_percentage = float(\"{0:.2f}\".format((float(sentiment_aggregate_list[0][1]/total*100))))\r\n neutral_percentage = float(\"{0:.2f}\".format((float(sentiment_aggregate_list[1][1]/total*100))))\r\n negati... | [
"0.67024827",
"0.66712636",
"0.66350305",
"0.66138715",
"0.65283984",
"0.6518941",
"0.6491312",
"0.6487166",
"0.64857775",
"0.6405299",
"0.62509996",
"0.6194273",
"0.6162189",
"0.6128368",
"0.61244524",
"0.6088544",
"0.6022574",
"0.6017512",
"0.60000277",
"0.59923315",
"0.597... | 0.854272 | 0 |
Generates basic statistics for a given query set of Tweets. | def get_query_statistics(tweets, sentiment_aggregate_list):
total = len(tweets)
positive_percentage = float("{0:.2f}".format((float(sentiment_aggregate_list[0][1]/total*100))))
neutral_percentage = float("{0:.2f}".format((float(sentiment_aggregate_list[1][1]/total*100))))
negative_percentage = flo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def statistics(all_new_tweets, all_retweets, all_quote_tweets):\n length_all_quote_tweets = len(all_quote_tweets)\n length_all_retweets = len(all_retweets)\n length_all_tweets = len(all_new_tweets)\n\n # print(db_twitter.collections.stats())\n total_tweets = length_all_quote_tweets + length_all_retw... | [
"0.69248664",
"0.620815",
"0.59848654",
"0.59815437",
"0.5954515",
"0.5952684",
"0.5883914",
"0.5861081",
"0.57721597",
"0.57669294",
"0.5752889",
"0.5752543",
"0.564709",
"0.564132",
"0.5640209",
"0.5572535",
"0.55670476",
"0.55010945",
"0.5492158",
"0.5483679",
"0.54743016"... | 0.7054746 | 0 |
Aggregates sentiment types for a given tweet collection. | def aggregate_sentiment(tweets):
positive = 0
negative = 0
neutral = 0
for tweet in tweets:
if tweet.sentiment_type == "positive":
positive += 1
elif tweet.sentiment_type == "negative":
negative += 1
else:
neutral += 1
resu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect(self, collect_types: List[str]) -> None:\n valid_types = [x for x in collect_types if x in self._valid_types.keys()]\n for ctype in valid_types:\n self._collect_tweets(ctype)",
"def do_sentiment_analysis(self):\n\n tweets_sentiment = []\n\n for tweet in self.twe... | [
"0.59929293",
"0.59618926",
"0.58570933",
"0.5779308",
"0.57485133",
"0.573751",
"0.56903654",
"0.56657684",
"0.55670786",
"0.5521338",
"0.54893357",
"0.542505",
"0.53890103",
"0.53886825",
"0.53880984",
"0.533604",
"0.52402407",
"0.52377105",
"0.5190812",
"0.51520646",
"0.51... | 0.72262305 | 0 |
Gets the predominant sentiment type from a list of sentiments. (Eg [[positive, 3],[neutral, 10],[negative,15]]) | def predominant_sentiment(sentiment_aggregate_list):
positive = int(sentiment_aggregate_list[0][1])
neutral = int(sentiment_aggregate_list[1][1])
negative = int(sentiment_aggregate_list[2][1])
if positive > neutral and positive > negative:
return "positive"
elif neutral > positive ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classify_sentiment(sent_index):\n\n\tif sent_index < -0.5:\n\t\treturn 'negative'\n\tif sent_index <= 0.5 and sent_index >= -0.5:\n\t\treturn 'neutral'\n\tif sent_index >= 0.5:\n\t\treturn 'positive'",
"def classify(tweets, positives, negatives):\n sentiment_list = makelist(tweets, positives, negatives)\n... | [
"0.6732237",
"0.63710135",
"0.6355821",
"0.6258131",
"0.61799365",
"0.611913",
"0.6108495",
"0.60978174",
"0.6085284",
"0.5958469",
"0.59254676",
"0.5863128",
"0.5860238",
"0.5843611",
"0.5822473",
"0.58167547",
"0.5785102",
"0.5766148",
"0.5755716",
"0.5731452",
"0.5707599",... | 0.7360832 | 0 |
Gets sentiment statistics for average sentiment for a given keyword (and location, if specified) over the past 10 days. | def get_sentiment_overtime(keyword, location=None):
# Get date 10 days ago
ten_days_ago = datetime.now() - timedelta(days=10)
# Get raw PyMongo collection
collection = Tweet._get_collection()
if location:
match = {
"$match":
{
"k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_historical_sentiment_avg(search_term, location=None):\r\n\r\n total = 0\r\n\r\n if location:\r\n tweets = Tweet.objects(Q(keyword_search_term=search_term) & Q(location_address=location))\r\n count = len(tweets)\r\n else:\r\n tweets = Tweet.objects(Q(keyword_search_term=search_... | [
"0.7494988",
"0.6593404",
"0.64326733",
"0.62750417",
"0.5912352",
"0.54747236",
"0.5449991",
"0.5329276",
"0.5303148",
"0.52833545",
"0.52704436",
"0.50593525",
"0.5013312",
"0.49506775",
"0.49489254",
"0.4912962",
"0.4879828",
"0.48639044",
"0.4842615",
"0.48359329",
"0.481... | 0.8139415 | 0 |
Gets the top 10 most positive / negative sentiment triggers from the past 7 days. | def get_sentiment_trends(order):
# Get date seven days ago
seven_days_ago = datetime.now() - timedelta(days=7)
# Get raw PyMongo collection
collection = Tweet._get_collection()
# Perform aggregate query
result = collection.aggregate([
{
"$match":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_extreme_tweets(self, sentiment, count=1, num_score=False):\n def return_polarity(tweet):\n return tweet['polarity']\n\n print(\"The top {} most {} tweets:\".format(count, sentiment))\n\n if sentiment == 'positive':\n sorted_tweet = sorted(self.positive_tweets, k... | [
"0.5406669",
"0.54055756",
"0.5391852",
"0.536155",
"0.5360676",
"0.5214797",
"0.5178173",
"0.51120335",
"0.50702655",
"0.5060932",
"0.5052575",
"0.501701",
"0.5007129",
"0.50032103",
"0.49881318",
"0.49561754",
"0.49547327",
"0.49525204",
"0.4947948",
"0.49175078",
"0.490440... | 0.54947144 | 0 |
Load the feed url into self.entries using the feedparser module. | def __init__(self, url=URL):
self.entries = feedparser.parse(url).entries | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_feed(self):\n parsed_feed = feedparser.parse(self.rss_url)\n # Check for malformed feed\n if parsed_feed['bozo']:\n raise Exception('malformed rss feed!')\n self.parsed_feed = parsed_feed",
"def feed(self):\n feed_dict = feedparser.parse(self.URL)\n ... | [
"0.7183806",
"0.68700135",
"0.66769147",
"0.6660742",
"0.6519246",
"0.6506825",
"0.6443622",
"0.6431346",
"0.64295334",
"0.6419183",
"0.6348568",
"0.6227926",
"0.61853313",
"0.6180963",
"0.610789",
"0.6107114",
"0.607002",
"0.6055648",
"0.60153824",
"0.5997344",
"0.5982748",
... | 0.8170361 | 0 |
Return a list of episode IDs (itunes_episode attribute) of the episodes the pass in domain was mentioned in. | def get_episode_numbers_for_mentioned_domain(self, domain: str) -> list:
return [ep.itunes_episode
for ep in self.entries
if domain.lower() in ep.summary.lower()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def episodes(self):\n episodes = []\n for series in self.series:\n episodes.extend(series.episodes)\n return episodes",
"def episodes(self):\n episodes = []\n for season in self.seasons:\n episodes.extend(season.episodes)\n return episodes",
"def ... | [
"0.68623555",
"0.6790614",
"0.64584225",
"0.62703633",
"0.6171073",
"0.616064",
"0.5982251",
"0.58765996",
"0.5858648",
"0.5848835",
"0.57939684",
"0.5776999",
"0.57678777",
"0.57606727",
"0.57389754",
"0.56692666",
"0.5666441",
"0.56479317",
"0.5601704",
"0.55696493",
"0.552... | 0.8150568 | 0 |
Get the most mentioned domain domains. We match a domain using | def get_most_mentioned_domain_names(self, n: int = 15) -> list:
rex = re.compile(r'https?://[^/]+')
c = Counter()
for entry in self.entries:
domains = set(re.findall(rex, entry.summary))
for domain in domains:
if domain not in IGNORE_DOMAINS:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_most_common_domains(emails, common_domains=None):\n if common_domains is None:\n common_domains = get_common_domains()\n\n most_common_prep = []\n for email in emails:\n domain = email.split(\"@\")[1]\n if domain in common_domains:\n continue\n else:\n ... | [
"0.6735951",
"0.6687723",
"0.65930104",
"0.58609587",
"0.5764132",
"0.5747643",
"0.5680006",
"0.55159426",
"0.5416647",
"0.53974265",
"0.5369249",
"0.5319094",
"0.53149176",
"0.5308091",
"0.5302462",
"0.52969885",
"0.5256669",
"0.5224873",
"0.52034307",
"0.519969",
"0.5192919... | 0.6606182 | 2 |
Return the number of episodes that had one of more special guests featured (use SPECIAL_GUEST). | def number_episodes_with_special_guest(self) -> int:
return len([ep for ep in self.entries if SPECIAL_GUEST in ep.summary]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_episodes(self) -> int:\n return len(self.episodes)",
"def n_episodes(self):\n raise NotImplementedError",
"def get_tv_episodes(self) -> int:\n return len(glob.glob(os.path.join(\n os.path.dirname(self.file),\n f\"*{os.path.splitext(self.file)[-1]}\"\n ... | [
"0.649917",
"0.62428266",
"0.5887413",
"0.5634373",
"0.552352",
"0.54988056",
"0.54770404",
"0.53177136",
"0.5314232",
"0.52770793",
"0.52533907",
"0.5198246",
"0.5186868",
"0.5182951",
"0.51779616",
"0.5158745",
"0.5125548",
"0.51043326",
"0.5093988",
"0.50591505",
"0.505139... | 0.8896974 | 0 |
Return the average duration in seconds of a Python Bytes episode, as | def get_average_duration_episode_in_seconds(self) -> NamedTuple:
times = [ep.itunes_duration for ep in self.entries]
format_times = []
for time in times:
if not time.startswith('00'):
time = '0' + time
format_times.append(time)
dts = [datetime.st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_wav_duration(wav_bytes: bytes) -> float:\n with io.BytesIO(wav_bytes) as wav_buffer:\n wav_file: wave.Wave_read = wave.open(wav_buffer, \"rb\")\n with wav_file:\n frames = wav_file.getnframes()\n rate = wav_file.getframerate()\n return frames / float(rate)"... | [
"0.67595243",
"0.65047795",
"0.64271915",
"0.64189667",
"0.6367844",
"0.6341444",
"0.6284898",
"0.6283205",
"0.6277745",
"0.62206906",
"0.62178415",
"0.6192925",
"0.6191467",
"0.6185916",
"0.61730164",
"0.6169899",
"0.61567783",
"0.6137445",
"0.6130938",
"0.6128692",
"0.61263... | 0.71605974 | 0 |
Build an index from word to set of document indexes This does the exact same thing as create_index() except that it uses your htable. As a number of htable buckets, use 4011. Returns a listofbuckets hashtable representation. | def myhtable_create_index(files):
res_buckets = htable(4011)
for id, file in enumerate(files):
if file[-4:] == '.txt':
word_list = words(get_text(file))
for word in word_list:
value = htable_get(res_buckets, word)
if value == None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createIndex(pages): \n index = defaultdict(list)\n for url, content, links in pages:\n counts = getNumberTerms(content)\n for term, count in counts.items():\n index[term].append((url, count))\n return index",
"def perform_indexing(self, words_list):\n\n indexer_tab... | [
"0.66589546",
"0.6544771",
"0.64670044",
"0.64168614",
"0.63033056",
"0.6180472",
"0.6178157",
"0.6154601",
"0.61489826",
"0.6104722",
"0.60848147",
"0.6009543",
"0.60010827",
"0.5981455",
"0.5976573",
"0.5911548",
"0.59066755",
"0.590064",
"0.5855223",
"0.58235234",
"0.58033... | 0.7427538 | 0 |
This does the exact same thing as index_search() except that it uses your htable. I.e., use htable_get(index, w) not index[w]. | def myhtable_index_search(files, index, terms):
res_file = []
count = 0
if len(terms) == 0:
print('empty terms')
return
for term in terms:
term = term.lower()
count += 1
if count == 1:
s = htable_get(index, term)
if s == None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup(index,keyword):\n\tif keyword in index:\n\t\treturn index[keyword]\n\treturn None",
"def __getitem__(self,idx):\n try:\n return self._cache[idx]\n except:\n pass\n\n try:\n # return full data entry as list\n out = self._data[idx]\n ... | [
"0.6155713",
"0.59609514",
"0.59491926",
"0.59410375",
"0.5900303",
"0.5845122",
"0.5789598",
"0.577333",
"0.57275766",
"0.5688099",
"0.5681756",
"0.56468856",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",
"0.5621905",... | 0.6331249 | 0 |
Produces contexts Runs CNN(s) followed by RNN(s) | def encode(self, input_):
return self.encoder(input_) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def context(model: Sequential) -> Sequential:\n model.add(ZeroPadding2D(padding=(33, 33)))\n model.add(Conv2D(42, (3, 3), activation='relu', name='ct_conv1_1'))\n model.add(Conv2D(42, (3, 3), activation='relu', name='ct_conv1_2'))\n model.add(AtrousConvolution2D(84, 3, 3, atrous_rate=(2, 2), activation='relu',... | [
"0.6682688",
"0.6489866",
"0.633372",
"0.6083568",
"0.60525763",
"0.6049823",
"0.60404956",
"0.5969165",
"0.59309137",
"0.5893104",
"0.5889334",
"0.58862287",
"0.5844192",
"0.5840538",
"0.5822752",
"0.58128786",
"0.5812776",
"0.58107114",
"0.58042026",
"0.57976633",
"0.576613... | 0.0 | -1 |
Tests if builsing an dirichlet ensemble is running without problems | def test_dirichletensemble():
np.random.seed(seed=2)
X, y = make_blobs(n_samples=200, centers=2, n_features=2, cluster_std=4,
random_state=2)
n_train = 100
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
n_members = 5
stack = Dir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_machine_learning():",
"def test_valid_ensemble(ensemble: bool) -> None:\n mapie = MapieRegressor(ensemble=ensemble)\n mapie.fit(X_toy, y_toy)",
"def test_training(self):\n\t\tpass",
"def run_experiment() -> List[bool]:\n return [random.random() < 0.5 for _ in range(1000)]",
"def main():\n... | [
"0.65376455",
"0.65050536",
"0.6211623",
"0.6093889",
"0.60780334",
"0.6073346",
"0.6068026",
"0.60495067",
"0.60197634",
"0.60121745",
"0.59868246",
"0.5984857",
"0.5951661",
"0.594414",
"0.5943446",
"0.5942952",
"0.5937696",
"0.59257823",
"0.5918587",
"0.59163463",
"0.59018... | 0.670472 | 0 |
Map s_new to t_new based on known mapping of s (source) to t (target), with s original/intrinsic coordinates and t intrinsic/original coordinates | def mapping(s, t, s_new, k,c):
n, s_dim = s.shape
t_dim = t.shape[1]
n_new = s_new.shape[0]
# 1. determine nearest neighbors
dist = np.sum((s[np.newaxis] - s_new[:,np.newaxis])**2,-1)
nn_ids = np.argsort(dist)[:,:k] # change to [:,:k]
nns = np.row_stack([s[nn_ids[:,ki]] for ki in range(k)])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_model(self, original, t1, t2, resolution_scaling_factor=1):\n img = Image()\n img.time_stamp = t2\n\n if t1 == t2:\n img.initialize_with_image(original)\n return img\n\n calc_shift_fnc = self.calculate_shift\n orig_get_fnc = original.get\n i... | [
"0.55668783",
"0.5532111",
"0.5460896",
"0.5447538",
"0.53842735",
"0.5356351",
"0.53368974",
"0.53297365",
"0.53066075",
"0.5294714",
"0.52837485",
"0.5263581",
"0.52585614",
"0.52573544",
"0.52403593",
"0.5213048",
"0.51814204",
"0.5172513",
"0.51586723",
"0.51488996",
"0.5... | 0.66779846 | 0 |
Activity of neurons for sequence of locations | def compute_activity(location, avg_activity, spatial_bins, noise_sigma=0):
interpolator = interp1d(spatial_bins, avg_activity,axis=0,bounds_error=False, fill_value='extrapolate')
mean_activity = interpolator(location)
if noise_sigma > 0:
activity = np.random.normal(loc=mean_activity, scale=noise_sig... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _neuron_location(self, m, n):\n for i in range(m):\n for j in range(n):\n yield np.array([i, j])",
"def apply_neurons(self):\n for neuron in range(self.n_outputs):\n self.uf_activate(neuron)",
"def run(self):\n count = self.neuron_count\n for... | [
"0.59099996",
"0.5725361",
"0.5699758",
"0.5679557",
"0.55904645",
"0.55668813",
"0.55668813",
"0.5518901",
"0.54514945",
"0.54417515",
"0.5437984",
"0.54246867",
"0.5385736",
"0.5354543",
"0.52761805",
"0.5255122",
"0.5224641",
"0.52234226",
"0.5208442",
"0.5205464",
"0.5204... | 0.0 | -1 |
To be written soon... | def get_shape_from_box(box):
from molsysmt.pbc.get_lengths_and_angles_from_box import get_lengths_and_angles_from_box
from molsysmt.pbc.get_shape_from_lengths_and_angles import get_shape_from_lengths_and_angles
if box is None:
return None
else:
lengths, angles = get_lengths_and_angles... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self) -> None:",
"def regular(self):",
"def exo2():",
"def support(self):",
"def use(self):",
"def degibber(self):",
"def __call__():",
"def __call__():",
"def __call__():",
"def __call__():",
"def __call__():",
"def __call__(self):\n\t\treturn",
"def cx():",
"def _regr_basic... | [
"0.6484565",
"0.64034045",
"0.6370542",
"0.6307648",
"0.62786925",
"0.6233077",
"0.6224396",
"0.6224396",
"0.6224396",
"0.6224396",
"0.6224396",
"0.609799",
"0.60457885",
"0.6035354",
"0.595735",
"0.5951163",
"0.5938122",
"0.5930624",
"0.5927453",
"0.591242",
"0.5904648",
"... | 0.0 | -1 |
Construct a new BlockScanner object. | def __init__(self, current_char, source):
self.current_char = current_char
self.source = source | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, tokenGenerator):\r\n\r\n\t\tself._iterator = iter(tokenGenerator)\r\n\t\tself._stack = []\r\n\t\tself._tokenMarker = None\r\n\r\n\t\tstartToken = next(self._iterator)\r\n\t\tstartBlock = StartOfDocumentBlock(startToken)\r\n\r\n\t\tif (not isinstance(startToken, StartOfDocu... | [
"0.597456",
"0.5563696",
"0.53400904",
"0.5296141",
"0.52921337",
"0.5256663",
"0.52089673",
"0.5207816",
"0.5177261",
"0.51647526",
"0.51439065",
"0.51185596",
"0.5116297",
"0.50943065",
"0.507248",
"0.50681114",
"0.5063206",
"0.5055973",
"0.5041467",
"0.5037778",
"0.5036207... | 0.0 | -1 |
Read source and creates a new brace token | def create_token(self):
token = Token(PAREN.get(self.current_char), "brace")
self.current_char = self.source.read(1)
return token | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_till_closing_brace(stream):\n rv = \"\"\n in_braces = 1\n while True:\n if EscapeCharToken.starts_here(stream, '{}'):\n rv += stream.next() + stream.next()\n else:\n c = stream.next()\n if c == '{': in_braces += 1\n elif c == '}': in_bra... | [
"0.59238863",
"0.58185357",
"0.5810777",
"0.5810427",
"0.5761932",
"0.5747912",
"0.542546",
"0.5393044",
"0.5324538",
"0.530029",
"0.5290811",
"0.5258126",
"0.5244535",
"0.52285373",
"0.5211549",
"0.517982",
"0.51321423",
"0.51276994",
"0.51232326",
"0.51212436",
"0.5091131",... | 0.71761155 | 0 |
Receives a char and returning if its a left or right brace | def should_lex(cls, char):
return char == '{' or char == '}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bracketed (phrase,bracketing='()'):\r\n\r\n level = 0\r\n left_point = None\r\n right_point = None\r\n \r\n\r\n for count,char in enumerate(phrase):\r\n\r\n if char == bracketing[0]:\r\n if level ==... | [
"0.6396085",
"0.6267263",
"0.6178741",
"0.61347187",
"0.6007452",
"0.6006558",
"0.59606045",
"0.5951733",
"0.59003645",
"0.58945894",
"0.58871955",
"0.58813554",
"0.58139944",
"0.58129483",
"0.58129483",
"0.5799351",
"0.57966834",
"0.5772036",
"0.57385767",
"0.57300985",
"0.5... | 0.72300553 | 0 |
Play the next song in the queue. | def _next(verbose=0, quiet=False):
Spotify.request('me/player/next', method='POST')
if not quiet:
from cli.commands.status import status
status.callback(verbose=verbose)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def async_media_next_track(self) -> None:\n cur_track_index = self._get_current_track_index()\n\n await self._table.active_playlist.play(\n self._table.active_playlist.tracks[cur_track_index + 1]\n )",
"async def next(self):\n await self._pytheos.api.player.play_next(... | [
"0.7804286",
"0.756156",
"0.7519215",
"0.7317698",
"0.7314149",
"0.72888863",
"0.713351",
"0.70998675",
"0.7088512",
"0.690234",
"0.68884444",
"0.6880905",
"0.68629616",
"0.6795466",
"0.67567676",
"0.6732975",
"0.6704325",
"0.6688262",
"0.6659063",
"0.66365665",
"0.6595123",
... | 0.57869184 | 94 |
Crop graph image Crops the desired image by it's type. | def crop_image(self):
image_data = Image.open(self.img_path)
return image_data.crop(self.data_type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crop_image(self, img):\n img.crop_image(self._center, 1.1 * self._radius)",
"def crop(image, dimX, dimY):\n # TODO\n return image",
"def crop(self, *args, **kwargs):\n return _image.image_crop(self, *args, **kwargs)",
"def __call__(self, img):\n image_width, image_height = img.... | [
"0.66398174",
"0.6505323",
"0.6446542",
"0.63750404",
"0.63750404",
"0.63555723",
"0.6341775",
"0.633309",
"0.62684494",
"0.626365",
"0.623445",
"0.6195632",
"0.61726093",
"0.61628",
"0.6140623",
"0.6068601",
"0.60564905",
"0.6035729",
"0.60079396",
"0.6002261",
"0.5993988",
... | 0.6803471 | 0 |
Transform Image into array Transform cropped image into an numpy multidimensional array. | def np_image_matrix(self):
return np.array(self.crop_image()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_to_array(self, img):\n x = np.asarray(img, dtype=self.dtype)\n if len(x.shape) == 3:\n if self.channels_first:\n x = x.transpose(2, 0, 1)\n elif len(x.shape) == 2:\n if self.channels_first:\n x = x.reshape((1, x.shape[0], x.shape[1]... | [
"0.722699",
"0.6876687",
"0.68659633",
"0.68560636",
"0.6853701",
"0.65742826",
"0.64895433",
"0.64520043",
"0.64459306",
"0.63613623",
"0.6347112",
"0.6313576",
"0.6297982",
"0.6266448",
"0.6222398",
"0.6181755",
"0.6175415",
"0.6161334",
"0.6153839",
"0.6122482",
"0.6093073... | 0.6892566 | 1 |
Find Blue pixels Finds all blue pixels inside the graph area, which represents the desired points of the graph. The method generates a numpy 2d array with these pixels relative positions. | def blue_matrix(self):
return np.vstack(np.where(self.np_image_matrix() == 2)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_blue(x, y, slot = 0):\r\n return __g[slot].pixels_rgb[__g[slot].width * 3 * y + x * 3 + 2]",
"def get_blue(self, x, y):\n self.__check_dimensions(x, y)\n return self.pixels[(x, y)].get_blue()",
"def blue_channel(img):\n\n blue = np.zeros(img.shape,dtype=float)\n\n blue[:,:,0] = n... | [
"0.6495526",
"0.64614147",
"0.62514365",
"0.60262513",
"0.5827481",
"0.57433754",
"0.5736232",
"0.5696482",
"0.56894076",
"0.5617795",
"0.5553846",
"0.55003446",
"0.54996854",
"0.54855716",
"0.5472395",
"0.54648805",
"0.5462373",
"0.5456809",
"0.5430799",
"0.5417668",
"0.5415... | 0.6844396 | 0 |
find the gray pixels and it's indexex | def get_days_index(self):
return np.where(self.np_image_matrix()[3] == 3)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def idx2pixel(idx, image_size):\n\tassert idx < image_size**2, \"index {} too large for image size {}\".format(idx, image_size)\n\ttmp = np.zeros(image_size**2)\n\ttmp[idx] = 1\n\ttmp = tmp.reshape(image_size, image_size)\n\ti, j = np.where(tmp==1)\n\treturn i[0], j[0]",
"def extract_pixels(img_):\n non_zero_... | [
"0.64722455",
"0.6425248",
"0.63054746",
"0.6227117",
"0.60191417",
"0.5980462",
"0.5958961",
"0.59191453",
"0.5893133",
"0.5882262",
"0.5881619",
"0.5873324",
"0.58663285",
"0.578935",
"0.57684404",
"0.57487696",
"0.57443494",
"0.57427096",
"0.5668703",
"0.5660894",
"0.56523... | 0.0 | -1 |
clean repeated j pixels Find the first item of each row and gets the pixels with the lowest j value, which represents the biggest real value of the y axis of the graph, crossed with x axis. | def clean_double_values(self):
trans_blue = self.blue_matrix().transpose()
b_array = []
for i in trans_blue:
min_col = [i[0], i[1]]
for j in trans_blue[0:]:
if j[1] == min_col[1]:
if j[0] < min_col[0]:
min_col[0]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_smaller_neighbour(plots, i, j):\n n = len(plots)\n neighbours = []\n if i > 0:\n neighbours.append((i-1, j))\n if i < n-1:\n neighbours.append((i+1, j))\n if j > 0:\n neighbours.append((i, j-1))\n if j < n-1:\n neighbours.append((i, j+1))\n\n min_elevation =... | [
"0.56734896",
"0.56369495",
"0.56135774",
"0.5611539",
"0.5562747",
"0.5554404",
"0.55534256",
"0.55487216",
"0.55104053",
"0.5484114",
"0.5463305",
"0.5457158",
"0.54555976",
"0.5414113",
"0.5403876",
"0.5402138",
"0.5381725",
"0.53808093",
"0.53107697",
"0.53102785",
"0.530... | 0.57108814 | 0 |
Calculates singel pixel value Calculates the numeric value of each pixel, with two digits precision\ | def calculate_data_value(self, single_val):
y_pixel_range = float(self.data_type[3] - self.data_type[1] - 2)
data = round((max(self.data_range) -
(single_val * (max(self.data_range) -
min(self.data_range))/y_pixel_range
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intensity(self) -> int:",
"def intensity(self, value: int, /) -> None:",
"def pixelvalue(self, *args, **kwargs):\n return _image.image_pixelvalue(self, *args, **kwargs)",
"def pixelConverter(pixels):\n intensity = int((sum(pixels[:3]) / 3) * (pixels[-1] / 100))\n return intensity",
"def pi... | [
"0.6738845",
"0.612546",
"0.6096547",
"0.60833734",
"0.6080692",
"0.59247875",
"0.5914754",
"0.59092516",
"0.58747435",
"0.5851009",
"0.5825441",
"0.5822911",
"0.57960194",
"0.5733289",
"0.5684153",
"0.56747544",
"0.5673314",
"0.56508255",
"0.56457996",
"0.55885434",
"0.55827... | 0.0 | -1 |
Convert pixels j values Converts all j pixel day values to numeric real values, based on the the type of data and the range submitted. | def converted_values(self):
for i in range(11):
lista = []
for j in self.clean_double_values():
if self.get_days_index()[i+1] > j[1] >= \
self.get_days_index()[i]:
lista.append(self.calculate_data_value(j[0].item()))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pixelConverter(pixels):\n intensity = int((sum(pixels[:3]) / 3) * (pixels[-1] / 100))\n return intensity",
"def intensity_conversion(mol_data):\n\n if not isinstance(mol_data, Phys):\n raise ValueError('mol_data must be a `sbpy.data.Phys` instance.')\n\n temp = mol_data['Temperature'][0]\n... | [
"0.5547551",
"0.54512304",
"0.5430343",
"0.5352986",
"0.53416616",
"0.53416616",
"0.5297769",
"0.51349705",
"0.51135844",
"0.5109829",
"0.51088685",
"0.5072228",
"0.5058128",
"0.5048625",
"0.5024074",
"0.5022969",
"0.49947834",
"0.49770075",
"0.4975461",
"0.49725404",
"0.4971... | 0.5446279 | 2 |
Saves csv file into image folder saves generated data by class into a csv file with the name, plus the type of data. This method keeps track if the file was generate, and replace it with a new one | def save_values(self):
f_name = self.img_path.split('.')[0] + '_{}_'.\
format(self.data_type_name) + '.csv'
dir_name = os.path.join(self.base_dir, f_name)
if not os.path.exists(dir_name):
for data_list in self.converted_values():
with open(f_name, 'a') as ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_csv(self):\n if not self.__is_csv():\n # creates the csv file if it did not exist.\n self.__create_csv()\n try:\n with open(self.__csv_file_name, 'a', newline='', encoding='utf-8') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames=sel... | [
"0.6624201",
"0.6549683",
"0.6435749",
"0.64239025",
"0.6376977",
"0.62230694",
"0.61884254",
"0.6154384",
"0.6124744",
"0.6118921",
"0.6071223",
"0.60594875",
"0.59954077",
"0.5983704",
"0.5972146",
"0.5940008",
"0.59392995",
"0.59351414",
"0.5909594",
"0.5909318",
"0.590845... | 0.7220325 | 0 |
Function that takes experimental data and gives us the dependent/independent variables for analysis. | def transform_data(data_orig):
if isinstance(data_orig, str):
data_orig = pd.read_csv(data_orig)
data = data_orig
num_rows,num_variables = data.shape
all_columns = data.columns.tolist()
clean_data(data,all_columns,ignore_na=False,fill_mode="prob")
expand_features(data)
variables = ['Pclass','Sex',"Fare","Age... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def independent_variables(self):\n return self._independent_variables",
"def variables(self):\n return self.dataset.data_vars",
"def get_variables(self) -> np.array:\n pass",
"def get_variables(self):\n\n self._enforce_coupling()\n\n dv = []\n for scenario in self.sc... | [
"0.6336049",
"0.59512174",
"0.5921359",
"0.5668966",
"0.5604752",
"0.5602149",
"0.55979866",
"0.55381906",
"0.5522577",
"0.5509207",
"0.5503682",
"0.54940444",
"0.54842937",
"0.54736096",
"0.54574496",
"0.5447266",
"0.54466516",
"0.5444418",
"0.5435213",
"0.5378646",
"0.53435... | 0.0 | -1 |
build new features from existing ones | def expand_features(data):
## combine num of siblings and parents to feature of family size
data["Fam_size"] = data["SibSp"] + data["Parch"]
## add friend category defined as either sharing a ticket with someone not family
## or share a room with someone not registered as family
friends = np.zeros((data['Passenge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_new_features(self):\n train = self.train\n \n train['is_context'] = train['context_type'].isin(CONTEXT_TYPE_TEST)\n train['is_context_flow'] = train['listen_type'] * train['is_context']\n \n train['is_listened_context'] = train['is_listened'] * train['is_context... | [
"0.7290179",
"0.67351234",
"0.66625017",
"0.66145927",
"0.65810287",
"0.65604347",
"0.64703894",
"0.6346428",
"0.632699",
"0.6295979",
"0.629188",
"0.62671566",
"0.6261998",
"0.6211165",
"0.62055224",
"0.61913365",
"0.6185411",
"0.6180887",
"0.61358607",
"0.61222315",
"0.6106... | 0.0 | -1 |
clean data from nans and format 'Ticket'/'Cabin' values to integer | def clean_data(data,variables,ignore_na=True,fill_mode="mode"):
num_rows,num_cols = data.shape
if ignore_na:
data = data.dropna(axis=0,how="any",subset=variables)
num_rows,num_cols = data.shape
else:
for variable in variables:
if data[variable].isna().sum()>0:
if fill_mode=="mode":
data[variable] =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correct_nans(y):\n y = str(y)\n if y == \"nan\":\n return \"\"\n else:\n y = float(y)\n return int(y)",
"def clean_abbreviations(x):\n # a few entries in Revenue were nan\n if pd.isnull(x):\n return np.nan\n elif 'K' in x:\n return int(float(x[:-1]) * 1e3)... | [
"0.5968471",
"0.5897729",
"0.55173296",
"0.53447956",
"0.5314134",
"0.5283075",
"0.5131418",
"0.51056665",
"0.50972974",
"0.50837404",
"0.5063842",
"0.5061318",
"0.50185454",
"0.501761",
"0.50118005",
"0.49980184",
"0.49884346",
"0.49771225",
"0.49757206",
"0.4972356",
"0.497... | 0.0 | -1 |
Initialize a model object. | def __init__(self, classific_method="LogisticRegression"):
self.classific_method = classific_method | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_model(self):\n pass",
"def init_model(self):\n pass",
"def initialize_model(self):\n model = self.model_class()\n return model",
"def initialize(self, model):\n pass",
"def __init__(self, model):\n self._model = model",
"def __init__(self, model: o... | [
"0.8386426",
"0.82832724",
"0.81248385",
"0.8097535",
"0.80893433",
"0.78528905",
"0.77985805",
"0.7795144",
"0.7786414",
"0.7762771",
"0.7762771",
"0.7762771",
"0.7762771",
"0.7587415",
"0.7512679",
"0.7500231",
"0.7500231",
"0.7455408",
"0.736257",
"0.736257",
"0.730667",
... | 0.0 | -1 |
Fit a Model to data. | def classify(self, x, y):
if self.classific_method=="LogisticRegression":
clf = LogisticRegression().fit(x,y)
score = clf.score(x,y)
params = {"coef" : clf.coef_, "intercept" : clf.intercept_}
elif self.classific_method=="RidgeClassifier":
clf = RidgeClassifier().fit(x,y)
score = clf.score(x,y)
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_from_model_data(self, model_data: np.ndarray) -> f.FitDataset:\r\n return f.FitDataset(dataset=self.dataset, model_data=model_data)",
"def fit_training_data(self):\n self.model.fit(self.X_train)",
"def fit_model(self):\n logger.info('Fitting model')\n if self.traj_dict is No... | [
"0.8031498",
"0.7638004",
"0.7561233",
"0.7355034",
"0.71993583",
"0.71700954",
"0.71613765",
"0.7147078",
"0.710955",
"0.7095396",
"0.7068235",
"0.7055775",
"0.704873",
"0.7047253",
"0.7034218",
"0.70294046",
"0.70294046",
"0.70294046",
"0.70294046",
"0.70294046",
"0.7029404... | 0.0 | -1 |
Loads average activity across trials (nonbeta series) | def loadRuleEncoding(subj,rule='Logic'):
x = tgp.loadTaskTiming(subj,'ALL')
stimIndex = np.asarray(x['stimIndex'])
ind = np.where(stimIndex==rule)[0]
datadir = projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')
data = h5f['ta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_experiment_load():\n loads = tempfeeder_exp()\n return total_load_in_experiment_periods(loads, loads.user_ids)",
"def calc_average_load (self):\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\n #~ [se... | [
"0.63504434",
"0.59144664",
"0.5864663",
"0.58144855",
"0.5810399",
"0.5723678",
"0.5679944",
"0.56216276",
"0.5613916",
"0.5502032",
"0.5484399",
"0.54355526",
"0.5433525",
"0.54297596",
"0.54288644",
"0.5420481",
"0.5404081",
"0.53961533",
"0.53927654",
"0.53615886",
"0.535... | 0.0 | -1 |
Loads average activity across trials (nonbeta series) | def loadMotorResponses(subj,hand='Right'):
hands = {'Left':[0,1],'Right':[2,3]}
x = tgp.loadTaskTiming(subj,'ALL')
stimIndex = np.asarray(x['stimIndex'])
ind = np.where(stimIndex=='motorResponse')[0]
datadir = projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_experiment_load():\n loads = tempfeeder_exp()\n return total_load_in_experiment_periods(loads, loads.user_ids)",
"def calc_average_load (self):\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\n #~ [se... | [
"0.63504434",
"0.59144664",
"0.5864663",
"0.58144855",
"0.5810399",
"0.5723678",
"0.5679944",
"0.56216276",
"0.5613916",
"0.5502032",
"0.5484399",
"0.54355526",
"0.5433525",
"0.54297596",
"0.54288644",
"0.5420481",
"0.5404081",
"0.53961533",
"0.53927654",
"0.53615886",
"0.535... | 0.0 | -1 |
Run an acrosssubject classification Decode responses on each hand separately from CPRO data Limit to ROIs within SMN network | def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):
ncond = data.shape[1] # two motor outputs
nSubjs = data.shape[2]
nsamples = nSubjs * ncond
stats = np.zeros((len(rois),nsamples))
rmatches = np.zeros((len(rois),))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(self, requests):\n responses = []\n for request in requests:\n infer_outputs = pb_utils.get_input_tensor_by_name(\n request, self.input_names[0])\n im_infos = pb_utils.get_input_tensor_by_name(request,\n ... | [
"0.56707114",
"0.56553566",
"0.5601765",
"0.55017805",
"0.5460834",
"0.5439918",
"0.54097337",
"0.537334",
"0.53697425",
"0.5360478",
"0.53484106",
"0.5340918",
"0.52992934",
"0.5270834",
"0.5248631",
"0.52458835",
"0.5234071",
"0.5232353",
"0.52291584",
"0.52209944",
"0.5219... | 0.6313217 | 0 |
Runs cross validation for an acrosssubject SVM analysis | def randomSplitLOOBaselineCV(ncvs, svm_mat, labels, subjarray, motorOutput=False, permutation=False, decoder='similarity', nproc=5, featsel=False):
ntasks = len(np.unique(labels))
nsamples = svm_mat.shape[0]
nsubjs = nsamples/ntasks
subjects = np.unique(subjarray)
indices = np.arange(nsamples... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossValidate(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationP... | [
"0.7582791",
"0.73694915",
"0.7243919",
"0.71949804",
"0.7167863",
"0.71519244",
"0.70678645",
"0.7039688",
"0.69975895",
"0.6991288",
"0.6983354",
"0.6981687",
"0.6946862",
"0.6944603",
"0.6925344",
"0.68498045",
"0.68492496",
"0.67716795",
"0.675217",
"0.6742814",
"0.673506... | 0.0 | -1 |
Run an acrosssubject classification Decode responses on each hand separately from CPRO data | def actflowDecodings(data, actflow_data, effects=False, featsel=True, ncvs=1, permutation=False, confusion=False, nproc=5):
nSubjs = data.shape[2]
stats = np.zeros((1,))
ncond = data.shape[1]
nsamples = nSubjs * ncond
nfeatures = data.shape[0]
# Label array for supervised learning
la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\n \n ncond = data.shape[1] # two motor outputs\n nSubjs = data.shape[2]\n\n nsamples = nSubjs * ncond\n stats = np.zeros((len(rois),nsamples))\n rmatches = np.zeros((len(... | [
"0.59594476",
"0.59384817",
"0.5736482",
"0.5718673",
"0.56810707",
"0.5647129",
"0.56446636",
"0.5607695",
"0.5556696",
"0.55397236",
"0.55289805",
"0.5528581",
"0.55254686",
"0.55149966",
"0.548933",
"0.54383725",
"0.54022396",
"0.53819793",
"0.5377064",
"0.5372356",
"0.536... | 0.5322647 | 23 |
Runs cross validation for an acrosssubject SVM analysis | def actflowRandomSplitLOOBaselineCV(ncvs, svm_mat, actflow_svm_mat, labels, subjarray, featsel=True, permutation=False,nproc=5):
ntasks = len(np.unique(labels))
nsamples = svm_mat.shape[0]
nsubjs = nsamples/ntasks
subjects = np.unique(subjarray)
indices = np.arange(nsamples)
#numsubjs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossValidate(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationP... | [
"0.7582791",
"0.73694915",
"0.7243919",
"0.71949804",
"0.7167863",
"0.71519244",
"0.70678645",
"0.7039688",
"0.69975895",
"0.6991288",
"0.6983354",
"0.6981687",
"0.6946862",
"0.6944603",
"0.6925344",
"0.68498045",
"0.68492496",
"0.67716795",
"0.675217",
"0.6742814",
"0.673506... | 0.0 | -1 |
Load direct input 2 output FC mappings control analysis | def loadSubjActFlowFC_NoHidden(subj,inputtype,fcdir):
if inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
h5f = h5py.File(fcdir + inputtype + 'ToOutputLayer_FC_subj' + subj + '.h5','r')
fcmapping = h5f['sourceToTargetMapping'][:].copy()
eigenvectors_input = h5f['eigenvectors'][:].copy... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_process(fasta_fp, mapping_fp, denoised_seqs_fp,\r\n otu_picker_otu_map_fp, out_dir):\r\n\r\n combine_mappings(open(fasta_fp), open(mapping_fp),\r\n open(denoised_seqs_fp),\r\n open(otu_picker_otu_map_fp), out_dir)",
"def _standard_mapping(self):... | [
"0.5957527",
"0.5901851",
"0.5898157",
"0.5824446",
"0.57429874",
"0.5724559",
"0.56925887",
"0.5678476",
"0.56662995",
"0.5650207",
"0.564394",
"0.56413573",
"0.56300575",
"0.5606228",
"0.5584282",
"0.5576899",
"0.55665374",
"0.5565627",
"0.55558133",
"0.55504113",
"0.550616... | 0.51014936 | 75 |
Load direct input 2 output FC mappings control analysis | def loadGroupActFlowFC_NoHidden(inputtype,fcdir):
if inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
h5f = h5py.File(fcdir + inputtype + 'ToOutputLayer_FC_Group.h5','r')
fcmapping = h5f['sourceToTargetMapping'][:].copy()
eigenvectors_input = h5f['eigenvectors'][:].copy()
h5f.clos... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_process(fasta_fp, mapping_fp, denoised_seqs_fp,\r\n otu_picker_otu_map_fp, out_dir):\r\n\r\n combine_mappings(open(fasta_fp), open(mapping_fp),\r\n open(denoised_seqs_fp),\r\n open(otu_picker_otu_map_fp), out_dir)",
"def _standard_mapping(self):... | [
"0.5958182",
"0.5901442",
"0.58976465",
"0.5824817",
"0.57437664",
"0.5723222",
"0.56925786",
"0.5678178",
"0.5666717",
"0.5651474",
"0.5641801",
"0.56411237",
"0.5631734",
"0.5607848",
"0.5584844",
"0.5577562",
"0.556734",
"0.5566151",
"0.55564994",
"0.55500746",
"0.5506336"... | 0.50639737 | 91 |
array can either be 360 array or ~59k array. If 360, will automatically map back to ~59k | def mapBackToSurface(array,filename):
#### Map back to surface
if array.shape[0]==360:
out_array = np.zeros((glasser2.shape[0],3))
roicount = 0
for roi in range(360):
for col in range(array.shape[1]):
vertex_ind = np.where(glasser2==roi+1)[0]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def changeArray(array):\r\n\r\n return [[float(array[j][i]) for j in range(len(array))] for i in range(len(array[0]))]",
"def solution(array):\n array1 = np.array(array)\n array2 = array1.astype(float)\n return array2",
"def mapping(array, map):\r\n n = map.shape[0] \r\n if array.dtype == np.... | [
"0.5801872",
"0.5736414",
"0.5607404",
"0.54848576",
"0.5462905",
"0.53815883",
"0.53789145",
"0.5347712",
"0.534731",
"0.5346173",
"0.5330794",
"0.53048295",
"0.53041655",
"0.5290421",
"0.52872",
"0.5281134",
"0.5254639",
"0.5245278",
"0.5217675",
"0.5208273",
"0.5203374",
... | 0.5695677 | 2 |
Run an acrosssubject classification Decode responses on each hand separately from CPRO data | def compositionalActflowDecodings(data, nov_actflow_data, prac_actflow_data, effects=False, featsel=True, ncvs=1, nproc=5):
nSubjs = data.shape[2]
stats = np.zeros((1,))
ncond = data.shape[1]
nsamples = nSubjs * ncond
nfeatures = data.shape[0]
# Label array for supervised learning
la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\n \n ncond = data.shape[1] # two motor outputs\n nSubjs = data.shape[2]\n\n nsamples = nSubjs * ncond\n stats = np.zeros((len(rois),nsamples))\n rmatches = np.zeros((len(... | [
"0.59594476",
"0.59384817",
"0.5736482",
"0.5718673",
"0.56810707",
"0.5647129",
"0.56446636",
"0.5607695",
"0.5556696",
"0.55397236",
"0.55289805",
"0.5528581",
"0.55254686",
"0.55149966",
"0.548933",
"0.54383725",
"0.54022396",
"0.53819793",
"0.5377064",
"0.5372356",
"0.536... | 0.53299624 | 22 |
Runs cross validation for an acrosssubject SVM analysis | def compositionalActflowRandomSplitLOOBaselineCV(ncvs, svm_mat, nov_svm_mat, prc_svm_mat, labels, subjarray, featsel=True, nproc=5):
ntasks = len(np.unique(labels))
nsamples = svm_mat.shape[0]
nsubjs = nsamples/ntasks
subjects = np.unique(subjarray)
indices = np.arange(nsamples)
numsu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossValidate(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationP... | [
"0.7582216",
"0.73700595",
"0.72442365",
"0.71962374",
"0.71674687",
"0.7151614",
"0.7067812",
"0.7040971",
"0.69988185",
"0.69910026",
"0.69847065",
"0.6981253",
"0.6946461",
"0.69450456",
"0.6925203",
"0.6850364",
"0.6849873",
"0.67713803",
"0.6751911",
"0.67439026",
"0.673... | 0.61284596 | 86 |
Try connecting to the server | def test_connect():
print("Testing connecting to the server")
try:
with socket.socket() as s:
s.connect(("localhost", 8000))
print("Connection attempt succeeded.")
return None
except socket.error:
return "Server didn't answer on localhost port 8000. Is it running?" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_connection(self):\n for _ in range(3):\n try:\n r = get(f\"http://{self.ip}/student/{self.user}\")\n if r.ok:\n break \n except OSError as e:\n print(f\"Connection error:\\n{e}\")\n sleep(2)\n ... | [
"0.74671197",
"0.7376107",
"0.7224917",
"0.71801555",
"0.71454126",
"0.7106595",
"0.6992818",
"0.69693106",
"0.69635016",
"0.6934962",
"0.69222325",
"0.69027525",
"0.68996257",
"0.68846506",
"0.68738174",
"0.68378454",
"0.6834296",
"0.6821374",
"0.6818732",
"0.67999405",
"0.6... | 0.7139742 | 5 |
The server should accept a POST and return the 'nessage' field | def test_POST():
print("Testing POST request.")
msg = random.choice(["Hellow!", "Hi!! you", "Greetings!!!"])
uri = "http://localhost:8000/"
try:
r = requests.post(uri, data={'message': msg})
except requests.RequestException as e:
return (f"Couldn't communicate with the server. ({e}), If it's running, take a l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n return write_msg(request.json)",
"def render_POST(self, request):\n\t\tprint request.args[\"message\"][0]\n\t\tself.jabberClient.sendMessage(request.args[\"message\"][0])\n\t\treturn ''",
"def post(self):\n try:\n msgId = int(request.form['text'])\n except Valu... | [
"0.700399",
"0.69622856",
"0.6937624",
"0.690975",
"0.6692679",
"0.6602576",
"0.64796257",
"0.6373835",
"0.63503146",
"0.63502765",
"0.6258975",
"0.62196815",
"0.6202336",
"0.61453116",
"0.61423415",
"0.6071141",
"0.60104567",
"0.60015494",
"0.5992528",
"0.5970044",
"0.596773... | 0.57780945 | 48 |
Fit the linear regression coefficients. This function will solve a linear regression with Gaussian priors on the coefficients. | def _fit_coefficients(
self, cadence_mask=None, prior_mu=None, prior_sigma=None, propagate_errors=False
):
# If prior_mu is specified, prior_sigma must be specified
if not ((prior_mu is None) & (prior_sigma is None)) | (
(prior_mu is not None) & (prior_sigma is not None)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linear_fit(x, y):\n x = np.array(x)\n y = np.array(y)\n \n invalid_idx = np.isnan(x) | np.isinf(x) | np.isnan(y) | np.isinf(y)\n x = x[~invalid_idx]\n y = y[~invalid_idx]\n\n covs = sm.add_constant(x, prepend=True)\n model = sm.OLS(y, covs)\n result = model.fit()\n return result.p... | [
"0.6792636",
"0.6785291",
"0.6730444",
"0.6671837",
"0.66564393",
"0.66392154",
"0.66048634",
"0.6589059",
"0.6574239",
"0.6574239",
"0.6574239",
"0.656269",
"0.65618896",
"0.6551248",
"0.6550165",
"0.65029776",
"0.64471906",
"0.6393028",
"0.638561",
"0.63669246",
"0.63662094... | 0.0 | -1 |
Find the best fit correction for the light curve. | def correct(
self,
design_matrix_collection,
cadence_mask=None,
sigma=5,
niters=5,
propagate_errors=False,
):
if not isinstance(design_matrix_collection, DesignMatrixCollection):
if isinstance(design_matrix_collection, SparseDesignMatrix):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_lip_best(self) -> float:\n pass",
"def test_intra_power_law_fit2(self):\n\t\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\n\t\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, sparsify=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\n\t\tactual_alpha = details.a... | [
"0.6179351",
"0.5929913",
"0.58914375",
"0.587837",
"0.58164775",
"0.57964665",
"0.5769313",
"0.575269",
"0.57327217",
"0.5724726",
"0.5707219",
"0.56688213",
"0.5661554",
"0.56298316",
"0.5593415",
"0.558705",
"0.5580057",
"0.55682325",
"0.55587983",
"0.5546923",
"0.5546372"... | 0.0 | -1 |
Returns a dictionary containing all diagnostic light curves. The dictionary will provide a light curve for each matrix in the design matrix collection. | def _create_diagnostic_lightcurves(self):
if self.coefficients is None:
raise ValueError("you need to call `correct()` first")
lcs = {}
for idx, submatrix in enumerate(self.dmc.matrices):
# What is the index of the first column for the submatrix?
firstcol_idx... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_materials_dict(self):\n c = 299792458.0\n w_mat = 2 * np.pi * c / self.l_mat - self.w0\n l2_mat = (self.l_mat * 1e6) ** 2\n\n n_air = 1 + 0.05792105 * l2_mat / (238.0185 * l2_mat - 1) + 0.00167917 * l2_mat / (57.362 * l2_mat - 1)\n air_ip = interp1d(w_mat, n_air, bou... | [
"0.60194796",
"0.59146357",
"0.5619035",
"0.55798995",
"0.55360436",
"0.54979974",
"0.54268354",
"0.5380969",
"0.53533584",
"0.53345037",
"0.5332291",
"0.52693045",
"0.52423155",
"0.5225769",
"0.52155113",
"0.5174672",
"0.51708114",
"0.51582485",
"0.51488817",
"0.51368886",
"... | 0.75933963 | 0 |
Produce diagnostic plots to assess the effectiveness of the correction. | def _diagnostic_plot(self):
if not hasattr(self, "corrected_lc"):
raise ValueError(
"Please call the `correct()` method before trying to diagnose."
)
with plt.style.context(MPLSTYLE):
_, axs = plt.subplots(2, figsize=(10, 6), sharex=True)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Diagnostic_plot2(self):\n\n probs = pd.read_csv(self.probfile)\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\... | [
"0.6873683",
"0.6821231",
"0.6672336",
"0.66437536",
"0.66437536",
"0.66437536",
"0.6629172",
"0.6596364",
"0.6589779",
"0.6557499",
"0.6521361",
"0.6518009",
"0.65085554",
"0.64940095",
"0.64903545",
"0.64805514",
"0.6445851",
"0.6403377",
"0.6347727",
"0.63423556",
"0.63348... | 0.7091261 | 0 |
Returns diagnostic plots to assess the most recent call to `correct()`. If `correct()` has not yet been called, a ``ValueError`` will be raised. Returns `~matplotlib.axes.Axes` The matplotlib axes object. | def diagnose(self):
return self._diagnostic_plot() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _diagnostic_plot(self):\n if not hasattr(self, \"corrected_lc\"):\n raise ValueError(\n \"Please call the `correct()` method before trying to diagnose.\"\n )\n\n with plt.style.context(MPLSTYLE):\n _, axs = plt.subplots(2, figsize=(10, 6), sharex=Tr... | [
"0.62973243",
"0.5582412",
"0.54954946",
"0.5457916",
"0.5377934",
"0.53028226",
"0.52979976",
"0.5198705",
"0.5156626",
"0.51140463",
"0.5106329",
"0.50978374",
"0.5094472",
"0.5083405",
"0.49963522",
"0.49693686",
"0.4965705",
"0.49536103",
"0.4950388",
"0.4943999",
"0.4924... | 0.5505739 | 2 |
Returns a diagnostic plot visualizing how the bestfit coefficients compare against the priors. The method will show the results obtained during the most recent call to `correct()`. If `correct()` has not yet been called, a ``ValueError`` will be raised. Returns `~matplotlib.axes.Axes` The matplotlib axes object. | def diagnose_priors(self):
if not hasattr(self, "corrected_lc"):
raise ValueError(
"Please call the `correct()` method before trying to diagnose."
)
names = [dm.name for dm in self.dmc]
with plt.style.context(MPLSTYLE):
_, axs = plt.subplots(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def robustnessPlot(ax):\n # Setup the range of avidity and ligand concentration we'll look at\n gnus = np.logspace(1, 3, 3, base=2, dtype=np.int)\n Los = np.logspace(start=-11, stop=-7, num=35, dtype=np.float)\n\n pp = pd.DataFrame(np.array(np.meshgrid(gnus, Los)).T.reshape(-1, 2),\n ... | [
"0.64745706",
"0.608616",
"0.60614175",
"0.6035531",
"0.58973026",
"0.5857323",
"0.5814659",
"0.5783457",
"0.57566994",
"0.5703762",
"0.5695166",
"0.56862897",
"0.565359",
"0.5642672",
"0.563932",
"0.5626169",
"0.5618816",
"0.5592678",
"0.5582807",
"0.5553929",
"0.555223",
... | 0.5709493 | 9 |
Returns where the arm end effector should be at time t | def target_position(self, time):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0",
"def end_time(self) -> float:\r\n ...",
"def endTime(self):\n return self.params['tend']",
"def get_last(t_, w_):\n return t_ - tf.constant(1)",
"def end(self):\n return self._t0... | [
"0.6262754",
"0.60054207",
"0.59560645",
"0.5919242",
"0.59007686",
"0.58521706",
"0.5844045",
"0.580404",
"0.5791151",
"0.5790337",
"0.5788008",
"0.57607013",
"0.57595277",
"0.57300097",
"0.57146317",
"0.5713964",
"0.56925106",
"0.56845766",
"0.56776744",
"0.56025434",
"0.55... | 0.0 | -1 |
Returns the arm's desired x,y,z velocity in workspace coordinates at time t | def target_velocity(self, time):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])",
"def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = ... | [
"0.6969122",
"0.67800456",
"0.65503675",
"0.6356482",
"0.6308465",
"0.630399",
"0.62948024",
"0.6286732",
"0.6198997",
"0.6128271",
"0.6115166",
"0.61008614",
"0.6078042",
"0.60758245",
"0.60072464",
"0.60019296",
"0.5946289",
"0.5930369",
"0.5901788",
"0.5872708",
"0.5855203... | 0.55071664 | 62 |
Returns the arm's desired x,y,z acceleration in workspace coordinates at time t | def target_acceleration(self, time):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])",
"def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n ... | [
"0.70698804",
"0.6440076",
"0.64124155",
"0.63377005",
"0.62645674",
"0.61269134",
"0.6121389",
"0.60776174",
"0.6065293",
"0.60262007",
"0.5981195",
"0.5970287",
"0.5951348",
"0.5951348",
"0.5893698",
"0.5862199",
"0.57664055",
"0.57601243",
"0.5720025",
"0.57073057",
"0.569... | 0.0 | -1 |
takes a discrete point in time, and puts the position, velocity, and acceleration into a ROS JointTrajectoryPoint() to be put into a RobotTrajectory. | def trajectory_point(self, t, jointspace):
point = JointTrajectoryPoint()
delta_t = .01
if jointspace:
x_t, x_t_1, x_t_2 = None, None, None
ik_attempts = 0
theta_t_2 = self.get_ik(self.target_position(t-2*delta_t))
theta_t_1 = self.get_ik(self.targ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trajectory_point(self, t, jointspace):\n point = JointTrajectoryPoint()\n delta_t = .01\n if jointspace:\n x_t, x_t_1, x_t_2 = None, None, None\n ik_attempts = 0\n theta_t = theta_t_1 = theta_t_2 = None\n while theta_t_2 is None:\n ... | [
"0.7366635",
"0.6119101",
"0.6077254",
"0.59451604",
"0.5930126",
"0.5914397",
"0.5907721",
"0.58628654",
"0.58250636",
"0.58205104",
"0.57535905",
"0.5750186",
"0.5665363",
"0.566258",
"0.56621027",
"0.5604078",
"0.560013",
"0.5575069",
"0.5521112",
"0.55184346",
"0.5504239"... | 0.7287572 | 1 |
Remember to call the constructor of MotionPath (__init__) | def __init__(self, total_time, kin, limb, start_pos, ar_tag_pos):
#raise NotImplementedError
MotionPath.__init__(self, limb, kin, total_time)
start_pos = np.array([abs(start_pos[0]), abs(start_pos[1]), abs(start_pos[2])])
#The ar tracking function was not working properly so we added t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, total_time, kin, limb, ar_tag_pos):\n # raise NotImplementedError\n self.r = .1 \n MotionPath.__init__(self, limb, kin, total_time)\n self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])\n self.ar_tag_pos[2] = 0.282\n self.start_pos =... | [
"0.7836744",
"0.7791446",
"0.77425086",
"0.68546695",
"0.6578746",
"0.63941026",
"0.63739896",
"0.6288861",
"0.62869287",
"0.62845355",
"0.62569",
"0.62209356",
"0.6177456",
"0.6177456",
"0.6177456",
"0.6177456",
"0.6142657",
"0.6134843",
"0.6126099",
"0.6106433",
"0.60999274... | 0.76483566 | 3 |
Returns where the arm end effector should be at time t | def target_position(self, time):
# get joint positions and use fk to get end effector position?
# ar_tag from topic
cur_pos = self.target_velocity(time)*time + self.start_pos
self.points_generated.append(cur_pos)
#print(self.start_pos)
# print(cur_pos)
return cu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0",
"def end_time(self) -> float:\r\n ...",
"def endTime(self):\n return self.params['tend']",
"def get_last(t_, w_):\n return t_ - tf.constant(1)",
"def end(self):\n return self._t0... | [
"0.6262754",
"0.60054207",
"0.59560645",
"0.5919242",
"0.59007686",
"0.58521706",
"0.5844045",
"0.580404",
"0.5791151",
"0.5790337",
"0.5788008",
"0.57607013",
"0.57595277",
"0.57300097",
"0.57146317",
"0.5713964",
"0.56925106",
"0.56845766",
"0.56776744",
"0.56025434",
"0.55... | 0.5366723 | 44 |
Returns the arm's desired x,y,z velocity in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_position() | def target_velocity(self, time):
avg_vel = (self.ar_tag_pos - self.start_pos)/self.total_time
return avg_vel | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])",
"def target_position(self, time):\n\n x_pos = self.r*sin(self.w*time)+self.ar_tag_... | [
"0.7266593",
"0.649724",
"0.64403063",
"0.6348583",
"0.63289547",
"0.63289547",
"0.6319826",
"0.62879527",
"0.62594193",
"0.6220879",
"0.62026346",
"0.61803794",
"0.61693144",
"0.6166686",
"0.6114781",
"0.6070687",
"0.6070687",
"0.6061902",
"0.60361063",
"0.59944755",
"0.5956... | 0.592703 | 23 |
Returns the arm's desired x,y,z acceleration in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_velocity() | def target_acceleration(self, time):
return np.array([0, 0, 0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])",
"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time... | [
"0.70134026",
"0.6654176",
"0.65230024",
"0.64852095",
"0.64031357",
"0.64031357",
"0.63639945",
"0.6288034",
"0.62409705",
"0.61979336",
"0.6173782",
"0.61587775",
"0.6142052",
"0.6091978",
"0.6033012",
"0.60062426",
"0.599504",
"0.5980418",
"0.58893937",
"0.58403546",
"0.58... | 0.6153133 | 12 |
Remember to call the constructor of MotionPath | def __init__(self, total_time, kin, limb, ar_tag_pos):
# raise NotImplementedError
self.r = .1
MotionPath.__init__(self, limb, kin, total_time)
self.ar_tag_pos = np.array([ar_tag_pos[0],ar_tag_pos[1],ar_tag_pos[2]])
self.ar_tag_pos[2] = 0.282
self.start_pos = [ar_tag_po... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, limb, kin, total_time, goal_pos, num_way, start_pos=None):\n MotionPath.__init__(self, limb, kin, total_time)\n self.start_pos = start_pos\n self.goal_pos = goal_pos\n self.num_way = num_way\n self.base_frame = 'base'\n self.tool_frame = 'left_hand_camer... | [
"0.7820282",
"0.7787644",
"0.77386826",
"0.6963891",
"0.6757834",
"0.65536493",
"0.65116596",
"0.64888525",
"0.6445253",
"0.63971484",
"0.6376502",
"0.636337",
"0.63444155",
"0.6312085",
"0.6276762",
"0.6248574",
"0.62414914",
"0.6194726",
"0.6188483",
"0.6171967",
"0.6170589... | 0.78976136 | 0 |
Returns where the arm end effector should be at time t | def target_position(self, time):
x_pos = self.r*sin(self.w*time)+self.ar_tag_pos[0]
y_pos = self.r*cos(self.w*time)+self.ar_tag_pos[1]
z_pos = self.ar_tag_pos[2]
# print(x_pos,y_pos)
# raise NotImplementedError
return np.array([x_pos,y_pos,z_pos]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0",
"def end_time(self) -> float:\r\n ...",
"def endTime(self):\n return self.params['tend']",
"def get_last(t_, w_):\n return t_ - tf.constant(1)",
"def end(self):\n return self._t0... | [
"0.6262754",
"0.60054207",
"0.59560645",
"0.5919242",
"0.59007686",
"0.58521706",
"0.5844045",
"0.580404",
"0.5791151",
"0.5790337",
"0.5788008",
"0.57607013",
"0.57595277",
"0.57300097",
"0.57146317",
"0.5713964",
"0.56925106",
"0.56845766",
"0.56776744",
"0.56025434",
"0.55... | 0.0 | -1 |
Returns the arm's desired velocity in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_position() | def target_velocity(self, time):
x_v = self.w*self.r*cos(self.w*time)
y_v = -self.w*self.r*sin(self.w*time)
z_v = 0
# raise NotImplementedError
return np.array([x_v,y_v,z_v]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)",
"def target_velocity(self, time):\n return self.target(time, self.velocities, self.dt, self.num_way)",
"def target_velocity(self, time):\n path, path_time = self.get_current_path(time)\n ... | [
"0.7068331",
"0.7068331",
"0.70444334",
"0.7034289",
"0.6955907",
"0.68580544",
"0.6856776",
"0.6856776",
"0.67172503",
"0.6685114",
"0.66773754",
"0.6674364",
"0.66353154",
"0.66283923",
"0.6606402",
"0.65924555",
"0.65924555",
"0.6582541",
"0.6543292",
"0.6520295",
"0.65179... | 0.72390187 | 0 |
Returns the arm's desired x,y,z acceleration in workspace coordinates at time t. You should NOT simply take a finite difference of self.target_velocity() | def target_acceleration(self, time):
x_a = -self.w**2*self.r*sin(self.w*time)
y_a = -self.w**2*self.r*cos(self.w*time)
z_a = 0
# raise NotImplementedError
return np.array([x_a,y_a,z_a]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])",
"def acceleration(v,u,t):\n return ((v-u)/t)",
"def acceleration(self):\n ux,... | [
"0.6654176",
"0.65230024",
"0.64852095",
"0.64031357",
"0.64031357",
"0.63639945",
"0.6288034",
"0.62409705",
"0.61979336",
"0.6173782",
"0.61587775",
"0.6153133",
"0.6142052",
"0.6091978",
"0.6033012",
"0.60062426",
"0.599504",
"0.5980418",
"0.58893937",
"0.58403546",
"0.580... | 0.70134026 | 0 |
Returns where the arm end effector should be at time t | def target_position(self, time):
"""
start_pos = self.points[self.cur_start]
seg_time = time - self.last_checkpoint_time
#The arguement of target-velocity dosent matter
cur_pos = self.target_velocity(time)*seg_time + start_pos
# or time > (self.total_time / 4)*... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0",
"def end_time(self) -> float:\r\n ...",
"def endTime(self):\n return self.params['tend']",
"def get_last(t_, w_):\n return t_ - tf.constant(1)",
"def end(self):\n return self._t0... | [
"0.6262754",
"0.60054207",
"0.59560645",
"0.5919242",
"0.59007686",
"0.58521706",
"0.5844045",
"0.580404",
"0.5791151",
"0.5790337",
"0.5788008",
"0.57607013",
"0.57595277",
"0.57300097",
"0.57146317",
"0.5713964",
"0.56925106",
"0.56845766",
"0.56776744",
"0.56025434",
"0.55... | 0.0 | -1 |
Returns the arm's desired velocity in workspace coordinates at time t | def target_velocity(self, time):
"""
start_point = self.points[self.cur_start]
cur_target = self.points[(self.cur_start + 1) % 4]
total_time = self.total_time / 4
avg_vel = (cur_target - start_point)/ total_time
return avg_vel
"""
total_time = self.total_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_velocity(self, time):\n\n x_v = self.w*self.r*cos(self.w*time)\n y_v = -self.w*self.r*sin(self.w*time)\n z_v = 0\n # raise NotImplementedError\n return np.array([x_v,y_v,z_v])",
"def vel(self, time):\n if (time < self.ti):\n t = 0\n elif (tim... | [
"0.7120653",
"0.697146",
"0.6872062",
"0.6827393",
"0.6781933",
"0.6706172",
"0.66989666",
"0.66028404",
"0.6586185",
"0.6578873",
"0.65184575",
"0.65106213",
"0.65106213",
"0.64967805",
"0.6452281",
"0.64379877",
"0.6426943",
"0.6426943",
"0.6386043",
"0.63796675",
"0.637894... | 0.6284519 | 25 |
Returns the arm's desired acceleration in workspace coordinates at time t | def target_acceleration(self, time):
#return np.array([0, 0, 0])
if time <= self.total_time/4:
return self.path1.target_acceleration(time)
elif time <= self.total_time/2:
return self.path2.target_acceleration(time)
elif time <= self.total_time/4*3:
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_acceleration(self, time):\n x_a = -self.w**2*self.r*sin(self.w*time)\n y_a = -self.w**2*self.r*cos(self.w*time)\n z_a = 0\n # raise NotImplementedError\n return np.array([x_a,y_a,z_a])",
"def acceleration(v,u,t):\n return ((v-u)/t)",
"def get_acceleration(self,v... | [
"0.7151567",
"0.69269055",
"0.6620792",
"0.6604044",
"0.6604044",
"0.64903134",
"0.6474762",
"0.6448839",
"0.642742",
"0.6288047",
"0.6253032",
"0.62328714",
"0.62094814",
"0.61376417",
"0.6014507",
"0.6013373",
"0.59907395",
"0.5975713",
"0.5963832",
"0.5947619",
"0.5936622"... | 0.65715986 | 5 |
Add tables to update. | def table(self, list_or_name):
if not isinstance(list_or_name, basestring):
for c in list_or_name:
self.table(c)
else:
self._table_names.append(list_or_name)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __new_tables_statement(self):\n new_tables = self.__new_tables()\n for table in new_tables:\n with open('./update/create_tables.sql', 'a') as f:\n create_statement = self.source.query_create_table_statement(table.name)\n f.write(create_statement)\n ... | [
"0.71956253",
"0.7121374",
"0.7104306",
"0.71029955",
"0.6936429",
"0.689795",
"0.68570906",
"0.6833193",
"0.68265414",
"0.68265414",
"0.6670361",
"0.66690147",
"0.65515643",
"0.65446407",
"0.65392756",
"0.6525563",
"0.64799553",
"0.6468853",
"0.6457003",
"0.645229",
"0.64522... | 0.0 | -1 |
Add expressions to order by. | def order_by(self, list_or_name):
if not isinstance(list_or_name, basestring):
for c in list_or_name:
self.order_by(c)
else:
self._orderby_conds.append(list_or_name)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _orderby_expression(self):\n return ''",
"def order_by(self, *fields):\n self._evaluated = False\n if self._order is None:\n self._order = []\n\n for field in fields:\n direction = \"asc\"\n if field.startswith('-'):\n direction = \"desc\"\n field = field[1:]\n\n ... | [
"0.7325629",
"0.68086284",
"0.6290014",
"0.6235323",
"0.6235261",
"0.62039375",
"0.6151792",
"0.61361706",
"0.6074596",
"0.6058576",
"0.60491574",
"0.6035678",
"0.60100913",
"0.59463125",
"0.59335196",
"0.5930086",
"0.5926631",
"0.57996154",
"0.5741835",
"0.5740553",
"0.56681... | 0.5119484 | 57 |
Add limit clause expression. | def limit(self, row_count):
self._limit = row_count
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def limit_clause(self, select):\n return \"\"",
"def apply_limit(self, query, limit):\n if limit is not None:\n limit = int(limit)\n if limit < 0:\n raise ValueError(\"limit can not be a negative integer.\")\n query = query.limit(limit)\n retur... | [
"0.7404516",
"0.72155404",
"0.69859445",
"0.67413896",
"0.6662522",
"0.6627026",
"0.65691817",
"0.6537712",
"0.6416191",
"0.6371152",
"0.62403226",
"0.62190896",
"0.6199445",
"0.61692774",
"0.61400425",
"0.60801107",
"0.6063965",
"0.6063965",
"0.6063965",
"0.60438126",
"0.599... | 0.57001954 | 33 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.