C x N\\n samps = samps_int16.astype(np.float)\\n # tranpose because I used to put channel axis first\\n if samps.ndim != 1:\\n samps = np.transpose(samps)\\n # normalize like MATLAB and librosa\\n if normalize:\\n samps = samps / MAX_INT16\\n return sampling_rate, samps\",\n \"def read(self, path):\\n pbase = os.path.splitext(path)[0]\\n gsid = pbase.split('/')[-2]\\n gender, sid = gsid[0], gsid[1:]\\n assert sid in self._spkr_table\\n phoneseq = phnread(pbase+'.PHN')\\n wrdseq = phnread(pbase+'.WRD')\\n transcrpt = txtread(pbase+'.TXT')\\n sample = TIMITSpeech(\\n *audioread(path), speaker=sid, gender=gender,\\n transcript=transcrpt, phonemeseq=phoneseq,\\n wordseq=wrdseq\\n )\\n #sample.phonemeseq = [\\n # (t, PHONETABLE[p]) for t, p in sample.phonemeseq]\\n return sample\",\n \"def audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n return sig\",\n \"def audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n return sig\",\n \"def read_wave(path):\\n with contextlib.closing(wave.open(path, 'rb')) as wf:\\n num_channels = wf.getnchannels()\\n assert num_channels == 1\\n sample_width = wf.getsampwidth()\\n assert sample_width == 2\\n sample_rate = wf.getframerate()\\n assert sample_rate in (8000, 16000, 32000)\\n pcm_data = wf.readframes(wf.getnframes())\\n return pcm_data, sample_rate\",\n \"def read_audio(audio_paths, speaker_dict, tool, config, normalize, is_training,\\n save_path=None, save_format='numpy',\\n global_mean_male=None, global_mean_female=None,\\n global_std_male=None, global_std_female=None,\\n dtype=np.float32):\\n if not is_training:\\n if global_mean_male is None or global_mean_female is None:\\n raise ValueError('Set mean & std computed in the training set.')\\n if normalize not in ['global', 'speaker', 'utterance', 'no']:\\n raise ValueError(\\n 'normalize must be \\\"utterance\\\" or \\\"speaker\\\" or \\\"global\\\" or \\\"no\\\".')\\n if tool not in ['htk', 'python_speech_features', 'librosa']:\\n raise TypeError(\\n 'tool must be \\\"htk\\\" or \\\"python_speech_features\\\"' +\\n ' or \\\"librosa\\\".')\\n\\n audio_path_list_male, audio_path_list_female = [], []\\n total_frame_num_male, total_frame_num_female = 0, 0\\n total_frame_num_dict = {}\\n speaker_mean_dict = {}\\n\\n # NOTE: 講演ごとに異なるspeakerとみなす\\n\\n # Loop 1: Computing global mean and statistics\\n if is_training and normalize != 'no':\\n print('=====> Reading audio files...')\\n for i, audio_path in enumerate(tqdm(audio_paths)):\\n speaker = basename(audio_path).split('.')[0]\\n\\n # Divide each audio file into utterances\\n _, input_utt_sum, speaker_mean, _, total_frame_num_speaker = segment(\\n audio_path,\\n speaker,\\n speaker_dict[speaker],\\n is_training=True,\\n sil_duration=0,\\n tool=tool,\\n config=config)\\n\\n if i == 0:\\n # Initialize global statistics\\n feature_dim = input_utt_sum.shape[0]\\n global_mean_male = np.zeros((feature_dim,), dtype=dtype)\\n global_mean_female = np.zeros(\\n (feature_dim,), dtype=dtype)\\n global_std_male = np.zeros((feature_dim,), dtype=dtype)\\n global_std_female = np.zeros((feature_dim,), dtype=dtype)\\n\\n # For computing global mean\\n if speaker[3] == 'M':\\n audio_path_list_male.append(audio_path)\\n global_mean_male += input_utt_sum\\n total_frame_num_male += total_frame_num_speaker\\n elif speaker[3] == 'F':\\n audio_path_list_female.append(audio_path)\\n global_mean_female += input_utt_sum\\n total_frame_num_female += total_frame_num_speaker\\n else:\\n raise ValueError\\n\\n # For computing speaker stddev\\n if normalize == 'speaker':\\n speaker_mean_dict[speaker] = speaker_mean\\n total_frame_num_dict[speaker] = total_frame_num_speaker\\n # NOTE: speaker mean is already computed\\n\\n print('=====> Computing global mean & stddev...')\\n # Compute global mean per gender\\n global_mean_male /= total_frame_num_male\\n global_mean_female /= total_frame_num_female\\n\\n for audio_path in tqdm(audio_paths):\\n speaker = basename(audio_path).split('.')[0]\\n\\n # Divide each audio into utterances\\n input_data_dict_speaker, _, _, _, _ = segment(\\n audio_path,\\n speaker,\\n speaker_dict[speaker],\\n is_training=True,\\n sil_duration=0,\\n tool=tool,\\n config=config)\\n\\n # For computing global stddev\\n if speaker[3] == 'M':\\n for input_utt in input_data_dict_speaker.values():\\n global_std_male += np.sum(\\n np.abs(input_utt - global_mean_male) ** 2, axis=0)\\n elif speaker[3] == 'F':\\n for input_utt in input_data_dict_speaker.values():\\n global_std_female += np.sum(\\n np.abs(input_utt - global_mean_female) ** 2, axis=0)\\n else:\\n raise ValueError\\n\\n # Compute global stddev per gender\\n global_std_male = np.sqrt(\\n global_std_male / (total_frame_num_male - 1))\\n global_std_female = np.sqrt(\\n global_std_female / (total_frame_num_female - 1))\\n\\n if save_path is not None:\\n # Save global mean & std per gender\\n np.save(join(save_path, 'global_mean_male.npy'),\\n global_mean_male)\\n np.save(join(save_path, 'global_mean_female.npy'),\\n global_mean_female)\\n np.save(join(save_path, 'global_std_male.npy'),\\n global_std_male)\\n np.save(join(save_path, 'global_std_female.npy'),\\n global_std_female)\\n\\n # Loop 2: Normalization and Saving\\n print('=====> Normalization...')\\n frame_num_dict = {}\\n sampPeriod, parmKind = None, None\\n for audio_path in tqdm(audio_paths):\\n speaker = basename(audio_path).split('.')[0]\\n\\n if normalize == 'speaker' and is_training:\\n speaker_mean = speaker_mean_dict[speaker]\\n else:\\n speaker_mean = None\\n\\n # Divide each audio into utterances\\n input_data_dict_speaker, _, speaker_mean, speaker_std, _ = segment(\\n audio_path,\\n speaker,\\n speaker_dict[speaker],\\n is_training=is_training,\\n sil_duration=0,\\n tool=tool,\\n config=config,\\n mean=speaker_mean) # for compute speaker sttdev\\n # NOTE: input_data_dict_speaker have been not normalized yet\\n\\n for utt_index, input_utt in input_data_dict_speaker.items():\\n\\n if normalize == 'no':\\n pass\\n elif normalize == 'global' or not is_training:\\n # Normalize by mean & std over the training set per gender\\n if speaker[3] == 'M':\\n input_utt -= global_mean_male\\n input_utt /= global_std_male\\n elif speaker[3] == 'F':\\n input_utt -= global_mean_female\\n input_utt /= global_std_female\\n else:\\n raise ValueError\\n elif normalize == 'speaker':\\n # Normalize by mean & std per speaker\\n input_utt = (input_utt - speaker_mean) / speaker_std\\n elif normalize == 'utterance':\\n # Normalize by mean & std per utterance\\n utt_mean = np.mean(input_utt, axis=0, dtype=dtype)\\n utt_std = np.std(input_utt, axis=0, dtype=dtype)\\n input_utt = (input_utt - utt_mean) / utt_std\\n else:\\n raise ValueError\\n\\n frame_num_dict[speaker + '_' + utt_index] = input_utt.shape[0]\\n\\n if save_path is not None:\\n # Save input features\\n if save_format == 'numpy':\\n input_data_save_path = mkdir_join(\\n save_path, speaker, speaker + '_' + utt_index + '.npy')\\n np.save(input_data_save_path, input_utt)\\n elif save_format == 'htk':\\n if sampPeriod is None:\\n _, sampPeriod, parmKind = read(audio_path)\\n write(input_utt,\\n htk_path=mkdir_join(\\n save_path, speaker, speaker + '_' + utt_index + '.htk'),\\n sampPeriod=sampPeriod,\\n parmKind=parmKind)\\n else:\\n raise ValueError('save_format is numpy or htk.')\\n\\n if save_path is not None:\\n # Save the frame number dictionary\\n with open(join(save_path, 'frame_num.pickle'), 'wb') as f:\\n pickle.dump(frame_num_dict, f)\\n\\n return (global_mean_male, global_mean_female,\\n global_std_male, global_std_female, frame_num_dict)\",\n \"def play_music1(music_file):\\n clock = pygame.time.Clock()\\n try:\\n pygame.mixer.music.load(music_file)\\n print (\\\"Music file %s loaded!\\\" % music_file)\\n except pygame.error:\\n print (\\\"File %s not found! (%s)\\\" % (music_file, pygame.get_error()))\\n return\\n pygame.mixer.music.play()\\n while pygame.mixer.music.get_busy():\\n # check if playback has finished\\n clock.tick(30)\",\n \"def _read_data_into_packet(self, p):\\n\\n length = p.length * self.disc.audio_format.bytes_per_frame\\n\\n if p.file_pos is None:\\n # Silence, so send on null bytes to player\\n p.data = '\\\\0' * length\\n\\n else:\\n file_pos = p.file_pos * self.disc.audio_format.bytes_per_frame\\n self.audio_file.seek(file_pos)\\n\\n p.data = self.audio_file.read(length)\\n length -= len(p.data)\\n file_pos += len(p.data)\\n\\n # If we didn't get all data, iterate with a timeout until\\n # it's all been read or the ripping process has stopped.\\n # This is not very efficient, and there's a small race\\n # condition at the end of the disc, but this should be\\n # very rare so keep it unoptimised for now.\\n\\n while length > 0 and self.is_ripping and self.is_ripping.is_set():\\n time.sleep(1)\\n\\n self.audio_file.seek(file_pos)\\n d = self.audio_file.read(length)\\n\\n length -= len(d)\\n file_pos += len(d)\\n\\n p.data += d\\n\\n # Still didn't get all data, treat it as an exception\\n if length > 0:\\n raise SourceError('unexpected end of file, expected at least {0} bytes'\\n .format(length))\",\n \"def load_audio(fhandle: BinaryIO, sr=None) -> Tuple[np.ndarray, float]:\\n audio, sr = librosa.load(fhandle, sr=sr, mono=True)\\n return audio, sr\",\n \"def make_audio(audio_path):\\n content, sample_rate = librosa.load(audio_path, sr=16000)\\n del sample_rate\\n if content.dtype in (np.float32, np.float64):\\n content = (content * np.iinfo(np.int16).max).astype(np.int16)\\n return speech.RecognitionAudio(content=content.tobytes())\",\n \"def load_audio(self):\\n\\n self.audio_file = tkFileDialog.askopenfilename()\\n self.audio_parser = AudioFileParser(self.audio_file)\\n\\n self.audio_entries = self.audio_parser.entries\\n\\n for index, entry in enumerate(self.audio_parser.entries):\\n self.audio_box.insert(index, entry.word)\",\n \"def read(f, normalized=False):\\r\\n a = pydub.AudioSegment.from_mp3(f)\\r\\n y = np.array(a.get_array_of_samples())\\r\\n if a.channels == 2:\\r\\n y = y.reshape((-1, 2))\\r\\n if normalized:\\r\\n return a.frame_rate, np.float32(y) / 2**15\\r\\n else:\\r\\n return a.frame_rate, y\",\n \"def playmusic(self, soundfile):\\n clock = pygame.time.Clock()\\n pygame.mixer.music.load(soundfile)\\n pygame.mixer.music.play()\\n while pygame.mixer.music.get_busy():\\n clock.tick(FRAMERATE)\",\n \"def modulated_play(file_name,\\n sample_rate = 44100,\\n chunk = 1024,\\n channel = 1,\\n width = 2):\\n\\n data = np.fromfile(file_name, dtype = np.uint8)\\n wave = custom.modulate(data)\\n\\n p = pyaudio.PyAudio()\\n\\n stream = p.open(format = p.get_format_from_width(width),\\n channels = channel,\\n rate = sample_rate,\\n output = True)\\n\\n stream.write(wave)\\n\\n stream.stop_stream()\\n stream.close()\\n p.terminate()\",\n \"def run(self) -> None:\\n self._running = True\\n while self._running:\\n self._ist_mut.acquire()\\n self.buff = np.zeros(params.BUF)\\n for i in self.ist:\\n self.buff += np.asarray(struct.unpack('f'*params.BUF, i.read(params.BUF)))\\n self.buff /= len(self.ist)\\n self._ist_mut.release()\\n self.buff = self.transf.apply_all(self.buff)\\n self._sou_mut.acquire()\\n dels = []\\n for i, s in enumerate(self.sounds):\\n so_raw = s.read(params.BUF)\\n if so_raw == b'':\\n dels.append(i)\\n continue\\n so = np.asarray(struct.unpack(s.format*(len(so_raw)//s.f_size), so_raw)).astype(np.float32)\\n so /= 2**(8*s.f_size-1)\\n so = np.hstack((so, np.zeros(params.BUF-len(so))))*s.amp\\n self.buff = np.average([self.buff, so], axis=0, weights=[.8,.2])\\n for d in reversed(dels):\\n del self.sounds[d]\\n self._sou_mut.release()\\n raw = struct.pack('f'*len(self.buff), *self.buff)\\n self._ost_mut.acquire()\\n for o in self.ost:\\n o.write(raw)\\n self._ost_mut.release()\",\n \"def read_audio_from_stream(stream, sr=None, mono=False, duration=None, exp_format=\\\"wav\\\"):\\n _, file_ext = stream.filename.rsplit('.', 1)\\n ext_converter = {\\n 'mp3': AudioSegment.from_mp3,\\n }\\n converter = ext_converter.get(file_ext)\\n if not converter:\\n raise InvalidUsage(f\\\"Invalid extension: {file_ext}\\\")\\n\\n with tempfile.NamedTemporaryFile() as ntf:\\n sound = converter(stream)\\n sound.export(ntf, format=exp_format)\\n return read_audio(ntf.name, sr, mono, duration)\",\n \"async def transcribe_wav(args: argparse.Namespace, core: Voice2JsonCore) -> None:\\n from rhasspyasr import Transcription\\n\\n # Make sure profile has been trained\\n assert core.check_trained(), \\\"Not trained\\\"\\n\\n # Get speech to text transcriber for profile\\n transcriber = core.get_transcriber(open_transcription=args.open, debug=args.debug)\\n\\n # Directory to report WAV file names relative to\\n relative_dir = (\\n None if args.relative_directory is None else Path(args.relative_directory)\\n )\\n\\n try:\\n if args.wav_file or args.stdin_files:\\n # Read WAV file paths\\n wav_files = args.wav_file\\n if args.stdin_files:\\n _LOGGER.debug(\\\"Reading file paths from stdin\\\")\\n wav_files = itertools.chain(wav_files, sys.stdin)\\n\\n for wav_path_str in wav_files:\\n wav_path_str = wav_path_str.strip()\\n\\n # Load and convert\\n wav_path = Path(wav_path_str)\\n _LOGGER.debug(\\\"Transcribing %s\\\", wav_path)\\n\\n wav_data = await core.maybe_convert_wav(wav_path.read_bytes())\\n\\n # Transcribe\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n if relative_dir is None:\\n # Add name of WAV file to result\\n result[\\\"wav_name\\\"] = wav_path.name\\n else:\\n # Make relative to some directory\\n result[\\\"wav_name\\\"] = str(\\n wav_path.absolute().relative_to(relative_dir.absolute())\\n )\\n\\n print_json(result)\\n else:\\n # Read WAV data from stdin\\n _LOGGER.debug(\\\"Reading WAV data from stdin\\\")\\n\\n if args.input_size:\\n # Number of bytes is on separate line\\n line = sys.stdin.buffer.readline().strip()\\n if not line:\\n return\\n\\n num_bytes = int(line)\\n while num_bytes > 0:\\n # Read in WAV\\n wav_data = sys.stdin.buffer.read(num_bytes)\\n while len(wav_data) < num_bytes:\\n wav_data = sys.stdin.buffer.read(num_bytes - len(wav_data))\\n\\n # Transcribe\\n wav_data = await core.maybe_convert_wav(wav_data)\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n print_json(result)\\n\\n # Next WAV\\n line = sys.stdin.buffer.readline().strip()\\n if not line:\\n break\\n\\n num_bytes = int(line)\\n else:\\n # Load and convert entire input\\n wav_data = await core.maybe_convert_wav(sys.stdin.buffer.read())\\n\\n # Transcribe\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n print_json(result)\\n finally:\\n transcriber.stop()\",\n \"def single_analyze_wav(self, filePath):\\n\\n tChopped, vChopped, fVals,\\\\\\n powerFFT, peakFreqs, peakAmps = Utils.AnalyzeFFT(filePath, tChop=self.settings['processing']['tChop'],\\n detail=self.settings['processing']['detail'])\\n\\n self.analyzeDone.emit(tChopped, vChopped, fVals, powerFFT, peakFreqs, peakAmps, filePath)\\n self.update_table(peakFreqs, peakAmps)\",\n \"def read(self, filename, normalize=True):\\n if self.gcp == False:\\n\\n\\t\\t filepath = self.mixed_dir + filename\\n\\t\\t sf, time_signal = wavfile.read(filepath, mmap=True)\\n\\n else:\\n\\n blob = list(self.bucket.list_blobs(prefix=filename))[0]\\n # download blob as string\\n file_as_string = blob.download_as_string()\\n sf, time_signal = wavfile.read(io.BytesIO(file_as_string), mmap=True)\\n\\n\\t\\tif normalize == True:\\n\\t\\t\\t\\n # normalization, assuming 2^15 is the highest possible quantization\\n\\t\\t\\ttime_signal = time_signal/np.power(2,15)\\n\\n\\t\\treturn time_signal\",\n \"def load_wav(wav_file):\\n rate, data = wavfile.read(wav_file)\\n return rate, data\",\n \"def read_audio_from_path(path: str) ->Optional[TorchAudioTuple]:\\n bytes_obj = get_bytes_obj_from_path(path)\\n return read_audio_from_bytes_obj(bytes_obj)\",\n \"def play(filename):\\n SoundClient(blocking=True).playWave(filename)\",\n \"def read(filename):\\n\\n fileName, fileExtension = os.path.splitext(filename)\\n wav_filename = filename\\n rate, data = scipy.io.wavfile.read(str(wav_filename)) # the data is read in its native format\\n if data.dtype =='int16':\\n data = numpy.cast['float'](data)\\n return [rate,data]\",\n \"def read_wav(filename, offset=0, nframes=None, dtype=torch.double):\\n\\n if nframes is None: # Load whole file\\n fs, x = wavfile.read(filename, mmap=False)\\n x = torch.tensor(x, dtype=dtype)\\n x.unsqueeze_(dim=0)\\n\\n else: # Load a part\\n with wave.open(filename) as f:\\n fs = f.getframerate()\\n f.setpos(offset)\\n buff = f.readframes(nframes)\\n x = torch.tensor(np.frombuffer(buff, np.int16), dtype=dtype)\\n x.unsqueeze_(dim=0)\\n x -= x.mean()\\n\\n return x.to(DEVICE), fs\",\n \"def process_sound_map():\\n pass\",\n \"def map_audio(self): \\n for root, dirs, files in os.walk(self.dir):\\n for name in files:\\n if (name.split(\\\".\\\")[-1].lower() == 'm4a' or \\\\\\n name.split(\\\".\\\")[-1].lower() == 'mp3'):\\n \\n cur_path = \\\"{0}/{1}\\\".format(root, name)\\n cur_file = auto.File(cur_path)\\n \\n artist = cur_file.artist.lower().strip()\\n album = cur_file.album.lower().strip()\\n title = cur_file.title.lower().strip()\\n bitrate = cur_file.bitrate\\n \\n if not artist in self.audio_dict:\\n self.audio_dict[artist] = {}\\n \\n if not album in self.audio_dict[artist]:\\n self.audio_dict[artist][album] = {}\\n \\n title_key = title\\n for in_album_title in self.audio_dict[artist][album]:\\n if sm(None, title, in_album_title).ratio() > 0.9:\\n title_key = in_album_title\\n \\n if not title_key in \\\\\\n self.audio_dict[artist][album]:\\n self.audio_dict[artist][album][title_key] = []\\n \\n self.audio_dict[artist][album][title_key].append({\\n 'path': cur_path,\\n 'bitrate': bitrate,\\n 'file_name': name\\n })\\n \\n return self\",\n \"def _process_audio(self, root: str, id: str) -> bool:\\n path = os.path.join(root, id + \\\".flac\\\")\\n si, _ = torchaudio.info(path)\\n duration = (si.length / si.channels) / si.rate\\n if self.max_duration is not None and duration > self.max_duration:\\n return True\\n self.paths.append(path)\\n self.durations.append(duration)\\n return False\",\n \"def play_prog(self):\\r\\n\\r\\n serial_number = range(47845, 47869)\\r\\n chord_number = range(1, 25)\\r\\n for i in self.cnv:\\r\\n # Look for matching audio files and play them.\\r\\n try:\\r\\n filename = \\\"audio files/{}__{}.wav\\\".format(serial_number[i-1], chord_number[i-1])\\r\\n playsound.playsound(filename)\\r\\n except FileNotFoundError:\\r\\n print('Error: audio files not found.')\",\n \"def _record_audio(self) -> io.BytesIO:\\n frames = io.BytesIO()\\n audio_stream = self.audio_interface.open(\\n channels=self.channels,\\n format=self.SAMPLE_FORMAT,\\n frames_per_buffer=self.chunk_size,\\n input=True,\\n rate=self.framerate,\\n stream_callback=functools.partial(\\n self._fill_audio_buffer,\\n frames))\\n\\n while audio_stream.is_active():\\n pass\\n\\n audio_stream.stop_stream()\\n audio_stream.close()\\n\\n return frames\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72694874","0.7045707","0.6956398","0.6821181","0.6742061","0.6704527","0.6699321","0.6644113","0.6615665","0.64650714","0.6453779","0.63955903","0.63811314","0.63749427","0.6367572","0.63429946","0.6340871","0.633396","0.6314544","0.6308602","0.6294938","0.6285965","0.62740135","0.62489915","0.623837","0.6233427","0.62217736","0.6196891","0.618415","0.6141494","0.6132818","0.61327016","0.6072964","0.60648024","0.6053477","0.6053171","0.604283","0.6034881","0.6016926","0.6007087","0.600231","0.6001837","0.59928614","0.5991923","0.5990197","0.59824836","0.5970262","0.5936505","0.5935647","0.5932384","0.59256643","0.59164584","0.5911463","0.59061843","0.58888954","0.588063","0.5877161","0.5876366","0.58651054","0.5862576","0.58527976","0.5828484","0.5814212","0.580452","0.5789877","0.5788685","0.5775275","0.5768632","0.5764965","0.5760695","0.5758041","0.5740839","0.5739856","0.57366556","0.57348984","0.57348984","0.5731569","0.5728181","0.57270306","0.57072973","0.56976074","0.5685951","0.56839347","0.568042","0.5676626","0.56749207","0.5664367","0.5664219","0.5659049","0.56504446","0.5648043","0.5646563","0.56454086","0.5641915","0.56326896","0.56307846","0.56233025","0.5617952","0.56137264","0.5613083","0.5612471"],"string":"[\n \"0.72694874\",\n \"0.7045707\",\n \"0.6956398\",\n \"0.6821181\",\n \"0.6742061\",\n \"0.6704527\",\n \"0.6699321\",\n \"0.6644113\",\n \"0.6615665\",\n \"0.64650714\",\n \"0.6453779\",\n \"0.63955903\",\n \"0.63811314\",\n \"0.63749427\",\n \"0.6367572\",\n \"0.63429946\",\n \"0.6340871\",\n \"0.633396\",\n \"0.6314544\",\n \"0.6308602\",\n \"0.6294938\",\n \"0.6285965\",\n \"0.62740135\",\n \"0.62489915\",\n \"0.623837\",\n \"0.6233427\",\n \"0.62217736\",\n \"0.6196891\",\n \"0.618415\",\n \"0.6141494\",\n \"0.6132818\",\n \"0.61327016\",\n \"0.6072964\",\n \"0.60648024\",\n \"0.6053477\",\n \"0.6053171\",\n \"0.604283\",\n \"0.6034881\",\n \"0.6016926\",\n \"0.6007087\",\n \"0.600231\",\n \"0.6001837\",\n \"0.59928614\",\n \"0.5991923\",\n \"0.5990197\",\n \"0.59824836\",\n \"0.5970262\",\n \"0.5936505\",\n \"0.5935647\",\n \"0.5932384\",\n \"0.59256643\",\n \"0.59164584\",\n \"0.5911463\",\n \"0.59061843\",\n \"0.58888954\",\n \"0.588063\",\n \"0.5877161\",\n \"0.5876366\",\n \"0.58651054\",\n \"0.5862576\",\n \"0.58527976\",\n \"0.5828484\",\n \"0.5814212\",\n \"0.580452\",\n \"0.5789877\",\n \"0.5788685\",\n \"0.5775275\",\n \"0.5768632\",\n \"0.5764965\",\n \"0.5760695\",\n \"0.5758041\",\n \"0.5740839\",\n \"0.5739856\",\n \"0.57366556\",\n \"0.57348984\",\n \"0.57348984\",\n \"0.5731569\",\n \"0.5728181\",\n \"0.57270306\",\n \"0.57072973\",\n \"0.56976074\",\n \"0.5685951\",\n \"0.56839347\",\n \"0.568042\",\n \"0.5676626\",\n \"0.56749207\",\n \"0.5664367\",\n \"0.5664219\",\n \"0.5659049\",\n \"0.56504446\",\n \"0.5648043\",\n \"0.5646563\",\n \"0.56454086\",\n \"0.5641915\",\n \"0.56326896\",\n \"0.56307846\",\n \"0.56233025\",\n \"0.5617952\",\n \"0.56137264\",\n \"0.5613083\",\n \"0.5612471\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6876,"cells":{"query":{"kind":"string","value":"Compute log mel filterbank features with deltas and double deltas"},"document":{"kind":"string","value":"def _extract_fbank(self, sig, sr):\n\n emphasized_signal = np.append(sig[0], sig[1:] - 0.97 * sig[:-1])\n frame_length, frame_step = FRAME_SIZE * sr, FRAME_STRIDE * sr\n signal_length = len(emphasized_signal)\n frame_length = int(round(frame_length))\n frame_step = int(round(frame_step))\n num_frames = int(np.ceil(float(np.abs(signal_length - frame_length)) / frame_step))\n\n pad_signal_length = num_frames * frame_step + frame_length\n z = np.zeros((pad_signal_length - signal_length))\n pad_signal = np.append(emphasized_signal, z)\n\n indices = np.tile(np.arange(0, frame_length),\n (num_frames, 1)) + np.tile(np.arange(0, num_frames * frame_step, frame_step),\n (frame_length, 1)).T\n frames = pad_signal[indices.astype(np.int32, copy=False)]\n # Apply the hamming window function\n frames *= np.hamming(frame_length)\n nfft, nfilt = 512, 40\n mag_frames = np.absolute(np.fft.rfft(frames, nfft))\n pow_frames = ((1.0 / nfft) * (mag_frames ** 2))\n low_freq_mel = 0\n \n ### AI:\n # the following line works correcty as-is in python3\n # *** high_freq_mel = (2595 * np.log10(1 + (sr / 2) / 700)) ***\n # however, in python it results in a smaller value of 'high_freq_mel'\n # as the 'sr' variable is interpreted as integer\n # it has minor impact on the performance of the natively trained and tested models\n # however, if one uses python to test the models that were created in python3\n # the models show the CER drop as much as 1% absolute\n # the line below fixes that issue completely\n high_freq_mel = (2595 * np.log10(1 + (float(sr) / 2) / 700))\n \n mel_points = np.linspace(low_freq_mel, high_freq_mel, nfilt + 2)\n hz_points = (700 * (10**(mel_points / 2595) - 1))\n bin = np.floor((nfft + 1) * hz_points / sr)\n\n fbank = np.zeros((nfilt, int(np.floor(nfft / 2 + 1))))\n for m in range(1, nfilt + 1):\n f_m_minus = int(bin[m - 1]) # left\n f_m = int(bin[m]) # center\n f_m_plus = int(bin[m + 1]) # right\n\n for k in range(f_m_minus, f_m):\n fbank[m - 1, k] = (k - bin[m - 1]) / (bin[m] - bin[m - 1])\n for k in range(f_m, f_m_plus):\n fbank[m - 1, k] = (bin[m + 1] - k) / (bin[m + 1] - bin[m])\n filter_banks = np.dot(pow_frames, fbank.T)\n filter_banks = np.where(filter_banks == 0, np.finfo(float).eps, filter_banks)\n \n # AI:\n # *** filter_banks = 20 * np.log10(filter_banks) ***\n # 'pow_frames' contains the power spectrum (i.e. squared magnitude)\n # the proper formula to convert to the logarithm scale in decibels is\n # 10*log10(POW), while 20*log10(MAG) is used for the un-squared magnitude\n # this way both formuli result in the same outcome\n filter_banks = 10 * np.log10(filter_banks)\n \n # Apply mean normalization\n filter_banks -= (np.mean(filter_banks, axis=0) + 1e-8)\n filter_banks = filter_banks.transpose()\n delta = librosa.feature.delta(filter_banks)\n double_delta = librosa.feature.delta(delta)\n fbank_feat = np.vstack([filter_banks, delta, double_delta]);\n\n fbank_feat = fbank_feat.transpose()\n\n assert np.shape(fbank_feat)[1] == 120, \"input dimensions incorrect\"\n\n # Truncate if audio sequence is too long\n fbank_length = len(fbank_feat)\n if fbank_length > self.max_input_seq_length:\n fbank_feat = fbank_feat[:self.max_input_seq_length]\n\n return fbank_feat, fbank_length"},"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 logMelSpectrum(input, samplingrate):\n nfft = input.shape[1]\n N = input.shape[0]\n filters = trfbank(samplingrate, nfft)\n\n # plot Mel filters\n # plt.plot(filters)\n # plt.title('Mel filters')\n # plt.show()\n\n output = np.zeros((N, filters.shape[0]))\n for j in range(filters.shape[0]): # apply each filterbank to the whole power spectrum\n for i in range(N):\n output[i, j] = np.log(np.sum(input[i] * filters[j]))\n\n # myplot(output, 'Filter Banks')\n\n return output","def statePosteriors(log_alpha, log_beta):\n return log_alpha + log_beta - logsumexp(log_alpha[-1,:])","def log2FC_data(data):\n log2FC_df = pd.DataFrame()\n for i in range(0,len(data.columns),10):\n i = i\n data_subset = data[data.columns[i:i+10]]\n log_data = data_subset.apply(np.log2)\n \n new_df = pd.DataFrame()\n for j in range(len(log_data.columns)):\n tmp_col = log_data.iloc[:, j].name\n tmp_df = log_data.iloc[:,0] - log_data.iloc[:,j]\n new_df[tmp_col] = tmp_df\n \n log2FC_df = log2FC_df.append(new_df.T)\n log2FC_df = log2FC_df.T\n return log2FC_df","def statePosteriors(log_alpha, log_beta):","def extract_features(self, np_samples):\n log_mel_examples = []\n samples = np_samples.shape[0]\n if self._normalize:\n min_ratio = 0.1 # = 10^(max_db/-20) with max_db = 20\n np_samples /= np.maximum(min_ratio, np.amax(np_samples))\n if self._step_size is not None:\n samples_splits = []\n for i in xrange(0, samples - vggish_params.SAMPLE_RATE + 1,\n self._step_size):\n samples_splits.append(np_samples[i:i + vggish_params.SAMPLE_RATE])\n else:\n samples_splits = np.split(np_samples, samples / vggish_params.SAMPLE_RATE)\n # Compute log mel spectrogram features.\n for samples_window in samples_splits:\n log_mel = mel_features.log_mel_spectrogram(\n samples_window,\n audio_sample_rate=vggish_params.SAMPLE_RATE,\n log_offset=vggish_params.LOG_OFFSET,\n window_length_secs=vggish_params.STFT_WINDOW_LENGTH_SECONDS,\n hop_length_secs=vggish_params.STFT_HOP_LENGTH_SECONDS,\n num_mel_bins=vggish_params.NUM_MEL_BINS,\n lower_edge_hertz=vggish_params.MEL_MIN_HZ,\n upper_edge_hertz=vggish_params.MEL_MAX_HZ)\n\n log_mel_examples.append(\n mel_features.frame(\n log_mel,\n window_length=self._example_window_length,\n hop_length=self._example_window_length))\n return log_mel_examples","def test_loglike(dlm,Cl,noise,beam):\n lmax = Cl.shape[0]\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\n #plt.plot(Cl[:,1])\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \n tt_f = tt_exp + tt_det\n return tt_exp,tt_det,tt_f#,Cl[:,1]","def log_distr_fdmw(self, dnu, logflux, dme, logw, alpha, logls, logl0, mu, sigma, gtype=None):\n #stepdms = 100/1000.\n #vdms = np.arange(0, 100, stepdm)\n stepz = (np.log(self.Zmax) - np.log(self.Zmin)) / 1000\n vz = np.exp(np.arange(np.log(self.Zmin), np.log(self.Zmax), stepz))\n lik = 0\n for z in vz:\n likv = np.exp(self.log_distr_fdmwz(dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=gtype))\n lik += z * stepz * likv\n ind = lik > 0\n ind2 = lik <= 0\n loglik = lik.copy()\n loglik[ind] = np.log(lik[ind])\n loglik[ind2] = np.ones(loglik[ind2].shape) * -1e99\n return loglik","def _log_fold_change_pairs(self, idx0, idx1, base):\n logfc = np.zeros(shape=(len(idx0), len(idx1), self._theta_mle.shape[1]))\n for i, xi in enumerate(idx0):\n for j, xj in enumerate(idx1):\n logfc[i, j, :] = self._theta_mle[xi, :] - self._theta_mle[xj, :]\n\n if base == np.e:\n return logfc\n else:\n return logfc / np.log(base)","def compute_edge_logits(self):","def _log_fold_change_pairs(self, idx0, idx1, base):\n logfc = np.tile(np.NaN, [len(idx0), len(idx1), self.model_estim.x.shape[1]])\n for i, xi in enumerate(idx0):\n for j, xj in enumerate(idx1):\n logfc[i, j, :] = self._theta_mle[xj, :] - self._theta_mle[xi, :]\n logfc[j, i, :] = -logfc[i, j, :]\n\n if base == np.e:\n return logfc\n else:\n return logfc / np.log(base)","def logfbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\n nfilt=40,nfft=512,lowfreq=64,highfreq=None,dither=1.0,remove_dc_offset=True,preemph=0.97,wintype='hamming'):\n feat,energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,dither, remove_dc_offset,preemph,wintype)\n return numpy.log(feat)","def logits(self, features: torch.Tensor) -> torch.Tensor:\n return self.temporal_module(features)","def logMelSpectrum(input, samplingrate):\n nfft = input.shape[1]\n tr_filter = trfbank(samplingrate, nfft)\n return np.log(np.dot(input, tr_filter.transpose()))","def log_prior_grad(self, inputs):","def get_logCRF(train, model):\n word = train[0]\n Y = train[1]\n char_count, _ = word.shape\n # calculating forward messages\n alpha = np.zeros((char_count, model.dimY))\n first_term = np.dot(word, model.getW(model.labels))\n second_term = model._T\n for i in range(1, char_count):\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \n # getting logZ from messages\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\sum_{j=1}^m {W_{yj} . x_j}$\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\n value = -logZ + w_term + t_term\n return value","def loglf2py(store):\n loglike=0.0\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)","def logfbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97): \n feat, energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,preemph)\n return pylab.log(feat)","def logistic_derivative(errors):\n return [log_deriv(error) for error in errors]","def log(self): # just use base?\n return Factor().__build( VarSet(self.v) , np.log(self.t) )","def log2(self):\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )","def log_fbank(signal, samplerate=16000, win_length=0.025, win_step=0.01, filters_num=26, NFFT=512, low_freq=0,\n\t\t\t high_freq=None, pre_emphasis_coeff=0.97):\n\tfeat, energy = fbank(signal, samplerate, win_length, win_step, filters_num, NFFT, low_freq, high_freq,\n\t\t\t\t\t\t pre_emphasis_coeff)\n\treturn numpy.log(feat)","def fdm(self,trc,fd_step,lags,noise_scalar):\n ress=[]\n trc_out=trc/np.amax(np.abs(trc))\n noise=np.random.normal(0,1,len(trc_out))*(np.std(trc_out)/noise_scalar)\n trc_out=trc_out+noise\n for i,lag in enumerate(lags):\n trc_cp=trc_out.copy()\n t=len(trc)-1\n trc_cp[0:fd_step]=0\n while t>fd_step-1:\n trc_win=trc_out[t-fd_step:t+1]\n t_win=fd_step-1\n res=0\n while t_win>lag-1:\n res+=np.square(trc_win[t_win-lag]-trc_win[t_win])\n t_win-=1\n res=np.log10(1/(fd_step-lag)*res)\n trc_cp[t]=res\n t-=1\n if len(ress)==0:\n ress=np.reshape(trc_cp,(len(trc_cp),1))\n else:\n ress=np.concatenate((ress,np.reshape(trc_cp,(len(trc_cp),1))),axis=1)\n for i,j in enumerate(ress):\n slope = linregress(lags,ress[i,:])[0]\n trc_out[i]=slope\n \n return trc_out","def log_forward_computations(self, x: list): \n n_x = len(x)\n \n # log_f_x initialized to -Inf because log(0) = -Inf\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\n \n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\n \n for i in range(1,n_x):\n for s in range(self.n_states):\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \n log_f_x[:,i-1]) + x_emission_scores[s, i]\n\n \n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\n \n return log_f_x, log_likelihood","def log_distr_fdmwz(self, dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=None):\n flux = np.power(10., logflux)\n logl = np.log10(self.cos.Luminosity(z, f=flux, dnu=dnu))\n logint1 = self.log_IntBeam(logl, alpha, logls, logl0)\n #print logint1\n logw0 = logw - np.log10(1+z)\n logfw = self.log_dis_logw(logw0, mu, sigma)\n logfz = self.log_Distribution_volume(z)\n dmi = self.cos.DispersionMeasure_IGM(z)\n u1 = (dme-dmi)*(1+z)*self.kappa(z)\n u2 = ((dme-dmi)*(1+z)-self.DMsmax)*self.kappa(z)\n #print u2\n logint2 = np.ones(u2.shape) * (-1e99)\n ind = u2 > 0\n logint2[ind] = self.log_IntDMsrc(u1[ind],u2[ind],gtype=gtype)\n #print logint2\n loglikv = logint1 + logfz + logfw + logint2 + np.log(1+z)\n return loglikv","def loglike(store):\n nobs = store['yvec'].shape[0]\n calcweighted(store)\n store['regsampler'].update_yvec(store['yvectil'])\n store['regsampler'].update_xmat(store['xmattil'])\n return store['regsampler'].loglike(store['sigma'], store['beta'])","def addFactors(self, flist, copy=True, isLog=False):\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\n for k,f in enumerate(flist):\n if not isLog: \n if np.any(f.t<=0): f = f+1e-10; # TODO: log nonzero tol\n f = f.log()\n if f.nvar == 1:\n Xi = f.vars[0]\n self.h[Xi] += .5*(f[1]-f[0])\n self.c += .5*(f[1]+f[0])\n else:\n Xi,Xj = f.vars[0],f.vars[1]\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n self.h[Xi] += .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.h[Xj] += .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.c += .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\n self.L += csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar));","def logmelfilterbank(\n audio,\n sampling_rate,\n fft_size=1024,\n hop_size=256,\n win_length=None,\n window=\"hann\",\n num_mels=80,\n fmin=None,\n fmax=None,\n eps=1e-10,\n):\n # # get amplitude spectrogram\n # x_stft = librosa.stft(audio, n_fft=fft_size, hop_length=hop_size,\n # win_length=win_length, window=window, pad_mode=\"reflect\")\n # spc = np.abs(x_stft).T # (#frames, #bins)\n\n # # get mel basis\n # fmin = 0 if fmin is None else fmin\n # fmax = sampling_rate / 2 if fmax is None else fmax\n # mel_basis = librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax)\n\n # return np.log10(np.maximum(eps, np.dot(spc, mel_basis.T)))\n # logger.info('{} {}'.format(audio.shape, audio.device))\n x_stft2 = (\n torch.stft(\n audio,\n n_fft=fft_size,\n hop_length=hop_size,\n win_length=win_length,\n window=window,\n pad_mode=\"reflect\",\n ).transpose(0, 1)\n ** 2\n )\n # logger.info('{} {}'.format(x_stft2.shape, x_stft2.device))\n spc = (x_stft2[:, :, 0] + x_stft2[:, :, 1]).sqrt()\n\n # get mel basis\n fmin = 0 if fmin is None else fmin\n fmax = sampling_rate / 2 if fmax is None else fmax\n mel_basis = torch.tensor(\n librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax),\n device=spc.device,\n ).transpose(0, 1)\n return torch.matmul(spc, mel_basis).clamp(min=eps).log10()","def forward(log_emlik, log_startprob, log_transmat):\n alpha = np.zeros(log_emlik.shape)\n\n alpha[0,:] = log_startprob[0:-1] + log_emlik[0,:]\n\n sum_row = 0;\n log_transmat = log_transmat[0:-1];\n\n\n for frame in range(1,len(log_emlik)):\n\n for state in range(0,len(log_emlik[0])):\n\n alpha[frame,state] = logsumexp(alpha[frame-1,:] + log_transmat[:,state]) + log_emlik[frame,state]\n #print(alpha[frame,state])\n #print(alpha[frame,:])\n\n return alpha","def statePosteriors(log_alpha, log_beta):\n\n gamma = np.zeros(log_alpha.shape)\n\n gamma = log_alpha + log_beta\n\n gamma = gamma - logsumexp(log_alpha[-1,:])\n\n return gamma","def get_weights_from_log(log, plot = False):\n with open(log, 'r') as f:\n log_file = f.readlines()\n\n i = 0\n time = []\n weights_info = []\n weights_0 = []\n while i < len(log_file):\n if 'init-lambda-weights[' in log_file[i]:\n weights_0.append(float(log_file[i].split('=')[-1]))\n\n if 'MC-lambda information' in log_file[i]:\n # Finding the time\n for j in range(i,0,-1):\n if log_file[j].startswith(' Step Time'):\n j += 1\n time.append(float(log_file[j].split()[-1]))\n break\n # Finding the weight\n weights_info_tmp = []\n i += 3\n while log_file[i] != '\\n':\n split = log_file[i].split()\n count = int(split[2])\n weight = float(split[3])\n weights_info_tmp.append((count, weight))\n i += 1\n weights_info.append(weights_info_tmp)\n i += 1\n # Add weights at t = 0, because the counts are all 0 and I delate the entrances with total count 0 in next lines,\n # What i could do is put 1 in the initial temperature\n time.insert(0,0)\n weights_info.insert(0,list(zip([1] + (len(weights_0) - 1)*[0], weights_0)))\n\n #Converting to array\n time = np.array(time)\n weights_info = np.array(weights_info)\n # Some times (I don't know why) GROMACS reset all the weights and all the counts are 0. We need to eliminate those points\n sum_of_weights = weights_info[:,:,0].sum(axis = 1)\n time = time[sum_of_weights != 0]\n weights_info = weights_info[sum_of_weights != 0]\n sum_of_weights = sum_of_weights[sum_of_weights != 0]\n\n\n if plot:\n dir = os.path.dirname(log)\n fig, axes = plt.subplots(2, figsize = (16,9), sharex=True)\n NUM_COLORS = weights_info.shape[1]\n cm = plt.get_cmap('viridis')#gist_rainbow viridis\n for axe in axes:\n axe.set_prop_cycle('color', [cm(1.*j/NUM_COLORS) for j in range(NUM_COLORS)])\n\n probability = weights_info[:,:,0] / sum_of_weights[:,np.newaxis]\n for j in range(weights_info.shape[1]):\n #axes[0].plot(time, weights_info[:,j,0], label = str(j))\n axes[0].plot(time, probability[:,j], label = str(j))\n axes[1].plot(time, weights_info[:,j,1])\n\n fig.legend(loc = 'lower center', ncol = int(weights_info.shape[1] / 2))\n axes[0].set(\n xlim = (time.min(), time.max()),\n ylim = (0,1),\n ylabel = 'Probability',\n )\n axes[1].set(\n xlabel = 'Time [ps]',\n ylabel = 'Weight values'\n )\n #plt.show()\n fig.savefig(os.path.join(dir,'weights_progression.svg'), bbox_inches=\"tight\")\n\n # Plotting the violin plot of the weights\n df = pd.DataFrame()\n for j in range(weights_info.shape[1]):\n #df[temperatures[j]] = weights_info[:,j,1]\n df[j] = weights_info[:,j,1]\n # Set up the matplotlib figure\n sns.set_theme(style=\"whitegrid\")\n fig, ax = plt.subplots(figsize=(25, 25))\n\n # Draw a violinplot with a narrower bandwidth than the default\n sns.violinplot(data=df, palette=\"Set3\", bw=.2, cut=1, linewidth=1)\n # The plot is not over the actual temperatures, the temperatures ara only labels\n ax.plot(range(len(weights_info[0,:,1])), weights_info[0,:,1], '-o', label = 'Initial weights')\n ax.set(\n title = 'Weights per state over the entire simulation',\n xlabel = 'Sate',\n ylabel = 'Weight',\n )\n plt.legend()\n sns.despine(left=True, bottom=True)\n #plt.show()\n fig.savefig(os.path.join(dir,'weights_per_state.svg'), bbox_inches=\"tight\")\n sns.reset_defaults()\n\n return time, weights_info","def log_features(data, columns):\n for col in columns:\n # deal with 0/1 values\n if np.sum(data[col] == 0) > 0:\n print('Replacing 0s with 0.025...')\n data.loc[data[col] == 0, col] = 0.025\n\n data[col] = np.log(data[col])","def forward(self, reps):\n assert reps.shape[-1] == N_DIMS_PER_REP\n logits = torch.zeros(len(reps), N_UNIQUE_FEATS)\n logits[:, feat] = 1\n return logits","def og_features(scan,filt=None,base_noise=None,thresh=-1.4781e-10,diff=1,verbose=False,scale=10):\n #get gradients of data\n der = np.array(np.gradient(scan,diff))\n \n #calculate gardient magnitudes and directions\n der_mag = np.linalg.norm(der,axis=0) \n der_uvecs = der/der_mag\n \n z_cur = np.copy(scan).ravel()\n\n #estimate noise level and set derivative filter threshold\n if filt is None:\n filt = np.mean(signaltonoise(der_mag)[-1])\n \n \n if base_noise is not None:\n filt = np.maximum(filt,base_noise)\n \n\n\n #filter directions and magnitudes\n x, y, z = der_uvecs[0].ravel(), der_uvecs[1].ravel(), der_mag.ravel()\n \n #filter using threshold and filt\n x_filt, y_filt, z_filt = x[z_cur>thresh], y[z_cur>thresh], z[z_cur>thresh]\n #x_filt, y_filt, z_filt = x, y, z\n\n \n #print(len(z_filt))\n x_filt, y_filt, z_filt = x_filt[z_filt>filt], y_filt[z_filt>filt], z_filt[z_filt>filt]\n\n \n #calculate angles\n angles_filt = np.sign(y_filt)*np.arccos(x_filt/1)\n\n \n #print(len(angles_filt))\n \n if len(angles_filt) < 2:\n return 0,0,0\n \n #fit single line\n sol1 = least_squares(ress_1line,[-np.pi/2],args=(angles_filt,),bounds=[-np.pi,0],method='dogbox',jac='2-point',max_nfev=2000)\n\n #fit two lines by grid search\n #sol_grid = grid_search(ress_2line,angles_filt,[[-np.pi,0],[-np.pi,0]])\n \n \n singleline = sol1.x[0]\n \n mx = np.minimum(np.abs(singleline-(-np.pi)),np.abs(singleline))\n \n sol_grid = grid_search(ress_2line_pm,angles_filt,[[0,mx]],umid = singleline)\n spread_lines = sol_grid[1]\n sol_grid[1] = [singleline+spread_lines,singleline-spread_lines]\n \n \n #compute average of squared residuals for both cases\n resid1 = ress_1line(sol1.x,angles_filt)\n\n grid_c11 = np.average(np.power(resid1,2))\n \n grid_c11 = np.average(np.abs(resid1))\n \n grid_c21 = sol_grid[-1]\n \n \n multip = cotunnel_score2(scan,scan>thresh,diff,scale)\n \n final_grid2 = multip*(grid_c11-grid_c21)\n \n \n \"\"\"\n plt.scatter(angles_filt,z_filt,marker='x',c='k',s=15,linewidth=0.4)\n plt.axvline(sol1.x,color='b')\n plt.axvline(sol1.x+(np.pi),color='b')\n plt.axvline(sol_grid[1][0],0,color='r', linestyle='--')\n plt.axvline(sol_grid[1][1],0,color='r', linestyle='--')\n \n plt.axvline(sol_grid[1][0]+(np.pi),0,color='r', linestyle='--')\n plt.axvline(sol_grid[1][1]+(np.pi),0,color='r', linestyle='--')\n \n plt.xlabel(\"$\\\\theta_g$ / rad\")\n \n plt.xlim([-np.pi,np.pi])\n plt.ylim([0,z.max()])\n \n \n plt.ylabel(\"$|g|$\")\n \n plt.xticks([-np.pi,0,np.pi])\n \n plt.locator_params(axis='y', nbins=2)\n \n plt.savefig(\"og_fig.svg\")\n \n plt.show()\n \"\"\"\n return final_grid2,multip,(grid_c11-grid_c21)","def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):","def llf(self):\n return self.model.loglike(self.params)","def logistic(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def compute_forward_variables(self, normalized_logits, target):\n\n target_length = target.shape[0]\n num_time_steps = normalized_logits.shape[0]\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n \n blank_label = normalized_logits.shape[1] - 1\n l = add_blanks(target, blank_label)\n target_length = l.shape[0]\n\n # init\n alpha = np.zeros((target_length, num_time_steps))\n alpha[0, 0] = normalized_logits[0, blank_label] # where s = 0, t = 0\n alpha[1, 0] = normalized_logits[0, target[0]] # where s = 1, t = 0\n for i in xrange(2, num_time_steps): # for all s >= 2, t = 0\n alpha[i, 0] = 0\n\n # recursive case\n for t in xrange(1, num_time_steps):\n for s in xrange(2, target_length):\n \n a_bar = alpha[s, t-1] + alpha[s-1, t-1] \n\n if l[s] == blank_label or l[s-2] == l[s]:\n alpha[s, t] = normalized_logits[t, l[s]] * a_bar\n else:\n alpha[s, t] = normalized_logits[t, l[s]] * (a_bar + alpha[s-2, t-1])\n return alpha","def __convert_to_log(self):\n for i in range(self.nStates):\n if self.pi[i]>0:\n self.pi[i]=log(self.pi[i])\n else:\n self.pi[i]=float('-inf')\n for j in range(self.nStates):\n if self.t[i][j]>0:\n self.t[i][j]=log(self.t[i][j])\n else:\n self.t[i][j]=float('-inf')\n for j in range(self.nObs):\n if self.e[i][j]>0:\n self.e[i][j]=log(self.e[i][j])\n else:\n self.e[i][j]=float('-inf')\n self.logdomain=True","def forward(log_emlik, log_startprob, log_transmat):\n logPi=log_startprob[:-1]\n logB=log_emlik\n logA=log_transmat[:-1,:-1]\n alpha = np.zeros_like(logB)\n alpha[0]=logB[0]+logPi\n for i in range(1,logB.shape[0]):\n for j in range(logA.shape[0]):\n alpha[i][j]=logsumexp(alpha[i-1]+logA[:,j]+logB[i][j])\n return alpha","def logmelfilterbank(audio,\r\n sampling_rate,\r\n fft_size=1024,\r\n hop_size=256,\r\n win_length=None,\r\n window=\"hann\",\r\n num_mels=80,\r\n fmin=None,\r\n fmax=None,\r\n eps=1e-10,\r\n ):\r\n # get amplitude spectrogram\r\n x_stft = librosa.stft(audio, n_fft=fft_size, hop_length=hop_size,\r\n win_length=win_length, window=window, pad_mode=\"reflect\")\r\n spc = np.abs(x_stft).T # (#frames, #bins)\r\n\r\n # get mel basis\r\n fmin = 0 if fmin is None else fmin\r\n fmax = sampling_rate / 2 if fmax is None else fmax\r\n mel_basis = librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax)\r\n\r\n return np.log10(np.maximum(eps, np.dot(spc, mel_basis.T)))","def NMF(model, maxIter=100, beliefs=None, verbose=False):\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\n \n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter 0: \"+str(lnZ))\n\n for t in xrange(1,maxIter+1): # for each iteration:\n # Update all the beliefs via coordinate ascent:\n for Xi in model.X: # for each variable, \n bNew = 0.0 # compute E[ log f ] as a function of Xi:\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\n m = f.log() # E[log f_a] = \\sum \\log f_a \\prod b_v\n for v in f.vars - [Xi]: m *= beliefs[v]\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\n bNew -= bNew.max() # (numerical issues)\n bNew = bNew.exp()\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\n beliefs[Xi] = bNew\n #\n # Compute the lower bound on the partition function:\n # E_b [ log f ] + H(b) = \\sum_a E[log f_a] + \\sum_i H(b_i) for independent beliefs\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter \"+str(t)+\": \"+str(lnZ))\n return lnZ,beliefs","def forward(self, mel_coarse):\n logit = self.layers(mel_coarse)\n y = F.sigmoid(logit)\n return y, logit","def brownian_motion_log_returns(param):\n sqrt_delta_sigma = math.sqrt(param.time_rate) * param.vol\n return nrand.normal(loc=0, scale=sqrt_delta_sigma, size=param.time)","def brownian_motion_levels(param):\n return convert_to_prices(param, brownian_motion_log_returns(param))","def log10(self):\n return Factor().__build( VarSet(self.v) , np.log10(self.t) )","def log2_inplace(a):","def _log_fold_change_pairs(self, idx0, idx1, base):\n assert np.all([x < self._pval.shape[1] for x in idx0])\n assert np.all([x < self._pval.shape[1] for x in idx1])\n if base == np.e:\n return self._logfc[idx0, :, :][:, idx1, :]\n else:\n return self._logfc[idx0, :, :][:, idx1, :] / np.log(base)","def __log_likelihood(self, params, *args):\n\t\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\n\n\t\tno_example = len(X)\n\t\ttotal_logZ = 0\n\t\ttotal_logProb = 0\n\t\texpected_weights = np.zeros(len(feature_set))\n\t\tfor t in range(len(X)):\n\t\t\t# example_features = X[t], example_labels = y[t]\n\n\t\t\tpotential = np.zeros(len(X[t]))\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\t#candidate_features = X[t][i], candidate_label = y[t][i]\n\t\t\t\tpotential[i] = feature_set.calc_inner_product(X[t][i], params)\n\n\t\t\t#scaling\n\t\t\tpotential = potential - np.max(potential, keepdims=True)\n\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\ttotal_logProb += potential[i] * y[t][i]\n\n\t\t\tpotential, Z = self.__softmax(potential)\n\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\tfeature_set.calc_inner_sum(expected_weights, X[t][i], potential[i])\n\n\t\t\ttotal_logZ += log(Z)\n\n\t\t# _params = feature_set.get_regularized_params(params, 'bias')\n\t\t_params = params\n\t\tlog_likelihood = total_logProb - total_logZ - (lambda_reg/2) * np.sum(np.multiply(_params,_params))\n\t\tgradients = empirical_weights - expected_weights - lambda_reg * _params\n\n\t\tglobal SUB_ITERATION_NUM\n\t\tif verbose:\n\t\t\tsub_iteration_str = ' '\n\t\t\tif SUB_ITERATION_NUM > 0:\n\t\t\t\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\n\t\t\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\n\n\t\tSUB_ITERATION_NUM += 1\n\n\t\treturn sign * log_likelihood, sign * gradients","def add_mf_updates(self):\n \n if self.num_hidden == 0:\n \n self.mf_updates, _ =\\\n theano.scan(lambda i: self.sigmoid_update(self.mf_vis_p,i),\n sequences = [T.arange(self.num_vars)])\n \n elif self.num_hidden > 0:\n \n self.mf_vis_updates = self.sigmoid_update_vis(self.mf_hid_p)\n \n self.mf_hid_updates = self.sigmoid_update_hid(self.mf_vis_p)\n \n # damp high oscillations:\n self.mf_vis_updates = 0.02*self.mf_vis_p + 0.98*self.mf_vis_updates\n \n self.mf_hid_updates = 0.02*self.mf_hid_p + 0.98*self.mf_hid_updates\n #####","def log_inplace(a):","def f_log_decoding(x, out_reflection=False):\n a = 0.555556\n b = 0.009468\n c = 0.344676\n d = 0.790453\n e = 8.735631\n f = 0.092864\n cut2 = 0.100537775223865\n\n y = np.where(x < cut2,\n (x - f) / e,\n (10 ** ((x - d) / c)) / a - (b / a))\n\n if not out_reflection:\n y = y / 0.9\n\n return y","def backward(log_emlik, log_startprob, log_transmat):\n #print(log_transmat)\n beta = np.zeros(log_emlik.shape)\n n = len(log_emlik)-2\n log_transmat = log_transmat[0:-1,0:-1];\n\n\n\n while n >= 0:\n\n for j in range(0,len(log_emlik[0])):\n\n beta[n,j] = logsumexp(log_transmat[j,:] + log_emlik[n+1,:] + beta[n+1,:])\n\n n = n -1\n #print(beta[n,:])\n #print(beta)\n return beta","def KFilt(sample,fs=25):\n\t#kalman filter inputs\n \n # Dimensions of parameters:\n # 'transition_matrices': 2,\n # 'transition_offsets': 1,\n # 'observation_matrices': 2,\n # 'observation_offsets': 1,\n # 'transition_covariance': 2,\n # 'observation_covariance': 2,\n # 'initial_state_mean': 1,\n # 'initial_state_covariance': 2,\n \n n_timesteps = len(sample)\n trans_mat = []\n\n\t#mask missing values\n observations = np.ma.array(sample,mask=np.zeros(sample.shape))\n missing_loc = np.where(np.isnan(sample))\n observations[missing_loc[0][:],missing_loc[1][:]] = np.ma.masked\n\t\n\t#Import Kalman filter, inerpolate missing points and get 2nd, 3rd orde kinematics\n dt = 1./25\t#Length of each frame (should be iether 1/25 or 1/30)\t\n n_timesteps = len(sample)\n \n observation_matrix = np.array([[1,0,0,0],\n [0,1,0,0]])#np.eye(4) \n t = np.linspace(0,len(observations)*dt,len(observations))\n q = np.cov(observations.T[:2,:400])\n qdot = np.cov(np.diff(observations.T[:2,:400]))#np.cov(observations[:1,:400])\n\n h=(t[-1]-t[0])/t.shape[0]\n A=np.array([[1,0,h,.5*h**2], \n [0,1,0,h], \n [0,0,1,0],\n [0,0,0,1]]) \n\n init_mean = [sample[0],0,0] #initial mean should be close to the first point, esp if first point is human-picked and tracking starts at the beginning of a video\n observation_covariance = q*500 #ADJUST THIS TO CHANGE SMOOTHNESS OF FILTER\n init_cov = np.eye(4)*.001#*0.0026\n transition_matrix = A\n transition_covariance = np.array([[q[0,0],q[0,1],0,0],\n [q[1,0],q[1,1],0,0],\n [0,0,qdot[0,0],qdot[0,1]],\n [0,0,qdot[1,0],qdot[1,1]]])\n\n kf = KalmanFilter(transition_matrix, observation_matrix,transition_covariance,observation_covariance,n_dim_obs=2)\n\n kf = kf.em(observations,n_iter=1,em_vars=['transition_covariance','transition_matrix','observation_covariance'])\n\n #pdb.set_trace()\n \n global trans_mat, trans_cov, init_cond\n x_filt = kf.filter(observations[0])[0]#observations.T[0])[0]\n kf_means = kf.smooth(observations[0])[0]\n\t\n return kf_means,x_filt #np.column_stack((color_x[:,0],color_y[:,0],color_x[:,1],color_y[:,1])),frames","def pre_logits(self, feats: Tuple[torch.Tensor]) -> torch.Tensor:\n # The EfficientFormerClsHead doesn't have other module, just return\n # after unpacking.\n return feats[-1]","def llf_obs(self):\n return self.model.loglikeobs(self.params)","def test_lfc_ml2():\n levels = np.array([1024.95703125, 1016.61474609, 1005.33056641, 991.08544922, 973.4163208,\n 951.3381958, 924.82836914, 898.25482178, 873.46124268, 848.69830322,\n 823.92553711, 788.49304199, 743.44580078, 700.50970459, 659.62017822,\n 620.70861816, 583.69421387, 548.49719238, 515.03826904, 483.24401855,\n 453.0418396, 424.36477661, 397.1505127, 371.33441162, 346.85922241,\n 323.66995239, 301.70935059, 280.92651367, 261.27053833, 242.69168091,\n 225.14237976, 208.57781982, 192.95333862, 178.22599792, 164.39630127,\n 151.54336548, 139.68635559, 128.74923706, 118.6588974, 109.35111237,\n 100.76405334, 92.84288025, 85.53556824, 78.79430389, 72.57549286,\n 66.83885193, 61.54678726, 56.66480637, 52.16108322]) * units.mbar\n temperatures = np.array([6.00750732, 5.14892578, 4.177948, 3.00268555, 1.55535889,\n -0.25527954, -1.93988037, -3.57766724, -4.40600586, -4.19238281,\n -3.71185303, -4.47943115, -6.81280518, -8.08685303, -8.41287231,\n -10.79302979, -14.13262939, -16.85784912, -19.51675415,\n -22.28689575, -24.99938965, -27.79664612, -30.90414429,\n -34.49435425, -38.438797, -42.27981567, -45.99230957,\n -49.75340271, -53.58230591, -57.30686951, -60.76026917,\n -63.92070007, -66.72470093, -68.97846985, -70.4264679,\n -71.16407776, -71.53797913, -71.64375305, -71.52735901,\n -71.53523254, -71.61097717, -71.92687988, -72.68682861,\n -74.129776, -76.02471924, -76.88977051, -76.26008606,\n -75.90351868, -76.15809631]) * units.celsius\n dewpoints = np.array([4.50012302, 3.42483997, 2.78102994, 2.24474645, 1.593485, -0.9440815,\n -3.8044982, -3.55629468, -9.7376976, -10.2950449, -9.67498302,\n -10.30486488, -8.70559597, -8.71669006, -12.66509628, -18.6697197,\n -23.00351334, -29.46240425, -36.82178497, -41.68824768, -44.50320816,\n -48.54426575, -52.50753403, -51.09564209, -48.92690659, -49.97380829,\n -51.57516098, -52.62096405, -54.24332809, -57.09109879, -60.5596199,\n -63.93486404, -67.07530212, -70.01263428, -72.9258728, -76.12271881,\n -79.49847412, -82.2350769, -83.91127014, -84.95665741, -85.61238861,\n -86.16391754, -86.7653656, -87.34436035, -87.87495422, -88.34281921,\n -88.74453735, -89.04680634, -89.26436615]) * units.celsius\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof, td_mixed)\n assert_almost_equal(lfc_pressure, 962.34 * units.mbar, 2)\n assert_almost_equal(lfc_temp, 0.767 * units.degC, 2)","def Log2T(X):\n data_headers = X.select_dtypes(include=[\"float64\"]).columns\n X[data_headers] = np.log2(X[data_headers])\n return X","def statePosteriors(log_alpha, log_beta):\n N = log_alpha.shape[0]\n M = log_alpha.shape[1]\n log_gamma = np.zeros((N, M))\n for n in range(N):\n log_gamma[n, :] = log_alpha[n, :] + log_beta[n, :] - logsumexp(log_alpha[N-1, :])\n\n return log_gamma","def loglweave(store):\n code = \"\"\"\n double sum = 0.0, xbeta;\n for(int i=0; i<nobs; i++){\n xbeta = 0.0;\n for(int j=0; j<kreg; j++){\n xbeta += xmat(i,j) * beta(j);\n }\n sum += yvec(i) * xbeta - exp(xbeta);\n }\n return_val = sum;\n \"\"\"\n yvec = store['yvec']\n xmat = store['xmat']\n nobs, kreg = xmat.shape\n beta = store['beta']\n val = weave.inline(code,['yvec','xmat', 'beta','nobs','kreg'],\n compiler='gcc',\n type_converters=converters.blitz\n )\n return val","def log_filter(stack, sigma):\n stack_cp = stack.astype(np.int16)\n gauss = ndi.filters.gaussian_filter(stack_cp, sigma=sigma)\n log = ndi.filters.laplace(gauss)\n return log","def beinflumat(x_axis, y_axis, e_eff):\n len_x = len(x_axis)\n len_y = len(y_axis)\n influence_matrix_complete = np.zeros((len_x, len_y, len_x, len_y))\n\n # generate coordinate grids\n a_factor = (x_axis[-1] - x_axis[0]) / (len_x - 1) / 2\n b_factor = (y_axis[-1] - y_axis[0]) / (len_y - 1) / 2\n x_grid = __beinflumatgrid(x_axis)\n y_grid = __beinflumatgrid(y_axis)\n\n # use numexpr to evaluate expressions\n xpa = ne.evaluate('x_grid + a_factor')\n xma = ne.evaluate('x_grid - a_factor')\n ypb = ne.evaluate('y_grid + b_factor')\n ymb = ne.evaluate('y_grid - b_factor')\n\n # calculate complete influence matrix\n for j in range(0, len_y):\n for j_prime in range(0, len_y):\n influence_matrix_complete[:, j, :, j_prime] = \\\n (np.multiply(xpa, np.log(\n np.divide(\n ((ypb[j, j_prime]) +\n np.sqrt(np.multiply((ypb[j, j_prime]),\n (ypb[j, j_prime])) +\n np.multiply(xpa, xpa))),\n ((ymb[j, j_prime]) +\n np.sqrt(np.multiply((ymb[j, j_prime]),\n (ymb[j, j_prime])) +\n np.multiply(xpa, xpa)))))) +\n (ypb[j, j_prime]) * np.log(\n np.divide(\n (xpa +\n np.sqrt(np.multiply((ypb[j, j_prime]),\n (ypb[j, j_prime])) +\n np.multiply(xpa, xpa))),\n (xma +\n np.sqrt(np.multiply((ypb[j, j_prime]),\n (ypb[j, j_prime])) +\n np.multiply(xma, xma))))) +\n np.multiply(xma, np.log(\n np.divide(\n ((ymb[j, j_prime]) +\n np.sqrt(np.multiply((ymb[j, j_prime]),\n (ymb[j, j_prime])) +\n np.multiply(xma, xma))),\n ((ypb[j, j_prime]) +\n np.sqrt(np.multiply((ypb[j, j_prime]),\n (ypb[j, j_prime])) +\n np.multiply(xma, xma)))))) +\n (ymb[j, j_prime]) * np.log(\n np.divide(\n (xma +\n np.sqrt(np.multiply((ymb[j, j_prime]),\n (ymb[j, j_prime])) +\n np.multiply(xma, xma))),\n (xpa +\n np.sqrt(np.multiply((ymb[j, j_prime]),\n (ymb[j, j_prime])) +\n np.multiply(xpa, xpa))))))\n\n return influence_matrix_complete * 1 / e_eff * 2 / pi","def coefs(logger, model, data=clean_data, target=target):\n\n df = pd.read_csv(data)\n X = df.drop(columns=target)\n coef_df = pd.DataFrame({'Variable': X.columns, 'Coefficient': model.coef_[0]})\\\n .sort_values(by='Coefficient')\n\n coef_path = data_config['outputs']['logreg_coefs']\n coef_df.to_csv(coef_path, index=False)\n print(f'Coefficients saved to {coef_path}')\n\n return","def front_column_model_p_gain():","def information_gain(features, attribute_index, targets):\r\n\r\n possible_feature_values = [0,1]\r\n \r\n possible_classifications = [0,1]\r\n \r\n feature = features[:,attribute_index]\r\n \r\n \r\n number_of_samples = len(feature)\r\n \r\n import math\r\n \r\n \r\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\r\n \r\n terms_to_be_summed_for_current_entropy = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_elements_with_this_classification = len(targets[targets==classification])\r\n \r\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\r\n \r\n if p_for_this_classification != 0:\r\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\r\n else:\r\n terms_to_be_summed_for_current_entropy.append(0)\r\n \r\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n \r\n \r\n terms_to_be_summed_for_weighted_entropy = []\r\n \r\n for possible_value in possible_feature_values:\r\n \r\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\r\n \r\n if len(targets_split_by_feature_value) != 0:\r\n \r\n \r\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\r\n \r\n terms_for_entropy_within_subset = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\r\n \r\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\r\n \r\n if p_in_subset_for_this_classification != 0:\r\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\r\n else:\r\n terms_for_entropy_within_subset.append(0)\r\n \r\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\r\n \r\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\r\n \r\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\r\n \r\n \r\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\r\n\r\n information_gain = current_entropy - weighted_entropy \r\n \r\n return information_gain","def load(self, old_log):\n all_log = tflog2pandas(old_log)\n\n for _, row in all_log.iterrows():\n tag, value, step = row\n self.writer.add_scalar(tag,value,step)","def log_mae(labels, predictions):\n\n result = abs(labels - predictions)\n result = reduce_mean(result)\n result = log(result)\n\n return result","def calc_tf_log(doc):\r\n tf = calc_tf(doc)\r\n max_tf = tf[max(tf, key=tf.get)]\r\n tf_log = {}\r\n for key, val in tf.items():\r\n tf_log[key] = (1 + math.log(val)) / (1 + math.log(max_tf))\r\n return tf_log","def analyse_loglike(test_data, mods):\r\n l1 = list(map(lambda x: x + ' NB', mods.names))\r\n l1.extend(list(map(lambda x: x + ' ZI', mods.names)))\r\n l1.extend(list(map(lambda x: x + ' P', mods.names)))\r\n loglikeNB = np.array(mods.compute_log_likelihood(test_data, 'NB'))\r\n loglikeZI = np.array(mods.compute_log_likelihood(test_data, 'ZI'))\r\n loglikeP = np.array(mods.compute_log_likelihood(test_data, 'P'))\r\n # loglikeG = np.array(mods.compute_log_likelihood_gaussian(test_data))\r\n # loglikegeo = np.array(mods.compute_log_likelihood_geom(test_data))\r\n LL = np.zeros((loglikeNB.shape[0] * 3, loglikeNB.shape[1]))\r\n LL[:loglikeNB.shape[0], :] = loglikeNB\r\n LL[loglikeNB.shape[0]:2 * loglikeNB.shape[0], :] = loglikeZI\r\n LL[2 * loglikeNB.shape[0]:3 * loglikeNB.shape[0], :] = loglikeP\r\n # LL[3 * loglikeNB.shape[0]:4 * loglikeNB.shape[0], :] = loglikeG\r\n # LL[4 * llzi.shape[0]:, :] = np.array(mods.loglikegeo)\r\n print('mean per model', list(zip(np.ma.masked_invalid(LL).sum(axis=1), map(lambda x: x.mod.name, mods.models))))\r\n print('mean per distrib')\r\n print(np.ma.masked_invalid(LL[:loglikeNB.shape[0], :]).mean())\r\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0]:loglikeNB.shape[0] * 2, :]).mean())\r\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0] * 2:loglikeNB.shape[0] * 3, :]).mean())\r\n # print(np.nanmean(LL[1-np.isinf(LL)], axis=1))\r\n # print(np.nanmean(LL[LL != np.inf],axis=1))\r\n LL[np.isnan(LL)] = 0\r\n LL[np.isinf(LL)] = 0\r\n LL[LL == 0] = -np.inf\r\n r = np.argmax(LL, axis=0)\r\n # LL /= mx\r\n print('mean_best', np.mean(np.ma.masked_invalid(LL[r, range(LL.shape[1])])))\r\n mx = np.max(LL, axis=0)\r\n LL = LL / mx\r\n means = test_data.get_miniOD(None)[test_data.get_stations_col(None)].mean(axis=0).to_numpy()\r\n # for i in np.unique(r):\r\n # print(means[r == i].max())\r\n print('mean NB', means[r < loglikeNB.shape[0]].mean())\r\n print('mean ZI', means[(r < 2 * loglikeNB.shape[0]) * (r > loglikeNB.shape[0])].mean())\r\n print('mean poisson', means[(r < 3 * loglikeNB.shape[0]) * (r > 2 * loglikeNB.shape[0])].mean())\r\n # print('mean ga', means[(r < 4 * llzi.shape[0]) * (r > 3 * llzi.shape[0])].mean())\r\n # print('mean Gaussian', means[r > 3 * loglikeNB.shape[0]].mean())\r\n print('model name, mean trips per model, LL/maxLL, N inf')\r\n for i in range(LL.shape[0]):\r\n print(l1[i], means[r == i].mean(), np.mean(np.ma.masked_invalid(LL[i, :])), np.sum(np.isinf(LL[i, :])))\r\n print(np.ma.corrcoef(np.ma.masked_invalid(LL[i, :]), means[:LL.shape[1]])[1, 0])\r\n plt.hist(r, bins=np.arange(-0.5, 3 * len(mods.names) + 1, 1))\r\n\r\n # l1.extend(list(map(lambda x: x + ' geo', mods.names)))\r\n # l1.extend(list(map(lambda x: x + ' G', mods.names)))\r\n plt.xticks(range(len(l1)), l1, rotation='vertical')\r\n plt.show()\r\n\r\n for m in mods.loglike:\r\n print(m)\r\n print(m[np.logical_not(np.isinf(m))].mean())","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def loglloop(store):\n suml=0.0\n for i in xrange(store['yvec'].shape[0]):\n xbeta=dot(store['xmat'][i,:],store['beta'])\n suml=suml+store['yvec'][i] * xbeta - exp(xbeta)\n return suml","def compute_gradients(self, logits, target):\n\n target_length = target.shape[0]\n num_time_steps = logits.shape[0]\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n\n # expand labels by inserting a blank between each pair\n normalized_logits = softmax(logits)\n blank_label = normalized_logits.shape[1] - 1\n l = add_blanks(target, blank_label)\n target_length = l.shape[0]\n\n alpha = self.compute_forward_variables(normalized_logits, target) \n beta = self.compute_backward_variables(normalized_logits, target)\n\n # rescale\n alpha = alpha / np.sum(alpha, axis=0)\n beta = beta / np.sum(beta, axis=0)\n alphabeta = alpha * beta\n print \"alpha\"\n print alpha\n\n # compute zt\n z = Counter()\n for t in xrange(num_time_steps):\n for s, k in enumerate(l):\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\n \n # normalized_logits is time steps t by labels k\n # alpha is 2 * target_length - 1 by time steps\n lab_zk = np.zeros_like(normalized_logits)\n for s, k in enumerate(l):\n for t in xrange(num_time_steps):\n lab_zk[t, k] += alphabeta[s, t]\n\n grad = normalized_logits\n for k in xrange(target.shape[0]):\n for t in xrange(num_time_steps):\n ytk = normalized_logits[t, k]\n constant = 1.0 / (ytk * z[t])\n grad[t, k] = ytk - constant * lab_zk[t, k]\n \n return grad","def extrapolate_fwds(h, ufr, llfr, alpha=0.10):\n fwd_fsp_fsp_plus_h = np.log(1 + ufr) + (llfr - np.log(1 + ufr)) * big_b(h, alpha)\n return fwd_fsp_fsp_plus_h","def logits_on_features(self, h, batch):\n batch = batch.to(h.device)\n # Extract features with the model\n features = h.view(batch.size, -1)\n # Log loss\n logits = self.head(features)\n return logits","def compute_loglike(self, tools: ModelingTools) -> float:\n return -1.5","def estimate_logreg(x,y,N_its,learning_rate=1e-4,regularizer=1e-2,lazy_reg=True):\n weights = defaultdict(float)\n weight_hist = [] #keep a history of the weights after each iteration\n all_labels = set(y)\n \n # this block is for lazy regularization\n ratereg = learning_rate * regularizer\n def regularize(base_feats):\n for base_feat in base_feats:\n for label in all_labels:\n #print \"regularizing\",(label,base_feat),t,last_update[base_feat],(1. - ratereg) ** (t-last_update[base_feat])\n weights[(label,base_feat)] *= (1. - ratereg) ** (t-last_update[base_feat])\n last_update[base_feat] = t\n\n t = 0\n last_update = defaultdict(int)\n\n eeta = learning_rate\n\n for it in xrange(N_its):\n\n for i,(x_i,y_i) in enumerate(zip(x,y)): #keep\n t += 1\n\n # regularization\n if lazy_reg: # lazy regularization is essential for speed\n regularize(x_i) # only regularize features in this instance\n if not lazy_reg: # for testing/explanatory purposes only\n for feat,weight in weights.iteritems():\n if feat[1] is not OFFSET: # usually don't regularize offset\n weights[feat] -= ratereg * weight\n\n p_y = compute_py(x_i,weights,all_labels) #hint\n\n term2 = make_feature_vector(x_i, y_i)\n\n for key in term2.keys():\n weights[key] = weights[key] + (term2[key]*eeta)\n\n for label in all_labels:\n temp = make_feature_vector(x_i, label)\n for key in temp.keys():\n weights[key] = weights[key] - (temp[key]*eeta*p_y[label])\n\n\n print it,\n weight_hist.append(weights.copy()) \n\n # if lazy, let regularizer catch up\n if lazy_reg:\n # iterate over base features\n regularize(list(set([f[1] for f in weights.keys() if f[1] is not OFFSET])))\n\n return weights,weight_hist","def log_trans(data, test=False):\n logs = ['Administrative', 'Administrative_Duration', 'Informational',\n 'Informational_Duration', 'ProductRelated',\n 'ProductRelated_Duration', 'BounceRates', 'ExitRates',\n 'PageValues']\n if test:\n data_test = data.loc[data['Train'] == 0]\n data = data.loc[data['Train'] == 1]\n\n for col in logs:\n zero_val = float((min(i for i in list(data[col]) if i > 0))/2)\n data[col] = data[col].apply(lambda x: zero_val if x == 0 else x)\n data[col] = data[col].apply(lambda x: np.log(x))\n if test:\n data_test[col] = data_test[col].apply(lambda x:\n zero_val\n if x == 0 else x)\n data_test[col] = data_test[col].apply(lambda x: np.log(x))\n if test:\n data = pd.concat([data, data_test])\n return data","def logistic(weights, data, targets, hyperparameters):\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n df = np.reshape(df, ((len(df), 1)))\n\n return f, df, np.reshape(y, (len(y), 1))","def _backward(n_samples, n_components, log_startprob,\n log_transmat, framelogprob, mask):\n \n bwdlattice = torch.zeros_like(framelogprob)\n # last row is already zeros, so omit the zero setting step\n for t in range(n_samples - 2, -1, -1):\n for i in range(n_components):\n work_buffer = log_transmat[i,:] + framelogprob[:,t + 1, :] + bwdlattice[:,t+1, :]\n bwdlattice[:, t, i] = torch.logsumexp(work_buffer, dim=-1) * mask[:, t+1].type(framelogprob.dtype)\n return bwdlattice","def get_logits(image):\n x = image\n for filters in (32, 64):\n x = tf.layers.conv2d(x, filters, 3)\n x = tf.nn.relu(x)\n x = tf.layers.max_pooling2d(x, 3, 2)\n x = tf.reduce_mean(x, axis=(1, 2))\n logits = tf.layers.dense(x, 10)\n return logits","def log_likelihood(self, data, reward_model, bias_params):","def loglnumpy(store):\n xbeta = dot(store['xmat'], store['beta'])\n lamb = exp(xbeta)\n return sum(store['yvec'] * xbeta - lamb)","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def gradient_ascent(f, df, theta_init, step_size, max_iter):\n\n fs = []\n xs = []\n thetas = theta_init\n for i in range(max_iter): #for each data example\n fs.append(f(thetas))\n\n temp = step_size*df(thetas)\n thetas = step_size*df(thetas) #modify that feature by using the derivative of log likelihood\n xs.append(thetas.flatten())\n if i % 10 == 0:\n print(i, thetas)\n\n return thetas, fs, xs","def logm(self, x):\n\n if K.backend() == 'theano':\n # construct theano tensor operation\n from theano.tensor.nlinalg import svd, diag\n from theano.tensor.elemwise import Elemwise\n from theano.scalar import log\n import theano.tensor as T\n # This implementation would be extremely slow. but efficient?\n u, d, v = svd(x)\n d += self.eps\n inner = diag(T.log(d))\n res = T.dot(u, T.dot(inner, v))\n return res\n else:\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\n return batch_matrix_log(x, self.eps)","def calcfeat_delta_delta(signal, samplerate=16000, win_length=0.025, win_step=0.01, filters_num=26, NFFT=512,\n\t\t\t\t\t\t low_freq=0, high_freq=None, pre_emphasis_coeff=0.97, cep_lifter=22, appendEnergy=True,\n\t\t\t\t\t\t mode='mfcc', feature_len=13):\n\tfilters_num = 2 * feature_len\n\tfeat = calcMFCC(signal, samplerate, win_length, win_step, feature_len, filters_num, NFFT, low_freq, high_freq,\n\t\t\t\t\tpre_emphasis_coeff, cep_lifter, appendEnergy, mode=mode) # 首先获取13个一般MFCC系数\n\tfeat_delta = delta(feat)\n\tfeat_delta_delta = delta(feat_delta)\n\n\tresult = numpy.concatenate((feat, feat_delta, feat_delta_delta), axis=1)\n\treturn result","def _forward(n_samples, n_components, log_startprob,\n log_transmat, batch_framelogprob, mask):\n\n batch_size = batch_framelogprob.shape[0]\n fwdlattice = torch.zeros_like(batch_framelogprob)\n \n fwdlattice[:, 0, :] = log_startprob + batch_framelogprob[:,0, :]\n for t in range(1, n_samples):\n for j in range(n_components):\n work_buffer = fwdlattice[:, t-1, :] + log_transmat[:, j]\n # fwdlattice[:,t, j] = torch.logsumexp(work_buffer, dim=-1) + \\\n # framelogprob[:,t, j] \n \n fwdlattice[:,t, j] = torch.logsumexp(work_buffer, dim=-1) * \\\n mask[:, t].type(batch_framelogprob.dtype) + batch_framelogprob[:,t, j] \n\n # need to find the idx for last sample of each sequence by mask.sum(dim=-1)-1, fwdlattice[:, -1, :] would give the padded zeros\n batch_logprob = torch.logsumexp(fwdlattice[list(range(batch_size)), mask.sum(dim=-1)-1, :], dim=-1)\n return batch_logprob, fwdlattice","def M(f):\n return 1127 * numpy.log(1 + f/700.0)","def loglike(self, params):\n\n if type(params) is not MixedLMParams:\n params = MixedLMParams.from_packed(params, self.k_fe,\n self.use_sqrt)\n\n fe_params = params.get_fe_params()\n cov_re = params.get_cov_re()\n try:\n cov_re_inv = np.linalg.inv(cov_re)\n except np.linalg.LinAlgError:\n cov_re_inv = None\n _, cov_re_logdet = np.linalg.slogdet(cov_re)\n\n # The residuals\n expval = np.dot(self.exog, fe_params)\n resid_all = self.endog - expval\n\n likeval = 0.\n\n # Handle the covariance penalty\n if self.cov_pen is not None:\n likeval -= self.cov_pen.func(cov_re, cov_re_inv)\n\n # Handle the fixed effects penalty\n if self.fe_pen is not None:\n likeval -= self.fe_pen.func(fe_params)\n\n xvx, qf = 0., 0.\n for k, lab in enumerate(self.group_labels):\n\n exog = self.exog_li[k]\n ex_r = self.exog_re_li[k]\n ex2_r = self.exog_re2_li[k]\n resid = resid_all[self.row_indices[lab]]\n\n # Part 1 of the log likelihood (for both ML and REML)\n ld = _smw_logdet(1., ex_r, ex2_r, cov_re, cov_re_inv,\n cov_re_logdet)\n likeval -= ld / 2.\n\n # Part 2 of the log likelihood (for both ML and REML)\n u = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv, resid)\n qf += np.dot(resid, u)\n\n # Adjustment for REML\n if self.reml:\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\n exog)\n xvx += np.dot(exog.T, mat)\n\n if self.reml:\n likeval -= (self.n_totobs - self.k_fe) * np.log(qf) / 2.\n _,ld = np.linalg.slogdet(xvx)\n likeval -= ld / 2.\n likeval -= (self.n_totobs - self.k_fe) * np.log(2 * np.pi) / 2.\n likeval += ((self.n_totobs - self.k_fe) *\n np.log(self.n_totobs - self.k_fe) / 2.)\n likeval -= (self.n_totobs - self.k_fe) / 2.\n else:\n likeval -= self.n_totobs * np.log(qf) / 2.\n likeval -= self.n_totobs * np.log(2 * np.pi) / 2.\n likeval += self.n_totobs * np.log(self.n_totobs) / 2.\n likeval -= self.n_totobs / 2.\n\n return likeval","def f_log_encoding(x, in_reflection=False):\n a = 0.555556\n b = 0.009468\n c = 0.344676\n d = 0.790453\n e = 8.735631\n f = 0.092864\n cut1 = 0.00089\n\n if not in_reflection:\n x = x * 0.9\n\n y = np.where(x < cut1,\n e * x + f,\n c * np.log10(a * x + b) + d)\n\n return y","def log_det_Jxz(self):\n #return self.log_det_xz.output\n log_det_Jxzs = []\n for l in self.layers:\n if hasattr(l, 'log_det_Jxz'):\n log_det_Jxzs.append(l.log_det_Jxz)\n if len(log_det_Jxzs) == 0:\n return tf.ones((self.output_z.shape[0],))\n if len(log_det_Jxzs) == 1:\n return log_det_Jxzs[0]\n return tf.reduce_sum(log_det_Jxzs, axis=0, keepdims=False)","def test_l2_metric_log_vectorization(\n self, l2_metric_s2, times, landmarks_a, landmarks_b, landmarks_c\n ):\n landmarks_ab = l2_metric_s2.geodesic(landmarks_a, landmarks_b)\n landmarks_bc = l2_metric_s2.geodesic(landmarks_b, landmarks_c)\n landmarks_ab = landmarks_ab(times)\n landmarks_bc = landmarks_bc(times)\n\n tangent_vecs = l2_metric_s2.log(point=landmarks_bc, base_point=landmarks_ab)\n\n result = tangent_vecs\n self.assertAllClose(gs.shape(result), gs.shape(landmarks_ab))","def kullbackLeibler(mu, log_sigma):\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)","def log_shift(data):\n result = [np.log(1 + np.abs(d.copy())) for d in data]\n return result","def log_boltzmann_dist(Q, temperature):\n return nn.LogSoftmax(dim=0)(Q/temperature)","def removeFactors(self,flist, isLog=False):\n # Currently: just divide out factors (add inverse factors) -- can't check if factor present? (minimal)\n # TODO: set entries to zero, then call self.L.eliminate_zeros()\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\n for k,f in enumerate(flist):\n if not isLog: \n if np.any(f.t==0): f = f+1e-30; # TODO: log nonzero tol\n f = f.log()\n if f.nvar == 1:\n Xi = f.vars[0]\n self.h[Xi] -= .5*(f[1]-f[0])\n self.c -= .5*(f[1]+f[0])\n else:\n Xi,Xj = f.vars[0],f.vars[1]\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n self.h[Xi] -= .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.h[Xj] -= .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.c -= .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\n self.L -= csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar)); \n #raise NotImplementedError();","def started_log(X,params):\n \n offset = params['offset']\n if not is_number(params['offset']):\n offset=1.\n X = np.log(X+offset)\n return X","def binlogreg_train(X, Y_):\n N = X.shape[0]\n\n w = np.random.randn(X.shape[1], 1) # D x 1\n b = np.random.randn(N, 1) # N x 1\n\n for i in range(PARAM_NITER+1):\n # klasifikacijski rezultati\n scores = np.dot(X, w) + b # N x 1\n\n # vjerojatnosti razreda c_1\n probs = sigmoid(scores, y=1) # N x 1\n\n # gubitak\n loss = -1 * float(np.dot(Y_.T, np.log(probs))) # scalar\n\n # dijagnostički ispis\n if i % 10 == 0:\n print(\"iteration {}: loss {}\".format(i, loss))\n\n # if i % 1000 == 0:\n # Y = np.around(probs, decimals=0)\n # decfun = binlogreg_decfun(w, b)\n # bbox = (np.min(X, axis=0), np.max(X, axis=0))\n # data.graph_surface(decfun, bbox, offset=0.5)\n # data.graph_data(X, Y_, Y)\n\n # derivacije gubitka po klasifikacijskom rezultatu\n dL_dscores = np.subtract(probs, Y_) # N x 1\n\n # gradijenti parametara\n grad_w = np.divide(np.dot(X.T, dL_dscores), N) # D x 1\n grad_b = np.divide(np.sum(dL_dscores), N) # 1 x 1\n\n # poboljšani parametri\n w += -PARAM_DELTA * grad_w\n b += -PARAM_DELTA * grad_b\n\n return w, b","def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def _object_func_marginals_coarse_log(log_params, *args, **kwargs):\n return _object_func_marginals_coarse(numpy.exp(log_params), *args, **kwargs)","def ComputeLogGradientTerm(self, *args):\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogGradientTerm(self, *args)","def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self._LL(self.endog, rate=lambda_)\n\n return -np.log(ll_output)"],"string":"[\n \"def logMelSpectrum(input, samplingrate):\\n nfft = input.shape[1]\\n N = input.shape[0]\\n filters = trfbank(samplingrate, nfft)\\n\\n # plot Mel filters\\n # plt.plot(filters)\\n # plt.title('Mel filters')\\n # plt.show()\\n\\n output = np.zeros((N, filters.shape[0]))\\n for j in range(filters.shape[0]): # apply each filterbank to the whole power spectrum\\n for i in range(N):\\n output[i, j] = np.log(np.sum(input[i] * filters[j]))\\n\\n # myplot(output, 'Filter Banks')\\n\\n return output\",\n \"def statePosteriors(log_alpha, log_beta):\\n return log_alpha + log_beta - logsumexp(log_alpha[-1,:])\",\n \"def log2FC_data(data):\\n log2FC_df = pd.DataFrame()\\n for i in range(0,len(data.columns),10):\\n i = i\\n data_subset = data[data.columns[i:i+10]]\\n log_data = data_subset.apply(np.log2)\\n \\n new_df = pd.DataFrame()\\n for j in range(len(log_data.columns)):\\n tmp_col = log_data.iloc[:, j].name\\n tmp_df = log_data.iloc[:,0] - log_data.iloc[:,j]\\n new_df[tmp_col] = tmp_df\\n \\n log2FC_df = log2FC_df.append(new_df.T)\\n log2FC_df = log2FC_df.T\\n return log2FC_df\",\n \"def statePosteriors(log_alpha, log_beta):\",\n \"def extract_features(self, np_samples):\\n log_mel_examples = []\\n samples = np_samples.shape[0]\\n if self._normalize:\\n min_ratio = 0.1 # = 10^(max_db/-20) with max_db = 20\\n np_samples /= np.maximum(min_ratio, np.amax(np_samples))\\n if self._step_size is not None:\\n samples_splits = []\\n for i in xrange(0, samples - vggish_params.SAMPLE_RATE + 1,\\n self._step_size):\\n samples_splits.append(np_samples[i:i + vggish_params.SAMPLE_RATE])\\n else:\\n samples_splits = np.split(np_samples, samples / vggish_params.SAMPLE_RATE)\\n # Compute log mel spectrogram features.\\n for samples_window in samples_splits:\\n log_mel = mel_features.log_mel_spectrogram(\\n samples_window,\\n audio_sample_rate=vggish_params.SAMPLE_RATE,\\n log_offset=vggish_params.LOG_OFFSET,\\n window_length_secs=vggish_params.STFT_WINDOW_LENGTH_SECONDS,\\n hop_length_secs=vggish_params.STFT_HOP_LENGTH_SECONDS,\\n num_mel_bins=vggish_params.NUM_MEL_BINS,\\n lower_edge_hertz=vggish_params.MEL_MIN_HZ,\\n upper_edge_hertz=vggish_params.MEL_MAX_HZ)\\n\\n log_mel_examples.append(\\n mel_features.frame(\\n log_mel,\\n window_length=self._example_window_length,\\n hop_length=self._example_window_length))\\n return log_mel_examples\",\n \"def test_loglike(dlm,Cl,noise,beam):\\n lmax = Cl.shape[0]\\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\\n #plt.plot(Cl[:,1])\\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \\n tt_f = tt_exp + tt_det\\n return tt_exp,tt_det,tt_f#,Cl[:,1]\",\n \"def log_distr_fdmw(self, dnu, logflux, dme, logw, alpha, logls, logl0, mu, sigma, gtype=None):\\n #stepdms = 100/1000.\\n #vdms = np.arange(0, 100, stepdm)\\n stepz = (np.log(self.Zmax) - np.log(self.Zmin)) / 1000\\n vz = np.exp(np.arange(np.log(self.Zmin), np.log(self.Zmax), stepz))\\n lik = 0\\n for z in vz:\\n likv = np.exp(self.log_distr_fdmwz(dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=gtype))\\n lik += z * stepz * likv\\n ind = lik > 0\\n ind2 = lik <= 0\\n loglik = lik.copy()\\n loglik[ind] = np.log(lik[ind])\\n loglik[ind2] = np.ones(loglik[ind2].shape) * -1e99\\n return loglik\",\n \"def _log_fold_change_pairs(self, idx0, idx1, base):\\n logfc = np.zeros(shape=(len(idx0), len(idx1), self._theta_mle.shape[1]))\\n for i, xi in enumerate(idx0):\\n for j, xj in enumerate(idx1):\\n logfc[i, j, :] = self._theta_mle[xi, :] - self._theta_mle[xj, :]\\n\\n if base == np.e:\\n return logfc\\n else:\\n return logfc / np.log(base)\",\n \"def compute_edge_logits(self):\",\n \"def _log_fold_change_pairs(self, idx0, idx1, base):\\n logfc = np.tile(np.NaN, [len(idx0), len(idx1), self.model_estim.x.shape[1]])\\n for i, xi in enumerate(idx0):\\n for j, xj in enumerate(idx1):\\n logfc[i, j, :] = self._theta_mle[xj, :] - self._theta_mle[xi, :]\\n logfc[j, i, :] = -logfc[i, j, :]\\n\\n if base == np.e:\\n return logfc\\n else:\\n return logfc / np.log(base)\",\n \"def logfbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\\n nfilt=40,nfft=512,lowfreq=64,highfreq=None,dither=1.0,remove_dc_offset=True,preemph=0.97,wintype='hamming'):\\n feat,energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,dither, remove_dc_offset,preemph,wintype)\\n return numpy.log(feat)\",\n \"def logits(self, features: torch.Tensor) -> torch.Tensor:\\n return self.temporal_module(features)\",\n \"def logMelSpectrum(input, samplingrate):\\n nfft = input.shape[1]\\n tr_filter = trfbank(samplingrate, nfft)\\n return np.log(np.dot(input, tr_filter.transpose()))\",\n \"def log_prior_grad(self, inputs):\",\n \"def get_logCRF(train, model):\\n word = train[0]\\n Y = train[1]\\n char_count, _ = word.shape\\n # calculating forward messages\\n alpha = np.zeros((char_count, model.dimY))\\n first_term = np.dot(word, model.getW(model.labels))\\n second_term = model._T\\n for i in range(1, char_count):\\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \\n # getting logZ from messages\\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\\\sum_{j=1}^m {W_{yj} . x_j}$\\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\\n value = -logZ + w_term + t_term\\n return value\",\n \"def loglf2py(store):\\n loglike=0.0\\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)\",\n \"def logfbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97): \\n feat, energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,preemph)\\n return pylab.log(feat)\",\n \"def logistic_derivative(errors):\\n return [log_deriv(error) for error in errors]\",\n \"def log(self): # just use base?\\n return Factor().__build( VarSet(self.v) , np.log(self.t) )\",\n \"def log2(self):\\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )\",\n \"def log_fbank(signal, samplerate=16000, win_length=0.025, win_step=0.01, filters_num=26, NFFT=512, low_freq=0,\\n\\t\\t\\t high_freq=None, pre_emphasis_coeff=0.97):\\n\\tfeat, energy = fbank(signal, samplerate, win_length, win_step, filters_num, NFFT, low_freq, high_freq,\\n\\t\\t\\t\\t\\t\\t pre_emphasis_coeff)\\n\\treturn numpy.log(feat)\",\n \"def fdm(self,trc,fd_step,lags,noise_scalar):\\n ress=[]\\n trc_out=trc/np.amax(np.abs(trc))\\n noise=np.random.normal(0,1,len(trc_out))*(np.std(trc_out)/noise_scalar)\\n trc_out=trc_out+noise\\n for i,lag in enumerate(lags):\\n trc_cp=trc_out.copy()\\n t=len(trc)-1\\n trc_cp[0:fd_step]=0\\n while t>fd_step-1:\\n trc_win=trc_out[t-fd_step:t+1]\\n t_win=fd_step-1\\n res=0\\n while t_win>lag-1:\\n res+=np.square(trc_win[t_win-lag]-trc_win[t_win])\\n t_win-=1\\n res=np.log10(1/(fd_step-lag)*res)\\n trc_cp[t]=res\\n t-=1\\n if len(ress)==0:\\n ress=np.reshape(trc_cp,(len(trc_cp),1))\\n else:\\n ress=np.concatenate((ress,np.reshape(trc_cp,(len(trc_cp),1))),axis=1)\\n for i,j in enumerate(ress):\\n slope = linregress(lags,ress[i,:])[0]\\n trc_out[i]=slope\\n \\n return trc_out\",\n \"def log_forward_computations(self, x: list): \\n n_x = len(x)\\n \\n # log_f_x initialized to -Inf because log(0) = -Inf\\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\\n \\n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\\n \\n for i in range(1,n_x):\\n for s in range(self.n_states):\\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \\n log_f_x[:,i-1]) + x_emission_scores[s, i]\\n\\n \\n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\\n \\n return log_f_x, log_likelihood\",\n \"def log_distr_fdmwz(self, dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=None):\\n flux = np.power(10., logflux)\\n logl = np.log10(self.cos.Luminosity(z, f=flux, dnu=dnu))\\n logint1 = self.log_IntBeam(logl, alpha, logls, logl0)\\n #print logint1\\n logw0 = logw - np.log10(1+z)\\n logfw = self.log_dis_logw(logw0, mu, sigma)\\n logfz = self.log_Distribution_volume(z)\\n dmi = self.cos.DispersionMeasure_IGM(z)\\n u1 = (dme-dmi)*(1+z)*self.kappa(z)\\n u2 = ((dme-dmi)*(1+z)-self.DMsmax)*self.kappa(z)\\n #print u2\\n logint2 = np.ones(u2.shape) * (-1e99)\\n ind = u2 > 0\\n logint2[ind] = self.log_IntDMsrc(u1[ind],u2[ind],gtype=gtype)\\n #print logint2\\n loglikv = logint1 + logfz + logfw + logint2 + np.log(1+z)\\n return loglikv\",\n \"def loglike(store):\\n nobs = store['yvec'].shape[0]\\n calcweighted(store)\\n store['regsampler'].update_yvec(store['yvectil'])\\n store['regsampler'].update_xmat(store['xmattil'])\\n return store['regsampler'].loglike(store['sigma'], store['beta'])\",\n \"def addFactors(self, flist, copy=True, isLog=False):\\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\\n for k,f in enumerate(flist):\\n if not isLog: \\n if np.any(f.t<=0): f = f+1e-10; # TODO: log nonzero tol\\n f = f.log()\\n if f.nvar == 1:\\n Xi = f.vars[0]\\n self.h[Xi] += .5*(f[1]-f[0])\\n self.c += .5*(f[1]+f[0])\\n else:\\n Xi,Xj = f.vars[0],f.vars[1]\\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \\n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n self.h[Xi] += .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.h[Xj] += .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.c += .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\\n self.L += csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar));\",\n \"def logmelfilterbank(\\n audio,\\n sampling_rate,\\n fft_size=1024,\\n hop_size=256,\\n win_length=None,\\n window=\\\"hann\\\",\\n num_mels=80,\\n fmin=None,\\n fmax=None,\\n eps=1e-10,\\n):\\n # # get amplitude spectrogram\\n # x_stft = librosa.stft(audio, n_fft=fft_size, hop_length=hop_size,\\n # win_length=win_length, window=window, pad_mode=\\\"reflect\\\")\\n # spc = np.abs(x_stft).T # (#frames, #bins)\\n\\n # # get mel basis\\n # fmin = 0 if fmin is None else fmin\\n # fmax = sampling_rate / 2 if fmax is None else fmax\\n # mel_basis = librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax)\\n\\n # return np.log10(np.maximum(eps, np.dot(spc, mel_basis.T)))\\n # logger.info('{} {}'.format(audio.shape, audio.device))\\n x_stft2 = (\\n torch.stft(\\n audio,\\n n_fft=fft_size,\\n hop_length=hop_size,\\n win_length=win_length,\\n window=window,\\n pad_mode=\\\"reflect\\\",\\n ).transpose(0, 1)\\n ** 2\\n )\\n # logger.info('{} {}'.format(x_stft2.shape, x_stft2.device))\\n spc = (x_stft2[:, :, 0] + x_stft2[:, :, 1]).sqrt()\\n\\n # get mel basis\\n fmin = 0 if fmin is None else fmin\\n fmax = sampling_rate / 2 if fmax is None else fmax\\n mel_basis = torch.tensor(\\n librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax),\\n device=spc.device,\\n ).transpose(0, 1)\\n return torch.matmul(spc, mel_basis).clamp(min=eps).log10()\",\n \"def forward(log_emlik, log_startprob, log_transmat):\\n alpha = np.zeros(log_emlik.shape)\\n\\n alpha[0,:] = log_startprob[0:-1] + log_emlik[0,:]\\n\\n sum_row = 0;\\n log_transmat = log_transmat[0:-1];\\n\\n\\n for frame in range(1,len(log_emlik)):\\n\\n for state in range(0,len(log_emlik[0])):\\n\\n alpha[frame,state] = logsumexp(alpha[frame-1,:] + log_transmat[:,state]) + log_emlik[frame,state]\\n #print(alpha[frame,state])\\n #print(alpha[frame,:])\\n\\n return alpha\",\n \"def statePosteriors(log_alpha, log_beta):\\n\\n gamma = np.zeros(log_alpha.shape)\\n\\n gamma = log_alpha + log_beta\\n\\n gamma = gamma - logsumexp(log_alpha[-1,:])\\n\\n return gamma\",\n \"def get_weights_from_log(log, plot = False):\\n with open(log, 'r') as f:\\n log_file = f.readlines()\\n\\n i = 0\\n time = []\\n weights_info = []\\n weights_0 = []\\n while i < len(log_file):\\n if 'init-lambda-weights[' in log_file[i]:\\n weights_0.append(float(log_file[i].split('=')[-1]))\\n\\n if 'MC-lambda information' in log_file[i]:\\n # Finding the time\\n for j in range(i,0,-1):\\n if log_file[j].startswith(' Step Time'):\\n j += 1\\n time.append(float(log_file[j].split()[-1]))\\n break\\n # Finding the weight\\n weights_info_tmp = []\\n i += 3\\n while log_file[i] != '\\\\n':\\n split = log_file[i].split()\\n count = int(split[2])\\n weight = float(split[3])\\n weights_info_tmp.append((count, weight))\\n i += 1\\n weights_info.append(weights_info_tmp)\\n i += 1\\n # Add weights at t = 0, because the counts are all 0 and I delate the entrances with total count 0 in next lines,\\n # What i could do is put 1 in the initial temperature\\n time.insert(0,0)\\n weights_info.insert(0,list(zip([1] + (len(weights_0) - 1)*[0], weights_0)))\\n\\n #Converting to array\\n time = np.array(time)\\n weights_info = np.array(weights_info)\\n # Some times (I don't know why) GROMACS reset all the weights and all the counts are 0. We need to eliminate those points\\n sum_of_weights = weights_info[:,:,0].sum(axis = 1)\\n time = time[sum_of_weights != 0]\\n weights_info = weights_info[sum_of_weights != 0]\\n sum_of_weights = sum_of_weights[sum_of_weights != 0]\\n\\n\\n if plot:\\n dir = os.path.dirname(log)\\n fig, axes = plt.subplots(2, figsize = (16,9), sharex=True)\\n NUM_COLORS = weights_info.shape[1]\\n cm = plt.get_cmap('viridis')#gist_rainbow viridis\\n for axe in axes:\\n axe.set_prop_cycle('color', [cm(1.*j/NUM_COLORS) for j in range(NUM_COLORS)])\\n\\n probability = weights_info[:,:,0] / sum_of_weights[:,np.newaxis]\\n for j in range(weights_info.shape[1]):\\n #axes[0].plot(time, weights_info[:,j,0], label = str(j))\\n axes[0].plot(time, probability[:,j], label = str(j))\\n axes[1].plot(time, weights_info[:,j,1])\\n\\n fig.legend(loc = 'lower center', ncol = int(weights_info.shape[1] / 2))\\n axes[0].set(\\n xlim = (time.min(), time.max()),\\n ylim = (0,1),\\n ylabel = 'Probability',\\n )\\n axes[1].set(\\n xlabel = 'Time [ps]',\\n ylabel = 'Weight values'\\n )\\n #plt.show()\\n fig.savefig(os.path.join(dir,'weights_progression.svg'), bbox_inches=\\\"tight\\\")\\n\\n # Plotting the violin plot of the weights\\n df = pd.DataFrame()\\n for j in range(weights_info.shape[1]):\\n #df[temperatures[j]] = weights_info[:,j,1]\\n df[j] = weights_info[:,j,1]\\n # Set up the matplotlib figure\\n sns.set_theme(style=\\\"whitegrid\\\")\\n fig, ax = plt.subplots(figsize=(25, 25))\\n\\n # Draw a violinplot with a narrower bandwidth than the default\\n sns.violinplot(data=df, palette=\\\"Set3\\\", bw=.2, cut=1, linewidth=1)\\n # The plot is not over the actual temperatures, the temperatures ara only labels\\n ax.plot(range(len(weights_info[0,:,1])), weights_info[0,:,1], '-o', label = 'Initial weights')\\n ax.set(\\n title = 'Weights per state over the entire simulation',\\n xlabel = 'Sate',\\n ylabel = 'Weight',\\n )\\n plt.legend()\\n sns.despine(left=True, bottom=True)\\n #plt.show()\\n fig.savefig(os.path.join(dir,'weights_per_state.svg'), bbox_inches=\\\"tight\\\")\\n sns.reset_defaults()\\n\\n return time, weights_info\",\n \"def log_features(data, columns):\\n for col in columns:\\n # deal with 0/1 values\\n if np.sum(data[col] == 0) > 0:\\n print('Replacing 0s with 0.025...')\\n data.loc[data[col] == 0, col] = 0.025\\n\\n data[col] = np.log(data[col])\",\n \"def forward(self, reps):\\n assert reps.shape[-1] == N_DIMS_PER_REP\\n logits = torch.zeros(len(reps), N_UNIQUE_FEATS)\\n logits[:, feat] = 1\\n return logits\",\n \"def og_features(scan,filt=None,base_noise=None,thresh=-1.4781e-10,diff=1,verbose=False,scale=10):\\n #get gradients of data\\n der = np.array(np.gradient(scan,diff))\\n \\n #calculate gardient magnitudes and directions\\n der_mag = np.linalg.norm(der,axis=0) \\n der_uvecs = der/der_mag\\n \\n z_cur = np.copy(scan).ravel()\\n\\n #estimate noise level and set derivative filter threshold\\n if filt is None:\\n filt = np.mean(signaltonoise(der_mag)[-1])\\n \\n \\n if base_noise is not None:\\n filt = np.maximum(filt,base_noise)\\n \\n\\n\\n #filter directions and magnitudes\\n x, y, z = der_uvecs[0].ravel(), der_uvecs[1].ravel(), der_mag.ravel()\\n \\n #filter using threshold and filt\\n x_filt, y_filt, z_filt = x[z_cur>thresh], y[z_cur>thresh], z[z_cur>thresh]\\n #x_filt, y_filt, z_filt = x, y, z\\n\\n \\n #print(len(z_filt))\\n x_filt, y_filt, z_filt = x_filt[z_filt>filt], y_filt[z_filt>filt], z_filt[z_filt>filt]\\n\\n \\n #calculate angles\\n angles_filt = np.sign(y_filt)*np.arccos(x_filt/1)\\n\\n \\n #print(len(angles_filt))\\n \\n if len(angles_filt) < 2:\\n return 0,0,0\\n \\n #fit single line\\n sol1 = least_squares(ress_1line,[-np.pi/2],args=(angles_filt,),bounds=[-np.pi,0],method='dogbox',jac='2-point',max_nfev=2000)\\n\\n #fit two lines by grid search\\n #sol_grid = grid_search(ress_2line,angles_filt,[[-np.pi,0],[-np.pi,0]])\\n \\n \\n singleline = sol1.x[0]\\n \\n mx = np.minimum(np.abs(singleline-(-np.pi)),np.abs(singleline))\\n \\n sol_grid = grid_search(ress_2line_pm,angles_filt,[[0,mx]],umid = singleline)\\n spread_lines = sol_grid[1]\\n sol_grid[1] = [singleline+spread_lines,singleline-spread_lines]\\n \\n \\n #compute average of squared residuals for both cases\\n resid1 = ress_1line(sol1.x,angles_filt)\\n\\n grid_c11 = np.average(np.power(resid1,2))\\n \\n grid_c11 = np.average(np.abs(resid1))\\n \\n grid_c21 = sol_grid[-1]\\n \\n \\n multip = cotunnel_score2(scan,scan>thresh,diff,scale)\\n \\n final_grid2 = multip*(grid_c11-grid_c21)\\n \\n \\n \\\"\\\"\\\"\\n plt.scatter(angles_filt,z_filt,marker='x',c='k',s=15,linewidth=0.4)\\n plt.axvline(sol1.x,color='b')\\n plt.axvline(sol1.x+(np.pi),color='b')\\n plt.axvline(sol_grid[1][0],0,color='r', linestyle='--')\\n plt.axvline(sol_grid[1][1],0,color='r', linestyle='--')\\n \\n plt.axvline(sol_grid[1][0]+(np.pi),0,color='r', linestyle='--')\\n plt.axvline(sol_grid[1][1]+(np.pi),0,color='r', linestyle='--')\\n \\n plt.xlabel(\\\"$\\\\\\\\theta_g$ / rad\\\")\\n \\n plt.xlim([-np.pi,np.pi])\\n plt.ylim([0,z.max()])\\n \\n \\n plt.ylabel(\\\"$|g|$\\\")\\n \\n plt.xticks([-np.pi,0,np.pi])\\n \\n plt.locator_params(axis='y', nbins=2)\\n \\n plt.savefig(\\\"og_fig.svg\\\")\\n \\n plt.show()\\n \\\"\\\"\\\"\\n return final_grid2,multip,(grid_c11-grid_c21)\",\n \"def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):\",\n \"def llf(self):\\n return self.model.loglike(self.params)\",\n \"def logistic(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def compute_forward_variables(self, normalized_logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = normalized_logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n \\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n # init\\n alpha = np.zeros((target_length, num_time_steps))\\n alpha[0, 0] = normalized_logits[0, blank_label] # where s = 0, t = 0\\n alpha[1, 0] = normalized_logits[0, target[0]] # where s = 1, t = 0\\n for i in xrange(2, num_time_steps): # for all s >= 2, t = 0\\n alpha[i, 0] = 0\\n\\n # recursive case\\n for t in xrange(1, num_time_steps):\\n for s in xrange(2, target_length):\\n \\n a_bar = alpha[s, t-1] + alpha[s-1, t-1] \\n\\n if l[s] == blank_label or l[s-2] == l[s]:\\n alpha[s, t] = normalized_logits[t, l[s]] * a_bar\\n else:\\n alpha[s, t] = normalized_logits[t, l[s]] * (a_bar + alpha[s-2, t-1])\\n return alpha\",\n \"def __convert_to_log(self):\\n for i in range(self.nStates):\\n if self.pi[i]>0:\\n self.pi[i]=log(self.pi[i])\\n else:\\n self.pi[i]=float('-inf')\\n for j in range(self.nStates):\\n if self.t[i][j]>0:\\n self.t[i][j]=log(self.t[i][j])\\n else:\\n self.t[i][j]=float('-inf')\\n for j in range(self.nObs):\\n if self.e[i][j]>0:\\n self.e[i][j]=log(self.e[i][j])\\n else:\\n self.e[i][j]=float('-inf')\\n self.logdomain=True\",\n \"def forward(log_emlik, log_startprob, log_transmat):\\n logPi=log_startprob[:-1]\\n logB=log_emlik\\n logA=log_transmat[:-1,:-1]\\n alpha = np.zeros_like(logB)\\n alpha[0]=logB[0]+logPi\\n for i in range(1,logB.shape[0]):\\n for j in range(logA.shape[0]):\\n alpha[i][j]=logsumexp(alpha[i-1]+logA[:,j]+logB[i][j])\\n return alpha\",\n \"def logmelfilterbank(audio,\\r\\n sampling_rate,\\r\\n fft_size=1024,\\r\\n hop_size=256,\\r\\n win_length=None,\\r\\n window=\\\"hann\\\",\\r\\n num_mels=80,\\r\\n fmin=None,\\r\\n fmax=None,\\r\\n eps=1e-10,\\r\\n ):\\r\\n # get amplitude spectrogram\\r\\n x_stft = librosa.stft(audio, n_fft=fft_size, hop_length=hop_size,\\r\\n win_length=win_length, window=window, pad_mode=\\\"reflect\\\")\\r\\n spc = np.abs(x_stft).T # (#frames, #bins)\\r\\n\\r\\n # get mel basis\\r\\n fmin = 0 if fmin is None else fmin\\r\\n fmax = sampling_rate / 2 if fmax is None else fmax\\r\\n mel_basis = librosa.filters.mel(sampling_rate, fft_size, num_mels, fmin, fmax)\\r\\n\\r\\n return np.log10(np.maximum(eps, np.dot(spc, mel_basis.T)))\",\n \"def NMF(model, maxIter=100, beliefs=None, verbose=False):\\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\\n \\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter 0: \\\"+str(lnZ))\\n\\n for t in xrange(1,maxIter+1): # for each iteration:\\n # Update all the beliefs via coordinate ascent:\\n for Xi in model.X: # for each variable, \\n bNew = 0.0 # compute E[ log f ] as a function of Xi:\\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\\n m = f.log() # E[log f_a] = \\\\sum \\\\log f_a \\\\prod b_v\\n for v in f.vars - [Xi]: m *= beliefs[v]\\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\\n bNew -= bNew.max() # (numerical issues)\\n bNew = bNew.exp()\\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\\n beliefs[Xi] = bNew\\n #\\n # Compute the lower bound on the partition function:\\n # E_b [ log f ] + H(b) = \\\\sum_a E[log f_a] + \\\\sum_i H(b_i) for independent beliefs\\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter \\\"+str(t)+\\\": \\\"+str(lnZ))\\n return lnZ,beliefs\",\n \"def forward(self, mel_coarse):\\n logit = self.layers(mel_coarse)\\n y = F.sigmoid(logit)\\n return y, logit\",\n \"def brownian_motion_log_returns(param):\\n sqrt_delta_sigma = math.sqrt(param.time_rate) * param.vol\\n return nrand.normal(loc=0, scale=sqrt_delta_sigma, size=param.time)\",\n \"def brownian_motion_levels(param):\\n return convert_to_prices(param, brownian_motion_log_returns(param))\",\n \"def log10(self):\\n return Factor().__build( VarSet(self.v) , np.log10(self.t) )\",\n \"def log2_inplace(a):\",\n \"def _log_fold_change_pairs(self, idx0, idx1, base):\\n assert np.all([x < self._pval.shape[1] for x in idx0])\\n assert np.all([x < self._pval.shape[1] for x in idx1])\\n if base == np.e:\\n return self._logfc[idx0, :, :][:, idx1, :]\\n else:\\n return self._logfc[idx0, :, :][:, idx1, :] / np.log(base)\",\n \"def __log_likelihood(self, params, *args):\\n\\t\\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\\n\\n\\t\\tno_example = len(X)\\n\\t\\ttotal_logZ = 0\\n\\t\\ttotal_logProb = 0\\n\\t\\texpected_weights = np.zeros(len(feature_set))\\n\\t\\tfor t in range(len(X)):\\n\\t\\t\\t# example_features = X[t], example_labels = y[t]\\n\\n\\t\\t\\tpotential = np.zeros(len(X[t]))\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\t#candidate_features = X[t][i], candidate_label = y[t][i]\\n\\t\\t\\t\\tpotential[i] = feature_set.calc_inner_product(X[t][i], params)\\n\\n\\t\\t\\t#scaling\\n\\t\\t\\tpotential = potential - np.max(potential, keepdims=True)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\ttotal_logProb += potential[i] * y[t][i]\\n\\n\\t\\t\\tpotential, Z = self.__softmax(potential)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\tfeature_set.calc_inner_sum(expected_weights, X[t][i], potential[i])\\n\\n\\t\\t\\ttotal_logZ += log(Z)\\n\\n\\t\\t# _params = feature_set.get_regularized_params(params, 'bias')\\n\\t\\t_params = params\\n\\t\\tlog_likelihood = total_logProb - total_logZ - (lambda_reg/2) * np.sum(np.multiply(_params,_params))\\n\\t\\tgradients = empirical_weights - expected_weights - lambda_reg * _params\\n\\n\\t\\tglobal SUB_ITERATION_NUM\\n\\t\\tif verbose:\\n\\t\\t\\tsub_iteration_str = ' '\\n\\t\\t\\tif SUB_ITERATION_NUM > 0:\\n\\t\\t\\t\\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\\n\\t\\t\\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\\n\\n\\t\\tSUB_ITERATION_NUM += 1\\n\\n\\t\\treturn sign * log_likelihood, sign * gradients\",\n \"def add_mf_updates(self):\\n \\n if self.num_hidden == 0:\\n \\n self.mf_updates, _ =\\\\\\n theano.scan(lambda i: self.sigmoid_update(self.mf_vis_p,i),\\n sequences = [T.arange(self.num_vars)])\\n \\n elif self.num_hidden > 0:\\n \\n self.mf_vis_updates = self.sigmoid_update_vis(self.mf_hid_p)\\n \\n self.mf_hid_updates = self.sigmoid_update_hid(self.mf_vis_p)\\n \\n # damp high oscillations:\\n self.mf_vis_updates = 0.02*self.mf_vis_p + 0.98*self.mf_vis_updates\\n \\n self.mf_hid_updates = 0.02*self.mf_hid_p + 0.98*self.mf_hid_updates\\n #####\",\n \"def log_inplace(a):\",\n \"def f_log_decoding(x, out_reflection=False):\\n a = 0.555556\\n b = 0.009468\\n c = 0.344676\\n d = 0.790453\\n e = 8.735631\\n f = 0.092864\\n cut2 = 0.100537775223865\\n\\n y = np.where(x < cut2,\\n (x - f) / e,\\n (10 ** ((x - d) / c)) / a - (b / a))\\n\\n if not out_reflection:\\n y = y / 0.9\\n\\n return y\",\n \"def backward(log_emlik, log_startprob, log_transmat):\\n #print(log_transmat)\\n beta = np.zeros(log_emlik.shape)\\n n = len(log_emlik)-2\\n log_transmat = log_transmat[0:-1,0:-1];\\n\\n\\n\\n while n >= 0:\\n\\n for j in range(0,len(log_emlik[0])):\\n\\n beta[n,j] = logsumexp(log_transmat[j,:] + log_emlik[n+1,:] + beta[n+1,:])\\n\\n n = n -1\\n #print(beta[n,:])\\n #print(beta)\\n return beta\",\n \"def KFilt(sample,fs=25):\\n\\t#kalman filter inputs\\n \\n # Dimensions of parameters:\\n # 'transition_matrices': 2,\\n # 'transition_offsets': 1,\\n # 'observation_matrices': 2,\\n # 'observation_offsets': 1,\\n # 'transition_covariance': 2,\\n # 'observation_covariance': 2,\\n # 'initial_state_mean': 1,\\n # 'initial_state_covariance': 2,\\n \\n n_timesteps = len(sample)\\n trans_mat = []\\n\\n\\t#mask missing values\\n observations = np.ma.array(sample,mask=np.zeros(sample.shape))\\n missing_loc = np.where(np.isnan(sample))\\n observations[missing_loc[0][:],missing_loc[1][:]] = np.ma.masked\\n\\t\\n\\t#Import Kalman filter, inerpolate missing points and get 2nd, 3rd orde kinematics\\n dt = 1./25\\t#Length of each frame (should be iether 1/25 or 1/30)\\t\\n n_timesteps = len(sample)\\n \\n observation_matrix = np.array([[1,0,0,0],\\n [0,1,0,0]])#np.eye(4) \\n t = np.linspace(0,len(observations)*dt,len(observations))\\n q = np.cov(observations.T[:2,:400])\\n qdot = np.cov(np.diff(observations.T[:2,:400]))#np.cov(observations[:1,:400])\\n\\n h=(t[-1]-t[0])/t.shape[0]\\n A=np.array([[1,0,h,.5*h**2], \\n [0,1,0,h], \\n [0,0,1,0],\\n [0,0,0,1]]) \\n\\n init_mean = [sample[0],0,0] #initial mean should be close to the first point, esp if first point is human-picked and tracking starts at the beginning of a video\\n observation_covariance = q*500 #ADJUST THIS TO CHANGE SMOOTHNESS OF FILTER\\n init_cov = np.eye(4)*.001#*0.0026\\n transition_matrix = A\\n transition_covariance = np.array([[q[0,0],q[0,1],0,0],\\n [q[1,0],q[1,1],0,0],\\n [0,0,qdot[0,0],qdot[0,1]],\\n [0,0,qdot[1,0],qdot[1,1]]])\\n\\n kf = KalmanFilter(transition_matrix, observation_matrix,transition_covariance,observation_covariance,n_dim_obs=2)\\n\\n kf = kf.em(observations,n_iter=1,em_vars=['transition_covariance','transition_matrix','observation_covariance'])\\n\\n #pdb.set_trace()\\n \\n global trans_mat, trans_cov, init_cond\\n x_filt = kf.filter(observations[0])[0]#observations.T[0])[0]\\n kf_means = kf.smooth(observations[0])[0]\\n\\t\\n return kf_means,x_filt #np.column_stack((color_x[:,0],color_y[:,0],color_x[:,1],color_y[:,1])),frames\",\n \"def pre_logits(self, feats: Tuple[torch.Tensor]) -> torch.Tensor:\\n # The EfficientFormerClsHead doesn't have other module, just return\\n # after unpacking.\\n return feats[-1]\",\n \"def llf_obs(self):\\n return self.model.loglikeobs(self.params)\",\n \"def test_lfc_ml2():\\n levels = np.array([1024.95703125, 1016.61474609, 1005.33056641, 991.08544922, 973.4163208,\\n 951.3381958, 924.82836914, 898.25482178, 873.46124268, 848.69830322,\\n 823.92553711, 788.49304199, 743.44580078, 700.50970459, 659.62017822,\\n 620.70861816, 583.69421387, 548.49719238, 515.03826904, 483.24401855,\\n 453.0418396, 424.36477661, 397.1505127, 371.33441162, 346.85922241,\\n 323.66995239, 301.70935059, 280.92651367, 261.27053833, 242.69168091,\\n 225.14237976, 208.57781982, 192.95333862, 178.22599792, 164.39630127,\\n 151.54336548, 139.68635559, 128.74923706, 118.6588974, 109.35111237,\\n 100.76405334, 92.84288025, 85.53556824, 78.79430389, 72.57549286,\\n 66.83885193, 61.54678726, 56.66480637, 52.16108322]) * units.mbar\\n temperatures = np.array([6.00750732, 5.14892578, 4.177948, 3.00268555, 1.55535889,\\n -0.25527954, -1.93988037, -3.57766724, -4.40600586, -4.19238281,\\n -3.71185303, -4.47943115, -6.81280518, -8.08685303, -8.41287231,\\n -10.79302979, -14.13262939, -16.85784912, -19.51675415,\\n -22.28689575, -24.99938965, -27.79664612, -30.90414429,\\n -34.49435425, -38.438797, -42.27981567, -45.99230957,\\n -49.75340271, -53.58230591, -57.30686951, -60.76026917,\\n -63.92070007, -66.72470093, -68.97846985, -70.4264679,\\n -71.16407776, -71.53797913, -71.64375305, -71.52735901,\\n -71.53523254, -71.61097717, -71.92687988, -72.68682861,\\n -74.129776, -76.02471924, -76.88977051, -76.26008606,\\n -75.90351868, -76.15809631]) * units.celsius\\n dewpoints = np.array([4.50012302, 3.42483997, 2.78102994, 2.24474645, 1.593485, -0.9440815,\\n -3.8044982, -3.55629468, -9.7376976, -10.2950449, -9.67498302,\\n -10.30486488, -8.70559597, -8.71669006, -12.66509628, -18.6697197,\\n -23.00351334, -29.46240425, -36.82178497, -41.68824768, -44.50320816,\\n -48.54426575, -52.50753403, -51.09564209, -48.92690659, -49.97380829,\\n -51.57516098, -52.62096405, -54.24332809, -57.09109879, -60.5596199,\\n -63.93486404, -67.07530212, -70.01263428, -72.9258728, -76.12271881,\\n -79.49847412, -82.2350769, -83.91127014, -84.95665741, -85.61238861,\\n -86.16391754, -86.7653656, -87.34436035, -87.87495422, -88.34281921,\\n -88.74453735, -89.04680634, -89.26436615]) * units.celsius\\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof, td_mixed)\\n assert_almost_equal(lfc_pressure, 962.34 * units.mbar, 2)\\n assert_almost_equal(lfc_temp, 0.767 * units.degC, 2)\",\n \"def Log2T(X):\\n data_headers = X.select_dtypes(include=[\\\"float64\\\"]).columns\\n X[data_headers] = np.log2(X[data_headers])\\n return X\",\n \"def statePosteriors(log_alpha, log_beta):\\n N = log_alpha.shape[0]\\n M = log_alpha.shape[1]\\n log_gamma = np.zeros((N, M))\\n for n in range(N):\\n log_gamma[n, :] = log_alpha[n, :] + log_beta[n, :] - logsumexp(log_alpha[N-1, :])\\n\\n return log_gamma\",\n \"def loglweave(store):\\n code = \\\"\\\"\\\"\\n double sum = 0.0, xbeta;\\n for(int i=0; i<nobs; i++){\\n xbeta = 0.0;\\n for(int j=0; j<kreg; j++){\\n xbeta += xmat(i,j) * beta(j);\\n }\\n sum += yvec(i) * xbeta - exp(xbeta);\\n }\\n return_val = sum;\\n \\\"\\\"\\\"\\n yvec = store['yvec']\\n xmat = store['xmat']\\n nobs, kreg = xmat.shape\\n beta = store['beta']\\n val = weave.inline(code,['yvec','xmat', 'beta','nobs','kreg'],\\n compiler='gcc',\\n type_converters=converters.blitz\\n )\\n return val\",\n \"def log_filter(stack, sigma):\\n stack_cp = stack.astype(np.int16)\\n gauss = ndi.filters.gaussian_filter(stack_cp, sigma=sigma)\\n log = ndi.filters.laplace(gauss)\\n return log\",\n \"def beinflumat(x_axis, y_axis, e_eff):\\n len_x = len(x_axis)\\n len_y = len(y_axis)\\n influence_matrix_complete = np.zeros((len_x, len_y, len_x, len_y))\\n\\n # generate coordinate grids\\n a_factor = (x_axis[-1] - x_axis[0]) / (len_x - 1) / 2\\n b_factor = (y_axis[-1] - y_axis[0]) / (len_y - 1) / 2\\n x_grid = __beinflumatgrid(x_axis)\\n y_grid = __beinflumatgrid(y_axis)\\n\\n # use numexpr to evaluate expressions\\n xpa = ne.evaluate('x_grid + a_factor')\\n xma = ne.evaluate('x_grid - a_factor')\\n ypb = ne.evaluate('y_grid + b_factor')\\n ymb = ne.evaluate('y_grid - b_factor')\\n\\n # calculate complete influence matrix\\n for j in range(0, len_y):\\n for j_prime in range(0, len_y):\\n influence_matrix_complete[:, j, :, j_prime] = \\\\\\n (np.multiply(xpa, np.log(\\n np.divide(\\n ((ypb[j, j_prime]) +\\n np.sqrt(np.multiply((ypb[j, j_prime]),\\n (ypb[j, j_prime])) +\\n np.multiply(xpa, xpa))),\\n ((ymb[j, j_prime]) +\\n np.sqrt(np.multiply((ymb[j, j_prime]),\\n (ymb[j, j_prime])) +\\n np.multiply(xpa, xpa)))))) +\\n (ypb[j, j_prime]) * np.log(\\n np.divide(\\n (xpa +\\n np.sqrt(np.multiply((ypb[j, j_prime]),\\n (ypb[j, j_prime])) +\\n np.multiply(xpa, xpa))),\\n (xma +\\n np.sqrt(np.multiply((ypb[j, j_prime]),\\n (ypb[j, j_prime])) +\\n np.multiply(xma, xma))))) +\\n np.multiply(xma, np.log(\\n np.divide(\\n ((ymb[j, j_prime]) +\\n np.sqrt(np.multiply((ymb[j, j_prime]),\\n (ymb[j, j_prime])) +\\n np.multiply(xma, xma))),\\n ((ypb[j, j_prime]) +\\n np.sqrt(np.multiply((ypb[j, j_prime]),\\n (ypb[j, j_prime])) +\\n np.multiply(xma, xma)))))) +\\n (ymb[j, j_prime]) * np.log(\\n np.divide(\\n (xma +\\n np.sqrt(np.multiply((ymb[j, j_prime]),\\n (ymb[j, j_prime])) +\\n np.multiply(xma, xma))),\\n (xpa +\\n np.sqrt(np.multiply((ymb[j, j_prime]),\\n (ymb[j, j_prime])) +\\n np.multiply(xpa, xpa))))))\\n\\n return influence_matrix_complete * 1 / e_eff * 2 / pi\",\n \"def coefs(logger, model, data=clean_data, target=target):\\n\\n df = pd.read_csv(data)\\n X = df.drop(columns=target)\\n coef_df = pd.DataFrame({'Variable': X.columns, 'Coefficient': model.coef_[0]})\\\\\\n .sort_values(by='Coefficient')\\n\\n coef_path = data_config['outputs']['logreg_coefs']\\n coef_df.to_csv(coef_path, index=False)\\n print(f'Coefficients saved to {coef_path}')\\n\\n return\",\n \"def front_column_model_p_gain():\",\n \"def information_gain(features, attribute_index, targets):\\r\\n\\r\\n possible_feature_values = [0,1]\\r\\n \\r\\n possible_classifications = [0,1]\\r\\n \\r\\n feature = features[:,attribute_index]\\r\\n \\r\\n \\r\\n number_of_samples = len(feature)\\r\\n \\r\\n import math\\r\\n \\r\\n \\r\\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\\r\\n \\r\\n terms_to_be_summed_for_current_entropy = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_elements_with_this_classification = len(targets[targets==classification])\\r\\n \\r\\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\\r\\n \\r\\n if p_for_this_classification != 0:\\r\\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\\r\\n else:\\r\\n terms_to_be_summed_for_current_entropy.append(0)\\r\\n \\r\\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n \\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy = []\\r\\n \\r\\n for possible_value in possible_feature_values:\\r\\n \\r\\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\\r\\n \\r\\n if len(targets_split_by_feature_value) != 0:\\r\\n \\r\\n \\r\\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\\r\\n \\r\\n terms_for_entropy_within_subset = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\\r\\n \\r\\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\\r\\n \\r\\n if p_in_subset_for_this_classification != 0:\\r\\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\\r\\n else:\\r\\n terms_for_entropy_within_subset.append(0)\\r\\n \\r\\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\\r\\n \\r\\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\\r\\n \\r\\n \\r\\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\\r\\n\\r\\n information_gain = current_entropy - weighted_entropy \\r\\n \\r\\n return information_gain\",\n \"def load(self, old_log):\\n all_log = tflog2pandas(old_log)\\n\\n for _, row in all_log.iterrows():\\n tag, value, step = row\\n self.writer.add_scalar(tag,value,step)\",\n \"def log_mae(labels, predictions):\\n\\n result = abs(labels - predictions)\\n result = reduce_mean(result)\\n result = log(result)\\n\\n return result\",\n \"def calc_tf_log(doc):\\r\\n tf = calc_tf(doc)\\r\\n max_tf = tf[max(tf, key=tf.get)]\\r\\n tf_log = {}\\r\\n for key, val in tf.items():\\r\\n tf_log[key] = (1 + math.log(val)) / (1 + math.log(max_tf))\\r\\n return tf_log\",\n \"def analyse_loglike(test_data, mods):\\r\\n l1 = list(map(lambda x: x + ' NB', mods.names))\\r\\n l1.extend(list(map(lambda x: x + ' ZI', mods.names)))\\r\\n l1.extend(list(map(lambda x: x + ' P', mods.names)))\\r\\n loglikeNB = np.array(mods.compute_log_likelihood(test_data, 'NB'))\\r\\n loglikeZI = np.array(mods.compute_log_likelihood(test_data, 'ZI'))\\r\\n loglikeP = np.array(mods.compute_log_likelihood(test_data, 'P'))\\r\\n # loglikeG = np.array(mods.compute_log_likelihood_gaussian(test_data))\\r\\n # loglikegeo = np.array(mods.compute_log_likelihood_geom(test_data))\\r\\n LL = np.zeros((loglikeNB.shape[0] * 3, loglikeNB.shape[1]))\\r\\n LL[:loglikeNB.shape[0], :] = loglikeNB\\r\\n LL[loglikeNB.shape[0]:2 * loglikeNB.shape[0], :] = loglikeZI\\r\\n LL[2 * loglikeNB.shape[0]:3 * loglikeNB.shape[0], :] = loglikeP\\r\\n # LL[3 * loglikeNB.shape[0]:4 * loglikeNB.shape[0], :] = loglikeG\\r\\n # LL[4 * llzi.shape[0]:, :] = np.array(mods.loglikegeo)\\r\\n print('mean per model', list(zip(np.ma.masked_invalid(LL).sum(axis=1), map(lambda x: x.mod.name, mods.models))))\\r\\n print('mean per distrib')\\r\\n print(np.ma.masked_invalid(LL[:loglikeNB.shape[0], :]).mean())\\r\\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0]:loglikeNB.shape[0] * 2, :]).mean())\\r\\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0] * 2:loglikeNB.shape[0] * 3, :]).mean())\\r\\n # print(np.nanmean(LL[1-np.isinf(LL)], axis=1))\\r\\n # print(np.nanmean(LL[LL != np.inf],axis=1))\\r\\n LL[np.isnan(LL)] = 0\\r\\n LL[np.isinf(LL)] = 0\\r\\n LL[LL == 0] = -np.inf\\r\\n r = np.argmax(LL, axis=0)\\r\\n # LL /= mx\\r\\n print('mean_best', np.mean(np.ma.masked_invalid(LL[r, range(LL.shape[1])])))\\r\\n mx = np.max(LL, axis=0)\\r\\n LL = LL / mx\\r\\n means = test_data.get_miniOD(None)[test_data.get_stations_col(None)].mean(axis=0).to_numpy()\\r\\n # for i in np.unique(r):\\r\\n # print(means[r == i].max())\\r\\n print('mean NB', means[r < loglikeNB.shape[0]].mean())\\r\\n print('mean ZI', means[(r < 2 * loglikeNB.shape[0]) * (r > loglikeNB.shape[0])].mean())\\r\\n print('mean poisson', means[(r < 3 * loglikeNB.shape[0]) * (r > 2 * loglikeNB.shape[0])].mean())\\r\\n # print('mean ga', means[(r < 4 * llzi.shape[0]) * (r > 3 * llzi.shape[0])].mean())\\r\\n # print('mean Gaussian', means[r > 3 * loglikeNB.shape[0]].mean())\\r\\n print('model name, mean trips per model, LL/maxLL, N inf')\\r\\n for i in range(LL.shape[0]):\\r\\n print(l1[i], means[r == i].mean(), np.mean(np.ma.masked_invalid(LL[i, :])), np.sum(np.isinf(LL[i, :])))\\r\\n print(np.ma.corrcoef(np.ma.masked_invalid(LL[i, :]), means[:LL.shape[1]])[1, 0])\\r\\n plt.hist(r, bins=np.arange(-0.5, 3 * len(mods.names) + 1, 1))\\r\\n\\r\\n # l1.extend(list(map(lambda x: x + ' geo', mods.names)))\\r\\n # l1.extend(list(map(lambda x: x + ' G', mods.names)))\\r\\n plt.xticks(range(len(l1)), l1, rotation='vertical')\\r\\n plt.show()\\r\\n\\r\\n for m in mods.loglike:\\r\\n print(m)\\r\\n print(m[np.logical_not(np.isinf(m))].mean())\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def loglloop(store):\\n suml=0.0\\n for i in xrange(store['yvec'].shape[0]):\\n xbeta=dot(store['xmat'][i,:],store['beta'])\\n suml=suml+store['yvec'][i] * xbeta - exp(xbeta)\\n return suml\",\n \"def compute_gradients(self, logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n\\n # expand labels by inserting a blank between each pair\\n normalized_logits = softmax(logits)\\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n alpha = self.compute_forward_variables(normalized_logits, target) \\n beta = self.compute_backward_variables(normalized_logits, target)\\n\\n # rescale\\n alpha = alpha / np.sum(alpha, axis=0)\\n beta = beta / np.sum(beta, axis=0)\\n alphabeta = alpha * beta\\n print \\\"alpha\\\"\\n print alpha\\n\\n # compute zt\\n z = Counter()\\n for t in xrange(num_time_steps):\\n for s, k in enumerate(l):\\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\\n \\n # normalized_logits is time steps t by labels k\\n # alpha is 2 * target_length - 1 by time steps\\n lab_zk = np.zeros_like(normalized_logits)\\n for s, k in enumerate(l):\\n for t in xrange(num_time_steps):\\n lab_zk[t, k] += alphabeta[s, t]\\n\\n grad = normalized_logits\\n for k in xrange(target.shape[0]):\\n for t in xrange(num_time_steps):\\n ytk = normalized_logits[t, k]\\n constant = 1.0 / (ytk * z[t])\\n grad[t, k] = ytk - constant * lab_zk[t, k]\\n \\n return grad\",\n \"def extrapolate_fwds(h, ufr, llfr, alpha=0.10):\\n fwd_fsp_fsp_plus_h = np.log(1 + ufr) + (llfr - np.log(1 + ufr)) * big_b(h, alpha)\\n return fwd_fsp_fsp_plus_h\",\n \"def logits_on_features(self, h, batch):\\n batch = batch.to(h.device)\\n # Extract features with the model\\n features = h.view(batch.size, -1)\\n # Log loss\\n logits = self.head(features)\\n return logits\",\n \"def compute_loglike(self, tools: ModelingTools) -> float:\\n return -1.5\",\n \"def estimate_logreg(x,y,N_its,learning_rate=1e-4,regularizer=1e-2,lazy_reg=True):\\n weights = defaultdict(float)\\n weight_hist = [] #keep a history of the weights after each iteration\\n all_labels = set(y)\\n \\n # this block is for lazy regularization\\n ratereg = learning_rate * regularizer\\n def regularize(base_feats):\\n for base_feat in base_feats:\\n for label in all_labels:\\n #print \\\"regularizing\\\",(label,base_feat),t,last_update[base_feat],(1. - ratereg) ** (t-last_update[base_feat])\\n weights[(label,base_feat)] *= (1. - ratereg) ** (t-last_update[base_feat])\\n last_update[base_feat] = t\\n\\n t = 0\\n last_update = defaultdict(int)\\n\\n eeta = learning_rate\\n\\n for it in xrange(N_its):\\n\\n for i,(x_i,y_i) in enumerate(zip(x,y)): #keep\\n t += 1\\n\\n # regularization\\n if lazy_reg: # lazy regularization is essential for speed\\n regularize(x_i) # only regularize features in this instance\\n if not lazy_reg: # for testing/explanatory purposes only\\n for feat,weight in weights.iteritems():\\n if feat[1] is not OFFSET: # usually don't regularize offset\\n weights[feat] -= ratereg * weight\\n\\n p_y = compute_py(x_i,weights,all_labels) #hint\\n\\n term2 = make_feature_vector(x_i, y_i)\\n\\n for key in term2.keys():\\n weights[key] = weights[key] + (term2[key]*eeta)\\n\\n for label in all_labels:\\n temp = make_feature_vector(x_i, label)\\n for key in temp.keys():\\n weights[key] = weights[key] - (temp[key]*eeta*p_y[label])\\n\\n\\n print it,\\n weight_hist.append(weights.copy()) \\n\\n # if lazy, let regularizer catch up\\n if lazy_reg:\\n # iterate over base features\\n regularize(list(set([f[1] for f in weights.keys() if f[1] is not OFFSET])))\\n\\n return weights,weight_hist\",\n \"def log_trans(data, test=False):\\n logs = ['Administrative', 'Administrative_Duration', 'Informational',\\n 'Informational_Duration', 'ProductRelated',\\n 'ProductRelated_Duration', 'BounceRates', 'ExitRates',\\n 'PageValues']\\n if test:\\n data_test = data.loc[data['Train'] == 0]\\n data = data.loc[data['Train'] == 1]\\n\\n for col in logs:\\n zero_val = float((min(i for i in list(data[col]) if i > 0))/2)\\n data[col] = data[col].apply(lambda x: zero_val if x == 0 else x)\\n data[col] = data[col].apply(lambda x: np.log(x))\\n if test:\\n data_test[col] = data_test[col].apply(lambda x:\\n zero_val\\n if x == 0 else x)\\n data_test[col] = data_test[col].apply(lambda x: np.log(x))\\n if test:\\n data = pd.concat([data, data_test])\\n return data\",\n \"def logistic(weights, data, targets, hyperparameters):\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n df = np.reshape(df, ((len(df), 1)))\\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def _backward(n_samples, n_components, log_startprob,\\n log_transmat, framelogprob, mask):\\n \\n bwdlattice = torch.zeros_like(framelogprob)\\n # last row is already zeros, so omit the zero setting step\\n for t in range(n_samples - 2, -1, -1):\\n for i in range(n_components):\\n work_buffer = log_transmat[i,:] + framelogprob[:,t + 1, :] + bwdlattice[:,t+1, :]\\n bwdlattice[:, t, i] = torch.logsumexp(work_buffer, dim=-1) * mask[:, t+1].type(framelogprob.dtype)\\n return bwdlattice\",\n \"def get_logits(image):\\n x = image\\n for filters in (32, 64):\\n x = tf.layers.conv2d(x, filters, 3)\\n x = tf.nn.relu(x)\\n x = tf.layers.max_pooling2d(x, 3, 2)\\n x = tf.reduce_mean(x, axis=(1, 2))\\n logits = tf.layers.dense(x, 10)\\n return logits\",\n \"def log_likelihood(self, data, reward_model, bias_params):\",\n \"def loglnumpy(store):\\n xbeta = dot(store['xmat'], store['beta'])\\n lamb = exp(xbeta)\\n return sum(store['yvec'] * xbeta - lamb)\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def gradient_ascent(f, df, theta_init, step_size, max_iter):\\n\\n fs = []\\n xs = []\\n thetas = theta_init\\n for i in range(max_iter): #for each data example\\n fs.append(f(thetas))\\n\\n temp = step_size*df(thetas)\\n thetas = step_size*df(thetas) #modify that feature by using the derivative of log likelihood\\n xs.append(thetas.flatten())\\n if i % 10 == 0:\\n print(i, thetas)\\n\\n return thetas, fs, xs\",\n \"def logm(self, x):\\n\\n if K.backend() == 'theano':\\n # construct theano tensor operation\\n from theano.tensor.nlinalg import svd, diag\\n from theano.tensor.elemwise import Elemwise\\n from theano.scalar import log\\n import theano.tensor as T\\n # This implementation would be extremely slow. but efficient?\\n u, d, v = svd(x)\\n d += self.eps\\n inner = diag(T.log(d))\\n res = T.dot(u, T.dot(inner, v))\\n return res\\n else:\\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\\n return batch_matrix_log(x, self.eps)\",\n \"def calcfeat_delta_delta(signal, samplerate=16000, win_length=0.025, win_step=0.01, filters_num=26, NFFT=512,\\n\\t\\t\\t\\t\\t\\t low_freq=0, high_freq=None, pre_emphasis_coeff=0.97, cep_lifter=22, appendEnergy=True,\\n\\t\\t\\t\\t\\t\\t mode='mfcc', feature_len=13):\\n\\tfilters_num = 2 * feature_len\\n\\tfeat = calcMFCC(signal, samplerate, win_length, win_step, feature_len, filters_num, NFFT, low_freq, high_freq,\\n\\t\\t\\t\\t\\tpre_emphasis_coeff, cep_lifter, appendEnergy, mode=mode) # 首先获取13个一般MFCC系数\\n\\tfeat_delta = delta(feat)\\n\\tfeat_delta_delta = delta(feat_delta)\\n\\n\\tresult = numpy.concatenate((feat, feat_delta, feat_delta_delta), axis=1)\\n\\treturn result\",\n \"def _forward(n_samples, n_components, log_startprob,\\n log_transmat, batch_framelogprob, mask):\\n\\n batch_size = batch_framelogprob.shape[0]\\n fwdlattice = torch.zeros_like(batch_framelogprob)\\n \\n fwdlattice[:, 0, :] = log_startprob + batch_framelogprob[:,0, :]\\n for t in range(1, n_samples):\\n for j in range(n_components):\\n work_buffer = fwdlattice[:, t-1, :] + log_transmat[:, j]\\n # fwdlattice[:,t, j] = torch.logsumexp(work_buffer, dim=-1) + \\\\\\n # framelogprob[:,t, j] \\n \\n fwdlattice[:,t, j] = torch.logsumexp(work_buffer, dim=-1) * \\\\\\n mask[:, t].type(batch_framelogprob.dtype) + batch_framelogprob[:,t, j] \\n\\n # need to find the idx for last sample of each sequence by mask.sum(dim=-1)-1, fwdlattice[:, -1, :] would give the padded zeros\\n batch_logprob = torch.logsumexp(fwdlattice[list(range(batch_size)), mask.sum(dim=-1)-1, :], dim=-1)\\n return batch_logprob, fwdlattice\",\n \"def M(f):\\n return 1127 * numpy.log(1 + f/700.0)\",\n \"def loglike(self, params):\\n\\n if type(params) is not MixedLMParams:\\n params = MixedLMParams.from_packed(params, self.k_fe,\\n self.use_sqrt)\\n\\n fe_params = params.get_fe_params()\\n cov_re = params.get_cov_re()\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n _, cov_re_logdet = np.linalg.slogdet(cov_re)\\n\\n # The residuals\\n expval = np.dot(self.exog, fe_params)\\n resid_all = self.endog - expval\\n\\n likeval = 0.\\n\\n # Handle the covariance penalty\\n if self.cov_pen is not None:\\n likeval -= self.cov_pen.func(cov_re, cov_re_inv)\\n\\n # Handle the fixed effects penalty\\n if self.fe_pen is not None:\\n likeval -= self.fe_pen.func(fe_params)\\n\\n xvx, qf = 0., 0.\\n for k, lab in enumerate(self.group_labels):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n resid = resid_all[self.row_indices[lab]]\\n\\n # Part 1 of the log likelihood (for both ML and REML)\\n ld = _smw_logdet(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n cov_re_logdet)\\n likeval -= ld / 2.\\n\\n # Part 2 of the log likelihood (for both ML and REML)\\n u = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv, resid)\\n qf += np.dot(resid, u)\\n\\n # Adjustment for REML\\n if self.reml:\\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n exog)\\n xvx += np.dot(exog.T, mat)\\n\\n if self.reml:\\n likeval -= (self.n_totobs - self.k_fe) * np.log(qf) / 2.\\n _,ld = np.linalg.slogdet(xvx)\\n likeval -= ld / 2.\\n likeval -= (self.n_totobs - self.k_fe) * np.log(2 * np.pi) / 2.\\n likeval += ((self.n_totobs - self.k_fe) *\\n np.log(self.n_totobs - self.k_fe) / 2.)\\n likeval -= (self.n_totobs - self.k_fe) / 2.\\n else:\\n likeval -= self.n_totobs * np.log(qf) / 2.\\n likeval -= self.n_totobs * np.log(2 * np.pi) / 2.\\n likeval += self.n_totobs * np.log(self.n_totobs) / 2.\\n likeval -= self.n_totobs / 2.\\n\\n return likeval\",\n \"def f_log_encoding(x, in_reflection=False):\\n a = 0.555556\\n b = 0.009468\\n c = 0.344676\\n d = 0.790453\\n e = 8.735631\\n f = 0.092864\\n cut1 = 0.00089\\n\\n if not in_reflection:\\n x = x * 0.9\\n\\n y = np.where(x < cut1,\\n e * x + f,\\n c * np.log10(a * x + b) + d)\\n\\n return y\",\n \"def log_det_Jxz(self):\\n #return self.log_det_xz.output\\n log_det_Jxzs = []\\n for l in self.layers:\\n if hasattr(l, 'log_det_Jxz'):\\n log_det_Jxzs.append(l.log_det_Jxz)\\n if len(log_det_Jxzs) == 0:\\n return tf.ones((self.output_z.shape[0],))\\n if len(log_det_Jxzs) == 1:\\n return log_det_Jxzs[0]\\n return tf.reduce_sum(log_det_Jxzs, axis=0, keepdims=False)\",\n \"def test_l2_metric_log_vectorization(\\n self, l2_metric_s2, times, landmarks_a, landmarks_b, landmarks_c\\n ):\\n landmarks_ab = l2_metric_s2.geodesic(landmarks_a, landmarks_b)\\n landmarks_bc = l2_metric_s2.geodesic(landmarks_b, landmarks_c)\\n landmarks_ab = landmarks_ab(times)\\n landmarks_bc = landmarks_bc(times)\\n\\n tangent_vecs = l2_metric_s2.log(point=landmarks_bc, base_point=landmarks_ab)\\n\\n result = tangent_vecs\\n self.assertAllClose(gs.shape(result), gs.shape(landmarks_ab))\",\n \"def kullbackLeibler(mu, log_sigma):\\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)\",\n \"def log_shift(data):\\n result = [np.log(1 + np.abs(d.copy())) for d in data]\\n return result\",\n \"def log_boltzmann_dist(Q, temperature):\\n return nn.LogSoftmax(dim=0)(Q/temperature)\",\n \"def removeFactors(self,flist, isLog=False):\\n # Currently: just divide out factors (add inverse factors) -- can't check if factor present? (minimal)\\n # TODO: set entries to zero, then call self.L.eliminate_zeros()\\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\\n for k,f in enumerate(flist):\\n if not isLog: \\n if np.any(f.t==0): f = f+1e-30; # TODO: log nonzero tol\\n f = f.log()\\n if f.nvar == 1:\\n Xi = f.vars[0]\\n self.h[Xi] -= .5*(f[1]-f[0])\\n self.c -= .5*(f[1]+f[0])\\n else:\\n Xi,Xj = f.vars[0],f.vars[1]\\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \\n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n self.h[Xi] -= .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.h[Xj] -= .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.c -= .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\\n self.L -= csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar)); \\n #raise NotImplementedError();\",\n \"def started_log(X,params):\\n \\n offset = params['offset']\\n if not is_number(params['offset']):\\n offset=1.\\n X = np.log(X+offset)\\n return X\",\n \"def binlogreg_train(X, Y_):\\n N = X.shape[0]\\n\\n w = np.random.randn(X.shape[1], 1) # D x 1\\n b = np.random.randn(N, 1) # N x 1\\n\\n for i in range(PARAM_NITER+1):\\n # klasifikacijski rezultati\\n scores = np.dot(X, w) + b # N x 1\\n\\n # vjerojatnosti razreda c_1\\n probs = sigmoid(scores, y=1) # N x 1\\n\\n # gubitak\\n loss = -1 * float(np.dot(Y_.T, np.log(probs))) # scalar\\n\\n # dijagnostički ispis\\n if i % 10 == 0:\\n print(\\\"iteration {}: loss {}\\\".format(i, loss))\\n\\n # if i % 1000 == 0:\\n # Y = np.around(probs, decimals=0)\\n # decfun = binlogreg_decfun(w, b)\\n # bbox = (np.min(X, axis=0), np.max(X, axis=0))\\n # data.graph_surface(decfun, bbox, offset=0.5)\\n # data.graph_data(X, Y_, Y)\\n\\n # derivacije gubitka po klasifikacijskom rezultatu\\n dL_dscores = np.subtract(probs, Y_) # N x 1\\n\\n # gradijenti parametara\\n grad_w = np.divide(np.dot(X.T, dL_dscores), N) # D x 1\\n grad_b = np.divide(np.sum(dL_dscores), N) # 1 x 1\\n\\n # poboljšani parametri\\n w += -PARAM_DELTA * grad_w\\n b += -PARAM_DELTA * grad_b\\n\\n return w, b\",\n \"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def _object_func_marginals_coarse_log(log_params, *args, **kwargs):\\n return _object_func_marginals_coarse(numpy.exp(log_params), *args, **kwargs)\",\n \"def ComputeLogGradientTerm(self, *args):\\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogGradientTerm(self, *args)\",\n \"def nloglikeobs(self, params):\\n lambda_ = params[0]\\n\\n ll_output = self._LL(self.endog, rate=lambda_)\\n\\n return -np.log(ll_output)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6378001","0.6166156","0.6106605","0.5986836","0.59717876","0.59704345","0.59436226","0.59277886","0.59004104","0.5880232","0.58595026","0.5850303","0.5847764","0.5805098","0.5797871","0.5773712","0.57430214","0.5730535","0.5728411","0.5695498","0.5692875","0.56894165","0.56871295","0.5641088","0.5625169","0.56205744","0.5615457","0.5612503","0.5609048","0.55979997","0.55879","0.5563873","0.55304533","0.5519584","0.55065334","0.55019194","0.54908335","0.54866207","0.5459678","0.54480726","0.54426587","0.5432098","0.54161847","0.5404022","0.5396066","0.53948337","0.53847915","0.53799236","0.53707767","0.53654844","0.53590035","0.5353767","0.5335818","0.5331275","0.53304774","0.53268474","0.532503","0.5316599","0.5315532","0.5313041","0.53116375","0.53033835","0.52984333","0.52945787","0.528327","0.5282651","0.52821815","0.5281049","0.5272419","0.52698946","0.52677405","0.5267534","0.52663547","0.5265353","0.52507097","0.52447474","0.5242855","0.52366304","0.52347183","0.5222501","0.5215998","0.52086055","0.5208299","0.5206244","0.5205503","0.5203742","0.51976013","0.5195578","0.5192546","0.51924056","0.5188186","0.5187208","0.5187134","0.51859534","0.51841575","0.5173836","0.51732194","0.51731825","0.5170564","0.51699156","0.5167506"],"string":"[\n \"0.6378001\",\n \"0.6166156\",\n \"0.6106605\",\n \"0.5986836\",\n \"0.59717876\",\n \"0.59704345\",\n \"0.59436226\",\n \"0.59277886\",\n \"0.59004104\",\n \"0.5880232\",\n \"0.58595026\",\n \"0.5850303\",\n \"0.5847764\",\n \"0.5805098\",\n \"0.5797871\",\n \"0.5773712\",\n \"0.57430214\",\n \"0.5730535\",\n \"0.5728411\",\n \"0.5695498\",\n \"0.5692875\",\n \"0.56894165\",\n \"0.56871295\",\n \"0.5641088\",\n \"0.5625169\",\n \"0.56205744\",\n \"0.5615457\",\n \"0.5612503\",\n \"0.5609048\",\n \"0.55979997\",\n \"0.55879\",\n \"0.5563873\",\n \"0.55304533\",\n \"0.5519584\",\n \"0.55065334\",\n \"0.55019194\",\n \"0.54908335\",\n \"0.54866207\",\n \"0.5459678\",\n \"0.54480726\",\n \"0.54426587\",\n \"0.5432098\",\n \"0.54161847\",\n \"0.5404022\",\n \"0.5396066\",\n \"0.53948337\",\n \"0.53847915\",\n \"0.53799236\",\n \"0.53707767\",\n \"0.53654844\",\n \"0.53590035\",\n \"0.5353767\",\n \"0.5335818\",\n \"0.5331275\",\n \"0.53304774\",\n \"0.53268474\",\n \"0.532503\",\n \"0.5316599\",\n \"0.5315532\",\n \"0.5313041\",\n \"0.53116375\",\n \"0.53033835\",\n \"0.52984333\",\n \"0.52945787\",\n \"0.528327\",\n \"0.5282651\",\n \"0.52821815\",\n \"0.5281049\",\n \"0.5272419\",\n \"0.52698946\",\n \"0.52677405\",\n \"0.5267534\",\n \"0.52663547\",\n \"0.5265353\",\n \"0.52507097\",\n \"0.52447474\",\n \"0.5242855\",\n \"0.52366304\",\n \"0.52347183\",\n \"0.5222501\",\n \"0.5215998\",\n \"0.52086055\",\n \"0.5208299\",\n \"0.5206244\",\n \"0.5205503\",\n \"0.5203742\",\n \"0.51976013\",\n \"0.5195578\",\n \"0.5192546\",\n \"0.51924056\",\n \"0.5188186\",\n \"0.5187208\",\n \"0.5187134\",\n \"0.51859534\",\n \"0.51841575\",\n \"0.5173836\",\n \"0.51732194\",\n \"0.51731825\",\n \"0.5170564\",\n \"0.51699156\",\n \"0.5167506\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6877,"cells":{"query":{"kind":"string","value":"Create the game, SpaceInvaders. Train or test it."},"document":{"kind":"string","value":"def __init__ (self,gameName,total_episodes=50,train_or_test=2):\r\n\t\t#additional param:- doLoadNetwork=True\r\n\t\r\n\t\tself.createGame(gameName)\r\n\t\t\r\n\t\t### Training Hyperparameters\r\n\t\tself.TOT_EPISODES = total_episodes \t#no. of episodes/epochs\r\n\t\tself.MAX_STEPS = 50000 \t\t \t#max steps taken every episode/epoch\r\n\t\t\r\n\t\t### Preprocessing Hyperparameters\r\n\t\tself.stack_size = 4\t\t\t\t\t#stacking 3 frames at once.\t\t\t\t\t\r\n\t\tself.stacked_frames = deque([np.zeros((84,84), dtype=np.int) \r\n\t\t\t\t\tfor i in range(self.stack_size)], maxlen=4)\t\r\n\t\t\t\t\t\r\n\t\t### Model\r\n\t\tself.dqn = DDQN(self.action_space)\r\n\t\t\r\n\t\tself.path = \"saved.h5\"\r\n\t\t\t\t\r\n\t\t# train agent or simulate the game.\r\n\t\tif train_or_test == 1:\r\n\t\t\tself.trainAgent()\r\n\t\telif train_or_test == 2:\r\n\t\t\t#load network before simulating.\r\n\t\t\tself.load_network()\r\n\t\t\tself.simulate()"},"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, game_name, skip_actions=4, num_frames=4, w=84, h=84):\n self.env = gym.make(game_name)\n self.num_frames = num_frames\n self.skip_actions = skip_actions\n self.w = w\n self.h = h\n\n if game_name == 'SpaceInvaders-v0':\n self.action_space=[1,2,3]\n\n self.action_size = len(self.action_space)\n self.state = None\n self.game_name = game_name","def create_game(self):\n\n\t\tself.player_model.grid = []\n\t\tself.player_model.available_cells = []\n\n\t\tfor i in range(9):\n\t\t\tc = Cell(i, None)\n\t\t\tself.player_model.grid.append(c)\n\t\t\tself.player_model.available_cells.append(c)\n\n\t\tself.player_frame.setup_game(self.player_model.current_player.name)","def _create_games(self):\n\n ''''''","def start_game(self):\n\n\t\tpass","def setup_game(self):","def make_game(self):\n game = Game(self.data['gamename'])\n self.game = game\n return game","def game_start():\n herolist = Hero_List(hots_db)\n heroclasses = []\n for item in herolist:\n heroclasses.append(Item(item, 'hero'))\n curgame = Game(Team('home'), Team('enemy'), Team('hero_pool', heroclasses), '')\n return curgame","def create(game):\r\n ## Create Garbage\r\n game.garbage = deque([])\r\n\r\n ## Create Stars\r\n game.create_stars()\r\n\r\n ## Create Millenium Falcon\r\n game.falcons = MilleniumFalcon.init(game)\r\n game.millenium_falcon = MilleniumFalcon()\r\n \r\n ## Create TIE Fighters\r\n game.fighters = Fighter.init(game)\r\n\r\n ## Create Asteroids\r\n game.rocks = Group.mesh(Rock1.init(game), Rock2.init(game))\r\n\r\n ## Create Lasers\r\n game.pro_lasers = ProLaser.init(game)\r\n game.con_lasers = ConLaser.init(game)\r\n\r\n ## Setup collision groups\r\n Group.bind(game.pro_lasers, game.rocks, game.act_laser_void)","def start(self):\n self.player = Player()\n self.dealer = Dealer()\n self.pot = 0\n self.side_bet = 0\n start_game()","def init_new_game(self):\n self.game = get_new_game(self.game_config)","def start_game(self):\n self.board = Board(num_tableaus=self.tableau_qty, num_decks=self.decks, deal_3=self.deal_3)\n self.board.init_move_dict()\n self.board.deal(self.deck)\n\n if self.api_use:\n self.init_game_api()\n elif self.commandline:\n self.init_cl_game()\n else:\n self.init_pygame()","def setUp(self):\r\n self.spaceship = SpaceShipGame()","def setUp(self):\r\n self.spaceship = SpaceShipGame()","def setUp(self):\r\n self.spaceship = SpaceShipGame()","def setUp(self):\r\n self.spaceship = SpaceShipGame()","def setUp(self):\r\n self.spaceship = SpaceShipGame()","def main():\n g = Game(800, 600)\n g.start()","def spawn_players(self) -> None:\n #Create the player\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//(3/2), self.screen_height-50, self.player_lives, self.fps, self.player1_bullet, Direction.UP, self.debug)\n\n #Create the AI\n self.player2 = AIPlayer(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//3, self.screen_height-50, self.player_lives, self.fps, self.player2_bullet, Direction.UP, 1, True, self.debug)","def create_one_game(self):\n return Game2048(task_name=self.result_path, game_mode=False)","def setup_new_game(self):\r\n self._player = Player()\r\n self._stats = GameStats(self._bb_settings)\r\n self._scoreboard = Scoreboard(self._bb_settings, self._screen)","def create_new_game(self):\r\n global game_instance\r\n game_instance = game.Game()\r\n game_instance.set_word(db.get_random_word())\r\n print(\"\\n---------NEW GAME---------\")\r\n self.current_word = \"----\"","def simulate(self):\r\n\t\tprint(\"##################################\")\r\n\t\tprint(\"SIMULATING GAME - SpaceInvaders..\")\r\n\t\tprint(\"##################################\")\r\n\t\t\r\n\t\t# Play 3 episodes:\r\n\t\tfor i in range(3):\r\n\t\t\tprint(\"Playing Episode %d\" % i)\r\n\t\t\tstate = self.env.reset()\r\n\t\t\t#self.env.render()\r\n\t\t\tdone = False\r\n\t\t\ttot_reward = 0\r\n\t\t\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \r\n\t\t\t\t\t\t\t\t\t\tstate, True)\r\n\t\t\t# play until dead.\t\t\t\r\n\t\t\twhile not done:\r\n\t\t\t\t# get the value predicted by the model and perform that action.\r\n\t\t\t\t# keras conv2d expects a 4D input. So add an empty axis. \r\n\t\t\t\tstate = np.expand_dims(state, axis=0)\r\n\t\t\t\t# predict action directly from the saved neural network.\r\n\t\t\t\taction = np.argmax(self.dqn.getModel().predict(state)[0])\r\n\t\t\t\t# perform that action.\r\n\t\t\t\tstate, reward, done, _ = self.env.step(action)\r\n\t\t\t\tself.env.render()\r\n\t\t\t\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \r\n\t\t\t\t\t\t\t\t\t\tstate, False)\r\n\t\t\t\ttot_reward+=reward\r\n\t\t\tprint(\"Reward: \", tot_reward)\r\n\t\tself.env.close() # to avoid sys.meta_path error\r","def __init__(self):\n\n # Change directory into the directory above this file - the\n # one containng the 'res' tree. Note that if we've been built via\n # py2exe, we will actually be in a zip file so account for that.\n path = os.path.dirname(os.path.dirname(__file__))\n if (os.path.basename(path) == \"library.zip\"):\n path = os.path.dirname(path)\n os.chdir( path )\n sys.path += [\".\"]\n\n # Services exposed to the entities.\n self.game_services = SpaceGameServices(self)\n\n # The resource loader.\n self.resource_loader = resource.ResourceLoader()\n\n # The configuration.\n if os.path.isfile(\"./config.txt\"):\n self.config = self.resource_loader.load_config_file_from(\"./config.txt\")\n else:\n self.config = self.resource_loader.load_config_file(\"base_config.txt\")\n\n # Create the renderer.\n renderer_name = self.config.get_or_default(\"renderer\", \"src.pygame_renderer.PygameRenderer\")\n renderer_class = utils.lookup_type(renderer_name)\n screen_size = (self.config.get_or_default(\"screen_width\", 1024),\n self.config.get_or_default(\"screen_height\", 768))\n self.renderer = renderer_class(screen_size, self.config, data_path=\"./res\")\n\n # The resource loaded needs a renderer to load images etc.\n self.resource_loader.set_renderer(self.renderer)\n\n # The input handling system.\n self.input_handling = None\n\n # The enemy.\n self.wave_spawner = None\n\n # Create the entity manager.\n self.entity_manager = ecs.EntityManager(self.game_services)\n\n # Configure the resource loader.\n self.resource_loader.set_minimise_image_loading(\n self.config.get_or_default(\"minimise_image_loading\", False)\n )\n\n # The drawing visitor.\n self.drawing = drawing.Drawing(self.game_services)\n\n # Is the game running?\n self.running = False\n\n # Should we load the game?\n self.want_load = False\n\n # Should we pause the game?\n self.want_pause = False\n\n # Should we unpause the game?\n self.want_resume = False\n\n # Should we simulate one frame and then pause?\n self.want_step = False","def _new(self, *args):\n if self.game:\n raise ServerException('already playing a game')\n self.game, self.player = self.server.new_game(self)","def setUp(self):\r\n self.spaceship = SpaceShipGame()\r\n self.spaceship.init()","def test_init_with_existing_game(self):\n pass\n # Ensure judge is the same","def load_game(self):\n game = Game(self.w, self.h, self.screen)\n game.run()","def new_game(cls, user):\n game = Game(user=user,\n game_state=\".........\",\n game_over=False)\n game.put()\n return game","def make_game():\n return ascii_art.ascii_art_to_game(\n GAME_ART, what_lies_beneath='.',\n sprites={'P': PlayerSprite})","def __init__(self, players, gamespace, start_state, transitions, setup, finish, get, post):\n\n self.players = players\n self.gamespace = gamespace\n self.start_state = start_state\n self.transitions = transitions\n self.setup = setup\n self.finish = finish\n self.get = get\n self.post = post\n\n self.turn = 1","def start_new_game(self):\r\n\r\n self.initialize_game_params()\r\n self.timer = Timer(self.screen)\r\n self.mine_counter = MineCounter(self.num_of_mines, self.screen)\r\n self.reset_button = ResetButton(self.screen)\r\n self.high_score = HighScore(self.rows, self.cols, self.num_of_mines, self.screen)\r\n self.board = Board(self.rows, self.cols, self.num_of_mines, self.screen)\r\n self.play_game()","def new_game(self, req):\n return models.BattleShip.create(req.left, req.right)","def run(self):\n pygame.init()\n pygame.display.set_caption(\"Genetic Game\")\n self.screen = pygame.display.set_mode((self.SCREEN_W, self.SCREEN_H), 0, 32)\n\n self.ominus_sprites = [OminusSprite(self.screen, o, PLAYERS_COLORS[o.id]) for o in self.model.get_players()]\n for o in self.ominus_sprites:\n self.agent_group.add(o)\n\n self.wall_sprites = [WallSprite(self.screen, w) for w in self.model.get_walls()]\n for w in self.wall_sprites:\n self.terrain_group.add(w)","def new_game(self):\n self.ui = UI()\n self.board.retract_board()\n self.board = Board()\n self.turn = BLUE\n self.selected_legal_moves = []\n self.selected_piece = None","def __init__(self, agent, make_env=lambda:gym.make(\"SpaceInvaders-v0\"), n_games=1, max_size=None,\n preprocess_observation = lambda obs:obs,agent_step=None):\n if not isinstance(make_env, function):\n env_name = make_env\n make_env = lambda: gym.make(env_name)\n\n #create atari games\n self.make_env = make_env\n self.envs = [self.make_env() for _ in range(n_games)]\n self.preprocess_observation = preprocess_observation\n\n\n #initial observations\n self.prev_observations = [self.preprocess_observation(make_env.reset()) for make_env in self.envs]\n\n #agent memory variables (if you use recurrent networks\n self.prev_memory_states = [np.zeros((n_games,)+tuple(mem.output_shape[1:]),\n dtype=get_layer_dtype(mem))\n for mem in agent.agent_states]\n\n #save agent\n self.agent = agent\n self.agent_step = agent_step or agent.get_react_function()\n\n # Create experience replay environment\n self.experience_replay = SessionPoolEnvironment(observations=agent.observation_layers,\n actions=agent.action_layers,\n agent_memories=agent.agent_states)\n self.max_size = max_size\n\n #whether particular session has just been terminated and needs restarting\n self.just_ended = [False] * len(self.envs)","def main():\n field = Field(10, 10)\n snake = Snake((0, 0))\n game = Game(field, snake)\n game.start()","def do_create_game(self):\n\t\tself.nickname = self.e_nickname.text\n\n\t\tself.hide_all()\n\t\tself.show_create()\n\t\tself.renderer.color = (255, 255, 255, 0)","def start(self):\n self.save_checkpoint(\"setup\")\n\n logging.info(\"Starting game...\")\n body = render_message(\n \"welcome.html\",\n game_name=self.name,\n night_end=self.night_end.strftime(\"%I:%M %p\"),\n day_end=self.day_end.strftime(\"%I:%M %p\"),\n players=self.game.players,\n )\n self.send_message(mafia.events.PUBLIC, \"%s: Start\" % self.name, body)\n self.game.begin()\n self.started = True\n\n self.save_checkpoint(\"start\")","async def createGameSpace(self, ctx):\n self.category = await ctx.guild.create_category_channel(name=self.categoryName)\n print(\"Category created\")\n await self.category.set_permissions(self.roleForPlayer, read_messages=True, connect=True)\n roleEveryone = discord.utils.get(ctx.guild.roles, name=\"@everyone\")\n await self.category.set_permissions(roleEveryone, read_messages=False, connect=False)\n\n self.textChannel = await ctx.guild.create_text_channel(name=\"Partie\", category=self.category)\n print(\"Text channel created\")\n self.voiceChannel = await ctx.guild.create_voice_channel(name=\"Village\", category=self.category)\n print(\"Voice channel created\")\n await self.voiceChannel.edit(user_limit=len(self.players) + 2, sync_permissions=True)\n await self.textChannel.edit(nsfw=True, sync_permissions=True)","async def new(ctx):\n if ctx.message.channel.name.lower() not in tod_channels:\n return\n\n room = ctx.message.channel.name.lower()\n host = ctx.message.author\n if room not in tod_games:\n tod_games[room] = {'host': host.name, 'host_id': host.name, 'participants': {}, 'last': None}\n tod_games[room]['current'] = host.name\n tod_games[room]['last'] = host.name\n tod_games[room]['participants'][host.name.lower()] = {'spins': 0}\n await amor_manager.say(\"New Game of Truth Or Dare started in {}\".format(room))\n else:\n host = tod_games[room]['host']\n await amor_manager.say(\"Truth or Dare already in progress in {}. Game host: {}\".format(room, host))","def create_game(agent, other_agent, games_counter, verbose_mode,\n from_db=False, cards_in_hand=13):\n if from_db:\n pass\n # todo(maryna): create single game from db. pay attention to players\n # initialization + the iterator.\n trick_counter = [0, 0, ] # [Team 0, Team 1]\n previous_tricks = []\n game = Game(agent, other_agent, games_counter, trick_counter, verbose_mode,\n previous_tricks, Trick({}), cards_in_hand=cards_in_hand)\n return game","def new_game(self):\n self.bet_history = []\n self.in_game = [True] * len(self.agents)\n self.in_game_count = len(self.agents)\n self.bet_hist = []\n self.pot = big_blind + small_blind\n self.chips[self.starting_player] -= small_blind\n self.chips[(self.starting_player + 1) % len(self.agents)] -= big_blind\n self.all_in = [False] * len(self.agents)\n\n self.hands = None\n self.community_cards = []\n\n self.shuffle_deck()\n\n for i in range(0, len(agents)):\n self.agents[i].new_game(len(agents), i)","def test_valid_game_setup(self):\n self.assertEqual(self._game.active_players(), 1)\n for x in xrange(1, 4):\n self._game.add_player(self._users[x], x)\n self.assertEqual(self._game.active_players(), 4)\n self.assertIsREADY(self._game)","def start(self):\n self.__init__()\n self.set_n_players()\n self.init_players()\n self.init_territory_selection_phase()\n self.init_troop_deployment_phase()\n # self.game_phase()","def setup_game(self, player, opponent):\n\n self.display.clear_screen()\n\n ship_index = 0\n\n while not player.ready(len(self.SHIP_INFO)):\n # prints the currrent board\n board = self.display.construct_player_board(player, opponent, True)\n self.display.print_board(board)\n\n ship_name, ship_length = self.SHIP_INFO[ship_index]\n ship_to_add = Ship(ship_name, ship_length)\n\n try:\n player.add_ship(ship_to_add)\n except Exception as e:\n ship_to_add = player.ships[ship_index]\n\n origin, orientation = self.display.prompt_for_ship_placement(\n ship_to_add)\n\n try:\n player.place_ship(ship_to_add, origin, orientation,\n self.BOARD_SIZE)\n except ValueError as ve:\n self.display.clear_screen()\n print(ve)\n print()\n continue\n\n self.display.clear_screen()\n ship_index += 1\n self.display.prompt_switch(opponent.name)","def populate_games():\n global games\n games[0] = SnakeGame(lp)","def __init__(self, game):\n self.rooms = self.load_rooms(f\"data/{game}Rooms.txt\")\n self.items = self.load_items(f\"data/{game}Items.txt\")\n self.inventory = self.load_inventory()\n self.current_room = self.rooms[0]\n self.idlist = []\n self.player = Inventory()","def start_game(self):\n self._add_mines()","def test_runGame(self):\n # this is tested by playing the game. No good way to unit test this.\n pass","def basic_begin_game(game_context) :\n game_context.world.set_game_defined()\n execute_context(game_context)","def new(self):\n self.playing = True\n self.score = 0\n # GROUPS AND LAYERS\n self.all_sprites = pg.sprite.LayeredUpdates() # Lets you assign layer to group to render in correct order\n self.planets = pg.sprite.Group()\n self.moons = pg.sprite.Group()\n self.mobs = pg.sprite.Group()\n self.stars = pg.sprite.Group()\n self.pickups = pg.sprite.Group()\n self.arrows = pg.sprite.Group()\n # SCREEN\n self.frame_coordinates = vec(0, 0)\n self.first_planet = Planet(self) # Add 1st Planet\n self.player = Player(self, self.first_planet) # Add Player on First Planet\n self.added_planets = 0\n self.spawn_planets(PLANETS + self.added_planets)\n self.arrow = Arrow(self)\n self.sun = Sun(self)\n\n # Messages\n self.corner_msg = 'Traverse & Score!'\n self.corner_msg_flag = False\n self.corner_msg_start_time = pg.time.get_ticks()\n\n self.arrow_msg = False\n\n # Play Music\n pg.mixer.music.load(path.join(self.snd_dir, LEVEL_1_MUSIC))\n\n # Start Game Loop\n self.run()\n print(\"GOT TO END OF NEW()\")","def game_created(self, pname, game):\n logging.debug('Game Created:')\n logging.debug(game)\n g = self.games.get(game['matchid'], None)\n if g:\n g.roomid = game['roomid']\n g.tableindex = game['tableindex']\n self.comm.game_ready(g)","def new_game(self):\n self.cells = [] # Array of cells\n self.frame_count = 0\n self.database = []\n self.timer = [Consts[\"MAX_TIME\"], Consts[\"MAX_TIME\"]]\n self.result = None\n # Define the players first\n self.cells.append(Cell(0, [Consts[\"WORLD_X\"] / 4, Consts[\"WORLD_Y\"] / 2], [0, 0], Consts[\"DEFAULT_RADIUS\"]))\n self.cells.append(Cell(1, [Consts[\"WORLD_X\"] / 4 * 3, Consts[\"WORLD_Y\"] / 2], [0, 0], Consts[\"DEFAULT_RADIUS\"]))\n # Generate a bunch of random cells\n for i in range(Consts[\"CELLS_COUNT\"]):\n if i < 4:\n rad = 1.5 + (random.random() * 1.5) # Small cells\n elif i < 10:\n rad = 10 + (random.random() * 4) # Big cells\n else:\n rad = 2 + (random.random() * 9) # Everything else\n x = Consts[\"WORLD_X\"] * random.random()\n y = Consts[\"WORLD_Y\"] * random.random()\n cell = Cell(i + 2, [x, y], [(random.random() - 0.5) * 2, (random.random() - 0.5) * 2], rad)\n safe_dist = Consts[\"SAFE_DIST\"] + rad\n while min(map(cell.distance_from, self.cells[:2])) < safe_dist:\n cell.pos = [\n Consts[\"WORLD_X\"] * random.random(),\n Consts[\"WORLD_Y\"] * random.random()\n ]\n self.cells.append(cell)","async def new_game():\n if enough_players():\n GAME.new_game()\n await update_players()","async def creatingGame(self, ctx):\n if self.progression == \"\":\n self.progression = \"Création d'une partie\"\n msg1 = await ctx.channel.send(\n content=\"Seules les réactions ayant plus de 2 voix seront comptabilisées.\"\n \"```css\\nLes rôles en verts sont les membres du village.```\"\n \"```Markdown\\n#Les rôles en bleu dépendent de la partie.```\"\n \"```diff\\n-Les rôles en rouge sont les loups-garous.```\"\n \"```Fix\\n#Les rôles en orange doivent gagner seul.```\",\n embed=self.embedPage1)\n self.msgChoiceRole.append(msg1.id)\n self.msgToDelete.append(msg1)\n await self.addRolesOnEmbed(msg1)\n else:\n await self.wait(ctx)","def test_game():\n \n # check that all of the functions are callable\n assert callable(g.AdventureGame)\n \n # Load up the rooms for the test game\n testGame = g.AdventureGame(tg.testRooms, tg.starting_room)\n \n # Test that the constructor properly loads the rooms\n assert testGame.rooms == tg.testRooms\n assert testGame.starting_room == tg.starting_room\n assert testGame.current_room == tg.starting_room","def test_game_creation(self):\n self.assertTrue(len(models.Game.objects.all()) == 1)\n game = models.Game.objects.all()[0]\n\n # Hydrocarbon piles initialization test\n number_of_piles = len(settings.HYDROCARBON_STOCKS_PER_PLAYER)\n for i_pile in range(number_of_piles):\n self.assertEqual(0, game.hydrocarbon_piles.get(index=i_pile).stock_amount)\n\n # Events initialization test [TO DO]\n\n # Source buildings loading test\n version_source_buildings = models.SourceBuilding.objects.filter(version=game.version)\n self.assertEqual(version_source_buildings.count(), game.source_buildings.count())\n for version_source_building in version_source_buildings:\n self.assertEqual(version_source_building, game.source_buildings.get(slug=version_source_building.slug))\n\n # Source events loading test [TO DO]\n\n # Source technologies loading test\n version_source_technologies = models.SourceTechnology.objects.filter(version=game.version)\n self.assertEqual(version_source_technologies.count(), game.source_technologies.count())\n for version_source_technology in version_source_technologies:\n self.assertEqual(version_source_technology,\n game.source_technologies.get(slug=version_source_technology.slug))","def create_game(self, user, attempts_remaining, attempts_used,\n score, current_level):\n\n game = Game(user=user, attempts_remaining=attempts_remaining,\n score=score, attempts_used=attempts_used,\n current_level=current_level)\n game.put()\n return game","def create_scene():\n create_floor()\n if config.M != \"\":\n if config.LEVEL == 1:\n create_wall()\n create_enemy()\n create_gap()\n create_platform()\n create_marijuana()\n create_star()\n create_fish()\n elif config.LEVEL == 2:\n create_boss()\n create_platform()\n create_star()","def new_game(cls, user, raw_ships):\n ships = ShipsManager(Ship, raw_ships).create_ships()\n game = Game(player=user, players_ships=ships,\n opponents_ships=ShipsGenerator(\n Ship).generate_opponents_ships())\n game.put()\n return game","def init_game(self):\n self.view.carregar_jogadores_possiveis(self._possible_players_list())\n self.view.put_view_in_main_loop()","def __init__(self, players):\n\n # Instantiate a Players object with the players queue\n self._players = Players(players)\n # Instantiate the Die to be used for the current game\n self._die = Die()\n # Track the game status\n self._active_turn = True\n self._end_game = False","def received_CREATE(self, message):\n\n\t\t_, rival_name, order = message.split(' ')\n\n\t\tplayer_token = \"X\" if order == \"first\" else \"O\"\n\t\trival_token = \"O\" if order == \"first\" else \"X\"\n\n\t\tself.player_model.player.token = player_token\n\n\t\t#Initializing rival player\n\t\tself.player_model.rival_player.name = rival_name\n\t\tself.player_model.rival_player.token = rival_token\n\t\tself.player_model.current_player = self.player_model.player if order == \"first\" else self.player_model.rival_player\n\n\t\tself.create_game()\n\n\t\tif order == \"first\":\n\t\t\tself.play()\n\n\t\telse:\n\t\t\tself.wait_to_play()\n\n\t\tself.player_frame.message_screen.write(f\"New game against {rival_name}\")\n\t\tself.player_frame.message_screen.write(f\"You go {order}\")","def start(self, timed):\n\n if timed:\n self._game = TimedGame(self._players)\n else:\n self._game = Game(self._players)\n \n self._game.start()","def generate(self):\n DistributedObject.DistributedObject.generate(self)\n\n # Get the state machine stuff for playGame\n self.loader = self.cr.playGame.hood.loader\n self.trolleyStation = self.loader.geom.find('**/*trolley_station*')\n self.trolleyCar = self.trolleyStation.find('**/trolley_car')\n self.trolleySphereNode = self.trolleyStation.find('**/trolley_sphere').node()\n\n # We'll need a pair of fog objects to enshadow the trolley\n # while it's rolling through the entrance or exit tunnels.\n\n exitFog = Fog(\"TrolleyExitFog\")\n exitFog.setColor(0.0, 0.0, 0.0)\n exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)\n exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)\n exitFog.setLinearFallback(70.0, 999.0, 1000.0)\n self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)\n self.trolleyExitFogNode = exitFog\n \n enterFog = Fog(\"TrolleyEnterFog\")\n enterFog.setColor(0.0, 0.0, 0.0)\n enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)\n enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)\n enterFog.setLinearFallback(70.0, 999.0, 1000.0)\n self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)\n self.trolleyEnterFogNode = enterFog\n\n # We'll have fog explicitly disabled for the trolley car, by\n # default. This makes it look maybe a little weird in\n # Donald's Dock--why does the trolley punch through the fog so\n # well? But it keeps the trolley from flashing in and out as\n # we turn on and off the shadow fog.\n self.trolleyCar.setFogOff()\n\n # Variables used to animate trolley parts\n # Key\n self.keys = self.trolleyCar.findAllMatches('**/key')\n self.numKeys = self.keys.getNumPaths()\n self.keyInit = []\n self.keyRef = []\n for i in range(self.numKeys):\n key = self.keys[i]\n key.setTwoSided(1)\n ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')\n ref.iPosHpr(key)\n self.keyRef.append(ref)\n self.keyInit.append(key.getTransform())\n # Front wheels\n self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')\n self.numFrontWheels = self.frontWheels.getNumPaths()\n self.frontWheelInit = []\n self.frontWheelRef = []\n for i in range(self.numFrontWheels):\n wheel = self.frontWheels[i]\n ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')\n ref.iPosHpr(wheel)\n self.frontWheelRef.append(ref)\n self.frontWheelInit.append(wheel.getTransform())\n # Back wheels\n self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')\n self.numBackWheels = self.backWheels.getNumPaths()\n self.backWheelInit = []\n self.backWheelRef = []\n for i in range(self.numBackWheels):\n wheel = self.backWheels[i]\n ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')\n ref.iPosHpr(wheel)\n self.backWheelRef.append(ref)\n self.backWheelInit.append(wheel.getTransform())\n\n # Create the trolley enter track\n trolleyAnimationReset = Func(self.resetAnimation)\n trolleyEnterStartPos = Point3(-20, 14, -1)\n trolleyEnterEndPos = Point3(15, 14, -1)\n\n trolleyEnterPos = Sequence(name=\"TrolleyEnterPos\")\n if base.wantFog:\n trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))\n trolleyEnterPos.append(self.trolleyCar.posInterval(\n TROLLEY_ENTER_TIME,\n trolleyEnterEndPos,\n startPos=trolleyEnterStartPos,\n blendType=\"easeOut\"))\n if base.wantFog:\n trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))\n \n trolleyEnterTrack = Sequence(trolleyAnimationReset, \n trolleyEnterPos,\n name = 'trolleyEnter')\n # \n # How many revolutions of the wheel?\n keyAngle = round(TROLLEY_ENTER_TIME) * 360\n dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()\n wheelAngle = dist/(2.0 * math.pi * 0.95) * 360\n trolleyEnterAnimateInterval = LerpFunctionInterval(\n self.animateTrolley,\n duration = TROLLEY_ENTER_TIME,\n blendType = \"easeOut\",\n extraArgs = [keyAngle, wheelAngle],\n name = \"TrolleyAnimate\")\n trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)\n self.trolleyEnterTrack = Parallel(trolleyEnterTrack,\n trolleyEnterAnimateInterval,\n trolleyEnterSoundTrack,\n )\n\n # Create the trolley exit track\n trolleyExitStartPos = Point3(15, 14, -1)\n trolleyExitEndPos = Point3(50, 14, -1)\n\n trolleyExitPos = Sequence(name=\"TrolleyExitPos\")\n if base.wantFog:\n trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))\n trolleyExitPos.append(self.trolleyCar.posInterval(\n TROLLEY_EXIT_TIME,\n trolleyExitEndPos,\n startPos=trolleyExitStartPos,\n blendType=\"easeIn\"))\n if base.wantFog:\n trolleyExitPos.append(Func(self.trolleyCar.setFogOff))\n \n \n trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)\n trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)\n\n keyAngle = round(TROLLEY_EXIT_TIME) * 360\n dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()\n wheelAngle = dist/(2.0 * math.pi * 0.95) * 360\n trolleyExitAnimateInterval = LerpFunctionInterval(\n self.animateTrolley,\n duration = TROLLEY_EXIT_TIME,\n blendType = \"easeIn\",\n extraArgs = [keyAngle, wheelAngle],\n name = \"TrolleyAnimate\")\n\n self.trolleyExitTrack = Parallel(trolleyExitPos,\n trolleyExitBellInterval,\n trolleyExitAwayInterval,\n trolleyExitAnimateInterval,\n name = self.uniqueName(\"trolleyExit\")\n )","async def startingGame(self, ctx):\n # =-=-=-= ATTRIBUTE ROLES FOR PLAYERS =-=-=-= #\n self.msgToDelete.append(await ctx.message.channel.send(\"Attribution des rôles ...\"))\n self.rolesOrder = self.roles.copy()\n self.rolesOrder = list(dict.fromkeys(self.rolesOrder)) # Remove redundant roles for playGame()\n random.seed(time.time())\n random.shuffle(self.players)\n random.shuffle(self.roles)\n self.roles = self.roles[:len(self.players) + 3]\n if self.roles.count(\"Franc-Maçon\") % 2 != 0: # Only One Freemason in\n for i in range(len(self.roles)):\n if self.roles[i] == \"Franc-Maçon\":\n self.roles[(i + 1) % len(self.roles)] = \"Franc-Maçon\"\n random.seed(time.time())\n random.shuffle(self.players)\n random.shuffle(self.roles)\n break\n\n for numberPlayer in range(len(self.players)):\n # At least there is less player than role, so I need to get the number of players instead of roles.\n\n self.syncRole(user=self.players[numberPlayer], roleToAdd=self.roles[numberPlayer],\n listToAdd=self.playersAndRoles)\n\n # =-=-=-= ATTRIBUTE ROLES FOR DECK =-=-=-= #\n for numberCentralRole in range(len(self.players), len(self.players) + 3):\n if numberCentralRole == len(self.players) + 0:\n position = \"gauche\"\n elif numberCentralRole == len(self.players) + 1:\n position = \"milieu\"\n else:\n position = \"droite\"\n self.syncRole(user=position, roleToAdd=self.roles[numberCentralRole], listToAdd=self.centralDeck)\n\n # =-=-=-= Preparing requires =-=-=-= #\n await self.createRole(ctx=ctx)\n self.msgToDelete.append(await ctx.message.channel.send(\"Création du village ...\"))\n print(\"Create village ...\")\n self.lastVoiceChannel = ctx.author.voice.channel\n await self.deleteCategory(ctx=ctx, reason=\"Pas de dualité de channel.\")\n await self.createGameSpace(ctx=ctx)\n await self.movePlayer(ctx=ctx, voiceChannel=self.voiceChannel, reason=\"Début de partie.\")\n\n print(\"Game started\")\n self.msgToDelete.append(await ctx.message.channel.send(\"Début de la partie.\"))\n\n await ctx.channel.send(\"Cleaning all messages ...\")\n await self.delAllMsg(waitingTime=5)\n await self.playGame(ctx=ctx)","def run_game_logic(self):\n pass","def create_new_game(game_name, player_name, points_to_win=POINTS_TO_WIN,\n min_players=MIN_PLAYERS, max_players=MAX_PLAYERS):\n do_house_keeping()\n if not can_create_new_game():\n return {}\n game_name = game_name or generate_game_name()\n player_name = player_name or generate_player_name()\n points_to_win = points_to_win or POINTS_TO_WIN\n min_players = min_players or MIN_PLAYERS\n max_players = max_players or MAX_PLAYERS\n if min_players < 2:\n min_players = 2\n if max_players > 10:\n max_players = 10\n game_id = generate_id(GAME_ID_LENGTH)\n game_data = {\n 'id': game_id,\n 'name': game_name,\n 'deck': create_deck(),\n 'stack': [],\n 'created_at': serialize_datetime(datetime.utcnow()),\n 'started_at': None,\n 'ended_at': None,\n 'active': False,\n 'reverse': False,\n 'min_players': min_players,\n 'max_players': max_players,\n 'players': [],\n 'points_to_win': points_to_win\n }\n add_player_to_game(game_data, player_name, True)\n msg = make_info_message(\n 'Click \"Start\" after all player(s) have joined')\n flash_broadcast(game_data, msg)\n result = save_state(game_data)\n if result:\n return game_data\n return {}","def main():\n pygame.init()\n os.environ['SDL_VIDEO_CENTERED'] = '1'\n pygame.display.set_caption('8-Puzzle game')\n screen = pygame.display.set_mode((800, 500))\n fpsclock = pygame.time.Clock()\n program = SlidePuzzle((3, 3), 160, 5, difficulty=10) # program is also the gym environment\n\n choice = program.selectPlayerMenu(fpsclock, screen)\n if choice == \"AI\":\n pygame.display.quit()\n trainAI(program)\n elif choice == \"human\":\n launchWithGUI(program, fpsclock, screen)\n del program","def new_game(self, wid, data=None):\n \n self.stop_game(0)\n\n # Slight delay for improved UX\n Fl.add_timeout(0.3, self.play_seq)","def start_game(self) -> None:\n self.init_game()\n self.play()","def create_game(cls, user, misses_allowed, secret_word, current_solution):\n game = cls(parent=user,\n user=user,\n misses_allowed=misses_allowed,\n misses_remaining=misses_allowed,\n secret_word=secret_word,\n current_solution=current_solution)\n game.put()\n return game","def create_game(game_ID):\n\n if r.exists(\"state:\" + game_ID) == 1:\n raise Exception(\"Game exists already\")\n\n new_game = {\n \"winner\": \"none\",\n \"turn\": \"blue\",\n \"action\": \"spymaster\",\n \"hint\": \"\",\n \"attemptsLeft\": 0,\n \"redPoints\": 0,\n \"bluePoints\": 0,\n }\n words = create_board()\n set_fields = r.hset(\"state:\" + game_ID, mapping=new_game)\n set_fields += r.hset(\"words:\" + game_ID, mapping=words)\n\n if set_fields == 32:\n return {\"playerState\": new_game, \"wordsState\": words}\n else:\n raise Exception(\"Could not make Game\")","def __init__(self, players=None):\n self.game = Game()\n if players:\n self.player1 = players[0]\n self.player2 = players[1]\n else:\n self.player1 = Player('X')\n self.player2 = Player('O')\n self.record = Record()\n self.winning_moves = []","def __init__(self, game='pong', obs_type='ram', frameskip=(2, 5), repeat_action_probability=0.):\n\n utils.EzPickle.__init__(self, game, obs_type)\n assert obs_type in ('ram', 'image')\n\n self.game_path = atari_py.get_game_path(game)\n if not os.path.exists(self.game_path):\n raise IOError('You asked for game %s but path %s does not exist'%(game, self.game_path))\n self._obs_type = obs_type\n self.frameskip = frameskip\n self.ale = ALEInterface()\n self.viewer = None\n\n # Tune (or disable) ALE's action repeat:\n # https://github.com/openai/gym/issues/349\n assert isinstance(repeat_action_probability, (float, int)), \"Invalid repeat_action_probability: {!r}\".format(repeat_action_probability)\n self.ale.setFloat('repeat_action_probability'.encode('utf-8'), repeat_action_probability)\n\n self._seed()\n\n (screen_width, screen_height) = self.ale.getScreenDims()\n self._buffer = np.empty((screen_height, screen_width, 3), dtype=np.uint8)\n\n self._action_set = self.ale.getMinimalActionSet()\n self.action_space = spaces.Discrete(len(self._action_set))\n\n (screen_width,screen_height) = self.ale.getScreenDims()\n if self._obs_type == 'ram':\n self.observation_space = spaces.Box(low=np.zeros(128), high=np.zeros(128)+255)\n elif self._obs_type == 'image':\n self.observation_space = spaces.Box(low=0, high=255, shape=(screen_height, screen_width, 3))\n else:\n raise error.Error('Unrecognized observation type: {}'.format(self._obs_type))","def play_game(self):\n # need everyone to pass to move to next phase?\n self.deal_cards()\n self.plant_food()","async def new_game(self, players): \r\n if len(players) != 10:\r\n return discord.Embed(title=\"Valorant 10 Man Bot\",\r\n description=\"You cannot start a game with only {} players\".format(len(players)))\r\n self.teams = {\"A\": [], \"B\" : []}\r\n self.previous_captains = self.captains\r\n self.captains = {\"A\" : None, \"B\" : None}\r\n self.nick_to_player = {get_member_name(p) : p for p in players}\r\n self.previous_players = self.remaining\r\n self.remaining = players.copy()\r\n self.turn = 1\r\n self.order = []\r\n self.map_dict = {k : True for k in self.map_dict.keys()}\r\n return discord.Embed(title=\"Valorant 10 Man Bot\",\r\n description=\"New game started\".format(len(players)))","def new_game(cls, x_user, o_user, game_moves):\n game = Game(x_user=x_user,\n o_user=o_user,\n game_moves=game_moves,\n moves_count=0,\n game_over=False)\n game.put()\n usergame = UserGame(user=x_user, \n game_key=game.key,\n moves_count=0,\n game_over=False)\n usergame.put()\n usergame = UserGame(user=o_user, \n game_key=game.key,\n moves_count=0,\n game_over=False)\n usergame.put()\n return game","def init_gym_pygame(game_name):\n # OpenAI gym setup \n game_name = 'gvgai-aliens-lvl0-v0'\n env = gym.make(game_name)\n env.reset()\n \n # pygame setup\n pg.init()\n height = env.observation_space.shape[0]\n width = env.observation_space.shape[1]\n screen = pg.display.set_mode((width, height))\n\n return env, screen","def setUp(self):\r\n global ship_image\r\n self.spaceshipgame = SpaceShipGame()\r\n self.spaceshipgame.init()\r\n pos = [1,1]\r\n vel = [1,1]\r\n angle = 0\r\n image = ship_image\r\n\r\n center = [1,1]\r\n size = 1\r\n info = ImageInfo(center, size)\r\n\r\n self.ship = Ship( pos, vel, angle, image, info)","def setUp(self):\r\n global ship_image\r\n self.spaceshipgame = SpaceShipGame()\r\n self.spaceshipgame.init()\r\n pos = [1,1]\r\n vel = [1,1]\r\n angle = 0\r\n image = ship_image\r\n\r\n center = [1,1]\r\n size = 1\r\n info = ImageInfo(center, size)\r\n\r\n self.ship = Ship( pos, vel, angle, image, info)","def main():\n # parse arguments from the command line (argparse validates arguments)\n args = _get_args()\n # build the environment with the given ID\n env = gym.make(args.env)\n # play the environment with the given mode\n if args.mode == 'human':\n play_human(env)\n else:\n play_random(env, args.steps)","def new_game(self):\n\n self.board = {}","def run_gui_game():\n # Set up game\n view = GuiView()\n game = GameEngine(view)","def __init__(self, size, block_positions, starts, player_1, player_2, \n terminal_viz, print_game_in_terminal, \n time_to_make_a_move=2, game_time=100, \n penalty_score=300, max_fruit_score=300, max_fruit_time=15):\n\n # check that each Player implements the following methods:\n self.players = [player_1, player_2]\n for player in self.players:\n assert hasattr(player, 'set_game_params')\n assert hasattr(player, 'make_move')\n assert hasattr(player, 'set_rival_move')\n assert hasattr(player, 'update_fruits')\n\n self.print_game_in_terminal = print_game_in_terminal\n self.terminal_viz = terminal_viz\n self.time_to_make_a_move = time_to_make_a_move\n self.penalty_score = penalty_score\n self.some_player_cant_move = False\n \n \n self.game_time_left_for_players = [game_time, game_time]\n\n initial_board = self.set_initial_board(size, block_positions, starts)\n\n self.game = Game(initial_board, starts, max_fruit_score=max_fruit_score, max_fruit_time=max_fruit_time, \n animated=True, animation_func=self.animate_func)\n\n for i, player in enumerate(self.players):\n player.set_game_params(self.game.get_map_for_player_i(player_id=i))","def __init__(self):\n\n self.width = 10\n self.height = 10\n self.new_game()","def spawn_players(self) -> None:\n # Initialise the players\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width // 2, 50,\n self.player_lives, self.fps, self.player1_bullet, Direction.DOWN, self.debug)\n self.player2 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width // 2,\n self.screen_height - 50, self.player_lives, self.fps, self.player2_bullet, Direction.UP,\n self.debug)\n\n # Rotate the image of the player at the top\n self.player1.rotate(180)","def init(seed=None):\n\tglobal _game\n\n\tfrom .game import Game\n\tfrom .prompt import install_words\n\n\t_game = Game(seed)\n\tload_advent_dat(_game)\n\tinstall_words(_game)\n\t_game.start()\n\treturn _game","def main():\n g = DemoGame(800, 600)\n g.start()","def main(self):\n _age = info.getInfo(self)\n _flag = game.check_age(self, _age)\n if _flag == False:\n exit()\n game.wants_to_play(0)","def main():\n\n containerTextStyle = {\n 'color': '#ffffff',\n 'font': '10px',\n 'stroke': '#000000',\n 'strokeWidth': .15\n }\n spawnerRole = Spawner()\n # Clean up memory\n for creepName in Object.keys(Memory.creeps):\n if not Game.creeps[creepName]:\n if Memory.creeps[creepName].role == \"remoteHarvester\":\n print(\"Cleaning up remoteHarvester. It mined: \" + Memory.creeps[creepName].totalHarvested)\n del Memory.creeps[creepName]\n #print(\"Clearing non-existent creep memory: \" + creepName)\n\n if Game.cpu.bucket == 10000:\n Game.cpu.generatePixel()\n # Run each creep\n for name in Object.keys(Game.creeps):\n creep = Game.creeps[name]\n if creep.memory.role in Spawner.roles:\n Spawner.roles[creep.memory.role].run(creep)\n else:\n creep.say(\"No role\")\n\n # Run tower code\n homeRoom = Object.values(Game.spawns)[0].room\n towers = [struct for room in Object.values(Game.rooms) for struct in room.find(FIND_STRUCTURES) if struct.structureType == STRUCTURE_TOWER]\n hostiles = homeRoom.find(FIND_HOSTILE_CREEPS)\n for tower in towers:\n structures = sorted([struct for struct in tower.room.find(FIND_STRUCTURES) if struct.hits < struct.hitsMax], key=lambda struct: struct.hits)\n if len(hostiles) > 0:\n tower.attack(tower.pos.findClosestByPath(hostiles))\n continue\n\n for structure in structures:\n if structure.hits < structure.hitsMax and structure.hits < 100000:\n tower.repair(structure)\n break\n\n # Run visuals\n for room in Object.values(Game.rooms):\n for container in [struct for struct in room.find(FIND_STRUCTURES) if struct.structureType == STRUCTURE_CONTAINER or struct.structureType == STRUCTURE_STORAGE]:\n room.visual.text(Spawner.roles['harvester'].getStructureFutureEnergy(container), container.pos, containerTextStyle)\n\n # Run each spawn\n for name in Object.keys(Game.spawns)[0:1]:\n spawn = Game.spawns[name]\n spawnerRole.run(spawn)","def __init__(self, affinity, game_type, game_space, opponent=None):\n \n super().__init__(affinity, game_type, game_space, opponent)","def __init__(self):\n self.screen = pg.display.get_surface()\n self.screen_rect = self.screen.get_rect()\n self.clock = pg.time.Clock()\n self.fps = 60\n self.keys = pg.key.get_pressed()\n self.done = False\n # ship = random.choice(list(prepare.GFX[\"ships\"].values()))\n ship = list(prepare.GFX[\"ships\"].values())[7] # pick first ship available\n self.player = actors.Player((0, 0), ship)\n self.level = level.Level(self.screen_rect.copy(), self.player)\n\n self.energyloss_counter = 0\n self.energygain_counter = 0","def start_game(self):\n while self.can_deal:\n self.take_turn()","def __init__(self):\n pygame.init()\n self.settings = Settings()\n self.screen = pygame.display.set_mode(\n (self.settings.screen_width, self.settings.screen_height)\n )\n pygame.display.set_caption(\"Sideways Shooter\")\n self.stats = GameStats(self)\n self.sideways_ship = SidewaysShip(self)\n self.bullets = pygame.sprite.Group()\n self.aliens = pygame.sprite.Group()\n self._create_fleet()","def test_valid_new_game(self):\n self._game.new_game()\n self.assertIsRUNNING(self._game)\n self.assertIsNotNone(self._game.table)\n self.assertEqual(self._game.table.player_turn, 1,\n \"Game.table unsuccessful init.\")","def start_game(self):\n self.master.destroy()\n Game()","def do_start_hosted(self):\n\t\tself.game_name = self.e_gamename.text\n\t\tself.num_players = (1, int(self.e_players.text))\n\t\tself.boardsize = (int(self.e_boardw.text), int(self.e_boardh.text))\n\n\t\td = {\"state\": be.S_GAME,\n\t\t\t\t\"hosting\": True,\n\t\t\t\t\"uuid\": None,\n\t\t\t\t\"name\": self.game_name,\n\t\t\t\t\"nickname\": self.nickname,\n\t\t\t\t\"num_players\": self.num_players,\n\t\t\t\t\"boardsize\": self.boardsize}\n\t\tevent = pygame.event.Event(be.E_STATE, d)\n\t\tpygame.event.post(event)\n\n\t\tself.hide_all()\n\t\tself.renderer.color = (0, 0, 0, 0)","def __init__(self, game):\n self.rooms = self.load_rooms(f\"data/{game}Rooms.txt\")\n self.current_room = self.rooms[1]\n # use self.over to determine if the game if over\n self.over = 0\n self.load_items(f\"data/{game}Items.txt\")\n self.inventory = Inventory()\n # synonyms\n self.synonyms = {}\n self.load_synonyms(\"data/SmallSynonyms.txt\")","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline= True ) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit","async def game(self):\n pass"],"string":"[\n \"def __init__(self, game_name, skip_actions=4, num_frames=4, w=84, h=84):\\n self.env = gym.make(game_name)\\n self.num_frames = num_frames\\n self.skip_actions = skip_actions\\n self.w = w\\n self.h = h\\n\\n if game_name == 'SpaceInvaders-v0':\\n self.action_space=[1,2,3]\\n\\n self.action_size = len(self.action_space)\\n self.state = None\\n self.game_name = game_name\",\n \"def create_game(self):\\n\\n\\t\\tself.player_model.grid = []\\n\\t\\tself.player_model.available_cells = []\\n\\n\\t\\tfor i in range(9):\\n\\t\\t\\tc = Cell(i, None)\\n\\t\\t\\tself.player_model.grid.append(c)\\n\\t\\t\\tself.player_model.available_cells.append(c)\\n\\n\\t\\tself.player_frame.setup_game(self.player_model.current_player.name)\",\n \"def _create_games(self):\\n\\n ''''''\",\n \"def start_game(self):\\n\\n\\t\\tpass\",\n \"def setup_game(self):\",\n \"def make_game(self):\\n game = Game(self.data['gamename'])\\n self.game = game\\n return game\",\n \"def game_start():\\n herolist = Hero_List(hots_db)\\n heroclasses = []\\n for item in herolist:\\n heroclasses.append(Item(item, 'hero'))\\n curgame = Game(Team('home'), Team('enemy'), Team('hero_pool', heroclasses), '')\\n return curgame\",\n \"def create(game):\\r\\n ## Create Garbage\\r\\n game.garbage = deque([])\\r\\n\\r\\n ## Create Stars\\r\\n game.create_stars()\\r\\n\\r\\n ## Create Millenium Falcon\\r\\n game.falcons = MilleniumFalcon.init(game)\\r\\n game.millenium_falcon = MilleniumFalcon()\\r\\n \\r\\n ## Create TIE Fighters\\r\\n game.fighters = Fighter.init(game)\\r\\n\\r\\n ## Create Asteroids\\r\\n game.rocks = Group.mesh(Rock1.init(game), Rock2.init(game))\\r\\n\\r\\n ## Create Lasers\\r\\n game.pro_lasers = ProLaser.init(game)\\r\\n game.con_lasers = ConLaser.init(game)\\r\\n\\r\\n ## Setup collision groups\\r\\n Group.bind(game.pro_lasers, game.rocks, game.act_laser_void)\",\n \"def start(self):\\n self.player = Player()\\n self.dealer = Dealer()\\n self.pot = 0\\n self.side_bet = 0\\n start_game()\",\n \"def init_new_game(self):\\n self.game = get_new_game(self.game_config)\",\n \"def start_game(self):\\n self.board = Board(num_tableaus=self.tableau_qty, num_decks=self.decks, deal_3=self.deal_3)\\n self.board.init_move_dict()\\n self.board.deal(self.deck)\\n\\n if self.api_use:\\n self.init_game_api()\\n elif self.commandline:\\n self.init_cl_game()\\n else:\\n self.init_pygame()\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\",\n \"def main():\\n g = Game(800, 600)\\n g.start()\",\n \"def spawn_players(self) -> None:\\n #Create the player\\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//(3/2), self.screen_height-50, self.player_lives, self.fps, self.player1_bullet, Direction.UP, self.debug)\\n\\n #Create the AI\\n self.player2 = AIPlayer(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//3, self.screen_height-50, self.player_lives, self.fps, self.player2_bullet, Direction.UP, 1, True, self.debug)\",\n \"def create_one_game(self):\\n return Game2048(task_name=self.result_path, game_mode=False)\",\n \"def setup_new_game(self):\\r\\n self._player = Player()\\r\\n self._stats = GameStats(self._bb_settings)\\r\\n self._scoreboard = Scoreboard(self._bb_settings, self._screen)\",\n \"def create_new_game(self):\\r\\n global game_instance\\r\\n game_instance = game.Game()\\r\\n game_instance.set_word(db.get_random_word())\\r\\n print(\\\"\\\\n---------NEW GAME---------\\\")\\r\\n self.current_word = \\\"----\\\"\",\n \"def simulate(self):\\r\\n\\t\\tprint(\\\"##################################\\\")\\r\\n\\t\\tprint(\\\"SIMULATING GAME - SpaceInvaders..\\\")\\r\\n\\t\\tprint(\\\"##################################\\\")\\r\\n\\t\\t\\r\\n\\t\\t# Play 3 episodes:\\r\\n\\t\\tfor i in range(3):\\r\\n\\t\\t\\tprint(\\\"Playing Episode %d\\\" % i)\\r\\n\\t\\t\\tstate = self.env.reset()\\r\\n\\t\\t\\t#self.env.render()\\r\\n\\t\\t\\tdone = False\\r\\n\\t\\t\\ttot_reward = 0\\r\\n\\t\\t\\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tstate, True)\\r\\n\\t\\t\\t# play until dead.\\t\\t\\t\\r\\n\\t\\t\\twhile not done:\\r\\n\\t\\t\\t\\t# get the value predicted by the model and perform that action.\\r\\n\\t\\t\\t\\t# keras conv2d expects a 4D input. So add an empty axis. \\r\\n\\t\\t\\t\\tstate = np.expand_dims(state, axis=0)\\r\\n\\t\\t\\t\\t# predict action directly from the saved neural network.\\r\\n\\t\\t\\t\\taction = np.argmax(self.dqn.getModel().predict(state)[0])\\r\\n\\t\\t\\t\\t# perform that action.\\r\\n\\t\\t\\t\\tstate, reward, done, _ = self.env.step(action)\\r\\n\\t\\t\\t\\tself.env.render()\\r\\n\\t\\t\\t\\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tstate, False)\\r\\n\\t\\t\\t\\ttot_reward+=reward\\r\\n\\t\\t\\tprint(\\\"Reward: \\\", tot_reward)\\r\\n\\t\\tself.env.close() # to avoid sys.meta_path error\\r\",\n \"def __init__(self):\\n\\n # Change directory into the directory above this file - the\\n # one containng the 'res' tree. Note that if we've been built via\\n # py2exe, we will actually be in a zip file so account for that.\\n path = os.path.dirname(os.path.dirname(__file__))\\n if (os.path.basename(path) == \\\"library.zip\\\"):\\n path = os.path.dirname(path)\\n os.chdir( path )\\n sys.path += [\\\".\\\"]\\n\\n # Services exposed to the entities.\\n self.game_services = SpaceGameServices(self)\\n\\n # The resource loader.\\n self.resource_loader = resource.ResourceLoader()\\n\\n # The configuration.\\n if os.path.isfile(\\\"./config.txt\\\"):\\n self.config = self.resource_loader.load_config_file_from(\\\"./config.txt\\\")\\n else:\\n self.config = self.resource_loader.load_config_file(\\\"base_config.txt\\\")\\n\\n # Create the renderer.\\n renderer_name = self.config.get_or_default(\\\"renderer\\\", \\\"src.pygame_renderer.PygameRenderer\\\")\\n renderer_class = utils.lookup_type(renderer_name)\\n screen_size = (self.config.get_or_default(\\\"screen_width\\\", 1024),\\n self.config.get_or_default(\\\"screen_height\\\", 768))\\n self.renderer = renderer_class(screen_size, self.config, data_path=\\\"./res\\\")\\n\\n # The resource loaded needs a renderer to load images etc.\\n self.resource_loader.set_renderer(self.renderer)\\n\\n # The input handling system.\\n self.input_handling = None\\n\\n # The enemy.\\n self.wave_spawner = None\\n\\n # Create the entity manager.\\n self.entity_manager = ecs.EntityManager(self.game_services)\\n\\n # Configure the resource loader.\\n self.resource_loader.set_minimise_image_loading(\\n self.config.get_or_default(\\\"minimise_image_loading\\\", False)\\n )\\n\\n # The drawing visitor.\\n self.drawing = drawing.Drawing(self.game_services)\\n\\n # Is the game running?\\n self.running = False\\n\\n # Should we load the game?\\n self.want_load = False\\n\\n # Should we pause the game?\\n self.want_pause = False\\n\\n # Should we unpause the game?\\n self.want_resume = False\\n\\n # Should we simulate one frame and then pause?\\n self.want_step = False\",\n \"def _new(self, *args):\\n if self.game:\\n raise ServerException('already playing a game')\\n self.game, self.player = self.server.new_game(self)\",\n \"def setUp(self):\\r\\n self.spaceship = SpaceShipGame()\\r\\n self.spaceship.init()\",\n \"def test_init_with_existing_game(self):\\n pass\\n # Ensure judge is the same\",\n \"def load_game(self):\\n game = Game(self.w, self.h, self.screen)\\n game.run()\",\n \"def new_game(cls, user):\\n game = Game(user=user,\\n game_state=\\\".........\\\",\\n game_over=False)\\n game.put()\\n return game\",\n \"def make_game():\\n return ascii_art.ascii_art_to_game(\\n GAME_ART, what_lies_beneath='.',\\n sprites={'P': PlayerSprite})\",\n \"def __init__(self, players, gamespace, start_state, transitions, setup, finish, get, post):\\n\\n self.players = players\\n self.gamespace = gamespace\\n self.start_state = start_state\\n self.transitions = transitions\\n self.setup = setup\\n self.finish = finish\\n self.get = get\\n self.post = post\\n\\n self.turn = 1\",\n \"def start_new_game(self):\\r\\n\\r\\n self.initialize_game_params()\\r\\n self.timer = Timer(self.screen)\\r\\n self.mine_counter = MineCounter(self.num_of_mines, self.screen)\\r\\n self.reset_button = ResetButton(self.screen)\\r\\n self.high_score = HighScore(self.rows, self.cols, self.num_of_mines, self.screen)\\r\\n self.board = Board(self.rows, self.cols, self.num_of_mines, self.screen)\\r\\n self.play_game()\",\n \"def new_game(self, req):\\n return models.BattleShip.create(req.left, req.right)\",\n \"def run(self):\\n pygame.init()\\n pygame.display.set_caption(\\\"Genetic Game\\\")\\n self.screen = pygame.display.set_mode((self.SCREEN_W, self.SCREEN_H), 0, 32)\\n\\n self.ominus_sprites = [OminusSprite(self.screen, o, PLAYERS_COLORS[o.id]) for o in self.model.get_players()]\\n for o in self.ominus_sprites:\\n self.agent_group.add(o)\\n\\n self.wall_sprites = [WallSprite(self.screen, w) for w in self.model.get_walls()]\\n for w in self.wall_sprites:\\n self.terrain_group.add(w)\",\n \"def new_game(self):\\n self.ui = UI()\\n self.board.retract_board()\\n self.board = Board()\\n self.turn = BLUE\\n self.selected_legal_moves = []\\n self.selected_piece = None\",\n \"def __init__(self, agent, make_env=lambda:gym.make(\\\"SpaceInvaders-v0\\\"), n_games=1, max_size=None,\\n preprocess_observation = lambda obs:obs,agent_step=None):\\n if not isinstance(make_env, function):\\n env_name = make_env\\n make_env = lambda: gym.make(env_name)\\n\\n #create atari games\\n self.make_env = make_env\\n self.envs = [self.make_env() for _ in range(n_games)]\\n self.preprocess_observation = preprocess_observation\\n\\n\\n #initial observations\\n self.prev_observations = [self.preprocess_observation(make_env.reset()) for make_env in self.envs]\\n\\n #agent memory variables (if you use recurrent networks\\n self.prev_memory_states = [np.zeros((n_games,)+tuple(mem.output_shape[1:]),\\n dtype=get_layer_dtype(mem))\\n for mem in agent.agent_states]\\n\\n #save agent\\n self.agent = agent\\n self.agent_step = agent_step or agent.get_react_function()\\n\\n # Create experience replay environment\\n self.experience_replay = SessionPoolEnvironment(observations=agent.observation_layers,\\n actions=agent.action_layers,\\n agent_memories=agent.agent_states)\\n self.max_size = max_size\\n\\n #whether particular session has just been terminated and needs restarting\\n self.just_ended = [False] * len(self.envs)\",\n \"def main():\\n field = Field(10, 10)\\n snake = Snake((0, 0))\\n game = Game(field, snake)\\n game.start()\",\n \"def do_create_game(self):\\n\\t\\tself.nickname = self.e_nickname.text\\n\\n\\t\\tself.hide_all()\\n\\t\\tself.show_create()\\n\\t\\tself.renderer.color = (255, 255, 255, 0)\",\n \"def start(self):\\n self.save_checkpoint(\\\"setup\\\")\\n\\n logging.info(\\\"Starting game...\\\")\\n body = render_message(\\n \\\"welcome.html\\\",\\n game_name=self.name,\\n night_end=self.night_end.strftime(\\\"%I:%M %p\\\"),\\n day_end=self.day_end.strftime(\\\"%I:%M %p\\\"),\\n players=self.game.players,\\n )\\n self.send_message(mafia.events.PUBLIC, \\\"%s: Start\\\" % self.name, body)\\n self.game.begin()\\n self.started = True\\n\\n self.save_checkpoint(\\\"start\\\")\",\n \"async def createGameSpace(self, ctx):\\n self.category = await ctx.guild.create_category_channel(name=self.categoryName)\\n print(\\\"Category created\\\")\\n await self.category.set_permissions(self.roleForPlayer, read_messages=True, connect=True)\\n roleEveryone = discord.utils.get(ctx.guild.roles, name=\\\"@everyone\\\")\\n await self.category.set_permissions(roleEveryone, read_messages=False, connect=False)\\n\\n self.textChannel = await ctx.guild.create_text_channel(name=\\\"Partie\\\", category=self.category)\\n print(\\\"Text channel created\\\")\\n self.voiceChannel = await ctx.guild.create_voice_channel(name=\\\"Village\\\", category=self.category)\\n print(\\\"Voice channel created\\\")\\n await self.voiceChannel.edit(user_limit=len(self.players) + 2, sync_permissions=True)\\n await self.textChannel.edit(nsfw=True, sync_permissions=True)\",\n \"async def new(ctx):\\n if ctx.message.channel.name.lower() not in tod_channels:\\n return\\n\\n room = ctx.message.channel.name.lower()\\n host = ctx.message.author\\n if room not in tod_games:\\n tod_games[room] = {'host': host.name, 'host_id': host.name, 'participants': {}, 'last': None}\\n tod_games[room]['current'] = host.name\\n tod_games[room]['last'] = host.name\\n tod_games[room]['participants'][host.name.lower()] = {'spins': 0}\\n await amor_manager.say(\\\"New Game of Truth Or Dare started in {}\\\".format(room))\\n else:\\n host = tod_games[room]['host']\\n await amor_manager.say(\\\"Truth or Dare already in progress in {}. Game host: {}\\\".format(room, host))\",\n \"def create_game(agent, other_agent, games_counter, verbose_mode,\\n from_db=False, cards_in_hand=13):\\n if from_db:\\n pass\\n # todo(maryna): create single game from db. pay attention to players\\n # initialization + the iterator.\\n trick_counter = [0, 0, ] # [Team 0, Team 1]\\n previous_tricks = []\\n game = Game(agent, other_agent, games_counter, trick_counter, verbose_mode,\\n previous_tricks, Trick({}), cards_in_hand=cards_in_hand)\\n return game\",\n \"def new_game(self):\\n self.bet_history = []\\n self.in_game = [True] * len(self.agents)\\n self.in_game_count = len(self.agents)\\n self.bet_hist = []\\n self.pot = big_blind + small_blind\\n self.chips[self.starting_player] -= small_blind\\n self.chips[(self.starting_player + 1) % len(self.agents)] -= big_blind\\n self.all_in = [False] * len(self.agents)\\n\\n self.hands = None\\n self.community_cards = []\\n\\n self.shuffle_deck()\\n\\n for i in range(0, len(agents)):\\n self.agents[i].new_game(len(agents), i)\",\n \"def test_valid_game_setup(self):\\n self.assertEqual(self._game.active_players(), 1)\\n for x in xrange(1, 4):\\n self._game.add_player(self._users[x], x)\\n self.assertEqual(self._game.active_players(), 4)\\n self.assertIsREADY(self._game)\",\n \"def start(self):\\n self.__init__()\\n self.set_n_players()\\n self.init_players()\\n self.init_territory_selection_phase()\\n self.init_troop_deployment_phase()\\n # self.game_phase()\",\n \"def setup_game(self, player, opponent):\\n\\n self.display.clear_screen()\\n\\n ship_index = 0\\n\\n while not player.ready(len(self.SHIP_INFO)):\\n # prints the currrent board\\n board = self.display.construct_player_board(player, opponent, True)\\n self.display.print_board(board)\\n\\n ship_name, ship_length = self.SHIP_INFO[ship_index]\\n ship_to_add = Ship(ship_name, ship_length)\\n\\n try:\\n player.add_ship(ship_to_add)\\n except Exception as e:\\n ship_to_add = player.ships[ship_index]\\n\\n origin, orientation = self.display.prompt_for_ship_placement(\\n ship_to_add)\\n\\n try:\\n player.place_ship(ship_to_add, origin, orientation,\\n self.BOARD_SIZE)\\n except ValueError as ve:\\n self.display.clear_screen()\\n print(ve)\\n print()\\n continue\\n\\n self.display.clear_screen()\\n ship_index += 1\\n self.display.prompt_switch(opponent.name)\",\n \"def populate_games():\\n global games\\n games[0] = SnakeGame(lp)\",\n \"def __init__(self, game):\\n self.rooms = self.load_rooms(f\\\"data/{game}Rooms.txt\\\")\\n self.items = self.load_items(f\\\"data/{game}Items.txt\\\")\\n self.inventory = self.load_inventory()\\n self.current_room = self.rooms[0]\\n self.idlist = []\\n self.player = Inventory()\",\n \"def start_game(self):\\n self._add_mines()\",\n \"def test_runGame(self):\\n # this is tested by playing the game. No good way to unit test this.\\n pass\",\n \"def basic_begin_game(game_context) :\\n game_context.world.set_game_defined()\\n execute_context(game_context)\",\n \"def new(self):\\n self.playing = True\\n self.score = 0\\n # GROUPS AND LAYERS\\n self.all_sprites = pg.sprite.LayeredUpdates() # Lets you assign layer to group to render in correct order\\n self.planets = pg.sprite.Group()\\n self.moons = pg.sprite.Group()\\n self.mobs = pg.sprite.Group()\\n self.stars = pg.sprite.Group()\\n self.pickups = pg.sprite.Group()\\n self.arrows = pg.sprite.Group()\\n # SCREEN\\n self.frame_coordinates = vec(0, 0)\\n self.first_planet = Planet(self) # Add 1st Planet\\n self.player = Player(self, self.first_planet) # Add Player on First Planet\\n self.added_planets = 0\\n self.spawn_planets(PLANETS + self.added_planets)\\n self.arrow = Arrow(self)\\n self.sun = Sun(self)\\n\\n # Messages\\n self.corner_msg = 'Traverse & Score!'\\n self.corner_msg_flag = False\\n self.corner_msg_start_time = pg.time.get_ticks()\\n\\n self.arrow_msg = False\\n\\n # Play Music\\n pg.mixer.music.load(path.join(self.snd_dir, LEVEL_1_MUSIC))\\n\\n # Start Game Loop\\n self.run()\\n print(\\\"GOT TO END OF NEW()\\\")\",\n \"def game_created(self, pname, game):\\n logging.debug('Game Created:')\\n logging.debug(game)\\n g = self.games.get(game['matchid'], None)\\n if g:\\n g.roomid = game['roomid']\\n g.tableindex = game['tableindex']\\n self.comm.game_ready(g)\",\n \"def new_game(self):\\n self.cells = [] # Array of cells\\n self.frame_count = 0\\n self.database = []\\n self.timer = [Consts[\\\"MAX_TIME\\\"], Consts[\\\"MAX_TIME\\\"]]\\n self.result = None\\n # Define the players first\\n self.cells.append(Cell(0, [Consts[\\\"WORLD_X\\\"] / 4, Consts[\\\"WORLD_Y\\\"] / 2], [0, 0], Consts[\\\"DEFAULT_RADIUS\\\"]))\\n self.cells.append(Cell(1, [Consts[\\\"WORLD_X\\\"] / 4 * 3, Consts[\\\"WORLD_Y\\\"] / 2], [0, 0], Consts[\\\"DEFAULT_RADIUS\\\"]))\\n # Generate a bunch of random cells\\n for i in range(Consts[\\\"CELLS_COUNT\\\"]):\\n if i < 4:\\n rad = 1.5 + (random.random() * 1.5) # Small cells\\n elif i < 10:\\n rad = 10 + (random.random() * 4) # Big cells\\n else:\\n rad = 2 + (random.random() * 9) # Everything else\\n x = Consts[\\\"WORLD_X\\\"] * random.random()\\n y = Consts[\\\"WORLD_Y\\\"] * random.random()\\n cell = Cell(i + 2, [x, y], [(random.random() - 0.5) * 2, (random.random() - 0.5) * 2], rad)\\n safe_dist = Consts[\\\"SAFE_DIST\\\"] + rad\\n while min(map(cell.distance_from, self.cells[:2])) < safe_dist:\\n cell.pos = [\\n Consts[\\\"WORLD_X\\\"] * random.random(),\\n Consts[\\\"WORLD_Y\\\"] * random.random()\\n ]\\n self.cells.append(cell)\",\n \"async def new_game():\\n if enough_players():\\n GAME.new_game()\\n await update_players()\",\n \"async def creatingGame(self, ctx):\\n if self.progression == \\\"\\\":\\n self.progression = \\\"Création d'une partie\\\"\\n msg1 = await ctx.channel.send(\\n content=\\\"Seules les réactions ayant plus de 2 voix seront comptabilisées.\\\"\\n \\\"```css\\\\nLes rôles en verts sont les membres du village.```\\\"\\n \\\"```Markdown\\\\n#Les rôles en bleu dépendent de la partie.```\\\"\\n \\\"```diff\\\\n-Les rôles en rouge sont les loups-garous.```\\\"\\n \\\"```Fix\\\\n#Les rôles en orange doivent gagner seul.```\\\",\\n embed=self.embedPage1)\\n self.msgChoiceRole.append(msg1.id)\\n self.msgToDelete.append(msg1)\\n await self.addRolesOnEmbed(msg1)\\n else:\\n await self.wait(ctx)\",\n \"def test_game():\\n \\n # check that all of the functions are callable\\n assert callable(g.AdventureGame)\\n \\n # Load up the rooms for the test game\\n testGame = g.AdventureGame(tg.testRooms, tg.starting_room)\\n \\n # Test that the constructor properly loads the rooms\\n assert testGame.rooms == tg.testRooms\\n assert testGame.starting_room == tg.starting_room\\n assert testGame.current_room == tg.starting_room\",\n \"def test_game_creation(self):\\n self.assertTrue(len(models.Game.objects.all()) == 1)\\n game = models.Game.objects.all()[0]\\n\\n # Hydrocarbon piles initialization test\\n number_of_piles = len(settings.HYDROCARBON_STOCKS_PER_PLAYER)\\n for i_pile in range(number_of_piles):\\n self.assertEqual(0, game.hydrocarbon_piles.get(index=i_pile).stock_amount)\\n\\n # Events initialization test [TO DO]\\n\\n # Source buildings loading test\\n version_source_buildings = models.SourceBuilding.objects.filter(version=game.version)\\n self.assertEqual(version_source_buildings.count(), game.source_buildings.count())\\n for version_source_building in version_source_buildings:\\n self.assertEqual(version_source_building, game.source_buildings.get(slug=version_source_building.slug))\\n\\n # Source events loading test [TO DO]\\n\\n # Source technologies loading test\\n version_source_technologies = models.SourceTechnology.objects.filter(version=game.version)\\n self.assertEqual(version_source_technologies.count(), game.source_technologies.count())\\n for version_source_technology in version_source_technologies:\\n self.assertEqual(version_source_technology,\\n game.source_technologies.get(slug=version_source_technology.slug))\",\n \"def create_game(self, user, attempts_remaining, attempts_used,\\n score, current_level):\\n\\n game = Game(user=user, attempts_remaining=attempts_remaining,\\n score=score, attempts_used=attempts_used,\\n current_level=current_level)\\n game.put()\\n return game\",\n \"def create_scene():\\n create_floor()\\n if config.M != \\\"\\\":\\n if config.LEVEL == 1:\\n create_wall()\\n create_enemy()\\n create_gap()\\n create_platform()\\n create_marijuana()\\n create_star()\\n create_fish()\\n elif config.LEVEL == 2:\\n create_boss()\\n create_platform()\\n create_star()\",\n \"def new_game(cls, user, raw_ships):\\n ships = ShipsManager(Ship, raw_ships).create_ships()\\n game = Game(player=user, players_ships=ships,\\n opponents_ships=ShipsGenerator(\\n Ship).generate_opponents_ships())\\n game.put()\\n return game\",\n \"def init_game(self):\\n self.view.carregar_jogadores_possiveis(self._possible_players_list())\\n self.view.put_view_in_main_loop()\",\n \"def __init__(self, players):\\n\\n # Instantiate a Players object with the players queue\\n self._players = Players(players)\\n # Instantiate the Die to be used for the current game\\n self._die = Die()\\n # Track the game status\\n self._active_turn = True\\n self._end_game = False\",\n \"def received_CREATE(self, message):\\n\\n\\t\\t_, rival_name, order = message.split(' ')\\n\\n\\t\\tplayer_token = \\\"X\\\" if order == \\\"first\\\" else \\\"O\\\"\\n\\t\\trival_token = \\\"O\\\" if order == \\\"first\\\" else \\\"X\\\"\\n\\n\\t\\tself.player_model.player.token = player_token\\n\\n\\t\\t#Initializing rival player\\n\\t\\tself.player_model.rival_player.name = rival_name\\n\\t\\tself.player_model.rival_player.token = rival_token\\n\\t\\tself.player_model.current_player = self.player_model.player if order == \\\"first\\\" else self.player_model.rival_player\\n\\n\\t\\tself.create_game()\\n\\n\\t\\tif order == \\\"first\\\":\\n\\t\\t\\tself.play()\\n\\n\\t\\telse:\\n\\t\\t\\tself.wait_to_play()\\n\\n\\t\\tself.player_frame.message_screen.write(f\\\"New game against {rival_name}\\\")\\n\\t\\tself.player_frame.message_screen.write(f\\\"You go {order}\\\")\",\n \"def start(self, timed):\\n\\n if timed:\\n self._game = TimedGame(self._players)\\n else:\\n self._game = Game(self._players)\\n \\n self._game.start()\",\n \"def generate(self):\\n DistributedObject.DistributedObject.generate(self)\\n\\n # Get the state machine stuff for playGame\\n self.loader = self.cr.playGame.hood.loader\\n self.trolleyStation = self.loader.geom.find('**/*trolley_station*')\\n self.trolleyCar = self.trolleyStation.find('**/trolley_car')\\n self.trolleySphereNode = self.trolleyStation.find('**/trolley_sphere').node()\\n\\n # We'll need a pair of fog objects to enshadow the trolley\\n # while it's rolling through the entrance or exit tunnels.\\n\\n exitFog = Fog(\\\"TrolleyExitFog\\\")\\n exitFog.setColor(0.0, 0.0, 0.0)\\n exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)\\n exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)\\n exitFog.setLinearFallback(70.0, 999.0, 1000.0)\\n self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)\\n self.trolleyExitFogNode = exitFog\\n \\n enterFog = Fog(\\\"TrolleyEnterFog\\\")\\n enterFog.setColor(0.0, 0.0, 0.0)\\n enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)\\n enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)\\n enterFog.setLinearFallback(70.0, 999.0, 1000.0)\\n self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)\\n self.trolleyEnterFogNode = enterFog\\n\\n # We'll have fog explicitly disabled for the trolley car, by\\n # default. This makes it look maybe a little weird in\\n # Donald's Dock--why does the trolley punch through the fog so\\n # well? But it keeps the trolley from flashing in and out as\\n # we turn on and off the shadow fog.\\n self.trolleyCar.setFogOff()\\n\\n # Variables used to animate trolley parts\\n # Key\\n self.keys = self.trolleyCar.findAllMatches('**/key')\\n self.numKeys = self.keys.getNumPaths()\\n self.keyInit = []\\n self.keyRef = []\\n for i in range(self.numKeys):\\n key = self.keys[i]\\n key.setTwoSided(1)\\n ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')\\n ref.iPosHpr(key)\\n self.keyRef.append(ref)\\n self.keyInit.append(key.getTransform())\\n # Front wheels\\n self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')\\n self.numFrontWheels = self.frontWheels.getNumPaths()\\n self.frontWheelInit = []\\n self.frontWheelRef = []\\n for i in range(self.numFrontWheels):\\n wheel = self.frontWheels[i]\\n ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')\\n ref.iPosHpr(wheel)\\n self.frontWheelRef.append(ref)\\n self.frontWheelInit.append(wheel.getTransform())\\n # Back wheels\\n self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')\\n self.numBackWheels = self.backWheels.getNumPaths()\\n self.backWheelInit = []\\n self.backWheelRef = []\\n for i in range(self.numBackWheels):\\n wheel = self.backWheels[i]\\n ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')\\n ref.iPosHpr(wheel)\\n self.backWheelRef.append(ref)\\n self.backWheelInit.append(wheel.getTransform())\\n\\n # Create the trolley enter track\\n trolleyAnimationReset = Func(self.resetAnimation)\\n trolleyEnterStartPos = Point3(-20, 14, -1)\\n trolleyEnterEndPos = Point3(15, 14, -1)\\n\\n trolleyEnterPos = Sequence(name=\\\"TrolleyEnterPos\\\")\\n if base.wantFog:\\n trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))\\n trolleyEnterPos.append(self.trolleyCar.posInterval(\\n TROLLEY_ENTER_TIME,\\n trolleyEnterEndPos,\\n startPos=trolleyEnterStartPos,\\n blendType=\\\"easeOut\\\"))\\n if base.wantFog:\\n trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))\\n \\n trolleyEnterTrack = Sequence(trolleyAnimationReset, \\n trolleyEnterPos,\\n name = 'trolleyEnter')\\n # \\n # How many revolutions of the wheel?\\n keyAngle = round(TROLLEY_ENTER_TIME) * 360\\n dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()\\n wheelAngle = dist/(2.0 * math.pi * 0.95) * 360\\n trolleyEnterAnimateInterval = LerpFunctionInterval(\\n self.animateTrolley,\\n duration = TROLLEY_ENTER_TIME,\\n blendType = \\\"easeOut\\\",\\n extraArgs = [keyAngle, wheelAngle],\\n name = \\\"TrolleyAnimate\\\")\\n trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)\\n self.trolleyEnterTrack = Parallel(trolleyEnterTrack,\\n trolleyEnterAnimateInterval,\\n trolleyEnterSoundTrack,\\n )\\n\\n # Create the trolley exit track\\n trolleyExitStartPos = Point3(15, 14, -1)\\n trolleyExitEndPos = Point3(50, 14, -1)\\n\\n trolleyExitPos = Sequence(name=\\\"TrolleyExitPos\\\")\\n if base.wantFog:\\n trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))\\n trolleyExitPos.append(self.trolleyCar.posInterval(\\n TROLLEY_EXIT_TIME,\\n trolleyExitEndPos,\\n startPos=trolleyExitStartPos,\\n blendType=\\\"easeIn\\\"))\\n if base.wantFog:\\n trolleyExitPos.append(Func(self.trolleyCar.setFogOff))\\n \\n \\n trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)\\n trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)\\n\\n keyAngle = round(TROLLEY_EXIT_TIME) * 360\\n dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()\\n wheelAngle = dist/(2.0 * math.pi * 0.95) * 360\\n trolleyExitAnimateInterval = LerpFunctionInterval(\\n self.animateTrolley,\\n duration = TROLLEY_EXIT_TIME,\\n blendType = \\\"easeIn\\\",\\n extraArgs = [keyAngle, wheelAngle],\\n name = \\\"TrolleyAnimate\\\")\\n\\n self.trolleyExitTrack = Parallel(trolleyExitPos,\\n trolleyExitBellInterval,\\n trolleyExitAwayInterval,\\n trolleyExitAnimateInterval,\\n name = self.uniqueName(\\\"trolleyExit\\\")\\n )\",\n \"async def startingGame(self, ctx):\\n # =-=-=-= ATTRIBUTE ROLES FOR PLAYERS =-=-=-= #\\n self.msgToDelete.append(await ctx.message.channel.send(\\\"Attribution des rôles ...\\\"))\\n self.rolesOrder = self.roles.copy()\\n self.rolesOrder = list(dict.fromkeys(self.rolesOrder)) # Remove redundant roles for playGame()\\n random.seed(time.time())\\n random.shuffle(self.players)\\n random.shuffle(self.roles)\\n self.roles = self.roles[:len(self.players) + 3]\\n if self.roles.count(\\\"Franc-Maçon\\\") % 2 != 0: # Only One Freemason in\\n for i in range(len(self.roles)):\\n if self.roles[i] == \\\"Franc-Maçon\\\":\\n self.roles[(i + 1) % len(self.roles)] = \\\"Franc-Maçon\\\"\\n random.seed(time.time())\\n random.shuffle(self.players)\\n random.shuffle(self.roles)\\n break\\n\\n for numberPlayer in range(len(self.players)):\\n # At least there is less player than role, so I need to get the number of players instead of roles.\\n\\n self.syncRole(user=self.players[numberPlayer], roleToAdd=self.roles[numberPlayer],\\n listToAdd=self.playersAndRoles)\\n\\n # =-=-=-= ATTRIBUTE ROLES FOR DECK =-=-=-= #\\n for numberCentralRole in range(len(self.players), len(self.players) + 3):\\n if numberCentralRole == len(self.players) + 0:\\n position = \\\"gauche\\\"\\n elif numberCentralRole == len(self.players) + 1:\\n position = \\\"milieu\\\"\\n else:\\n position = \\\"droite\\\"\\n self.syncRole(user=position, roleToAdd=self.roles[numberCentralRole], listToAdd=self.centralDeck)\\n\\n # =-=-=-= Preparing requires =-=-=-= #\\n await self.createRole(ctx=ctx)\\n self.msgToDelete.append(await ctx.message.channel.send(\\\"Création du village ...\\\"))\\n print(\\\"Create village ...\\\")\\n self.lastVoiceChannel = ctx.author.voice.channel\\n await self.deleteCategory(ctx=ctx, reason=\\\"Pas de dualité de channel.\\\")\\n await self.createGameSpace(ctx=ctx)\\n await self.movePlayer(ctx=ctx, voiceChannel=self.voiceChannel, reason=\\\"Début de partie.\\\")\\n\\n print(\\\"Game started\\\")\\n self.msgToDelete.append(await ctx.message.channel.send(\\\"Début de la partie.\\\"))\\n\\n await ctx.channel.send(\\\"Cleaning all messages ...\\\")\\n await self.delAllMsg(waitingTime=5)\\n await self.playGame(ctx=ctx)\",\n \"def run_game_logic(self):\\n pass\",\n \"def create_new_game(game_name, player_name, points_to_win=POINTS_TO_WIN,\\n min_players=MIN_PLAYERS, max_players=MAX_PLAYERS):\\n do_house_keeping()\\n if not can_create_new_game():\\n return {}\\n game_name = game_name or generate_game_name()\\n player_name = player_name or generate_player_name()\\n points_to_win = points_to_win or POINTS_TO_WIN\\n min_players = min_players or MIN_PLAYERS\\n max_players = max_players or MAX_PLAYERS\\n if min_players < 2:\\n min_players = 2\\n if max_players > 10:\\n max_players = 10\\n game_id = generate_id(GAME_ID_LENGTH)\\n game_data = {\\n 'id': game_id,\\n 'name': game_name,\\n 'deck': create_deck(),\\n 'stack': [],\\n 'created_at': serialize_datetime(datetime.utcnow()),\\n 'started_at': None,\\n 'ended_at': None,\\n 'active': False,\\n 'reverse': False,\\n 'min_players': min_players,\\n 'max_players': max_players,\\n 'players': [],\\n 'points_to_win': points_to_win\\n }\\n add_player_to_game(game_data, player_name, True)\\n msg = make_info_message(\\n 'Click \\\"Start\\\" after all player(s) have joined')\\n flash_broadcast(game_data, msg)\\n result = save_state(game_data)\\n if result:\\n return game_data\\n return {}\",\n \"def main():\\n pygame.init()\\n os.environ['SDL_VIDEO_CENTERED'] = '1'\\n pygame.display.set_caption('8-Puzzle game')\\n screen = pygame.display.set_mode((800, 500))\\n fpsclock = pygame.time.Clock()\\n program = SlidePuzzle((3, 3), 160, 5, difficulty=10) # program is also the gym environment\\n\\n choice = program.selectPlayerMenu(fpsclock, screen)\\n if choice == \\\"AI\\\":\\n pygame.display.quit()\\n trainAI(program)\\n elif choice == \\\"human\\\":\\n launchWithGUI(program, fpsclock, screen)\\n del program\",\n \"def new_game(self, wid, data=None):\\n \\n self.stop_game(0)\\n\\n # Slight delay for improved UX\\n Fl.add_timeout(0.3, self.play_seq)\",\n \"def start_game(self) -> None:\\n self.init_game()\\n self.play()\",\n \"def create_game(cls, user, misses_allowed, secret_word, current_solution):\\n game = cls(parent=user,\\n user=user,\\n misses_allowed=misses_allowed,\\n misses_remaining=misses_allowed,\\n secret_word=secret_word,\\n current_solution=current_solution)\\n game.put()\\n return game\",\n \"def create_game(game_ID):\\n\\n if r.exists(\\\"state:\\\" + game_ID) == 1:\\n raise Exception(\\\"Game exists already\\\")\\n\\n new_game = {\\n \\\"winner\\\": \\\"none\\\",\\n \\\"turn\\\": \\\"blue\\\",\\n \\\"action\\\": \\\"spymaster\\\",\\n \\\"hint\\\": \\\"\\\",\\n \\\"attemptsLeft\\\": 0,\\n \\\"redPoints\\\": 0,\\n \\\"bluePoints\\\": 0,\\n }\\n words = create_board()\\n set_fields = r.hset(\\\"state:\\\" + game_ID, mapping=new_game)\\n set_fields += r.hset(\\\"words:\\\" + game_ID, mapping=words)\\n\\n if set_fields == 32:\\n return {\\\"playerState\\\": new_game, \\\"wordsState\\\": words}\\n else:\\n raise Exception(\\\"Could not make Game\\\")\",\n \"def __init__(self, players=None):\\n self.game = Game()\\n if players:\\n self.player1 = players[0]\\n self.player2 = players[1]\\n else:\\n self.player1 = Player('X')\\n self.player2 = Player('O')\\n self.record = Record()\\n self.winning_moves = []\",\n \"def __init__(self, game='pong', obs_type='ram', frameskip=(2, 5), repeat_action_probability=0.):\\n\\n utils.EzPickle.__init__(self, game, obs_type)\\n assert obs_type in ('ram', 'image')\\n\\n self.game_path = atari_py.get_game_path(game)\\n if not os.path.exists(self.game_path):\\n raise IOError('You asked for game %s but path %s does not exist'%(game, self.game_path))\\n self._obs_type = obs_type\\n self.frameskip = frameskip\\n self.ale = ALEInterface()\\n self.viewer = None\\n\\n # Tune (or disable) ALE's action repeat:\\n # https://github.com/openai/gym/issues/349\\n assert isinstance(repeat_action_probability, (float, int)), \\\"Invalid repeat_action_probability: {!r}\\\".format(repeat_action_probability)\\n self.ale.setFloat('repeat_action_probability'.encode('utf-8'), repeat_action_probability)\\n\\n self._seed()\\n\\n (screen_width, screen_height) = self.ale.getScreenDims()\\n self._buffer = np.empty((screen_height, screen_width, 3), dtype=np.uint8)\\n\\n self._action_set = self.ale.getMinimalActionSet()\\n self.action_space = spaces.Discrete(len(self._action_set))\\n\\n (screen_width,screen_height) = self.ale.getScreenDims()\\n if self._obs_type == 'ram':\\n self.observation_space = spaces.Box(low=np.zeros(128), high=np.zeros(128)+255)\\n elif self._obs_type == 'image':\\n self.observation_space = spaces.Box(low=0, high=255, shape=(screen_height, screen_width, 3))\\n else:\\n raise error.Error('Unrecognized observation type: {}'.format(self._obs_type))\",\n \"def play_game(self):\\n # need everyone to pass to move to next phase?\\n self.deal_cards()\\n self.plant_food()\",\n \"async def new_game(self, players): \\r\\n if len(players) != 10:\\r\\n return discord.Embed(title=\\\"Valorant 10 Man Bot\\\",\\r\\n description=\\\"You cannot start a game with only {} players\\\".format(len(players)))\\r\\n self.teams = {\\\"A\\\": [], \\\"B\\\" : []}\\r\\n self.previous_captains = self.captains\\r\\n self.captains = {\\\"A\\\" : None, \\\"B\\\" : None}\\r\\n self.nick_to_player = {get_member_name(p) : p for p in players}\\r\\n self.previous_players = self.remaining\\r\\n self.remaining = players.copy()\\r\\n self.turn = 1\\r\\n self.order = []\\r\\n self.map_dict = {k : True for k in self.map_dict.keys()}\\r\\n return discord.Embed(title=\\\"Valorant 10 Man Bot\\\",\\r\\n description=\\\"New game started\\\".format(len(players)))\",\n \"def new_game(cls, x_user, o_user, game_moves):\\n game = Game(x_user=x_user,\\n o_user=o_user,\\n game_moves=game_moves,\\n moves_count=0,\\n game_over=False)\\n game.put()\\n usergame = UserGame(user=x_user, \\n game_key=game.key,\\n moves_count=0,\\n game_over=False)\\n usergame.put()\\n usergame = UserGame(user=o_user, \\n game_key=game.key,\\n moves_count=0,\\n game_over=False)\\n usergame.put()\\n return game\",\n \"def init_gym_pygame(game_name):\\n # OpenAI gym setup \\n game_name = 'gvgai-aliens-lvl0-v0'\\n env = gym.make(game_name)\\n env.reset()\\n \\n # pygame setup\\n pg.init()\\n height = env.observation_space.shape[0]\\n width = env.observation_space.shape[1]\\n screen = pg.display.set_mode((width, height))\\n\\n return env, screen\",\n \"def setUp(self):\\r\\n global ship_image\\r\\n self.spaceshipgame = SpaceShipGame()\\r\\n self.spaceshipgame.init()\\r\\n pos = [1,1]\\r\\n vel = [1,1]\\r\\n angle = 0\\r\\n image = ship_image\\r\\n\\r\\n center = [1,1]\\r\\n size = 1\\r\\n info = ImageInfo(center, size)\\r\\n\\r\\n self.ship = Ship( pos, vel, angle, image, info)\",\n \"def setUp(self):\\r\\n global ship_image\\r\\n self.spaceshipgame = SpaceShipGame()\\r\\n self.spaceshipgame.init()\\r\\n pos = [1,1]\\r\\n vel = [1,1]\\r\\n angle = 0\\r\\n image = ship_image\\r\\n\\r\\n center = [1,1]\\r\\n size = 1\\r\\n info = ImageInfo(center, size)\\r\\n\\r\\n self.ship = Ship( pos, vel, angle, image, info)\",\n \"def main():\\n # parse arguments from the command line (argparse validates arguments)\\n args = _get_args()\\n # build the environment with the given ID\\n env = gym.make(args.env)\\n # play the environment with the given mode\\n if args.mode == 'human':\\n play_human(env)\\n else:\\n play_random(env, args.steps)\",\n \"def new_game(self):\\n\\n self.board = {}\",\n \"def run_gui_game():\\n # Set up game\\n view = GuiView()\\n game = GameEngine(view)\",\n \"def __init__(self, size, block_positions, starts, player_1, player_2, \\n terminal_viz, print_game_in_terminal, \\n time_to_make_a_move=2, game_time=100, \\n penalty_score=300, max_fruit_score=300, max_fruit_time=15):\\n\\n # check that each Player implements the following methods:\\n self.players = [player_1, player_2]\\n for player in self.players:\\n assert hasattr(player, 'set_game_params')\\n assert hasattr(player, 'make_move')\\n assert hasattr(player, 'set_rival_move')\\n assert hasattr(player, 'update_fruits')\\n\\n self.print_game_in_terminal = print_game_in_terminal\\n self.terminal_viz = terminal_viz\\n self.time_to_make_a_move = time_to_make_a_move\\n self.penalty_score = penalty_score\\n self.some_player_cant_move = False\\n \\n \\n self.game_time_left_for_players = [game_time, game_time]\\n\\n initial_board = self.set_initial_board(size, block_positions, starts)\\n\\n self.game = Game(initial_board, starts, max_fruit_score=max_fruit_score, max_fruit_time=max_fruit_time, \\n animated=True, animation_func=self.animate_func)\\n\\n for i, player in enumerate(self.players):\\n player.set_game_params(self.game.get_map_for_player_i(player_id=i))\",\n \"def __init__(self):\\n\\n self.width = 10\\n self.height = 10\\n self.new_game()\",\n \"def spawn_players(self) -> None:\\n # Initialise the players\\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width // 2, 50,\\n self.player_lives, self.fps, self.player1_bullet, Direction.DOWN, self.debug)\\n self.player2 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width // 2,\\n self.screen_height - 50, self.player_lives, self.fps, self.player2_bullet, Direction.UP,\\n self.debug)\\n\\n # Rotate the image of the player at the top\\n self.player1.rotate(180)\",\n \"def init(seed=None):\\n\\tglobal _game\\n\\n\\tfrom .game import Game\\n\\tfrom .prompt import install_words\\n\\n\\t_game = Game(seed)\\n\\tload_advent_dat(_game)\\n\\tinstall_words(_game)\\n\\t_game.start()\\n\\treturn _game\",\n \"def main():\\n g = DemoGame(800, 600)\\n g.start()\",\n \"def main(self):\\n _age = info.getInfo(self)\\n _flag = game.check_age(self, _age)\\n if _flag == False:\\n exit()\\n game.wants_to_play(0)\",\n \"def main():\\n\\n containerTextStyle = {\\n 'color': '#ffffff',\\n 'font': '10px',\\n 'stroke': '#000000',\\n 'strokeWidth': .15\\n }\\n spawnerRole = Spawner()\\n # Clean up memory\\n for creepName in Object.keys(Memory.creeps):\\n if not Game.creeps[creepName]:\\n if Memory.creeps[creepName].role == \\\"remoteHarvester\\\":\\n print(\\\"Cleaning up remoteHarvester. It mined: \\\" + Memory.creeps[creepName].totalHarvested)\\n del Memory.creeps[creepName]\\n #print(\\\"Clearing non-existent creep memory: \\\" + creepName)\\n\\n if Game.cpu.bucket == 10000:\\n Game.cpu.generatePixel()\\n # Run each creep\\n for name in Object.keys(Game.creeps):\\n creep = Game.creeps[name]\\n if creep.memory.role in Spawner.roles:\\n Spawner.roles[creep.memory.role].run(creep)\\n else:\\n creep.say(\\\"No role\\\")\\n\\n # Run tower code\\n homeRoom = Object.values(Game.spawns)[0].room\\n towers = [struct for room in Object.values(Game.rooms) for struct in room.find(FIND_STRUCTURES) if struct.structureType == STRUCTURE_TOWER]\\n hostiles = homeRoom.find(FIND_HOSTILE_CREEPS)\\n for tower in towers:\\n structures = sorted([struct for struct in tower.room.find(FIND_STRUCTURES) if struct.hits < struct.hitsMax], key=lambda struct: struct.hits)\\n if len(hostiles) > 0:\\n tower.attack(tower.pos.findClosestByPath(hostiles))\\n continue\\n\\n for structure in structures:\\n if structure.hits < structure.hitsMax and structure.hits < 100000:\\n tower.repair(structure)\\n break\\n\\n # Run visuals\\n for room in Object.values(Game.rooms):\\n for container in [struct for struct in room.find(FIND_STRUCTURES) if struct.structureType == STRUCTURE_CONTAINER or struct.structureType == STRUCTURE_STORAGE]:\\n room.visual.text(Spawner.roles['harvester'].getStructureFutureEnergy(container), container.pos, containerTextStyle)\\n\\n # Run each spawn\\n for name in Object.keys(Game.spawns)[0:1]:\\n spawn = Game.spawns[name]\\n spawnerRole.run(spawn)\",\n \"def __init__(self, affinity, game_type, game_space, opponent=None):\\n \\n super().__init__(affinity, game_type, game_space, opponent)\",\n \"def __init__(self):\\n self.screen = pg.display.get_surface()\\n self.screen_rect = self.screen.get_rect()\\n self.clock = pg.time.Clock()\\n self.fps = 60\\n self.keys = pg.key.get_pressed()\\n self.done = False\\n # ship = random.choice(list(prepare.GFX[\\\"ships\\\"].values()))\\n ship = list(prepare.GFX[\\\"ships\\\"].values())[7] # pick first ship available\\n self.player = actors.Player((0, 0), ship)\\n self.level = level.Level(self.screen_rect.copy(), self.player)\\n\\n self.energyloss_counter = 0\\n self.energygain_counter = 0\",\n \"def start_game(self):\\n while self.can_deal:\\n self.take_turn()\",\n \"def __init__(self):\\n pygame.init()\\n self.settings = Settings()\\n self.screen = pygame.display.set_mode(\\n (self.settings.screen_width, self.settings.screen_height)\\n )\\n pygame.display.set_caption(\\\"Sideways Shooter\\\")\\n self.stats = GameStats(self)\\n self.sideways_ship = SidewaysShip(self)\\n self.bullets = pygame.sprite.Group()\\n self.aliens = pygame.sprite.Group()\\n self._create_fleet()\",\n \"def test_valid_new_game(self):\\n self._game.new_game()\\n self.assertIsRUNNING(self._game)\\n self.assertIsNotNone(self._game.table)\\n self.assertEqual(self._game.table.player_turn, 1,\\n \\\"Game.table unsuccessful init.\\\")\",\n \"def start_game(self):\\n self.master.destroy()\\n Game()\",\n \"def do_start_hosted(self):\\n\\t\\tself.game_name = self.e_gamename.text\\n\\t\\tself.num_players = (1, int(self.e_players.text))\\n\\t\\tself.boardsize = (int(self.e_boardw.text), int(self.e_boardh.text))\\n\\n\\t\\td = {\\\"state\\\": be.S_GAME,\\n\\t\\t\\t\\t\\\"hosting\\\": True,\\n\\t\\t\\t\\t\\\"uuid\\\": None,\\n\\t\\t\\t\\t\\\"name\\\": self.game_name,\\n\\t\\t\\t\\t\\\"nickname\\\": self.nickname,\\n\\t\\t\\t\\t\\\"num_players\\\": self.num_players,\\n\\t\\t\\t\\t\\\"boardsize\\\": self.boardsize}\\n\\t\\tevent = pygame.event.Event(be.E_STATE, d)\\n\\t\\tpygame.event.post(event)\\n\\n\\t\\tself.hide_all()\\n\\t\\tself.renderer.color = (0, 0, 0, 0)\",\n \"def __init__(self, game):\\n self.rooms = self.load_rooms(f\\\"data/{game}Rooms.txt\\\")\\n self.current_room = self.rooms[1]\\n # use self.over to determine if the game if over\\n self.over = 0\\n self.load_items(f\\\"data/{game}Items.txt\\\")\\n self.inventory = Inventory()\\n # synonyms\\n self.synonyms = {}\\n self.load_synonyms(\\\"data/SmallSynonyms.txt\\\")\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline= True ) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\\n sim.run(n_trials=100) # press Esc or close pygame window to quit\",\n \"async def game(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6907318","0.68599695","0.6728783","0.66609395","0.6579913","0.6554996","0.6510835","0.64591074","0.64184606","0.6393087","0.63915473","0.6364802","0.6364802","0.6364802","0.6364802","0.6364802","0.6359255","0.635703","0.63438934","0.6340655","0.63222647","0.6230765","0.62276447","0.6192554","0.6190398","0.6188919","0.6171213","0.61516774","0.6145663","0.61230963","0.6119365","0.61087525","0.6093325","0.6091152","0.60795623","0.60722554","0.604758","0.60286254","0.60186446","0.60133606","0.599565","0.5957436","0.59409904","0.5925056","0.59159774","0.59091014","0.59082234","0.58997315","0.58959615","0.5890325","0.5882927","0.5879657","0.5875502","0.5875101","0.5868611","0.5862463","0.5858779","0.5856393","0.5846861","0.58307624","0.5821008","0.5820403","0.5797097","0.57960445","0.5791845","0.5788365","0.57852113","0.5783713","0.5774389","0.5774075","0.57694566","0.57627225","0.5761301","0.57539374","0.575246","0.5750212","0.5749559","0.5748215","0.574666","0.574538","0.574538","0.5742934","0.5740808","0.57402307","0.5739559","0.5737764","0.57328993","0.5730632","0.57301444","0.57223696","0.57221764","0.57182056","0.57131535","0.5711716","0.57010895","0.5698529","0.569274","0.56916517","0.56894803","0.5688346","0.56879526"],"string":"[\n \"0.6907318\",\n \"0.68599695\",\n \"0.6728783\",\n \"0.66609395\",\n \"0.6579913\",\n \"0.6554996\",\n \"0.6510835\",\n \"0.64591074\",\n \"0.64184606\",\n \"0.6393087\",\n \"0.63915473\",\n \"0.6364802\",\n \"0.6364802\",\n \"0.6364802\",\n \"0.6364802\",\n \"0.6364802\",\n \"0.6359255\",\n \"0.635703\",\n \"0.63438934\",\n \"0.6340655\",\n \"0.63222647\",\n \"0.6230765\",\n \"0.62276447\",\n \"0.6192554\",\n \"0.6190398\",\n \"0.6188919\",\n \"0.6171213\",\n \"0.61516774\",\n \"0.6145663\",\n \"0.61230963\",\n \"0.6119365\",\n \"0.61087525\",\n \"0.6093325\",\n \"0.6091152\",\n \"0.60795623\",\n \"0.60722554\",\n \"0.604758\",\n \"0.60286254\",\n \"0.60186446\",\n \"0.60133606\",\n \"0.599565\",\n \"0.5957436\",\n \"0.59409904\",\n \"0.5925056\",\n \"0.59159774\",\n \"0.59091014\",\n \"0.59082234\",\n \"0.58997315\",\n \"0.58959615\",\n \"0.5890325\",\n \"0.5882927\",\n \"0.5879657\",\n \"0.5875502\",\n \"0.5875101\",\n \"0.5868611\",\n \"0.5862463\",\n \"0.5858779\",\n \"0.5856393\",\n \"0.5846861\",\n \"0.58307624\",\n \"0.5821008\",\n \"0.5820403\",\n \"0.5797097\",\n \"0.57960445\",\n \"0.5791845\",\n \"0.5788365\",\n \"0.57852113\",\n \"0.5783713\",\n \"0.5774389\",\n \"0.5774075\",\n \"0.57694566\",\n \"0.57627225\",\n \"0.5761301\",\n \"0.57539374\",\n \"0.575246\",\n \"0.5750212\",\n \"0.5749559\",\n \"0.5748215\",\n \"0.574666\",\n \"0.574538\",\n \"0.574538\",\n \"0.5742934\",\n \"0.5740808\",\n \"0.57402307\",\n \"0.5739559\",\n \"0.5737764\",\n \"0.57328993\",\n \"0.5730632\",\n \"0.57301444\",\n \"0.57223696\",\n \"0.57221764\",\n \"0.57182056\",\n \"0.57131535\",\n \"0.5711716\",\n \"0.57010895\",\n \"0.5698529\",\n \"0.569274\",\n \"0.56916517\",\n \"0.56894803\",\n \"0.5688346\",\n \"0.56879526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6878,"cells":{"query":{"kind":"string","value":"load the network from saved.h5"},"document":{"kind":"string","value":"def load_network(self):\t\t\r\n\t\tself.dqn.load_network(self.path)"},"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 load_network(self, which_epoch):\n save_filename = '%s_net.pth' % which_epoch\n load_path = os.path.join(self.save_dir, save_filename)\n net = self.net\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print('loading the model from %s' % load_path)\n # PyTorch newer than 0.4 (e.g., built from\n # GitHub source), you can remove str() on self.device\n state_dict = torch.load(load_path, map_location=str(self.device))\n if hasattr(state_dict, '_metadata'):\n del state_dict._metadata\n net.load_state_dict(state_dict)","def load_model(self):\n self.pred_net.load((self.save_path / \"iqn_pred_net\").absolute().as_posix())\n self.target_net.load((self.save_path / \"iqn_target_net\").absolute().as_posix())","def load_trained_net(mal):\n model_root = os.path.join(os.getcwd(), 'data', 'models')\n model = load_model(os.path.join(model_root, 'model_' + mal + '.h5'))\n\n return model","def load_network(self, sess, filename):\n dir_path = os.path.dirname(os.path.realpath(__file__))\n dir_path += '/Models/'\n dir_path += filename\n saver = tf.train.Saver()\n saver.restore(sess, dir_path)","def load_network(fpath):\n\twith open(fpath, \"rb\") as f:\n\t\tnetwork = pickle.load(f)\n\treturn network","def __load_Model(self):\r\n PrintsForUser.printProcess(\"[INFO] Loading network...\")\r\n \r\n self.__model = load_model(self.__model_path)\r\n self.__lb = pickle.loads(open(self.__labels_path, \"rb\").read())","def load_networks(self, which_epoch):\n for name in self.model_names:\n if isinstance(name, str):\n filename = '%s_net_%s.pth' % (which_epoch, name)\n path = os.path.join(self.save_dir, filename)\n net = getattr(self, 'net_' + name)\n try:\n state_dict = torch.load(path)\n state_dict = {name.replace('module.', '', 1) : param for name, param in state_dict.items()}\n # net.load_state_dict(torch.load(path))\n net.load_state_dict(state_dict)\n except:\n pretrained_dict = torch.load(path)\n model_dict = net.state_dict()\n try:\n pretrained_dict = {k:v for k,v in pretrained_dict.items() if k in model_dict}\n net.load_state_dict(pretrained_dict)\n print('Pretrained network %s has excessive layers; Only loading layers that are used' % name)\n except:\n print('Pretrained network %s has fewer layers; The following are not initialized:' % name)\n not_initialized = set()\n for k, v in pretrained_dict.items():\n if v.size() == model_dict[k].size():\n model_dict[k] = v\n\n for k, v in model_dict.items():\n if k not in pretrained_dict or v.size() != pretrained_dict[k].size():\n not_initialized.add(k.split('.')[0])\n print(sorted(not_initialized))\n net.load_state_dict(model_dict)\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\n net.cuda()\n if not self.isTrain:\n net.eval()","def load_networks(self, epoch):\n for name in self.network_names:\n if isinstance(name, str):\n load_filename = '{0}_net_{1}.pth'.format(epoch, name)\n load_path = os.path.join(self.save_dir, load_filename)\n net = getattr(self, 'net')\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print('loading the model from {0}'.format(load_path))\n state_dict = torch.load(load_path, map_location=self.device)\n if hasattr(state_dict, '_metadata'):\n del state_dict._metadata\n\n net.load_state_dict(state_dict)","def _load_model(self):\n self._load_scaler('scaler.save')\n self._load_encoder('encoder0.save', 0)\n self._load_encoder('encoder1.save', 1)\n self._load_neural_network('model.json', 'model.h5')\n return","def load(uDir):\n import sys\n sys.path.append(uDir)\n from net_spec import spec\n \n builder = NetworkBuilder(spec)\n htm = builder.build()\n htm.start()\n \n ## restore each node state\n layers = htm.layers\n \n for l in range(len(layers) - 1):\n (r,c) = spec[l]['shape']\n\n if layers[l].node_sharing:\n state = {}\n state['coincidences'] = np.load(uDir + str(l) + \".0.0.coincidences.npy\")\n state['temporal_groups'] = [] ## !FIXME temporal groups should be saved, first\n state['PCG'] = np.load(uDir + str(l) + \".0.0.PCG.npy\")\n\n for i in range(r):\n for j in range(c):\n layers[l].pipes[i][j].send((\"set_state\", state))\n\n else:\n for i in range(r):\n for j in range(c):\n state = {}\n state['coincidences'] = np.load(uDir + str(l) + \".\" + str(i) + \".\" + str(j) + \".coincidences.npy\")\n state['temporal_groups'] = [] ## !FIXME temporal groups should be saved, first\n state['PCG'] = np.load(uDir + str(l) + \".\" + str(i) + \".\" + str(j) + \".PCG.npy\")\n layers[l].pipes[i][j].send((\"set_state\", state))\n \n ## restore also last node's state\n state = {}\n state['coincidences'] = np.load(uDir + str(len(layers) - 1) + \".0.0.coincidences.npy\")\n state['cls_prior_prob'] = np.load(uDir + str(len(layers) - 1) + \".0.0.cls_prior_prob.npy\")\n state['PCW'] = np.load(uDir + str(len(layers) - 1) + \".0.0.PCW.npy\")\n layers[-1].pipes[0][0].send((\"set_state\", state))\n\n return htm","def load(self, filename, path=\".\"):\n if filename is None:\n if self.verbose:\n print(\"Neural Network Model Class - Save Function: No file name\")\n return -1\n\n #trn_params\n self.trn_params = NeuralNetworkParams()\n self.trn_params.load('%s_trn_params.pickle'%(filename),path=path)\n\n #model\n json_file = open(\"%s/%s_model.json\"%(path,filename), 'r')\n loaded_model_json = json_file.read()\n json_file.close()\n loaded_model = model_from_json(loaded_model_json)\n loaded_model.load_weights(\"%s/%s_model.h5\"%(path,filename))\n self.model = loaded_model\n self.trained = True\n #trn_desc\n self.trn_desc = None\n self.trn_desc = pickle.load(open(\"%s/%s_trn_desc.pickle\"%(path,filename), \"rb\"))","def load_all(self, file):\n self.model = load_model(file + \"_model.h5\")","def _load_local_weights(self, h5file):\n for name, layer in self._layers_to_save.items():\n self._load_layer_weights(layer, name, h5file)","def load_hdf5_with_structure(file):\n n_classes = 80\n n_boxes = 5\n anchors = [[0.738768, 0.874946], [2.42204, 2.65704], [4.30971, 7.04493], [10.246, 4.59428], [12.6868, 11.8741]]\n\n yolov2 = YOLOv2(n_classes=n_classes, n_boxes=n_boxes)\n chainer.serializers.load_hdf5(file, yolov2)\n model = YOLOv2Predictor(yolov2)\n model.init_anchor(anchors)\n #model.predictor.train = False\n model.predictor.finetune = False\n return model","def load(self, uri):\r\n self._encoder = load_model(uri+\"_lstm_encoder.hdf5\")\r\n self._autoencoder = load_model(uri+\"_lstm_autoencoder.hdf5\")\r\n\r\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)))\r\n dict_options = pf[os.path.basename(uri)+\"_options.json\"]\r\n\r\n self._latent_space = dict_options['latent_space']\r\n self._input_cells = dict_options['input_cells']","def load(self, filename):\n hebbian_weights = open(filename, \"r\").read().split('\\n')\n for i in xrange(self.hidden):\n weights = hebbian_weights[i].split('\\t')\n self.vis_layer[i].set_weights(weights)\n for i in xrange(self.layers):\n for j in xrange(self.hidden):\n weights = hebbian_weights[((i+1)*self.hidden)+j].split('\\t')\n self.hidden_layers[i][j].set_weights(weights)\n weights = hebbian_weights[-2].split('\\t')\n self.output_neuron.set_weights(weights)","def load_networks(self, epoch):\n for name in self.model_names:\n if isinstance(name, str):\n load_filename = '%s_net_%s.pth' % (epoch, name)\n load_path = os.path.join(self.save_dir, load_filename)\n net = getattr(self, 'net' + name)\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print('loading the model from %s' % load_path)\n # if you are using PyTorch newer than 0.4 (e.g., built from\n # GitHub source), you can remove str() on self.device\n state_dict = torch.load(load_path, map_location=str(self.device))\n if hasattr(state_dict, '_metadata'):\n del state_dict._metadata\n\n # patch InstanceNorm checkpoints prior to 0.4\n for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\n self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\n net.load_state_dict(state_dict)","def restore_model(self, path):\n # if cuda is not available load everything to cpu\n if not self.use_cuda:\n state = torch.load(path, map_location=lambda storage, loc: storage)\n else:\n state = torch.load(path)\n self.net.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optimizer'])\n self.epoch_counter = state['epoch'] # counts number of epochs","def load_model(self, path):\n self._saver.restore(self._sess, path + '/model.ckp')\n pkl_file = open(path + '/som.pkl', 'rb')\n restored = pickle.load(pkl_file)\n pkl_file.close()\n self._m = restored['_m']\n self._n = restored['_n']\n self._neighbourhood = restored['_neighbourhood']\n # self._topography = restored['_topography']\n self._num_iterations = restored['_num_iterations']\n self._Wts = restored['_Wts']\n self._locations = restored['_locations']\n self._learned = restored['_learned']\n self._centroid_grid = restored['_centroid_grid']\n self.abnormal_dist = restored['abnormal_dist']\n\n print(\"Model restored from path: \" + path)","def load(self, path):\n print('Loading model from {}'.format(path.name))\n self.qnetwork_local.load_state_dict(torch.load(path))\n self.qnetwork_target.load_state_dict(torch.load(path))\n return","def load(self, path, nr_of_saves, test_it=-1):\n with self.graph.as_default():\n print(\"Loading networks...\")\n checkpoint_dir = os.path.join(os.environ['APPROXIMATOR_HOME'], path, \"network-\"+str(test_it))\n self.saver = tf.train.Saver(max_to_keep=nr_of_saves+1)\n try:\n self.saver.restore(self.sess, checkpoint_dir)\n print(\"Loaded: {}\".format(checkpoint_dir))\n except Exception:\n if test_it <= 0:\n # Initialize the variables\n self.sess.run(tf.global_variables_initializer())\n print(\"Failed! Initializing the network variables...\")\n else:\n raise","def model_load(file_name=None):\n if file_name is None :\n file_name = \"./data/_oP5_SegmentClassifier.dump\"\n else:\n pass\n\n return p5_util.object_load(file_name)","def load_networks(self, epoch: int) -> None:\n for name, module in self.modules.items():\n if isinstance(name, str):\n load_filename = '%s_net_%s.pth' % (epoch, name)\n load_path = os.path.join(self.save_dir, load_filename)\n if isinstance(module, torch.nn.DataParallel):\n module = module.module\n print('loading the model from %s' % load_path)\n state_dict = torch.load(load_path, map_location=str(self.device))\n if hasattr(state_dict, '_metadata'):\n del state_dict._metadata\n # patch InstanceNorm checkpoints prior to 0.4\n for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\n self.__patch_instance_norm_state_dict(state_dict, module, key.split('.'))\n module.load_state_dict(state_dict)\n return","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def load(self, name, path=None):\n if path is None:\n path = '.'\n if path[0] == '~':\n path = os.getenv(\"HOME\") + path[1:]\n\n try:\n with open(path + '/' + name, 'rb') as f:\n return pickle.load(f)\n except IOError as e:\n msg = str(e) + '\\nNeuralNetwork.load failed.'\n raise DNNetIOError(msg)","def loadh5(fname, path='/data'):\n fp = open_read(fname)\n slab = fp.get_node(path)\n mat = slab.read()\n fp.close()\n return mat","def load_network_for_training(file_name):\n global training_set, start_round, start_digit\n try:\n with open (file_name, 'r') as f:\n w = np.load(f)\n w_min = np.load(f)\n w_max = np.load(f)\n a_plus = np.load(f)\n a_minus = np.load(f)\n b_plus = np.load(f)\n b_minus = np.load(f)\n v_th = np.load(f)\n training_set = np.reshape(np.load(f), (TRAINING_SIZE, N))\n start_round = np.load(f)\n start_digit = np.load(f)\n\n Output.set_states({'v_th' : v_th})\n S.set_states({\n 'w' : w,\n 'w_min' : w_min, \n 'w_max' : w_max, \n 'a_plus' : a_plus, \n 'a_minus' : a_minus, \n 'b_plus' : b_plus, \n 'b_minus' : b_minus\n })\n print start_round\n print start_digit\n print v_th\n except IOError as e:\n print \"error opening file: %s\" % e.strerror\n sys.exit()","def load_bytes_subnetwork_pretrained_weights(self, model):\n print(\"ToImplement\")","def export_to_hdf5(cls, h5_file, model, loads):\n #encoding = model._encoding\n #comments = []\n sid = []\n node = []\n cid = []\n mag = []\n xyz = []\n for load in loads:\n #comments.append(loads.comment)\n sid.append(load.sid)\n node.append(load.node)\n cid.append(load.cid)\n mag.append(load.mag)\n xyz.append(load.xyz)\n\n #h5_file.create_dataset('_comment', data=comments)\n h5_file.create_dataset('sid', data=sid)\n h5_file.create_dataset('node', data=node)\n h5_file.create_dataset('cid', data=cid)\n h5_file.create_dataset('mag', data=mag)\n h5_file.create_dataset('xyz', data=xyz)","def load(self, name=\"\"):\n\n self.constructed = True\n if name == \"\":\n name = \"/home/unai/Escritorio/MultiNetwork/model/model\"\n\n network_descriptors = {\"Generic\": GenericDescriptor, \"Decoder\": DecoderDescriptor, \"Discrete\": DiscreteDescriptor, \"Convolution\": ConvolutionDescriptor}\n\n if not os.path.isfile(name):\n print(\"Error at loading the model\")\n return None\n\n f = open(name, \"r+\")\n\n lines = f.readlines()\n\n i = 0\n while lines[i] != \"\\n\": # Each component is stored in a line\n ident, n_inp, kind, n_hidden, layers, init, act, cond_rand, taking, producing, depth, reachable, belows = lines[i][:-1].split(\"_\")\n kwargs = {}\n if int(ident[1:]) > self.last_net:\n self.last_net = int(ident[1:])\n\n self.reachable[ident] = reachable.split(\",\")\n self.comps_below[ident] = belows.split(\",\")\n\n if \"onv\" in kind: # Not working right now\n filters, sizes, layers, strides = layers.split(\"*\")\n sizes = sizes.split(\",\")\n s = np.array([[int(sz) for sz in szs.split(\"/\")] for szs in sizes])\n desc = network_descriptors[kind](int(inp), int(outp), int(n_inp), layers.split(\",\"), filters.split(\",\"), [int(x) for x in strides.split(\",\")], s, [int(x) for x in act.split(\",\")], [int(x) for x in init.split(\",\")], kwargs)\n else:\n if len(kwargs) > 0: # Not working right now\n kwargs = kwargs.split(\"-\")\n kwargs[0] = [int(x) for x in kwargs[0].split(\".\") if len(x) > 0]\n kwargs[1] = [int(x) for x in kwargs[1].split(\".\") if len(x) > 0]\n if len(cond_rand) > 0:\n cond_rand = cond_rand.split(\"-\")\n cond_rand[0] = [int(x) for x in cond_rand[0].split(\",\") if len(x) > 0]\n cond_rand[1] = [int(x) for x in cond_rand[1].split(\",\") if len(x) > 0]\n kwargs[\"conds\"] = cond_rand\n desc = network_descriptors[kind](int(taking.split(\",\")[0]), int(producing.split(\",\")[0]), int(n_inp), int(n_hidden), [int(x) for x in layers.split(\",\") if x != \"-1\"], init_functions[[int(x) for x in init.split(\",\") if x != \"-1\"]],\n act_functions[[int(x) for x in act.split(\",\") if x != \"-1\"]], **kwargs)\n\n # print(\"ident\", ident, \"n_inp\", n_inp, \"kind\", kind, \"inp\", inp, \"outp\", outp, \"layers\", layers, \"init\", init, \"act\", act, \"taking\", taking, \"producing\", producing, \"depth\", depth, \"kwargs\", kwargs)\n net = NetworkComp(desc, InOut(size=int(taking.split(\",\")[0]), data_type=taking.split(\",\")[1]), InOut(data_type=producing.split(\",\")[1], size=int(producing.split(\",\")[0])), int(depth))\n\n self.add_net(net, ident)\n i += 1\n\n i += 1\n\n while lines[i] != \"\\n\": # Inputs\n\n ident, size, kind, depth = lines[i].split(\"_\")\n\n self.inputs[ident] = ModelComponent(None, InOut(size=int(size), data_type=kind), int(depth))\n i += 1\n\n i += 1\n\n while lines[i] != \"\\n\": # Outputs\n\n ident, size, kind, depth, belows = lines[i].split(\"_\")\n\n self.outputs[ident] = ModelComponent(InOut(size=int(size), data_type=kind), None, int(depth))\n self.comps_below[ident] = belows.split(\",\")\n i += 1\n\n i += 1\n\n while i < len(lines): # Connections\n name, inp, outp, kind, size = lines[i].split(\"_\")\n\n if int(name[1:]) > self.last_con:\n self.last_con = int(name[1:])\n\n self.connections[name] = Connection(inp, outp, InOut(kind, int(size)), name)\n i += 1\n self.update_below()","def load(self, name, hidden=False):\n\n prefix = \"\"\n if hidden:\n prefix = \".\"\n load = np.load(prefix + name + \".npy\", encoding=\"latin1\", allow_pickle=True)\n self.neurons = load[0]\n self.weights = load[1]\n\n if not self.silent:\n print(\"[NoxmainNetwork]: Network \\\"\" + str(name) + \"\\\" with neurons \" + str(self.neurons) + \" loaded!\")","def load(self):\n\n or_none = lambda x: x if x != \"none\" else None\n with h5py.File(self.filename, \"r\") as hf:\n for attr, val in hf.attrs.items():\n setattr(self, attr, or_none(val))","def test_hdf5_load_all():\n skip_if_no_h5py()\n import h5py\n\n # save random data to HDF5\n handle, filename = tempfile.mkstemp()\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\n num_examples=10, dim=5,\n num_classes=3)\n with h5py.File(filename, 'w') as f:\n f.create_dataset('X', data=dataset.get_design_matrix())\n f.create_dataset('y', data=dataset.get_targets())\n\n # instantiate Train object\n trainer = yaml_parse.load(load_all_yaml % {'filename': filename})\n trainer.main_loop()\n\n # cleanup\n os.remove(filename)","def load_model(self, fname: str) -> None:\n checkpoint_data = torch.load(fname)\n\n # Load the models\n # P-Net\n model_import_path = checkpoint_data['p_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\n self.p_net = mod()\n self.p_net.set_params(checkpoint_data['p_net'])\n # Q-Net\n model_import_path = checkpoint_data['q_net']['model_import_path']\n imp = importlib.import_module(model_import_path)\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\n self.q_net = mod()\n self.q_net.set_params(checkpoint_data['q_net'])","def import_network(file_name, NetworkClass):\r\n file = open(file_name, 'br')\r\n data_pickle = file.read()\r\n file.close()\r\n net = NetworkClass()\r\n net.__dict__ = pickle.loads(data_pickle)\r\n return net","def load_model(self, name: str):\n\n # Loading config\n self.cM = ConfigManager(name + \".cfg\")\n\n # Loading Vocabs\n out_voc = pickle.load(open(name + \".out_voc\", \"rb\"))\n in_voc = pickle.load(open(name + \".in_voc\", \"rb\"))\n\n self.output_field.vocab = out_voc\n self.input_field.vocab = in_voc\n\n num_classes = len(self.output_field.vocab)\n embed = nn.Embedding.from_pretrained(self.input_field.vocab.vectors)\n self.network = FrameIDNetwork(self.cM, embed, num_classes)\n\n self.network.load_model(name + \".ph\")","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def save_utility_network(self,path_save):\n print(\"Save the neural network to : \"+path_save)\n self.nn.save_on_file(path_save)","def load_model(path):\n if os.path.isfile(path):\n print(\"=> loading checkpoint '{}'\".format(path))\n checkpoint = torch.load(path)\n\n # # size of the top layer\n # N = checkpoint['state_dict']['top_layer.bias'].size()\n #\n # # build skeleton of the model\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\n #\n # # deal with a dataparallel table\n # def rename_key(key):\n # if not 'module' in key:\n # return key\n # return ''.join(key.split('.module'))\n #\n # checkpoint['state_dict'] = {rename_key(key): val\n # for key, val\n # in checkpoint['state_dict'].items()}\n #\n # # load weights\n # model.load_state_dict(checkpoint['state_dict'])\n # print(\"Loaded\")\n # else:\n # model = None\n # print(\"=> no checkpoint found at '{}'\".format(path))\n\n # net = models.__dict__['ResNet18'](low_dim=128)\n # net = models.__dict__['resnet18'](low_dim=128)\n\n net = models.__dict__['alexnet'](out=128)\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\n\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\n net.load_state_dict(checkpoint['net'])\n\n return net","def load_checkpoint(self, model):\n print(f\"load model {self.save_model_path}\")\n model.load_state_dict(torch.load(self.save_model_path))","def load_model(filename):\n checkpoint = torch.load(filename)\n model = QNetwork(checkpoint['input_size'], checkpoint['output_size'], checkpoint['hidden_layers'])\n model.load_state_dict(checkpoint['state_dict'])\n return model","def load_h5(filename: str, **kwargs):\n return open_h5(filename, 'r', **kwargs)","def load_model(self, model_path):\n\n\t\tmodel_path = osp.abspath(model_path)\n\t\tmodel_weights_path = osp.splitext(model_path)[0] + \".bin\"\n\n\t\tself.Helpers.logger.info(\"Loading the model from '%s'\" % (model_path))\n\t\tmodel = self.context.ie_core.read_network(model_path, model_weights_path)\n\t\tself.Helpers.logger.info(\"Model loaded\")\n\n\t\treturn model","def load_checkpoint_ram(self, checkpoint, train=True):\n # -- For all tasks, create a corresponding head, otherwise the restoring would not work due to mismatching weights -- #\n self.mh_network.add_n_tasks_and_activate(self.already_trained_on[str(self.fold)]['tasks_at_time_of_checkpoint'],\n self.already_trained_on[str(self.fold)]['active_task_at_time_of_checkpoint'])\n \n # -- Set the network to the full MultiHead_Module network to restore everything -- #\n self.network = self.mh_network\n \n # -- Use parent class to save checkpoint for MultiHead_Module model consisting of self.model, self.body and self.heads -- #\n super().load_checkpoint_ram(checkpoint, train)\n\n # -- Reset network to the assembled model to continue training -- #\n self.network = self.mh_network.model","def load_checkpoint(model, save_path):\n model.load_state_dict(torch.load(save_path))","def load_weights(self, file_path):\n self.model.load_weights(file_path + '/policy_network.h5')\n print(\"\\nrestored weights of the policy network.\\n\")","def deserialize_model(hypes):\n model_path_trained = hypes['segmenter']['serialized_model_path']\n if not os.path.isfile(model_path_trained):\n logging.warning(\"No model found at '%s'.\", model_path_trained)\n network_path = hypes['segmenter']['network_path']\n network = imp.load_source('sst.network', network_path)\n trained = network.load_model(hypes)\n return trained","def load_model(self, win_len, axis):\n\n print('Load model')\n if 'ouisir' not in self.name_dataset.lower():\n self.feature_extractor = resnet2D(\n False, 0, 0, stride=2, feature_generator=True)\n else:\n self.feature_extractor = resnet2D(\n False, 0, 0, stride=2, feature_generator=True)\n self.feature_extractor.build((None, win_len, axis, 1))\n self.feature_extractor.load_weights(\n self.path_save_model + self.name_model + '.h5', by_name=True)\n\n print('Load mean and std')\n self.mean = np.load(self.path_save_model + 'mean.npy')\n self.std = np.load(self.path_save_model + 'std.npy')","def load(self, folder):\n # load the weights from input folder\n self.generator.load_weights('%s/generator.h5'%folder)\n self.critic.load_weights('%s/critic.h5'%folder)","def load_model(self, filename):\n event = teca_time_py_event('teca_deeplab_ar_detect::load_model')\n\n # this creates OpenMP thread pools and imports torch\n # it must be called *before* we import torch\n self.initialize()\n\n # import our torch codes only now that torch has been initialized\n global teca_deeplab_ar_detect_internals\n from teca_deeplab_ar_detect_internals \\\n import teca_deeplab_ar_detect_internals\n\n # create an instance of the model\n model = teca_deeplab_ar_detect_internals.DeepLabv3_plus(\n n_classes=1, _print=False)\n\n # load model weights from state on disk\n super().load_model(filename, model)","def load_model():\r\n model = MobileNetV2(weights=\"imagenet\")\r\n print(\"Model loaded\")\r\n return model","def load_network(self, serialize_network):\n layer = self.first_layer\n current_index = 0\n for i in range(self.number_of_layers):\n for neuron in layer.neuron_array:\n number_of_weights = len(neuron.weights)\n neuron.weights = serialize_network[current_index: number_of_weights]\n neuron.bias = serialize_network[current_index + number_of_weights]\n current_index += number_of_weights + 1\n if i != self.number_of_layers - 1:\n layer = layer.next_layer","def load(self, filename='nn_model.pkl'):\n with open(filename,'rb') as f:\n nn_model = pickle.load(f, encoding='bytes')\n f.close()\n\n self.W = nn_model.W\n self.b = nn_model.b\n\n self.num_bn_layers = nn_model.num_bn_layers\n self.bn = nn_model.num_bn_layers > 0\n self.hiddens = nn_model.hiddens\n self.nlayers = len(nn_model.hiddens) + 1\n self.input_size = nn_model.input_size\n self.output_size = nn_model.output_size\n self.activations = nn_model.activations\n self.criterion = nn_model.criterion\n self.lr = nn_model.lr\n self.momentum = nn_model.momentum\n\n if self.bn:\n self.bn_layers = nn_model.bn_layers\n\n self.train_mode = nn_model.train_mode\n self.batch_size = nn_model.batch_size\n self.epochs = nn_model.epochs","def _load_layer_weights(self, layer, name, h5file): \n group = h5file[name]\n length = group['length'][0]\n weights = [group[\"{}\".format(idx)] for idx in range(length)]\n layer.set_weights(weights)","def save_network(network, fpath):\n\twith open(fpath, \"wb\") as f:\n\t\tpickle.dump(network, f)","def load_net(self, file_path):\n \twith open(file_path,'r') as f:\n \t\tparams = json.loads(f.read())\n \t#\n \tweights = np.array(params['weights'])\n \tbiases = np.array(params['biases'])\n \t# Since ann.ANN needs to be initialized with some data, which\n \t# we dont have yet, we are gonna make a canvas array with\n \t# the correct dimensions from the weights\n \tfake_data = np.array([np.zeros(len(weights[-1]))])\n \t# initialize stacked net\n \tself.init_stacked_net(fake_data)\n \t# fill in weights and biases\n \tself.stacked_net.weights = weights\n \tself.stacked_net.biases = biases","def load(self, path):\n checkpoint = torch.load(path, map_location=torch.device(\"cpu\"))\n self.load_state_dict(checkpoint[\"state_dict\"])\n self.on_epoch_start(checkpoint[\"epoch\"])\n self.logger.info(\"Loaded controller network from %s\", path)","def load(self):\n checkpoint = torch.load(self.checkpoint_path,\n map_location=self.net.device)\n self.load_state_dict(checkpoint)\n del checkpoint","def _loadHDF5File(self, filename):\n matfile = h5py.File(filename)\n\n self.StokesI = np.transpose(matfile['StokesI'][:,:])\n self.StokesQ = np.transpose(matfile['StokesQ'][:,:])\n self.StokesU = np.transpose(matfile['StokesU'][:,:])\n self.StokesV = np.transpose(matfile['StokesV'][:,:])\n self.detectorPosition = matfile['detectorPosition'][:,0]\n self.detectorDirection = matfile['detectorDirection'][:,0]\n self.detectorVisang = matfile['detectorVisang'][0,0]\n\n try: self.wall = matfile['wall'][:,:]\n except KeyError: pass\n\n try: self.separatrix = matfile['separatrix'][:,:]\n except KeyError: pass","def load_model():\n # Model reconstruction from JSON file\n with open('model/model_strides_25_13-25-54.json', 'r') as f:\n model = model_from_json(f.read())\n # Load weights into the new model\n model.load_weights('model/bestmodel_weights_strides.hdf5')\n return model","def load(self, output_folder: str=None):\n\n # Load the genesis model.\n if output_folder is None:\n output_folder = os.path.join(os.path.dirname(__file__), 'model')\n\n # Load necessary files.\n self.n_final = pickle.load(open(os.path.join(\n output_folder, 'n_final.pkl'), 'rb'))\n self.min_values = pickle.load(open(os.path.join(\n output_folder, 'min_params.pkl'), 'rb'))\n self.norm_params = pickle.load(open(os.path.join(\n output_folder, 'norm_params.pkl'), 'rb'))\n self.label_encoder = pickle.load(open(os.path.join(\n output_folder, 'label_encoder.pkl'), 'rb'))\n\n # Load network.\n net = Net(self.n_final)\n net.to(self.device)\n\n # If a refitted model exists.\n if os.path.exists(os.path.join(output_folder, 'state_dict.refit.pt')):\n genesis_model_path = os.path.join(\n output_folder, 'state_dict.refit.pt')\n else:\n genesis_model_path = os.path.join(output_folder, 'state_dict.pt')\n\n net.load_state_dict(torch.load(genesis_model_path))\n\n '''\n # Check the number of parameters in each layer.\n for key in torch.load(genesis_model_path).keys():\n if 'bias' in key:\n print(key, torch.load(genesis_model_path)[key].shape)\n '''\n\n self.net = net","def load_model(self):\n self.opt.load_weights_folder = os.path.expanduser(self.opt.load_weights_folder)\n\n assert os.path.isdir(self.opt.load_weights_folder), \\\n \"Cannot find folder {}\".format(self.opt.load_weights_folder)\n print(\"loading model from folder {}\".format(self.opt.load_weights_folder))\n\n for model_name in [\"encoder\", \"decoder\"]:\n print(\"Loading {} weights...\".format(model_name))\n path = os.path.join(self.opt.load_weights_folder, \"{}.pth\".format(model_name))\n model_dict = self.encoder.state_dict() if model_name == \"encoder\" else self.decoder.state_dict()\n pretrained_dict = torch.load(path)\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\n model_dict.update(pretrained_dict)\n if model_name == \"encoder\":\n self.encoder.load_state_dict(model_dict)\n else:\n self.decoder.load_state_dict(model_dict)\n\n # loading adam state\n optimizer_load_path = os.path.join(self.opt.load_weights_folder, \"adam.pth\")\n if os.path.isfile(optimizer_load_path):\n print(\"Loading Adam weights\")\n optimizer_dict = torch.load(optimizer_load_path)\n self.optimizer.load_state_dict(optimizer_dict)\n else:\n print(\"Cannot find Adam weights so Adam is randomly initialized\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load_net(filepath):\n\twith open(filepath, 'r') as fh:\n\t\treturn load(file = fh)","def loadNetwork(path, arch):\n if arch in resnet.__dict__:\n model = resnet.__dict__[arch]()\n model.load_state_dict(torch.load(path, map_location=device))\n return model\n elif arch in other_resnet.__dict__:\n model = other_resnet.__dict__[arch]()\n model.load_state_dict(torch.load(path, map_location=device))\n return model\n elif arch in vgg.__dict__:\n model = vgg.__dict__[arch]()\n model.load_state_dict(torch.load(path, map_location=device))\n return model","def load(self, filename):\n\n c = torch.load(filename)\n\n if type(c) is dict:\n sd = c['state_dict']\n self.net.load_state_dict(sd)\n if 'monitors' in c: # Remove the branching eventually\n self.monitors = c['monitors']\n else:\n self.monitors = {'loss_train': c['train_monitor'], 'loss_val': c['val_monitor'],\n 'accu_train': MetricHistory(), 'accu_val': MetricHistory()}\n if 'optimizer' in c: # Remove the branching eventually\n self.optimizer.load_state_dict(c['optimizer'])\n else:\n raise RuntimeError('Unsupported checkpoint. (Not a dict)')\n\n self.parent = filename\n self.last_checkpoint = filename\n self.start_epoch = self.monitors['loss_train'].num_epochs","def load_network(file_name):\n with open(file_name) as file:\n data = json.load(file)\n\n cost_fn = getattr(sys.modules[__name__], data[\"cost_func\"])\n act_fn = getattr(sys.modules[__name__], data[\"act_func\"])\n metric = getattr(sys.modules[__name__], data[\"metric\"])\n\n network = Network([1, 1], act_func=act_fn, cost_func=cost_fn, metric=metric)\n network.layers_num = data[\"layers_num\"]\n network.weights = [np.array(w) for w in data[\"weights\"]]\n network.biases = [np.array(b) for b in data[\"biases\"]]\n\n return network","def load_opcodes_subnetwork_pretrained_weights(self, model):\n print(\"ToImplement\")","def restore_model(self, prefix):\n model_file = prefix + \".json\"\n weight_file = prefix + \".h5\"\n self.model = model_from_json(json.load(open(model_file)))\n self.model.load_weights(weight_file)\n return self\n model.load_weights(\"./output/model.h5\")","def load_model(self, model_path, load_ae=True, map_location='cpu'):\n assert load_ae and (self.ae_net is not None), 'The trainer has not been initialized with an Autoencoder. It can thus not be loaded.'\n model_dict = torch.load(model_path, map_location=map_location)\n self.c = model_dict['c']\n self.net.load_state_dict(model_dict['net_dict'])\n\n if load_ae and (self.ae_net is not None):\n self.ae_net.load_state_dict(model_dict['ae_net_dict'])","def load_model():\r\n global model # 下面的那个predict也是要用的 所以在这里定义为全局\r\n model = DenseNet(n_input_channels=1, num_init_features=64,\r\n growth_rate=32,\r\n block_config=(3, 6, 12, 8), num_classes=4).to(device)\r\n model.load_state_dict(torch.load(\"./model29.pkl\"))\r\n model.eval()","def load_nn(self, filename):\n self.weights_and_biases = (np.load(filename, allow_pickle=True)).tolist()\n print('Weights and biases are loaded')","def load_bot(self, prefix=\"model_data/\"):\n attributes = np.load(prefix + \"model_attributes.npy\",\n allow_pickle='TRUE').item()\n \n self.num_rounds = attributes[\"num_rounds\"]\n self.c = attributes[\"c\"]\n self.alpha = attributes[\"alpha\"]\n if \"loss_history\" in attributes:\n self.loss_history = attributes[\"loss_history\"]\n self.evaluation_history_old = attributes[\"evaluation_history_old\"]\n self.evaluation_history_ran = attributes[\"evaluation_history_ran\"]\n \n network_load_command = attributes[\"network_load_command\"]\n exec(network_load_command)\n self.network.load_network(prefix)","def load(self, filename):\n with open(filename, 'rb') as f:\n data = pickle.load(f)\n # Set biases and weights\n self.W_input_to_hidden = data['wi']\n self.W_hidden_to_hidden = data['wh']\n self.W_hidden_to_output = data['wo']","def load_model(self, sess, pb_model_path):\n\n logging.info(\"Import yolo model from pb start .......\")\n\n with sess.as_default():\n with sess.graph.as_default():\n with tf.gfile.FastGFile(pb_model_path, 'rb') as f_handle:\n logging.info(\"ParseFromString start .......\")\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f_handle.read())\n logging.info(\"ParseFromString end .......\")\n\n tf.import_graph_def(graph_def, name='')\n logging.info(\"Import_graph_def end .......\")\n\n logging.info(\"Import yolo model from pb end .......\")","def load_networks(self, dir_weights, idx_load):\n\n path_p = dir_weights + 'p_{}.ckpt'\n path_D = dir_weights + 'D_{}.ckpt'\n path_U = dir_weights + 'U_{}.ckpt'\n\n self.net_p.load_weights(path_p.format(idx_load))\n self.net_D.load_weights(path_D.format(idx_load))\n self.net_U.load_weights(path_U.format(idx_load))","def load(self, filename):\n with open(filename, 'rb') as f:\n data = pickle.load(f)\n # Set biases and weights\n self.W_input_to_hidden = data['wi']\n self.W_hidden_to_output = data['wo']","def load_model(self, filename):\r\n pass","def load_block(state_dict, eval_type, src_name, tgt_name, h5_dir):\n h5f = h5py.File(os.path.join(h5_dir, '{:s}_{:s}.h5'.format(eval_type, src_name)), 'r')\n\n state_dict[tgt_name + '.branch_0.conv3d.weight'] = torch.from_numpy(h5f['b0_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_0.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_0.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_0.bn.bias'] = torch.from_numpy(h5f['b0_beta'][...])\n state_dict[tgt_name + '.branch_0.bn.running_mean'] = torch.from_numpy(h5f['b0_mv_mean'][...])\n state_dict[tgt_name + '.branch_0.bn.running_var'] = torch.from_numpy(h5f['b0_mv_var'][...])\n\n state_dict[tgt_name + '.branch_1a.conv3d.weight'] = torch.from_numpy(h5f['b1a_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_1a.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_1a.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_1a.bn.bias'] = torch.from_numpy(h5f['b1a_beta'][...])\n state_dict[tgt_name + '.branch_1a.bn.running_mean'] = torch.from_numpy(h5f['b1a_mv_mean'][...])\n state_dict[tgt_name + '.branch_1a.bn.running_var'] = torch.from_numpy(h5f['b1a_mv_var'][...])\n state_dict[tgt_name + '.branch_1b.conv3d.weight'] = torch.from_numpy(h5f['b1b_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_1b.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_1b.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_1b.bn.bias'] = torch.from_numpy(h5f['b1b_beta'][...])\n state_dict[tgt_name + '.branch_1b.bn.running_mean'] = torch.from_numpy(h5f['b1b_mv_mean'][...])\n state_dict[tgt_name + '.branch_1b.bn.running_var'] = torch.from_numpy(h5f['b1b_mv_var'][...])\n\n state_dict[tgt_name + '.branch_2a.conv3d.weight'] = torch.from_numpy(h5f['b2a_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_2a.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_2a.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_2a.bn.bias'] = torch.from_numpy(h5f['b2a_beta'][...])\n state_dict[tgt_name + '.branch_2a.bn.running_mean'] = torch.from_numpy(h5f['b2a_mv_mean'][...])\n state_dict[tgt_name + '.branch_2a.bn.running_var'] = torch.from_numpy(h5f['b2a_mv_var'][...])\n state_dict[tgt_name + '.branch_2b.conv3d.weight'] = torch.from_numpy(h5f['b2b_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_2b.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_2b.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_2b.bn.bias'] = torch.from_numpy(h5f['b2b_beta'][...])\n state_dict[tgt_name + '.branch_2b.bn.running_mean'] = torch.from_numpy(h5f['b2b_mv_mean'][...])\n state_dict[tgt_name + '.branch_2b.bn.running_var'] = torch.from_numpy(h5f['b2b_mv_var'][...])\n\n state_dict[tgt_name + '.branch_3b.conv3d.weight'] = torch.from_numpy(h5f['b3_weight'][...]).permute(4, 3, 0, 1, 2)\n output_channels = state_dict[tgt_name + '.branch_3b.conv3d.weight'].size(0)\n # Sonnet model does not scale batch norm output, it only adds bias.\n state_dict[tgt_name + '.branch_3b.bn.weight'] = torch.ones(output_channels)\n state_dict[tgt_name + '.branch_3b.bn.bias'] = torch.from_numpy(h5f['b3_beta'][...])\n state_dict[tgt_name + '.branch_3b.bn.running_mean'] = torch.from_numpy(h5f['b3_mv_mean'][...])\n state_dict[tgt_name + '.branch_3b.bn.running_var'] = torch.from_numpy(h5f['b3_mv_var'][...])","def _load_model(self):\r\n filepath = f\"Models/{self.environment.name}/q_network\"\r\n # Check if model exists in default directory\r\n if path.exists(filepath):\r\n self.q_network = NetworkBuilder._load_model(filepath)\r\n self.target_network = NetworkBuilder._load_model(filepath)\r\n print(\"Models loaded\")\r\n return True\r\n else:\r\n print(f\"'{filepath}' not found\")\r\n return False","def load_checkpoint(self, file):\n \"\"\"Load \"\"\"\n chkpnt = torch.load(file)\n self.load_state_dict(chkpnt['model_state_dict'])","def load_model(model_path, model_name, net=None):\n config_file, model_file = _get_config_file(model_path, model_name), _get_model_file(model_path, model_name)\n assert os.path.isfile(\n config_file\n ), f'Could not find the config file \"{config_file}\". Are you sure this is the correct path and you have your model config stored here?'\n assert os.path.isfile(\n model_file\n ), f'Could not find the model file \"{model_file}\". Are you sure this is the correct path and you have your model stored here?'\n with open(config_file) as f:\n config_dict = json.load(f)\n if net is None:\n act_fn_name = config_dict[\"act_fn\"].pop(\"name\").lower()\n act_fn = act_fn_by_name[act_fn_name](**config_dict.pop(\"act_fn\"))\n net = BaseNetwork(act_fn=act_fn, **config_dict)\n net.load_state_dict(torch.load(model_file, map_location=device))\n return net","def load(path_to_model):\n pass","def load_NeuralNet(self, path_model_dir, X_train, y_train, epochs):\n\n #fetch best params\n best_params_ = self.load('best_params_', 'dill', path_model_dir) \n \n #rebuild model_dict\n model_dict = _NeuralNet.DenseNet.model_dict(**best_params_)\n model_dict['best_model'] = _NeuralNet.utils.load_model(_os.path.join(path_model_dir,'best_estimator_.h5'))\n model_dict['best_params'] = best_params_ \n model_dict['best_cv_score'] = _np.nan\n\n return model_dict","def load_h5_file(file_path):\n # load\n fr = h5py.File(file_path, 'r')\n a_group_key = list(fr.keys())[0]\n data = list(fr[a_group_key])\n # transform to appropriate numpy array \n data=data[0:]\n data = np.stack(data, axis=0)\n return data","def load_h5_file(file_path):\n # load\n fr = h5py.File(file_path, 'r')\n a_group_key = list(fr.keys())[0]\n data = list(fr[a_group_key])\n # transform to appropriate numpy array \n data=data[0:]\n data = np.stack(data, axis=0)\n return data","def load(self):\n try:\n if self.model.is_cuda:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \"save_point.pth\")))\n else:\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\n \"save_point.pth\"), map_location=\"cpu\"))\n except:\n sys.exit(\"Unable to load previous model\")","def load_model(self):\n saved_path = self.config.path_tmp / self.model.model_name\n if saved_path.exists():\n self.model.load_weights(str(saved_path / 'model.vec'))","def save_as_hdf5(self, filename):","def load_model(self):\n print(\"=============start loading models=============\")\n # load models from basemodel and fine-tune layers\n base_model = DenseNet(reduction=0.5, classes=1000, weights_path=BASE_WEIGHT_DIR)\n base_model.layers.pop()\n base_model.layers.pop()\n x4 = Dense(6, activation='relu')(base_model.layers[-1].output)\n o = Activation('softmax')(x4)\n\n model = Model(inputs=base_model.input, outputs=[o])\n model.load_weights(WEIGHT_DIR)\n\n self.model = model\n print(\"=============finish loading models=============\")","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def load(filename):\n f = open(filename, \"r\")\n data = json.load(f)\n f.close()\n net = MFoMNetwork(data[\"sizes\"])\n net.weights = [np.array(w) for w in data[\"weights\"]]\n net.biases = [np.array(b) for b in data[\"biases\"]]\n return net","def load_weight(model):\n file = h5py.File(WEIGHT_SAVE, 'r')\n weight = []\n for i in range(len(file.keys())):\n weight.append(file['weight' + str(i)][:])\n model.set_weights(weight)","def load(self, path: str):\n self.model.load_state_dict(torch.load(path))","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def load(self, path):\n checkpoint = torch.load(path)\n self.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])","def load_pretrained_network(self):\n\n if self.manager is None or self.checkpoint is None:\n return False\n status = self.checkpoint.restore(self.manager.latest_checkpoint)\n return status","def load_pretrained_network(self):\n\n if self.manager is None or self.checkpoint is None:\n return False\n status = self.checkpoint.restore(self.manager.latest_checkpoint)\n return status","def test_save_load(tmp_path, num_mutations):\n\n def assert_networks_equal(net, loaded_net):\n assert net.in_size == loaded_net.in_size\n assert net.out_size == loaded_net.out_size\n assert net.p_initial_connection_enabled == loaded_net.p_initial_connection_enabled\n assert net.p_add_connection == loaded_net.p_add_connection\n assert net.p_add_node == loaded_net.p_add_node\n assert net.inherit_weights == loaded_net.inherit_weights\n assert net.activation_name == loaded_net.activation_name\n assert net.neurons_in_layer == loaded_net.neurons_in_layer\n assert net.connections == loaded_net.connections\n assert np.allclose(net.weights, loaded_net.weights)\n\n net = WeightLearningNetwork(5, 2, 0.5)\n for _ in range(num_mutations):\n net.mutate()\n\n # Save network, load it and check that everything is still correct.\n print(tmp_path / 'network.json')\n net.save(tmp_path / 'network.json')\n loaded_net = WeightLearningNetwork.load(tmp_path / 'network.json')\n assert_networks_equal(net, loaded_net)\n\n # Do this again after creating and deleting weight matrices.\n net.create_torch_layers()\n net.delete_torch_layers()\n\n net.save(tmp_path / 'network2.json')\n loaded_net = WeightLearningNetwork.load(tmp_path / 'network2.json')\n assert_networks_equal(net, loaded_net)\n\n # Check that we can still create weight matrices on loaded net.\n loaded_net.create_torch_layers()"],"string":"[\n \"def load_network(self, which_epoch):\\n save_filename = '%s_net.pth' % which_epoch\\n load_path = os.path.join(self.save_dir, save_filename)\\n net = self.net\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n print('loading the model from %s' % load_path)\\n # PyTorch newer than 0.4 (e.g., built from\\n # GitHub source), you can remove str() on self.device\\n state_dict = torch.load(load_path, map_location=str(self.device))\\n if hasattr(state_dict, '_metadata'):\\n del state_dict._metadata\\n net.load_state_dict(state_dict)\",\n \"def load_model(self):\\n self.pred_net.load((self.save_path / \\\"iqn_pred_net\\\").absolute().as_posix())\\n self.target_net.load((self.save_path / \\\"iqn_target_net\\\").absolute().as_posix())\",\n \"def load_trained_net(mal):\\n model_root = os.path.join(os.getcwd(), 'data', 'models')\\n model = load_model(os.path.join(model_root, 'model_' + mal + '.h5'))\\n\\n return model\",\n \"def load_network(self, sess, filename):\\n dir_path = os.path.dirname(os.path.realpath(__file__))\\n dir_path += '/Models/'\\n dir_path += filename\\n saver = tf.train.Saver()\\n saver.restore(sess, dir_path)\",\n \"def load_network(fpath):\\n\\twith open(fpath, \\\"rb\\\") as f:\\n\\t\\tnetwork = pickle.load(f)\\n\\treturn network\",\n \"def __load_Model(self):\\r\\n PrintsForUser.printProcess(\\\"[INFO] Loading network...\\\")\\r\\n \\r\\n self.__model = load_model(self.__model_path)\\r\\n self.__lb = pickle.loads(open(self.__labels_path, \\\"rb\\\").read())\",\n \"def load_networks(self, which_epoch):\\n for name in self.model_names:\\n if isinstance(name, str):\\n filename = '%s_net_%s.pth' % (which_epoch, name)\\n path = os.path.join(self.save_dir, filename)\\n net = getattr(self, 'net_' + name)\\n try:\\n state_dict = torch.load(path)\\n state_dict = {name.replace('module.', '', 1) : param for name, param in state_dict.items()}\\n # net.load_state_dict(torch.load(path))\\n net.load_state_dict(state_dict)\\n except:\\n pretrained_dict = torch.load(path)\\n model_dict = net.state_dict()\\n try:\\n pretrained_dict = {k:v for k,v in pretrained_dict.items() if k in model_dict}\\n net.load_state_dict(pretrained_dict)\\n print('Pretrained network %s has excessive layers; Only loading layers that are used' % name)\\n except:\\n print('Pretrained network %s has fewer layers; The following are not initialized:' % name)\\n not_initialized = set()\\n for k, v in pretrained_dict.items():\\n if v.size() == model_dict[k].size():\\n model_dict[k] = v\\n\\n for k, v in model_dict.items():\\n if k not in pretrained_dict or v.size() != pretrained_dict[k].size():\\n not_initialized.add(k.split('.')[0])\\n print(sorted(not_initialized))\\n net.load_state_dict(model_dict)\\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\\n net.cuda()\\n if not self.isTrain:\\n net.eval()\",\n \"def load_networks(self, epoch):\\n for name in self.network_names:\\n if isinstance(name, str):\\n load_filename = '{0}_net_{1}.pth'.format(epoch, name)\\n load_path = os.path.join(self.save_dir, load_filename)\\n net = getattr(self, 'net')\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n print('loading the model from {0}'.format(load_path))\\n state_dict = torch.load(load_path, map_location=self.device)\\n if hasattr(state_dict, '_metadata'):\\n del state_dict._metadata\\n\\n net.load_state_dict(state_dict)\",\n \"def _load_model(self):\\n self._load_scaler('scaler.save')\\n self._load_encoder('encoder0.save', 0)\\n self._load_encoder('encoder1.save', 1)\\n self._load_neural_network('model.json', 'model.h5')\\n return\",\n \"def load(uDir):\\n import sys\\n sys.path.append(uDir)\\n from net_spec import spec\\n \\n builder = NetworkBuilder(spec)\\n htm = builder.build()\\n htm.start()\\n \\n ## restore each node state\\n layers = htm.layers\\n \\n for l in range(len(layers) - 1):\\n (r,c) = spec[l]['shape']\\n\\n if layers[l].node_sharing:\\n state = {}\\n state['coincidences'] = np.load(uDir + str(l) + \\\".0.0.coincidences.npy\\\")\\n state['temporal_groups'] = [] ## !FIXME temporal groups should be saved, first\\n state['PCG'] = np.load(uDir + str(l) + \\\".0.0.PCG.npy\\\")\\n\\n for i in range(r):\\n for j in range(c):\\n layers[l].pipes[i][j].send((\\\"set_state\\\", state))\\n\\n else:\\n for i in range(r):\\n for j in range(c):\\n state = {}\\n state['coincidences'] = np.load(uDir + str(l) + \\\".\\\" + str(i) + \\\".\\\" + str(j) + \\\".coincidences.npy\\\")\\n state['temporal_groups'] = [] ## !FIXME temporal groups should be saved, first\\n state['PCG'] = np.load(uDir + str(l) + \\\".\\\" + str(i) + \\\".\\\" + str(j) + \\\".PCG.npy\\\")\\n layers[l].pipes[i][j].send((\\\"set_state\\\", state))\\n \\n ## restore also last node's state\\n state = {}\\n state['coincidences'] = np.load(uDir + str(len(layers) - 1) + \\\".0.0.coincidences.npy\\\")\\n state['cls_prior_prob'] = np.load(uDir + str(len(layers) - 1) + \\\".0.0.cls_prior_prob.npy\\\")\\n state['PCW'] = np.load(uDir + str(len(layers) - 1) + \\\".0.0.PCW.npy\\\")\\n layers[-1].pipes[0][0].send((\\\"set_state\\\", state))\\n\\n return htm\",\n \"def load(self, filename, path=\\\".\\\"):\\n if filename is None:\\n if self.verbose:\\n print(\\\"Neural Network Model Class - Save Function: No file name\\\")\\n return -1\\n\\n #trn_params\\n self.trn_params = NeuralNetworkParams()\\n self.trn_params.load('%s_trn_params.pickle'%(filename),path=path)\\n\\n #model\\n json_file = open(\\\"%s/%s_model.json\\\"%(path,filename), 'r')\\n loaded_model_json = json_file.read()\\n json_file.close()\\n loaded_model = model_from_json(loaded_model_json)\\n loaded_model.load_weights(\\\"%s/%s_model.h5\\\"%(path,filename))\\n self.model = loaded_model\\n self.trained = True\\n #trn_desc\\n self.trn_desc = None\\n self.trn_desc = pickle.load(open(\\\"%s/%s_trn_desc.pickle\\\"%(path,filename), \\\"rb\\\"))\",\n \"def load_all(self, file):\\n self.model = load_model(file + \\\"_model.h5\\\")\",\n \"def _load_local_weights(self, h5file):\\n for name, layer in self._layers_to_save.items():\\n self._load_layer_weights(layer, name, h5file)\",\n \"def load_hdf5_with_structure(file):\\n n_classes = 80\\n n_boxes = 5\\n anchors = [[0.738768, 0.874946], [2.42204, 2.65704], [4.30971, 7.04493], [10.246, 4.59428], [12.6868, 11.8741]]\\n\\n yolov2 = YOLOv2(n_classes=n_classes, n_boxes=n_boxes)\\n chainer.serializers.load_hdf5(file, yolov2)\\n model = YOLOv2Predictor(yolov2)\\n model.init_anchor(anchors)\\n #model.predictor.train = False\\n model.predictor.finetune = False\\n return model\",\n \"def load(self, uri):\\r\\n self._encoder = load_model(uri+\\\"_lstm_encoder.hdf5\\\")\\r\\n self._autoencoder = load_model(uri+\\\"_lstm_autoencoder.hdf5\\\")\\r\\n\\r\\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)))\\r\\n dict_options = pf[os.path.basename(uri)+\\\"_options.json\\\"]\\r\\n\\r\\n self._latent_space = dict_options['latent_space']\\r\\n self._input_cells = dict_options['input_cells']\",\n \"def load(self, filename):\\n hebbian_weights = open(filename, \\\"r\\\").read().split('\\\\n')\\n for i in xrange(self.hidden):\\n weights = hebbian_weights[i].split('\\\\t')\\n self.vis_layer[i].set_weights(weights)\\n for i in xrange(self.layers):\\n for j in xrange(self.hidden):\\n weights = hebbian_weights[((i+1)*self.hidden)+j].split('\\\\t')\\n self.hidden_layers[i][j].set_weights(weights)\\n weights = hebbian_weights[-2].split('\\\\t')\\n self.output_neuron.set_weights(weights)\",\n \"def load_networks(self, epoch):\\n for name in self.model_names:\\n if isinstance(name, str):\\n load_filename = '%s_net_%s.pth' % (epoch, name)\\n load_path = os.path.join(self.save_dir, load_filename)\\n net = getattr(self, 'net' + name)\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n print('loading the model from %s' % load_path)\\n # if you are using PyTorch newer than 0.4 (e.g., built from\\n # GitHub source), you can remove str() on self.device\\n state_dict = torch.load(load_path, map_location=str(self.device))\\n if hasattr(state_dict, '_metadata'):\\n del state_dict._metadata\\n\\n # patch InstanceNorm checkpoints prior to 0.4\\n for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\\n self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\\n net.load_state_dict(state_dict)\",\n \"def restore_model(self, path):\\n # if cuda is not available load everything to cpu\\n if not self.use_cuda:\\n state = torch.load(path, map_location=lambda storage, loc: storage)\\n else:\\n state = torch.load(path)\\n self.net.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optimizer'])\\n self.epoch_counter = state['epoch'] # counts number of epochs\",\n \"def load_model(self, path):\\n self._saver.restore(self._sess, path + '/model.ckp')\\n pkl_file = open(path + '/som.pkl', 'rb')\\n restored = pickle.load(pkl_file)\\n pkl_file.close()\\n self._m = restored['_m']\\n self._n = restored['_n']\\n self._neighbourhood = restored['_neighbourhood']\\n # self._topography = restored['_topography']\\n self._num_iterations = restored['_num_iterations']\\n self._Wts = restored['_Wts']\\n self._locations = restored['_locations']\\n self._learned = restored['_learned']\\n self._centroid_grid = restored['_centroid_grid']\\n self.abnormal_dist = restored['abnormal_dist']\\n\\n print(\\\"Model restored from path: \\\" + path)\",\n \"def load(self, path):\\n print('Loading model from {}'.format(path.name))\\n self.qnetwork_local.load_state_dict(torch.load(path))\\n self.qnetwork_target.load_state_dict(torch.load(path))\\n return\",\n \"def load(self, path, nr_of_saves, test_it=-1):\\n with self.graph.as_default():\\n print(\\\"Loading networks...\\\")\\n checkpoint_dir = os.path.join(os.environ['APPROXIMATOR_HOME'], path, \\\"network-\\\"+str(test_it))\\n self.saver = tf.train.Saver(max_to_keep=nr_of_saves+1)\\n try:\\n self.saver.restore(self.sess, checkpoint_dir)\\n print(\\\"Loaded: {}\\\".format(checkpoint_dir))\\n except Exception:\\n if test_it <= 0:\\n # Initialize the variables\\n self.sess.run(tf.global_variables_initializer())\\n print(\\\"Failed! Initializing the network variables...\\\")\\n else:\\n raise\",\n \"def model_load(file_name=None):\\n if file_name is None :\\n file_name = \\\"./data/_oP5_SegmentClassifier.dump\\\"\\n else:\\n pass\\n\\n return p5_util.object_load(file_name)\",\n \"def load_networks(self, epoch: int) -> None:\\n for name, module in self.modules.items():\\n if isinstance(name, str):\\n load_filename = '%s_net_%s.pth' % (epoch, name)\\n load_path = os.path.join(self.save_dir, load_filename)\\n if isinstance(module, torch.nn.DataParallel):\\n module = module.module\\n print('loading the model from %s' % load_path)\\n state_dict = torch.load(load_path, map_location=str(self.device))\\n if hasattr(state_dict, '_metadata'):\\n del state_dict._metadata\\n # patch InstanceNorm checkpoints prior to 0.4\\n for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\\n self.__patch_instance_norm_state_dict(state_dict, module, key.split('.'))\\n module.load_state_dict(state_dict)\\n return\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def load(self, name, path=None):\\n if path is None:\\n path = '.'\\n if path[0] == '~':\\n path = os.getenv(\\\"HOME\\\") + path[1:]\\n\\n try:\\n with open(path + '/' + name, 'rb') as f:\\n return pickle.load(f)\\n except IOError as e:\\n msg = str(e) + '\\\\nNeuralNetwork.load failed.'\\n raise DNNetIOError(msg)\",\n \"def loadh5(fname, path='/data'):\\n fp = open_read(fname)\\n slab = fp.get_node(path)\\n mat = slab.read()\\n fp.close()\\n return mat\",\n \"def load_network_for_training(file_name):\\n global training_set, start_round, start_digit\\n try:\\n with open (file_name, 'r') as f:\\n w = np.load(f)\\n w_min = np.load(f)\\n w_max = np.load(f)\\n a_plus = np.load(f)\\n a_minus = np.load(f)\\n b_plus = np.load(f)\\n b_minus = np.load(f)\\n v_th = np.load(f)\\n training_set = np.reshape(np.load(f), (TRAINING_SIZE, N))\\n start_round = np.load(f)\\n start_digit = np.load(f)\\n\\n Output.set_states({'v_th' : v_th})\\n S.set_states({\\n 'w' : w,\\n 'w_min' : w_min, \\n 'w_max' : w_max, \\n 'a_plus' : a_plus, \\n 'a_minus' : a_minus, \\n 'b_plus' : b_plus, \\n 'b_minus' : b_minus\\n })\\n print start_round\\n print start_digit\\n print v_th\\n except IOError as e:\\n print \\\"error opening file: %s\\\" % e.strerror\\n sys.exit()\",\n \"def load_bytes_subnetwork_pretrained_weights(self, model):\\n print(\\\"ToImplement\\\")\",\n \"def export_to_hdf5(cls, h5_file, model, loads):\\n #encoding = model._encoding\\n #comments = []\\n sid = []\\n node = []\\n cid = []\\n mag = []\\n xyz = []\\n for load in loads:\\n #comments.append(loads.comment)\\n sid.append(load.sid)\\n node.append(load.node)\\n cid.append(load.cid)\\n mag.append(load.mag)\\n xyz.append(load.xyz)\\n\\n #h5_file.create_dataset('_comment', data=comments)\\n h5_file.create_dataset('sid', data=sid)\\n h5_file.create_dataset('node', data=node)\\n h5_file.create_dataset('cid', data=cid)\\n h5_file.create_dataset('mag', data=mag)\\n h5_file.create_dataset('xyz', data=xyz)\",\n \"def load(self, name=\\\"\\\"):\\n\\n self.constructed = True\\n if name == \\\"\\\":\\n name = \\\"/home/unai/Escritorio/MultiNetwork/model/model\\\"\\n\\n network_descriptors = {\\\"Generic\\\": GenericDescriptor, \\\"Decoder\\\": DecoderDescriptor, \\\"Discrete\\\": DiscreteDescriptor, \\\"Convolution\\\": ConvolutionDescriptor}\\n\\n if not os.path.isfile(name):\\n print(\\\"Error at loading the model\\\")\\n return None\\n\\n f = open(name, \\\"r+\\\")\\n\\n lines = f.readlines()\\n\\n i = 0\\n while lines[i] != \\\"\\\\n\\\": # Each component is stored in a line\\n ident, n_inp, kind, n_hidden, layers, init, act, cond_rand, taking, producing, depth, reachable, belows = lines[i][:-1].split(\\\"_\\\")\\n kwargs = {}\\n if int(ident[1:]) > self.last_net:\\n self.last_net = int(ident[1:])\\n\\n self.reachable[ident] = reachable.split(\\\",\\\")\\n self.comps_below[ident] = belows.split(\\\",\\\")\\n\\n if \\\"onv\\\" in kind: # Not working right now\\n filters, sizes, layers, strides = layers.split(\\\"*\\\")\\n sizes = sizes.split(\\\",\\\")\\n s = np.array([[int(sz) for sz in szs.split(\\\"/\\\")] for szs in sizes])\\n desc = network_descriptors[kind](int(inp), int(outp), int(n_inp), layers.split(\\\",\\\"), filters.split(\\\",\\\"), [int(x) for x in strides.split(\\\",\\\")], s, [int(x) for x in act.split(\\\",\\\")], [int(x) for x in init.split(\\\",\\\")], kwargs)\\n else:\\n if len(kwargs) > 0: # Not working right now\\n kwargs = kwargs.split(\\\"-\\\")\\n kwargs[0] = [int(x) for x in kwargs[0].split(\\\".\\\") if len(x) > 0]\\n kwargs[1] = [int(x) for x in kwargs[1].split(\\\".\\\") if len(x) > 0]\\n if len(cond_rand) > 0:\\n cond_rand = cond_rand.split(\\\"-\\\")\\n cond_rand[0] = [int(x) for x in cond_rand[0].split(\\\",\\\") if len(x) > 0]\\n cond_rand[1] = [int(x) for x in cond_rand[1].split(\\\",\\\") if len(x) > 0]\\n kwargs[\\\"conds\\\"] = cond_rand\\n desc = network_descriptors[kind](int(taking.split(\\\",\\\")[0]), int(producing.split(\\\",\\\")[0]), int(n_inp), int(n_hidden), [int(x) for x in layers.split(\\\",\\\") if x != \\\"-1\\\"], init_functions[[int(x) for x in init.split(\\\",\\\") if x != \\\"-1\\\"]],\\n act_functions[[int(x) for x in act.split(\\\",\\\") if x != \\\"-1\\\"]], **kwargs)\\n\\n # print(\\\"ident\\\", ident, \\\"n_inp\\\", n_inp, \\\"kind\\\", kind, \\\"inp\\\", inp, \\\"outp\\\", outp, \\\"layers\\\", layers, \\\"init\\\", init, \\\"act\\\", act, \\\"taking\\\", taking, \\\"producing\\\", producing, \\\"depth\\\", depth, \\\"kwargs\\\", kwargs)\\n net = NetworkComp(desc, InOut(size=int(taking.split(\\\",\\\")[0]), data_type=taking.split(\\\",\\\")[1]), InOut(data_type=producing.split(\\\",\\\")[1], size=int(producing.split(\\\",\\\")[0])), int(depth))\\n\\n self.add_net(net, ident)\\n i += 1\\n\\n i += 1\\n\\n while lines[i] != \\\"\\\\n\\\": # Inputs\\n\\n ident, size, kind, depth = lines[i].split(\\\"_\\\")\\n\\n self.inputs[ident] = ModelComponent(None, InOut(size=int(size), data_type=kind), int(depth))\\n i += 1\\n\\n i += 1\\n\\n while lines[i] != \\\"\\\\n\\\": # Outputs\\n\\n ident, size, kind, depth, belows = lines[i].split(\\\"_\\\")\\n\\n self.outputs[ident] = ModelComponent(InOut(size=int(size), data_type=kind), None, int(depth))\\n self.comps_below[ident] = belows.split(\\\",\\\")\\n i += 1\\n\\n i += 1\\n\\n while i < len(lines): # Connections\\n name, inp, outp, kind, size = lines[i].split(\\\"_\\\")\\n\\n if int(name[1:]) > self.last_con:\\n self.last_con = int(name[1:])\\n\\n self.connections[name] = Connection(inp, outp, InOut(kind, int(size)), name)\\n i += 1\\n self.update_below()\",\n \"def load(self, name, hidden=False):\\n\\n prefix = \\\"\\\"\\n if hidden:\\n prefix = \\\".\\\"\\n load = np.load(prefix + name + \\\".npy\\\", encoding=\\\"latin1\\\", allow_pickle=True)\\n self.neurons = load[0]\\n self.weights = load[1]\\n\\n if not self.silent:\\n print(\\\"[NoxmainNetwork]: Network \\\\\\\"\\\" + str(name) + \\\"\\\\\\\" with neurons \\\" + str(self.neurons) + \\\" loaded!\\\")\",\n \"def load(self):\\n\\n or_none = lambda x: x if x != \\\"none\\\" else None\\n with h5py.File(self.filename, \\\"r\\\") as hf:\\n for attr, val in hf.attrs.items():\\n setattr(self, attr, or_none(val))\",\n \"def test_hdf5_load_all():\\n skip_if_no_h5py()\\n import h5py\\n\\n # save random data to HDF5\\n handle, filename = tempfile.mkstemp()\\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\\n num_examples=10, dim=5,\\n num_classes=3)\\n with h5py.File(filename, 'w') as f:\\n f.create_dataset('X', data=dataset.get_design_matrix())\\n f.create_dataset('y', data=dataset.get_targets())\\n\\n # instantiate Train object\\n trainer = yaml_parse.load(load_all_yaml % {'filename': filename})\\n trainer.main_loop()\\n\\n # cleanup\\n os.remove(filename)\",\n \"def load_model(self, fname: str) -> None:\\n checkpoint_data = torch.load(fname)\\n\\n # Load the models\\n # P-Net\\n model_import_path = checkpoint_data['p_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['p_net']['model_name'])\\n self.p_net = mod()\\n self.p_net.set_params(checkpoint_data['p_net'])\\n # Q-Net\\n model_import_path = checkpoint_data['q_net']['model_import_path']\\n imp = importlib.import_module(model_import_path)\\n mod = getattr(imp, checkpoint_data['q_net']['model_name'])\\n self.q_net = mod()\\n self.q_net.set_params(checkpoint_data['q_net'])\",\n \"def import_network(file_name, NetworkClass):\\r\\n file = open(file_name, 'br')\\r\\n data_pickle = file.read()\\r\\n file.close()\\r\\n net = NetworkClass()\\r\\n net.__dict__ = pickle.loads(data_pickle)\\r\\n return net\",\n \"def load_model(self, name: str):\\n\\n # Loading config\\n self.cM = ConfigManager(name + \\\".cfg\\\")\\n\\n # Loading Vocabs\\n out_voc = pickle.load(open(name + \\\".out_voc\\\", \\\"rb\\\"))\\n in_voc = pickle.load(open(name + \\\".in_voc\\\", \\\"rb\\\"))\\n\\n self.output_field.vocab = out_voc\\n self.input_field.vocab = in_voc\\n\\n num_classes = len(self.output_field.vocab)\\n embed = nn.Embedding.from_pretrained(self.input_field.vocab.vectors)\\n self.network = FrameIDNetwork(self.cM, embed, num_classes)\\n\\n self.network.load_model(name + \\\".ph\\\")\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def save_utility_network(self,path_save):\\n print(\\\"Save the neural network to : \\\"+path_save)\\n self.nn.save_on_file(path_save)\",\n \"def load_model(path):\\n if os.path.isfile(path):\\n print(\\\"=> loading checkpoint '{}'\\\".format(path))\\n checkpoint = torch.load(path)\\n\\n # # size of the top layer\\n # N = checkpoint['state_dict']['top_layer.bias'].size()\\n #\\n # # build skeleton of the model\\n # sob = 'sobel.0.weight' in checkpoint['state_dict'].keys()\\n # model = models.__dict__[checkpoint['arch']](sobel=sob, out=int(N[0]))\\n #\\n # # deal with a dataparallel table\\n # def rename_key(key):\\n # if not 'module' in key:\\n # return key\\n # return ''.join(key.split('.module'))\\n #\\n # checkpoint['state_dict'] = {rename_key(key): val\\n # for key, val\\n # in checkpoint['state_dict'].items()}\\n #\\n # # load weights\\n # model.load_state_dict(checkpoint['state_dict'])\\n # print(\\\"Loaded\\\")\\n # else:\\n # model = None\\n # print(\\\"=> no checkpoint found at '{}'\\\".format(path))\\n\\n # net = models.__dict__['ResNet18'](low_dim=128)\\n # net = models.__dict__['resnet18'](low_dim=128)\\n\\n net = models.__dict__['alexnet'](out=128)\\n # net = models.__dict__['Alexnet_C'](out=args.low_dim)\\n\\n net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))\\n net.load_state_dict(checkpoint['net'])\\n\\n return net\",\n \"def load_checkpoint(self, model):\\n print(f\\\"load model {self.save_model_path}\\\")\\n model.load_state_dict(torch.load(self.save_model_path))\",\n \"def load_model(filename):\\n checkpoint = torch.load(filename)\\n model = QNetwork(checkpoint['input_size'], checkpoint['output_size'], checkpoint['hidden_layers'])\\n model.load_state_dict(checkpoint['state_dict'])\\n return model\",\n \"def load_h5(filename: str, **kwargs):\\n return open_h5(filename, 'r', **kwargs)\",\n \"def load_model(self, model_path):\\n\\n\\t\\tmodel_path = osp.abspath(model_path)\\n\\t\\tmodel_weights_path = osp.splitext(model_path)[0] + \\\".bin\\\"\\n\\n\\t\\tself.Helpers.logger.info(\\\"Loading the model from '%s'\\\" % (model_path))\\n\\t\\tmodel = self.context.ie_core.read_network(model_path, model_weights_path)\\n\\t\\tself.Helpers.logger.info(\\\"Model loaded\\\")\\n\\n\\t\\treturn model\",\n \"def load_checkpoint_ram(self, checkpoint, train=True):\\n # -- For all tasks, create a corresponding head, otherwise the restoring would not work due to mismatching weights -- #\\n self.mh_network.add_n_tasks_and_activate(self.already_trained_on[str(self.fold)]['tasks_at_time_of_checkpoint'],\\n self.already_trained_on[str(self.fold)]['active_task_at_time_of_checkpoint'])\\n \\n # -- Set the network to the full MultiHead_Module network to restore everything -- #\\n self.network = self.mh_network\\n \\n # -- Use parent class to save checkpoint for MultiHead_Module model consisting of self.model, self.body and self.heads -- #\\n super().load_checkpoint_ram(checkpoint, train)\\n\\n # -- Reset network to the assembled model to continue training -- #\\n self.network = self.mh_network.model\",\n \"def load_checkpoint(model, save_path):\\n model.load_state_dict(torch.load(save_path))\",\n \"def load_weights(self, file_path):\\n self.model.load_weights(file_path + '/policy_network.h5')\\n print(\\\"\\\\nrestored weights of the policy network.\\\\n\\\")\",\n \"def deserialize_model(hypes):\\n model_path_trained = hypes['segmenter']['serialized_model_path']\\n if not os.path.isfile(model_path_trained):\\n logging.warning(\\\"No model found at '%s'.\\\", model_path_trained)\\n network_path = hypes['segmenter']['network_path']\\n network = imp.load_source('sst.network', network_path)\\n trained = network.load_model(hypes)\\n return trained\",\n \"def load_model(self, win_len, axis):\\n\\n print('Load model')\\n if 'ouisir' not in self.name_dataset.lower():\\n self.feature_extractor = resnet2D(\\n False, 0, 0, stride=2, feature_generator=True)\\n else:\\n self.feature_extractor = resnet2D(\\n False, 0, 0, stride=2, feature_generator=True)\\n self.feature_extractor.build((None, win_len, axis, 1))\\n self.feature_extractor.load_weights(\\n self.path_save_model + self.name_model + '.h5', by_name=True)\\n\\n print('Load mean and std')\\n self.mean = np.load(self.path_save_model + 'mean.npy')\\n self.std = np.load(self.path_save_model + 'std.npy')\",\n \"def load(self, folder):\\n # load the weights from input folder\\n self.generator.load_weights('%s/generator.h5'%folder)\\n self.critic.load_weights('%s/critic.h5'%folder)\",\n \"def load_model(self, filename):\\n event = teca_time_py_event('teca_deeplab_ar_detect::load_model')\\n\\n # this creates OpenMP thread pools and imports torch\\n # it must be called *before* we import torch\\n self.initialize()\\n\\n # import our torch codes only now that torch has been initialized\\n global teca_deeplab_ar_detect_internals\\n from teca_deeplab_ar_detect_internals \\\\\\n import teca_deeplab_ar_detect_internals\\n\\n # create an instance of the model\\n model = teca_deeplab_ar_detect_internals.DeepLabv3_plus(\\n n_classes=1, _print=False)\\n\\n # load model weights from state on disk\\n super().load_model(filename, model)\",\n \"def load_model():\\r\\n model = MobileNetV2(weights=\\\"imagenet\\\")\\r\\n print(\\\"Model loaded\\\")\\r\\n return model\",\n \"def load_network(self, serialize_network):\\n layer = self.first_layer\\n current_index = 0\\n for i in range(self.number_of_layers):\\n for neuron in layer.neuron_array:\\n number_of_weights = len(neuron.weights)\\n neuron.weights = serialize_network[current_index: number_of_weights]\\n neuron.bias = serialize_network[current_index + number_of_weights]\\n current_index += number_of_weights + 1\\n if i != self.number_of_layers - 1:\\n layer = layer.next_layer\",\n \"def load(self, filename='nn_model.pkl'):\\n with open(filename,'rb') as f:\\n nn_model = pickle.load(f, encoding='bytes')\\n f.close()\\n\\n self.W = nn_model.W\\n self.b = nn_model.b\\n\\n self.num_bn_layers = nn_model.num_bn_layers\\n self.bn = nn_model.num_bn_layers > 0\\n self.hiddens = nn_model.hiddens\\n self.nlayers = len(nn_model.hiddens) + 1\\n self.input_size = nn_model.input_size\\n self.output_size = nn_model.output_size\\n self.activations = nn_model.activations\\n self.criterion = nn_model.criterion\\n self.lr = nn_model.lr\\n self.momentum = nn_model.momentum\\n\\n if self.bn:\\n self.bn_layers = nn_model.bn_layers\\n\\n self.train_mode = nn_model.train_mode\\n self.batch_size = nn_model.batch_size\\n self.epochs = nn_model.epochs\",\n \"def _load_layer_weights(self, layer, name, h5file): \\n group = h5file[name]\\n length = group['length'][0]\\n weights = [group[\\\"{}\\\".format(idx)] for idx in range(length)]\\n layer.set_weights(weights)\",\n \"def save_network(network, fpath):\\n\\twith open(fpath, \\\"wb\\\") as f:\\n\\t\\tpickle.dump(network, f)\",\n \"def load_net(self, file_path):\\n \\twith open(file_path,'r') as f:\\n \\t\\tparams = json.loads(f.read())\\n \\t#\\n \\tweights = np.array(params['weights'])\\n \\tbiases = np.array(params['biases'])\\n \\t# Since ann.ANN needs to be initialized with some data, which\\n \\t# we dont have yet, we are gonna make a canvas array with\\n \\t# the correct dimensions from the weights\\n \\tfake_data = np.array([np.zeros(len(weights[-1]))])\\n \\t# initialize stacked net\\n \\tself.init_stacked_net(fake_data)\\n \\t# fill in weights and biases\\n \\tself.stacked_net.weights = weights\\n \\tself.stacked_net.biases = biases\",\n \"def load(self, path):\\n checkpoint = torch.load(path, map_location=torch.device(\\\"cpu\\\"))\\n self.load_state_dict(checkpoint[\\\"state_dict\\\"])\\n self.on_epoch_start(checkpoint[\\\"epoch\\\"])\\n self.logger.info(\\\"Loaded controller network from %s\\\", path)\",\n \"def load(self):\\n checkpoint = torch.load(self.checkpoint_path,\\n map_location=self.net.device)\\n self.load_state_dict(checkpoint)\\n del checkpoint\",\n \"def _loadHDF5File(self, filename):\\n matfile = h5py.File(filename)\\n\\n self.StokesI = np.transpose(matfile['StokesI'][:,:])\\n self.StokesQ = np.transpose(matfile['StokesQ'][:,:])\\n self.StokesU = np.transpose(matfile['StokesU'][:,:])\\n self.StokesV = np.transpose(matfile['StokesV'][:,:])\\n self.detectorPosition = matfile['detectorPosition'][:,0]\\n self.detectorDirection = matfile['detectorDirection'][:,0]\\n self.detectorVisang = matfile['detectorVisang'][0,0]\\n\\n try: self.wall = matfile['wall'][:,:]\\n except KeyError: pass\\n\\n try: self.separatrix = matfile['separatrix'][:,:]\\n except KeyError: pass\",\n \"def load_model():\\n # Model reconstruction from JSON file\\n with open('model/model_strides_25_13-25-54.json', 'r') as f:\\n model = model_from_json(f.read())\\n # Load weights into the new model\\n model.load_weights('model/bestmodel_weights_strides.hdf5')\\n return model\",\n \"def load(self, output_folder: str=None):\\n\\n # Load the genesis model.\\n if output_folder is None:\\n output_folder = os.path.join(os.path.dirname(__file__), 'model')\\n\\n # Load necessary files.\\n self.n_final = pickle.load(open(os.path.join(\\n output_folder, 'n_final.pkl'), 'rb'))\\n self.min_values = pickle.load(open(os.path.join(\\n output_folder, 'min_params.pkl'), 'rb'))\\n self.norm_params = pickle.load(open(os.path.join(\\n output_folder, 'norm_params.pkl'), 'rb'))\\n self.label_encoder = pickle.load(open(os.path.join(\\n output_folder, 'label_encoder.pkl'), 'rb'))\\n\\n # Load network.\\n net = Net(self.n_final)\\n net.to(self.device)\\n\\n # If a refitted model exists.\\n if os.path.exists(os.path.join(output_folder, 'state_dict.refit.pt')):\\n genesis_model_path = os.path.join(\\n output_folder, 'state_dict.refit.pt')\\n else:\\n genesis_model_path = os.path.join(output_folder, 'state_dict.pt')\\n\\n net.load_state_dict(torch.load(genesis_model_path))\\n\\n '''\\n # Check the number of parameters in each layer.\\n for key in torch.load(genesis_model_path).keys():\\n if 'bias' in key:\\n print(key, torch.load(genesis_model_path)[key].shape)\\n '''\\n\\n self.net = net\",\n \"def load_model(self):\\n self.opt.load_weights_folder = os.path.expanduser(self.opt.load_weights_folder)\\n\\n assert os.path.isdir(self.opt.load_weights_folder), \\\\\\n \\\"Cannot find folder {}\\\".format(self.opt.load_weights_folder)\\n print(\\\"loading model from folder {}\\\".format(self.opt.load_weights_folder))\\n\\n for model_name in [\\\"encoder\\\", \\\"decoder\\\"]:\\n print(\\\"Loading {} weights...\\\".format(model_name))\\n path = os.path.join(self.opt.load_weights_folder, \\\"{}.pth\\\".format(model_name))\\n model_dict = self.encoder.state_dict() if model_name == \\\"encoder\\\" else self.decoder.state_dict()\\n pretrained_dict = torch.load(path)\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\\n model_dict.update(pretrained_dict)\\n if model_name == \\\"encoder\\\":\\n self.encoder.load_state_dict(model_dict)\\n else:\\n self.decoder.load_state_dict(model_dict)\\n\\n # loading adam state\\n optimizer_load_path = os.path.join(self.opt.load_weights_folder, \\\"adam.pth\\\")\\n if os.path.isfile(optimizer_load_path):\\n print(\\\"Loading Adam weights\\\")\\n optimizer_dict = torch.load(optimizer_load_path)\\n self.optimizer.load_state_dict(optimizer_dict)\\n else:\\n print(\\\"Cannot find Adam weights so Adam is randomly initialized\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load_net(filepath):\\n\\twith open(filepath, 'r') as fh:\\n\\t\\treturn load(file = fh)\",\n \"def loadNetwork(path, arch):\\n if arch in resnet.__dict__:\\n model = resnet.__dict__[arch]()\\n model.load_state_dict(torch.load(path, map_location=device))\\n return model\\n elif arch in other_resnet.__dict__:\\n model = other_resnet.__dict__[arch]()\\n model.load_state_dict(torch.load(path, map_location=device))\\n return model\\n elif arch in vgg.__dict__:\\n model = vgg.__dict__[arch]()\\n model.load_state_dict(torch.load(path, map_location=device))\\n return model\",\n \"def load(self, filename):\\n\\n c = torch.load(filename)\\n\\n if type(c) is dict:\\n sd = c['state_dict']\\n self.net.load_state_dict(sd)\\n if 'monitors' in c: # Remove the branching eventually\\n self.monitors = c['monitors']\\n else:\\n self.monitors = {'loss_train': c['train_monitor'], 'loss_val': c['val_monitor'],\\n 'accu_train': MetricHistory(), 'accu_val': MetricHistory()}\\n if 'optimizer' in c: # Remove the branching eventually\\n self.optimizer.load_state_dict(c['optimizer'])\\n else:\\n raise RuntimeError('Unsupported checkpoint. (Not a dict)')\\n\\n self.parent = filename\\n self.last_checkpoint = filename\\n self.start_epoch = self.monitors['loss_train'].num_epochs\",\n \"def load_network(file_name):\\n with open(file_name) as file:\\n data = json.load(file)\\n\\n cost_fn = getattr(sys.modules[__name__], data[\\\"cost_func\\\"])\\n act_fn = getattr(sys.modules[__name__], data[\\\"act_func\\\"])\\n metric = getattr(sys.modules[__name__], data[\\\"metric\\\"])\\n\\n network = Network([1, 1], act_func=act_fn, cost_func=cost_fn, metric=metric)\\n network.layers_num = data[\\\"layers_num\\\"]\\n network.weights = [np.array(w) for w in data[\\\"weights\\\"]]\\n network.biases = [np.array(b) for b in data[\\\"biases\\\"]]\\n\\n return network\",\n \"def load_opcodes_subnetwork_pretrained_weights(self, model):\\n print(\\\"ToImplement\\\")\",\n \"def restore_model(self, prefix):\\n model_file = prefix + \\\".json\\\"\\n weight_file = prefix + \\\".h5\\\"\\n self.model = model_from_json(json.load(open(model_file)))\\n self.model.load_weights(weight_file)\\n return self\\n model.load_weights(\\\"./output/model.h5\\\")\",\n \"def load_model(self, model_path, load_ae=True, map_location='cpu'):\\n assert load_ae and (self.ae_net is not None), 'The trainer has not been initialized with an Autoencoder. It can thus not be loaded.'\\n model_dict = torch.load(model_path, map_location=map_location)\\n self.c = model_dict['c']\\n self.net.load_state_dict(model_dict['net_dict'])\\n\\n if load_ae and (self.ae_net is not None):\\n self.ae_net.load_state_dict(model_dict['ae_net_dict'])\",\n \"def load_model():\\r\\n global model # 下面的那个predict也是要用的 所以在这里定义为全局\\r\\n model = DenseNet(n_input_channels=1, num_init_features=64,\\r\\n growth_rate=32,\\r\\n block_config=(3, 6, 12, 8), num_classes=4).to(device)\\r\\n model.load_state_dict(torch.load(\\\"./model29.pkl\\\"))\\r\\n model.eval()\",\n \"def load_nn(self, filename):\\n self.weights_and_biases = (np.load(filename, allow_pickle=True)).tolist()\\n print('Weights and biases are loaded')\",\n \"def load_bot(self, prefix=\\\"model_data/\\\"):\\n attributes = np.load(prefix + \\\"model_attributes.npy\\\",\\n allow_pickle='TRUE').item()\\n \\n self.num_rounds = attributes[\\\"num_rounds\\\"]\\n self.c = attributes[\\\"c\\\"]\\n self.alpha = attributes[\\\"alpha\\\"]\\n if \\\"loss_history\\\" in attributes:\\n self.loss_history = attributes[\\\"loss_history\\\"]\\n self.evaluation_history_old = attributes[\\\"evaluation_history_old\\\"]\\n self.evaluation_history_ran = attributes[\\\"evaluation_history_ran\\\"]\\n \\n network_load_command = attributes[\\\"network_load_command\\\"]\\n exec(network_load_command)\\n self.network.load_network(prefix)\",\n \"def load(self, filename):\\n with open(filename, 'rb') as f:\\n data = pickle.load(f)\\n # Set biases and weights\\n self.W_input_to_hidden = data['wi']\\n self.W_hidden_to_hidden = data['wh']\\n self.W_hidden_to_output = data['wo']\",\n \"def load_model(self, sess, pb_model_path):\\n\\n logging.info(\\\"Import yolo model from pb start .......\\\")\\n\\n with sess.as_default():\\n with sess.graph.as_default():\\n with tf.gfile.FastGFile(pb_model_path, 'rb') as f_handle:\\n logging.info(\\\"ParseFromString start .......\\\")\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f_handle.read())\\n logging.info(\\\"ParseFromString end .......\\\")\\n\\n tf.import_graph_def(graph_def, name='')\\n logging.info(\\\"Import_graph_def end .......\\\")\\n\\n logging.info(\\\"Import yolo model from pb end .......\\\")\",\n \"def load_networks(self, dir_weights, idx_load):\\n\\n path_p = dir_weights + 'p_{}.ckpt'\\n path_D = dir_weights + 'D_{}.ckpt'\\n path_U = dir_weights + 'U_{}.ckpt'\\n\\n self.net_p.load_weights(path_p.format(idx_load))\\n self.net_D.load_weights(path_D.format(idx_load))\\n self.net_U.load_weights(path_U.format(idx_load))\",\n \"def load(self, filename):\\n with open(filename, 'rb') as f:\\n data = pickle.load(f)\\n # Set biases and weights\\n self.W_input_to_hidden = data['wi']\\n self.W_hidden_to_output = data['wo']\",\n \"def load_model(self, filename):\\r\\n pass\",\n \"def load_block(state_dict, eval_type, src_name, tgt_name, h5_dir):\\n h5f = h5py.File(os.path.join(h5_dir, '{:s}_{:s}.h5'.format(eval_type, src_name)), 'r')\\n\\n state_dict[tgt_name + '.branch_0.conv3d.weight'] = torch.from_numpy(h5f['b0_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_0.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_0.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_0.bn.bias'] = torch.from_numpy(h5f['b0_beta'][...])\\n state_dict[tgt_name + '.branch_0.bn.running_mean'] = torch.from_numpy(h5f['b0_mv_mean'][...])\\n state_dict[tgt_name + '.branch_0.bn.running_var'] = torch.from_numpy(h5f['b0_mv_var'][...])\\n\\n state_dict[tgt_name + '.branch_1a.conv3d.weight'] = torch.from_numpy(h5f['b1a_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_1a.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_1a.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_1a.bn.bias'] = torch.from_numpy(h5f['b1a_beta'][...])\\n state_dict[tgt_name + '.branch_1a.bn.running_mean'] = torch.from_numpy(h5f['b1a_mv_mean'][...])\\n state_dict[tgt_name + '.branch_1a.bn.running_var'] = torch.from_numpy(h5f['b1a_mv_var'][...])\\n state_dict[tgt_name + '.branch_1b.conv3d.weight'] = torch.from_numpy(h5f['b1b_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_1b.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_1b.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_1b.bn.bias'] = torch.from_numpy(h5f['b1b_beta'][...])\\n state_dict[tgt_name + '.branch_1b.bn.running_mean'] = torch.from_numpy(h5f['b1b_mv_mean'][...])\\n state_dict[tgt_name + '.branch_1b.bn.running_var'] = torch.from_numpy(h5f['b1b_mv_var'][...])\\n\\n state_dict[tgt_name + '.branch_2a.conv3d.weight'] = torch.from_numpy(h5f['b2a_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_2a.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_2a.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_2a.bn.bias'] = torch.from_numpy(h5f['b2a_beta'][...])\\n state_dict[tgt_name + '.branch_2a.bn.running_mean'] = torch.from_numpy(h5f['b2a_mv_mean'][...])\\n state_dict[tgt_name + '.branch_2a.bn.running_var'] = torch.from_numpy(h5f['b2a_mv_var'][...])\\n state_dict[tgt_name + '.branch_2b.conv3d.weight'] = torch.from_numpy(h5f['b2b_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_2b.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_2b.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_2b.bn.bias'] = torch.from_numpy(h5f['b2b_beta'][...])\\n state_dict[tgt_name + '.branch_2b.bn.running_mean'] = torch.from_numpy(h5f['b2b_mv_mean'][...])\\n state_dict[tgt_name + '.branch_2b.bn.running_var'] = torch.from_numpy(h5f['b2b_mv_var'][...])\\n\\n state_dict[tgt_name + '.branch_3b.conv3d.weight'] = torch.from_numpy(h5f['b3_weight'][...]).permute(4, 3, 0, 1, 2)\\n output_channels = state_dict[tgt_name + '.branch_3b.conv3d.weight'].size(0)\\n # Sonnet model does not scale batch norm output, it only adds bias.\\n state_dict[tgt_name + '.branch_3b.bn.weight'] = torch.ones(output_channels)\\n state_dict[tgt_name + '.branch_3b.bn.bias'] = torch.from_numpy(h5f['b3_beta'][...])\\n state_dict[tgt_name + '.branch_3b.bn.running_mean'] = torch.from_numpy(h5f['b3_mv_mean'][...])\\n state_dict[tgt_name + '.branch_3b.bn.running_var'] = torch.from_numpy(h5f['b3_mv_var'][...])\",\n \"def _load_model(self):\\r\\n filepath = f\\\"Models/{self.environment.name}/q_network\\\"\\r\\n # Check if model exists in default directory\\r\\n if path.exists(filepath):\\r\\n self.q_network = NetworkBuilder._load_model(filepath)\\r\\n self.target_network = NetworkBuilder._load_model(filepath)\\r\\n print(\\\"Models loaded\\\")\\r\\n return True\\r\\n else:\\r\\n print(f\\\"'{filepath}' not found\\\")\\r\\n return False\",\n \"def load_checkpoint(self, file):\\n \\\"\\\"\\\"Load \\\"\\\"\\\"\\n chkpnt = torch.load(file)\\n self.load_state_dict(chkpnt['model_state_dict'])\",\n \"def load_model(model_path, model_name, net=None):\\n config_file, model_file = _get_config_file(model_path, model_name), _get_model_file(model_path, model_name)\\n assert os.path.isfile(\\n config_file\\n ), f'Could not find the config file \\\"{config_file}\\\". Are you sure this is the correct path and you have your model config stored here?'\\n assert os.path.isfile(\\n model_file\\n ), f'Could not find the model file \\\"{model_file}\\\". Are you sure this is the correct path and you have your model stored here?'\\n with open(config_file) as f:\\n config_dict = json.load(f)\\n if net is None:\\n act_fn_name = config_dict[\\\"act_fn\\\"].pop(\\\"name\\\").lower()\\n act_fn = act_fn_by_name[act_fn_name](**config_dict.pop(\\\"act_fn\\\"))\\n net = BaseNetwork(act_fn=act_fn, **config_dict)\\n net.load_state_dict(torch.load(model_file, map_location=device))\\n return net\",\n \"def load(path_to_model):\\n pass\",\n \"def load_NeuralNet(self, path_model_dir, X_train, y_train, epochs):\\n\\n #fetch best params\\n best_params_ = self.load('best_params_', 'dill', path_model_dir) \\n \\n #rebuild model_dict\\n model_dict = _NeuralNet.DenseNet.model_dict(**best_params_)\\n model_dict['best_model'] = _NeuralNet.utils.load_model(_os.path.join(path_model_dir,'best_estimator_.h5'))\\n model_dict['best_params'] = best_params_ \\n model_dict['best_cv_score'] = _np.nan\\n\\n return model_dict\",\n \"def load_h5_file(file_path):\\n # load\\n fr = h5py.File(file_path, 'r')\\n a_group_key = list(fr.keys())[0]\\n data = list(fr[a_group_key])\\n # transform to appropriate numpy array \\n data=data[0:]\\n data = np.stack(data, axis=0)\\n return data\",\n \"def load_h5_file(file_path):\\n # load\\n fr = h5py.File(file_path, 'r')\\n a_group_key = list(fr.keys())[0]\\n data = list(fr[a_group_key])\\n # transform to appropriate numpy array \\n data=data[0:]\\n data = np.stack(data, axis=0)\\n return data\",\n \"def load(self):\\n try:\\n if self.model.is_cuda:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\"save_point.pth\\\")))\\n else:\\n self.model.load_state_dict(torch.load(os.path.join(self.save_path, \\\\\\n \\\"save_point.pth\\\"), map_location=\\\"cpu\\\"))\\n except:\\n sys.exit(\\\"Unable to load previous model\\\")\",\n \"def load_model(self):\\n saved_path = self.config.path_tmp / self.model.model_name\\n if saved_path.exists():\\n self.model.load_weights(str(saved_path / 'model.vec'))\",\n \"def save_as_hdf5(self, filename):\",\n \"def load_model(self):\\n print(\\\"=============start loading models=============\\\")\\n # load models from basemodel and fine-tune layers\\n base_model = DenseNet(reduction=0.5, classes=1000, weights_path=BASE_WEIGHT_DIR)\\n base_model.layers.pop()\\n base_model.layers.pop()\\n x4 = Dense(6, activation='relu')(base_model.layers[-1].output)\\n o = Activation('softmax')(x4)\\n\\n model = Model(inputs=base_model.input, outputs=[o])\\n model.load_weights(WEIGHT_DIR)\\n\\n self.model = model\\n print(\\\"=============finish loading models=============\\\")\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def load(filename):\\n f = open(filename, \\\"r\\\")\\n data = json.load(f)\\n f.close()\\n net = MFoMNetwork(data[\\\"sizes\\\"])\\n net.weights = [np.array(w) for w in data[\\\"weights\\\"]]\\n net.biases = [np.array(b) for b in data[\\\"biases\\\"]]\\n return net\",\n \"def load_weight(model):\\n file = h5py.File(WEIGHT_SAVE, 'r')\\n weight = []\\n for i in range(len(file.keys())):\\n weight.append(file['weight' + str(i)][:])\\n model.set_weights(weight)\",\n \"def load(self, path: str):\\n self.model.load_state_dict(torch.load(path))\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def load(self, path):\\n checkpoint = torch.load(path)\\n self.load_state_dict(checkpoint['model_state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\",\n \"def load_pretrained_network(self):\\n\\n if self.manager is None or self.checkpoint is None:\\n return False\\n status = self.checkpoint.restore(self.manager.latest_checkpoint)\\n return status\",\n \"def load_pretrained_network(self):\\n\\n if self.manager is None or self.checkpoint is None:\\n return False\\n status = self.checkpoint.restore(self.manager.latest_checkpoint)\\n return status\",\n \"def test_save_load(tmp_path, num_mutations):\\n\\n def assert_networks_equal(net, loaded_net):\\n assert net.in_size == loaded_net.in_size\\n assert net.out_size == loaded_net.out_size\\n assert net.p_initial_connection_enabled == loaded_net.p_initial_connection_enabled\\n assert net.p_add_connection == loaded_net.p_add_connection\\n assert net.p_add_node == loaded_net.p_add_node\\n assert net.inherit_weights == loaded_net.inherit_weights\\n assert net.activation_name == loaded_net.activation_name\\n assert net.neurons_in_layer == loaded_net.neurons_in_layer\\n assert net.connections == loaded_net.connections\\n assert np.allclose(net.weights, loaded_net.weights)\\n\\n net = WeightLearningNetwork(5, 2, 0.5)\\n for _ in range(num_mutations):\\n net.mutate()\\n\\n # Save network, load it and check that everything is still correct.\\n print(tmp_path / 'network.json')\\n net.save(tmp_path / 'network.json')\\n loaded_net = WeightLearningNetwork.load(tmp_path / 'network.json')\\n assert_networks_equal(net, loaded_net)\\n\\n # Do this again after creating and deleting weight matrices.\\n net.create_torch_layers()\\n net.delete_torch_layers()\\n\\n net.save(tmp_path / 'network2.json')\\n loaded_net = WeightLearningNetwork.load(tmp_path / 'network2.json')\\n assert_networks_equal(net, loaded_net)\\n\\n # Check that we can still create weight matrices on loaded net.\\n loaded_net.create_torch_layers()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71672744","0.7150659","0.6883396","0.67808","0.6710601","0.66247654","0.6531737","0.64843845","0.64828396","0.6471173","0.6450578","0.64475465","0.6441468","0.64281887","0.6308086","0.6201771","0.6194544","0.61861485","0.61786836","0.61785096","0.6171078","0.61476314","0.6136227","0.6135521","0.61285985","0.6118241","0.60975796","0.609501","0.6089223","0.6079766","0.60632443","0.605296","0.6022471","0.6016407","0.6016081","0.6014992","0.59946185","0.59823644","0.59776855","0.5959942","0.59392554","0.59309524","0.59289634","0.59218866","0.59205014","0.5906885","0.58989584","0.5891236","0.58876747","0.5886988","0.5872559","0.58720714","0.58666897","0.5863366","0.58626324","0.5846325","0.5840275","0.583734","0.58101135","0.5808156","0.58019584","0.5799748","0.5798377","0.5798377","0.5792889","0.5782245","0.57789737","0.57475543","0.57467103","0.57405704","0.57350004","0.57318735","0.57288694","0.5723476","0.5719712","0.57181966","0.57181257","0.57161635","0.57042634","0.57021797","0.5696144","0.5693677","0.5683629","0.56824213","0.56778884","0.56749946","0.56749946","0.5669785","0.5666282","0.5653698","0.564323","0.56419456","0.5637953","0.56283355","0.56268466","0.5623275","0.5623275","0.56098896","0.56098896","0.56063575"],"string":"[\n \"0.71672744\",\n \"0.7150659\",\n \"0.6883396\",\n \"0.67808\",\n \"0.6710601\",\n \"0.66247654\",\n \"0.6531737\",\n \"0.64843845\",\n \"0.64828396\",\n \"0.6471173\",\n \"0.6450578\",\n \"0.64475465\",\n \"0.6441468\",\n \"0.64281887\",\n \"0.6308086\",\n \"0.6201771\",\n \"0.6194544\",\n \"0.61861485\",\n \"0.61786836\",\n \"0.61785096\",\n \"0.6171078\",\n \"0.61476314\",\n \"0.6136227\",\n \"0.6135521\",\n \"0.61285985\",\n \"0.6118241\",\n \"0.60975796\",\n \"0.609501\",\n \"0.6089223\",\n \"0.6079766\",\n \"0.60632443\",\n \"0.605296\",\n \"0.6022471\",\n \"0.6016407\",\n \"0.6016081\",\n \"0.6014992\",\n \"0.59946185\",\n \"0.59823644\",\n \"0.59776855\",\n \"0.5959942\",\n \"0.59392554\",\n \"0.59309524\",\n \"0.59289634\",\n \"0.59218866\",\n \"0.59205014\",\n \"0.5906885\",\n \"0.58989584\",\n \"0.5891236\",\n \"0.58876747\",\n \"0.5886988\",\n \"0.5872559\",\n \"0.58720714\",\n \"0.58666897\",\n \"0.5863366\",\n \"0.58626324\",\n \"0.5846325\",\n \"0.5840275\",\n \"0.583734\",\n \"0.58101135\",\n \"0.5808156\",\n \"0.58019584\",\n \"0.5799748\",\n \"0.5798377\",\n \"0.5798377\",\n \"0.5792889\",\n \"0.5782245\",\n \"0.57789737\",\n \"0.57475543\",\n \"0.57467103\",\n \"0.57405704\",\n \"0.57350004\",\n \"0.57318735\",\n \"0.57288694\",\n \"0.5723476\",\n \"0.5719712\",\n \"0.57181966\",\n \"0.57181257\",\n \"0.57161635\",\n \"0.57042634\",\n \"0.57021797\",\n \"0.5696144\",\n \"0.5693677\",\n \"0.5683629\",\n \"0.56824213\",\n \"0.56778884\",\n \"0.56749946\",\n \"0.56749946\",\n \"0.5669785\",\n \"0.5666282\",\n \"0.5653698\",\n \"0.564323\",\n \"0.56419456\",\n \"0.5637953\",\n \"0.56283355\",\n \"0.56268466\",\n \"0.5623275\",\n \"0.5623275\",\n \"0.56098896\",\n \"0.56098896\",\n \"0.56063575\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7140678"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6879,"cells":{"query":{"kind":"string","value":"Train the model for a certain no of episodes"},"document":{"kind":"string","value":"def trainAgent(self):\r\n\t\tfor episode in range(self.TOT_EPISODES):\r\n\t\t\t#reset environment, stacked frames every episode.\r\n\t\t\tstate = self.env.reset()\r\n\t\t\trewards = 0\r\n\t\t\t#preprocess and stack the frame/state.\r\n\t\t\tstate, self.stacked_frames = stack_frames(self.stack_size,\r\n\t\t\t\t\t\t\t\t\tself.stacked_frames, state, True)\r\n\t\t\t\r\n\t\t\tfor step in range(self.MAX_STEPS):\r\n\t\t\t#for every step in episode:\r\n\t\t\t\r\n\t\t\t\tif (step%100==0):\r\n\t\t\t\t\tprint(\"Episode No.: \", episode, \"Step No.: \", step)\r\n\t\t\t\t\r\n\t\t\t\t#agent acts - explores or exploitation of the model\r\n\t\t\t\taction = self.dqn.predictAction(state)\r\n\t\t\t\t#reduce epsilon for more exploitation later.\r\n\t\t\t\tself.dqn.decayEpsilon()\r\n\t\t\t\t#Perform the action and get the next_state, reward, and done vals.\r\n\t\t\t\tnext_state, reward, done, _ = self.env.step(action)\r\n\t\t\t\t#append this state to the frame. Pass the previous stacked frame.\r\n\t\t\t\tnext_state, self.stacked_frames = stack_frames(self.stack_size,\r\n\t\t\t\t\t\t\t\t\t\tself.stacked_frames, next_state, False)\r\n\t\t\t\trewards+=reward\r\n\t\t\t\t\r\n\t\t\t\t#add this experience into memory (experience buffer)\r\n\t\t\t\tself.dqn.remember(state, action, reward, next_state, done)\r\n\t\t\t\t\r\n\t\t\t\tstate = next_state\r\n\t\t\t\t\r\n\t\t\t\tif done:\r\n\t\t\t\t\tprint(\"took %d steps\" %step)\r\n\t\t\t\t\tprint(\"Earned a total of reward equal to \", rewards)\r\n\t\t\t\t\tbreak\r\n\t\t\t\r\n\t\t\t\t# TRAIN\r\n\t\t\t\tself.dqn.replay()\r\n\t\t\t\t#sync target_model and model weights every 10k steps.\r\n\t\t\t\tif step % 10000 == 9999:\r\n\t\t\t\t\tself.dqn.target_train()\r\n\t\t\t\r\n\t\t\t# Save the network every 1000 iterations\r\n\t\t\tif episode % 5 == 4:\r\n\t\t\t\tprint(\"Saving Network\")\r\n\t\t\t\tself.dqn.save_network(self.path)"},"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 train(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\n while self.episodes_done < num_episodes:\n self.trainOneEpisode(num_episodes, max_episode_steps, save_freq, render)\n self.saveCheckpoint()","def train(self, training_steps=10):","def train(\n self, num_episodes, max_episode_length, reward_network=None,\n ):\n\n for _ in range(num_episodes):\n self.train_episode(max_episode_length)\n\n if self.training_i % self.play_interval == 0:\n self.play(\n max_episode_length,\n self.render,\n reward_network=reward_network,\n )","def train(self, iters, n_episodes):\n for i in range(iters):\n self.self_play(n_episodes)\n self.learn()","def train_epoch(self) -> None:\n ct = self.config.training\n total_games = self._get_total_games()\n print(f\"Total Games: {total_games}\")\n train_size = int(0.9 * total_games)\n dataset_wrapper = DatasetWrapper(self.config)\n self.agent.model.fit(\n dataset_wrapper.get_dataset(train_size),\n epochs=ct.epoch_to_checkpoint,\n validation_data=dataset_wrapper.get_dataset(train_size, is_training=False),\n )","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.num_epochs):\n print(\"EPOHA\")\n self.run_epoch()\n print(\"SAVE MODEL\")\n self.save_model()","def _train_model(self):\n self.experiment = EpisodicExperiment(self.task, self.agent)\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\n logger.debug(\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\"\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\n for i in range(n_epochs):\n logger.debug(\"RL epoch {}\".format(i))\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\n self.agent.learn()\n self.agent.reset() # reset buffers","def train_by_episode(self):\n # only REINFORCE and REINFORCE with baseline\n # use the ff code\n # convert the rewards to returns\n rewards = []\n gamma = 0.99\n for item in self.memory:\n [_, _, _, reward, _] = item\n rewards.append(reward)\n # rewards = np.array(self.memory)[:,3].tolist()\n\n # compute return per step\n # return is the sum of rewards from t til end of episode\n # return replaces reward in the list\n for i in range(len(rewards)):\n reward = rewards[i:]\n horizon = len(reward)\n discount = [math.pow(gamma, t) for t in range(horizon)]\n return_ = np.dot(reward, discount)\n self.memory[i][3] = return_\n\n # train every step\n for item in self.memory:\n self.train(item, gamma=gamma)","def train(n_episodes=1000, max_n_steps=300, eps_start=1.0, eps_end=0.01, eps_decay=0.995, strCheckpointFile='checkpoint.pth'):\n\n global env\n scores = [] # list containing scores from each episode\n scores_window = deque(maxlen=100) # last 100 scores\n eps = eps_start # initialize epsilon\n num_saves = 0\n for i_episode in range(1, n_episodes + 1):\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\n state = env_info.vector_observations[0] # get the current state\n score = 0 # initialize the score\n last_t = max_n_steps\n for t in range(max_n_steps):\n action = agent.act(state, eps) # agent returns an epsilon-greedy action based on state\n env_info = env.step(action)[brain_name] # send the action to the environment\n next_state = env_info.vector_observations[0] # get the next state\n reward = env_info.rewards[0] # get the reward\n done = env_info.local_done[0] # see if episode has finished\n agent.step(state, action, reward, next_state, done) # records experience and learns (depending on settings)\n state = next_state\n score += reward\n if done:\n last_t = t + 1\n break\n scores_window.append(score) # save most recent score\n scores.append(score) # save most recent score\n eps = max(eps_end, eps_decay * eps) # decrease epsilon\n print('\\rEpisode {}\\tNum steps: {}\\tAverage Score: {:.2f}'.format(i_episode, last_t, np.mean(scores_window)))\n # if i_episode % 100 == 0:\n # print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n if np.mean(scores_window) >= 13: # win condition in course\n if num_saves == 0:\n print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode - 100, np.mean(scores_window)))\n print('\\nTraining will continue and the checkpoint will be overwritten every 100 episodes')\n print('\\nSaving a checkpoint now, you may interrupt code execution with eg Ctrl+C')\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\n else:\n if i_episode % 100 == 0:\n print('\\nSaving another checkpoint now, you may interrupt code execution with eg Ctrl+C')\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\n num_saves += 1\n\n env.close()\n\n # plot the scores\n fig = plt.figure()\n ax = fig.add_subplot(111)\n plt.plot(np.arange(len(scores)), scores)\n plt.ylabel('Score')\n plt.xlabel('Episode #')\n # plt.show()\n plt.savefig('training_score_by_episode.png')\n return scores","def learn(self, num_episodes=10000):\n for i in range(num_episodes):\n self.actor()\n self.learner()","def train_model(num_episodes, model_version, discount_rate, learning_rate):\n\n # getting available models\n with open('model_architectures.yaml', 'r') as file:\n available_models = yaml.safe_load(stream = file)\n file.close()\n\n # input checks\n if type(num_episodes) != int:\n raise TypeError('num_episodes must be of type int')\n if num_episodes <= 0:\n raise ValueError('num_episodes must be greater than zero')\n if type(model_version) != str:\n raise TypeError('model_version must be of type string')\n if model_version not in available_models:\n raise ValueError('model_version not available')\n if type(discount_rate) != int and type(discount_rate) != float:\n raise TypeError('discount rate must be of type int or float')\n if discount_rate <= 0:\n raise ValueError('discount_rate must be greater than zero')\n if type(learning_rate) != float:\n raise TypeError('learning_rate must be of type float')\n if learning_rate <= 0 or learning_rate >= 1:\n raise ValueError('learning_rate must be within (0, 1)')\n\n # determining model sub-version\n model_sub_version_write = False\n sub_version = 0\n while not model_sub_version_write:\n if not os.path.exists(os.path.join('trained_models', model_version, model_version + '.' + str(sub_version) + '.0')):\n model_sub_version_write = True\n break\n sub_version += 1\n\n # building model\n model = eval(available_models[model_version])()\n optimizer = tf.keras.optimizers.Adam(learning_rate = learning_rate)\n compute_loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits = True)\n\n # holding gradients\n gradient_holder = model.trainable_variables\n for i, gradient in enumerate(gradient_holder):\n gradient_holder[i] = gradient * 0\n\n # creating gym environment\n env = gym.make('CartPole-v1')\n env._max_episode_steps = 15000\n\n scores = []\n every_update = 5\n\n # training loop\n for episode in range(num_episodes + 1):\n observation = env.reset()\n\n episode_memory = []\n episode_score = 0\n done = False\n\n while not done:\n\n # creates vector of form [Position, Velocity, Angle, Angular Velocity]\n observation = observation.reshape([1, 4])\n\n with tf.GradientTape() as tape:\n\n # creating loss function and action\n logits = model(observation)\n a_dist = logits.numpy()\n action = np.random.choice(a = a_dist[0], p = a_dist[0])\n action = np.argmax(a_dist == action)\n loss = compute_loss([action], logits)\n\n # performing action and getting feedback from environment\n observation, reward, done, info = env.step(action)\n\n episode_score += reward\n\n # trick for quicker convergence\n if done:\n reward -= 10\n\n # getting gradients\n gradients = tape.gradient(target = loss, sources = model.trainable_variables)\n episode_memory.append([gradients, reward])\n\n scores.append(episode_score)\n\n # discounting rewards\n episode_memory = np.array(episode_memory)\n episode_memory[:, 1] = discount_rewards(rewards = episode_memory[:, 1], discount_rate = discount_rate)\n\n # applying rewards to corresponding gradients\n for grads, reward in episode_memory:\n for i, grad in enumerate(grads):\n gradient_holder[i] += grad * reward\n\n # back-propagating gradients, resetting gradients\n if episode % every_update == 0:\n optimizer.apply_gradients(zip(gradient_holder, model.trainable_variables))\n for i, grad in enumerate(gradient_holder):\n gradient_holder[i] = grad * 0\n\n if episode % 100 == 0:\n print('Episode {} Score {}'.format(episode, np.mean(scores[-20:])))\n tf.keras.models.save_model(model = model,\n filepath = os.path.join('trained_models', model_version, model_version + '.' +\n str(sub_version) + '.{}'.format(episode)))\n\n final_performance = int(round(np.mean(scores[-20:])))\n\n # dumping training results into yaml file\n yaml_dump = {}\n yaml_dump['Model Version'] = model_version\n yaml_dump['Model Sub-version'] = sub_version\n yaml_dump['Number of Training Episodes'] = num_episodes\n yaml_dump['Discount Rate'] = discount_rate\n yaml_dump['Learning Rate'] = learning_rate\n yaml_dump['Final Performance'] = final_performance\n\n with open(os.path.join('trained_models', model_version, model_version + '.' + str(sub_version) + '_training_details.yaml'), 'w') as file:\n yaml.dump(data = yaml_dump, stream = file)\n file.close()","def train(self, num_episodes=10000):\n\n self.game.restart()\n\n self.exp_states = defaultdict(int)\n\n for i in tqdm(range(num_episodes)):\n\n self.game.deal_cards()\n\n possible_actions = self.game.get_actions()\n\n player_state = self.game.get_player_state()\n player_action = self.player.get_action(player_state,\n possible_actions,\n explore_exploit='explore')\n\n # Bookkeep visited states (?)\n player_state_str = np.array2string(player_state)\n self.exp_states[player_state_str] += 1\n\n opponent_state = self.game.get_opponent_state()\n opponent_action = self.opponent.get_action(opponent_state,\n possible_actions)\n\n self.game.set_player_action(player_action)\\\n .set_opponent_action(opponent_action)\n\n player_score, opponent_score = self.game.get_scores()\n\n reward = self._get_reward(player_score, opponent_score)\n self.player.learn(player_state,\n player_action,\n reward)\n self.player.learn(opponent_state,\n opponent_action,\n -reward)\n \n print(\"Training done!\")","def train(self, env):\n\n\t\tmin_average_reward_for_stopping = 195\n\t\tconsecutive_successful_episodes_to_stop = 10\n\t\tlast_10_rewards = deque(maxlen=consecutive_successful_episodes_to_stop)\n\n\t\tnum_Episodes = []\n\t\tEpisode_Rewards = []\n\n\t\tfor episode in range(self.episodes):\n\t\t\tstate = env.reset()\n\t\t\tstate = np.reshape(state, [1, self.state_size])\n\t\t\tdone = False\n\t\t\ttotal_reward = 0\n\n\t\t\twhile not done:\n\t\t\t\taction = self.act(state)\n\t\t\t\tnext_state, reward, done, _ = env.step(action)\n\t\t\t\tnext_state = np.reshape(next_state, [1, self.state_size])\n\t\t\t\tself.remember(state, action, reward, next_state, done)\n\t\t\t\tstate = next_state\n\t\t\t\ttotal_reward += reward\n\n\t\t\tnum_Episodes.append(episode)\n\t\t\tEpisode_Rewards.append(total_reward)\n\t\t\tlast_10_rewards.append(total_reward)\n\t\t\tlast_10_avg_reward = np.mean(last_10_rewards)\n\t\t\tprint(episode, last_10_avg_reward)\n\n\t\t\t# call experience relay\n\t\t\tif len(self.memory) >= self.batch_size:\n\t\t\t\tself.replay(self.batch_size)\n\t\t\t# Stopping criteria\n\t\t\tif len(\n\t\t\t\t\tlast_10_rewards) == consecutive_successful_episodes_to_stop \\\n\t\t\t\t\tand last_10_avg_reward > min_average_reward_for_stopping:\n\t\t\t\tprint(\"Solved after {} epsiodes\".format(episode))\n\t\t\t\tbreak","def train(self, episodes, epsilon_initial, epsilon_min, epsilon_stop_episode,\n network_update_freq, gamma, memory_capacity, batch_size):\n\n memory = ReplayMemory(memory_capacity)\n\n tot_steps = 0\n running_loss = 0\n\n depsilon = (epsilon_initial-epsilon_min)/epsilon_stop_episode\n\n for episode in range(episodes):\n\n if epsilon_initial > epsilon_min:\n epsilon_initial -= depsilon\n\n if episode % network_update_freq == 0:\n # Update target network\n self.NN_target.load_state_dict(self.NN.state_dict())\n\n if (episode + 1) % 10 == 0:\n print(f'Episode {episode + 1}/{episodes} completed!')\n print(f'Average steps per episode: {tot_steps / 10}')\n writer.add_scalar('training loss', running_loss / tot_steps, episode)\n self.plotValue()\n tot_steps = 0\n running_loss = 0\n\n state, done = self.env.reset()\n\n\n while not done:\n tot_steps += 1\n\n action = self.chooseAction(epsilon_initial, state)\n\n reward, next_state, done= self.env.transitionState(state, action)\n\n #score += reward\n reward = torch.tensor([[reward]], device=device)\n done = torch.tensor([[done]], device=device)\n\n # Saves the transition\n memory.push(self.RBF[state], self.RBF[next_state], reward, done)\n\n # Perform one step of batch gradient descent\n running_loss += self.optimizeModel(memory, batch_size, gamma)\n\n state = next_state\n\n writer.close()","def train_prediction(self, episodes=100, batch_size=32, steps=100):\n hidden_state = None\n for episode in range(episodes):\n state_data = self.env.dataset(batch_size=batch_size)\n state = self.state_to_observation(state_data)\n\n prediction = self.model(state, hidden_state)\n loss = F.mse_loss(prediction['value'], state_data['reward'])\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def train_network(self, batch, episode_nr):\n global eps, eps_min, eps_decay\n for exp in batch:\n S = exp[0]\n S = process_state(S)\n action_number = exp[1]\n r = exp[2]\n S_new = exp[3]\n S_new = process_state(S_new)\n terminal = exp[4]\n\n if not terminal: # If agent is not at its final destination\n target = (r + gamma*np.amax(self.target.predict(S_new)[0]))\n else:\n target = r\n target_f = self.policy.predict(S)\n\n target_f[0][action_number] = target # Update something???\n self.policy.fit(S, target_f, epochs=1, verbose=0) # Train network # Verbose - makes training line?\n if self.epsilon > self.eps_min and episode_nr > 10:\n self.epsilon *= self.eps_decay # Decrease exploration rate","def train(self, num_tickers=4, episodes_per_ticker=5, **kwargs):\n num_tickers = min(num_tickers, len(self.filtered_tickers))\n for i in range(num_tickers):\n ticker = self.filtered_tickers[i % num_tickers]\n env = self.ENV_CONSTRUCTOR(ticker=ticker, **kwargs)\n for j in tqdm(range(episodes_per_ticker)):\n history = self.run_episode(env)\n history[\"ticker\"] = ticker\n history[\"episode\"] = j + 1\n history[\"t\"] = range(len(history))\n self.history = pd.concat((self.history, history))\n self.history = self.history.reset_index(\"Date\", drop=True)","def train(self, num_decisions=350):\n os.system(\"mkdir \" + self.folder_name + \"Train\")\n for i in range(5000):\n episode_folder_name = self.folder_name + \"Train/\" + str(i) + \"/\"\n all_system_states = []\n all_system_rewards = []\n all_system_states_cluster = []\n all_grid_states_cluster = []\n all_surrounding_states_cluster = []\n os.system(\"mkdir \" + episode_folder_name)\n filename = episode_folder_name + str(i) + \".h5\"\n self.system.reset_context(filename)\n self.system.run_decorrelation(20)\n grid_dist, surrounding_dist, _, _, _, _ = self.system.get_state_reward()\n state = self._get_state(grid_dist, surrounding_dist)\n for j in range(num_decisions):\n action_index = self._get_action(state, i)\n transition_to_add = [state, action_index]\n tag = \"_train_\" + str(j)\n actions = [self.all_actions[i] for i in action_index]\n try:\n self.system.update_action(actions)\n system_states, system_rewards, system_states_cluster = self.system.run_step(\n is_detailed=True, tag=tag)\n all_system_states.append(system_states)\n all_system_rewards.append(system_rewards)\n all_system_states_cluster.append(system_states_cluster)\n\n except OpenMMException:\n print(\"Broken Simulation at Episode:\",\n str(i), \", Decision:\", str(j))\n break\n\n grid_dist, surrounding_dist, grid_reward, surrounding_reward, grid_states_cluster, surrounding_states_cluster = self.system.get_state_reward()\n state = self._get_state(grid_dist, surrounding_dist)\n reward = self._get_reward(grid_reward, surrounding_reward)\n\n all_grid_states_cluster.append(grid_states_cluster)\n all_surrounding_states_cluster.append(surrounding_states_cluster)\n\n # Use len_reward for number of grids\n done = [False] * len(reward) # Never Done\n transition_to_add.extend([reward, state, done])\n rb_decision_samples = 0\n for rb_tuple in zip(*transition_to_add):\n self.buffer.push(*list(rb_tuple))\n\n for _ in range(self.update_num):\n self._update()\n self._save_episode_data(episode_folder_name)\n np.save(episode_folder_name + \"system_states\",\n np.array(all_system_states))\n np.save(episode_folder_name + \"system_rewards\",\n np.array(all_system_rewards))\n np.save(episode_folder_name + \"system_states_cluster\",\n np.array(all_system_states_cluster))\n np.save(episode_folder_name + \"grid_states_cluster\",\n np.array(all_grid_states_cluster, dtype=object))\n np.save(episode_folder_name + \"all_states_cluster\",\n np.array(all_surrounding_states_cluster))\n self._save_data()","def trainOneEpisode(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\n # tqdm.write('------Episode {} / {}------'.format(self.episodes_done, num_episodes))\n self.resetEnv()\n r_total = 0\n with trange(1, max_episode_steps+1, leave=False) as t:\n\n for step in t:\n if render:\n self.env.render()\n state = self.state\n action, q = self.selectAction(state, require_q=True)\n obs_, r, done, info = self.takeAction(action.item())\n # if print_step:\n # print 'step {}, action: {}, q: {}, reward: {} done: {}' \\\n # .format(step, action.item(), q, r, done)\n r_total += r\n # t.set_postfix(step='{:>5}'.format(step), q='{:>5}'.format(round(q, 4)), total_reward='{:>5}'.format(r_total))\n t.set_postfix_str('step={:>5}, q={:>5}, total_reward={:>5}'.format(step, round(q, 2), r_total))\n if done or step == max_episode_steps:\n next_state = None\n else:\n next_state = self.getNextState(obs_)\n reward = torch.tensor([r], device=self.device, dtype=torch.float)\n self.memory.push(state, action, next_state, reward)\n self.optimizeModel()\n if self.steps_done % self.target_update == 0:\n self.target_net.load_state_dict(self.policy_net.state_dict())\n\n if done or step == max_episode_steps - 1:\n tqdm.write('------Episode {} ended, total reward: {}, step: {}------' \\\n .format(self.episodes_done, r_total, step))\n tqdm.write('------Total steps done: {}, current e: {} ------' \\\n .format(self.steps_done, self.exploration.value(self.steps_done)))\n # print '------Episode {} ended, total reward: {}, step: {}------' \\\n # .format(self.episodes_done, r_total, step)\n # print '------Total steps done: {}, current e: {} ------' \\\n # .format(self.steps_done, self.exploration.value(self.steps_done))\n self.episodes_done += 1\n self.episode_rewards.append(r_total)\n self.episode_lengths.append(step)\n if self.episodes_done % save_freq == 0:\n self.saveCheckpoint()\n break\n self.state = next_state","def train(self, episodes=2000, max_steps=99):\n\n for episode in range(episodes):\n state = self.env.reset()\n\n for step in range(max_steps):\n explore_eploit_tradeoff = np.random.uniform()\n\n if explore_eploit_tradeoff > self.epsilon:\n action = np.argmax(self.q_table[state, :])\n else:\n action = self.env.action_space.sample()\n\n new_state, reward, done, info = self.env.step(action)\n\n self.q_table[state, action] = self.q_table[state, action] \\\n + self.lr * (reward + self.gamma * np.amax(\n self.q_table[new_state, :]\n ) - self.q_table[state, action]\n )\n\n state = new_state\n if done:\n break\n exp_ = np.exp(-self.decay_rate * episode)\n self.epsilon = self.min_eps + exp_ * (self.max_eps - self.min_eps)","def on_train_begin(self, logs):\n print(f\"Testing for {self.params['nb_episodes']} episodes ...\")","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.opt.num_epochs):\n self.run_epoch()\n if (self.epoch + 1) % self.opt.save_frequency == 0:\n self.save_model()","def train(\r\n self,\r\n max_episodes : int,\r\n exploration_rate=0.9,\r\n discount=0.9,\r\n batch_size=32,\r\n timesteps_per_episode=200,\r\n warm_start=False,\r\n model_alignment_period=100,\r\n save_animation_period=100,\r\n save_model_period=10,\r\n evaluate_model_period=50,\r\n evaluation_size=10,\r\n exploration_rate_decay=0.99,\r\n min_exploration_rate=0.1,\r\n epochs=1,\r\n log_q_values=False) -> Controller:\r\n\r\n # Log training parameters\r\n params = {\r\n \"max_episodes\": max_episodes,\r\n \"exploration_rate\": exploration_rate,\r\n \"discount\": discount,\r\n \"batch_size\": batch_size,\r\n \"timesteps_per_episode\": timesteps_per_episode,\r\n \"model_alignment_period\": model_alignment_period,\r\n \"evaluate_model_period\": evaluate_model_period,\r\n \"evaluation_size\": evaluation_size,\r\n \"exploration_rate_decay\": exploration_rate_decay,\r\n \"min_exploration_rate\": min_exploration_rate,\r\n \"epochs\": epochs\r\n }\r\n self.params.update(params)\r\n self.Logger.log_params(self.params)\r\n\r\n # Load existing model for warm start\r\n if warm_start:\r\n check = self._load_model()\r\n if not check:\r\n print(\"Using default network\") # TODO: temp solution\r\n\r\n max_reward = -100\r\n for episode in range(1, max_episodes + 1):\r\n t1 = time.time()\r\n total_reward = 0\r\n eval_score = 0\r\n terminated = False\r\n steps = 0\r\n state = self.environment.reset(random=True) # start from random state\r\n\r\n # TODO: Check if possible to avoid reshape!!\r\n state = state[self.idx].reshape(1, self.state_size)\r\n\r\n for timestep in range(timesteps_per_episode):\r\n # Predict which action will yield the highest reward.\r\n action = self._act(state, exploration_rate,log_q_values)\r\n\r\n # Take the system forward one step in time.\r\n next_state = self.environment.step(action)\r\n\r\n # Compute the actual reward for the new state the system is in.\r\n current_time = timestep * self.environment.step_size\r\n reward = self.environment.reward(next_state, current_time)\r\n\r\n # Check whether the system has entered a terminal case.\r\n terminated = self.environment.terminated(next_state, current_time)\r\n\r\n # TODO: Can this be avoided?\r\n next_state = next_state[self.idx].reshape(1, self.state_size)\r\n\r\n # Store results for current step.\r\n self._store(state, action, reward, next_state, terminated)\r\n\r\n # Update statistics.\r\n total_reward += reward\r\n state = next_state\r\n steps = timestep+1\r\n\r\n if len(self.experience) >= batch_size:\r\n self._experience_replay(batch_size, discount, epochs)\r\n #exploration_rate *= exploration_rate_decay\r\n\r\n # Terminate episode if the system has reached a termination state.\r\n if terminated:\r\n break\r\n\r\n # Log the average loss for this episode\r\n\r\n self.Logger.log_loss(np.mean(self.episode_loss), episode)\r\n self.episode_loss = []\r\n\r\n # Log the average Q-values for this episode\r\n if log_q_values:\r\n self.Logger.log_q_values(self.episode_q_values/steps, episode)\r\n self.episode_q_values = np.zeros(len(self.environment.action_space))\r\n\r\n if exploration_rate > min_exploration_rate:\r\n exploration_rate *= exploration_rate_decay\r\n else:\r\n exploration_rate = min_exploration_rate\r\n t2 = time.time()\r\n print(\r\n f\"Episode: {episode:>5}, \"\r\n f\"Score: {total_reward:>10.1f}, \"\r\n f\"Steps: {steps:>4}, \"\r\n f\"Simulation Time: {(steps * self.environment.step_size):>6.2f} Seconds, \"\r\n f\"Computation Time: {(t2-t1):>6.2f} Seconds, \"\r\n f\"Exploration Rate: {exploration_rate:>0.3f}\")\r\n\r\n if episode % model_alignment_period == 0:\r\n self._align_target_model()\r\n\r\n # if episode % save_animation_period == 0:\r\n # self.environment.save(episode)\r\n\r\n\r\n if episode % evaluate_model_period == 0:\r\n eval_score = self._evaluate(evaluation_size, max_steps=timesteps_per_episode,episode=episode)\r\n\r\n if eval_score > max_reward:\r\n self._save_model(\"best\")\r\n max_reward = eval_score\r\n\r\n self._save_model(\"latest\")\r\n\r\n # Create Controller object\r\n controller = Controller(self.environment.get_action_space(), self.q_network, self.idx)\r\n print(\"Controller Created\")\r\n return controller","def train(self, n_episodes):\n for episode in trange(n_episodes):\n policy_loss, entropy, episode_reward = self.train_step()\n self.writer.add_scalar('policy_loss', policy_loss, episode)\n self.writer.add_scalar('entropy', entropy, episode)\n self.writer.add_scalar('episode_reward', episode_reward, episode)","def train(self, max_episodes= 1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n success = False\n i_episode = 0\n eps = eps_start\n \n print('Training in progress...')\n for i in range(max_episodes):\n score = self.run_training_episode(eps=eps)\n \n self.score_window.append(score)\n self.score_record.append(np.mean(self.score_window))\n \n i_episode += 1\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\n\n if i_episode%100 == 0:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\n \n if i_episode>100:\n if np.mean(self.score_window)>self.criteria:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\n success = True\n break\n\n if success:\n print('Criteria reached after {} episodes'.format(i_episode))\n else:\n print('Failed to reach Criteria after {} episodes'.format(i_episode))\n\n self.plot_training_progress()\n return success","def train(self, batch_size=64, n_episodes=100, max_episode_length=3000, save_path=\"last_save.h5\",\n load_path=None):\n\n self.explore = True # Explore if needed\n\n self._play_through(n_episodes=n_episodes, max_episode_length=max_episode_length, save_path=save_path,\n callbacks=self._train_callbacks_factory())","def train(self, num_batches: int):","def train(self, num_episodes = 10000, verbose = True):\n start_time = datetime.now().replace(microsecond=0)\n for e in range(num_episodes):\n S_old = self.env.reset()\n steps = 0\n # there is an interal limit of 100 steps\n while steps < 1000:\n steps += 1\n A = self.epsilon_greedy(S_old)\n S_new, reward, done, info = self.env.step(A)\n self.Q[S_old, A] = self.Q[S_old, A] + self.alpha * \\\n (reward + self.gamma * np.max(self.Q[S_new, :]) - self.Q[S_old, A])\n if done:\n break\n S_old = S_new\n if verbose:\n clear_output(wait=True)\n now_time = datetime.now().replace(microsecond=0)\n print(\"Epoch: {}/{} - Steps: {:4} - Duration: {}\".format(e+1, num_episodes, steps, now_time-start_time))\n\n return self.Q","def train_episode(self):\n state = self.env.reset()\n states = []\n actions = []\n rewards = []\n for _ in range(self.options.steps):\n probs = self.actor_baseline.predict([[state]])[0][0]\n action = np.random.choice(len(probs), p=probs)\n\n next_state, reward, done, _ = self.step(action)\n states.append(state)\n actions.append(action)\n rewards.append(reward)\n\n state = next_state\n\n if done:\n break\n\n # Compute and store returns in G\n G = np.zeros_like(rewards)\n ################################\n # YOUR IMPLEMENTATION HERE #\n ################################\n\n # One-hot encoding for actions\n actions_one_hot = np.zeros([len(actions), self.env.action_space.n])\n actions_one_hot[np.arange(len(actions)), actions] = 1\n\n # Compute one-hot encoded deltas\n ################################\n # YOUR IMPLEMENTATION HERE #\n ################################\n deltas = [[0]]\n\n # Update actor and state estimator\n self.actor_baseline.fit(x=[np.array(states)],\n y={'actor_output': deltas, 'baseline_output': returns},\n epochs=1, batch_size=self.options.batch_size, verbose=0)","def train(Game, agent, episodes=1000):\n a = agent\n # eps_start = a.epsilon\n # eps_end = a.epsilon_min\n # eps_dec = np.exp(1/episodes * np.log(eps_end/eps_start))\n # a.epsilon_decrement = eps_dec\n times_taken = np.zeros(episodes)\n print(\"Training starting\")\n for n in range(episodes):\n start_time = time.time()\n g = Game()\n print(\"EPISODE\", n+1)\n while not g.success:\n state = 1.0*g.get_state()\n action = a.action(state)\n reward = g.play(action)\n # print(g.success)\n # print(\"reward: \", reward)\n # print(state)\n # print(action)\n # print(g.get_state())\n a.train(state, action, reward, g.get_state(), g.success)\n end_time = time.time()\n times_taken[n] = end_time - start_time\n print(\"Training complete ({} episodes)\".format(episodes))\n return times_taken","def train_epoch(self):\n\n if self._train_data_set is not None and self._train_data_set is not None:\n self._model.fit_num_epochs(self._train_data_set, self._test_data_set)\n else:\n raise RuntimeError(\"[Triggerbot]: No training or test set available\")","def learn(self):\n epochswin = [] # count the number of wins at every epoch of the network against the preceding version\n epochdraw = [] # count the number of draws at every epoch of the network against the preceding version\n epochswingreedy = [] # count the number of wins against greedy at every epoch\n epochswinrandom = [] # count the number of wins against random at every epoch\n epochsdrawgreedy = [] # count the number of draws against greedy at every epoch\n epochsdrawrandom = [] # count the number of wins against random at every epoch\n epochswinminmax = [] # count the number of wins against minmax at every epoch\n epochsdrawminmax = [] # count the number of draws against minmax at every epoch\n\n\n if self.args.load_model == True:\n file = open(self.args.trainExampleCheckpoint + \"graphwins:iter\" + str(self.args.numIters) + \":eps\" + str(\n self.args.numEps) + \":dim\" + str(self.game.n) + \".txt\", \"r+\")\n lines = file.readlines()\n for index, line in enumerate(lines):\n for word in line.split():\n if index == 0:\n epochswin.append(word)\n elif index == 1:\n epochdraw.append(word)\n file.close()\n\n file = open(self.args.trainExampleCheckpoint + \"graphwins:iter\" + str(self.args.numIters) + \":eps\" + str(\n self.args.numEps) + \":dim\" + str(self.game.n) + \":greedyrandom.txt\", \"r+\")\n lines = file.readlines()\n for index, line in enumerate(lines):\n for word in line.split():\n if index == 0:\n epochswingreedy.append(word)\n elif index == 1:\n epochsdrawgreedy.append(word)\n elif index == 2:\n epochswinrandom.append(word)\n elif index == 3:\n epochsdrawrandom.append(word)\n elif index == 4:\n epochswinminmax.append(word)\n elif index == 5:\n epochsdrawminmax.append(word)\n file.close()\n self.loadTrainExamples()\n\n for i in range(1, self.args.numIters + 1):\n # bookkeeping\n print('------ITER ' + str(i) + '------')\n # examples of the iteration\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\n\n eps_time = AverageMeter()\n bar = Bar('Self Play', max=self.args.numEps)\n end = time.time()\n\n for eps in range(self.args.numEps):\n iterationTrainExamples += self.executeEpisode()\n\n # bookkeeping + plot progress\n eps_time.update(time.time() - end)\n end = time.time()\n bar.suffix = '({eps}/{maxeps}) Eps Time: {et:.3f}s | Total: {total:} | ETA: {eta:}'.format(eps=eps + 1,\n maxeps=self.args.numEps,\n et=eps_time.avg,\n total=bar.elapsed_td,\n eta=bar.eta_td)\n bar.next()\n bar.finish()\n\n # save the iteration examples to the history\n self.trainExamplesHistory.append(iterationTrainExamples)\n\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\n print(\"len(trainExamplesHistory) =\", len(self.trainExamplesHistory),\n \" => remove the oldest trainExamples\")\n self.trainExamplesHistory.pop(0)\n # backup history to a file\n # NB! the examples were collected using the model from the previous iteration, so (i-1)\n self.saveTrainExamples(i - 1)\n\n # shuffle examlpes before training\n trainExamples = []\n for e in self.trainExamplesHistory:\n trainExamples.extend(e)\n shuffle(trainExamples)\n\n # training new network, keeping a copy of the old one\n\n filename = \"curent\"+str(i)+\"temp:iter\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n filenameBest = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\n exists = os.path.isfile(filenameBest)\n if exists:\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\n else:\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\n pmcts = MCTS(self.game, self.pnet, self.args)\n\n self.nnet.train(trainExamples)\n nmcts = MCTS(self.game, self.nnet, self.args)\n\n print('PITTING AGAINST PREVIOUS VERSION')\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game,nmcts,pmcts,evaluate=True)\n\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare, False)\n\n pmcts.clear()\n nmcts.clear()\n del pmcts\n del nmcts\n\n print(' ')\n print('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\n if i == 1:\n epochswin.append(pwins)\n epochdraw.append(0)\n\n epochswin.append(nwins)\n epochdraw.append(draws)\n self.writeLogsToFile(epochswin, epochdraw)\n\n ''' Get all the players and then pit them against the network. You need to modify here if you implement \n more players\n '''\n (gp, rp, mp) = self.decidePlayers()\n\n if self.args.parallel == 0:\n\n\n nmcts1 = MCTS(self.game, self.nnet, self.args)\n nmcts2 = MCTS(self.game, self.nnet, self.args)\n nmcts3 = MCTS(self.game, self.nnet, self.args)\n\n arenagreedy = Arena(lambda x: np.argmax(nmcts1.getActionProb(x, temp=0)), gp, self.game,nmcts1)\n arenarandom = Arena(lambda x: np.argmax(nmcts2.getActionProb(x, temp=0)), rp, self.game,nmcts2)\n arenaminmax = Arena(lambda x: np.argmax(nmcts3.getActionProb(x, temp=0)), mp, self.game,nmcts3,evaluate=True)\n\n pwinsminmax, nwinsminmax, drawsminmax = arenaminmax.playGames(self.args.arenaCompare)\n print(\"minmax - \"+str(pwinsminmax)+\" \"+str(nwinsminmax)+\" \"+str(drawsminmax))\n pwinsgreedy, nwinsgreedy, drawsgreedy = arenagreedy.playGames(self.args.arenaCompare)\n print(\"greedy - \"+str(pwinsgreedy)+\" \"+str(nwinsgreedy)+\" \"+str(drawsgreedy))\n pwinsreandom, nwinsrandom, drawsrandom = arenarandom.playGames(self.args.arenaCompare)\n print(\"random - \"+str(pwinsreandom)+\" \"+str(nwinsrandom)+\" \"+str(drawsrandom))\n\n nmcts1.clear()\n nmcts2.clear()\n nmcts3.clear()\n del nmcts1\n del nmcts2\n del nmcts3\n\n else:\n '''\n This will be used if you want to evaluate the network against the benchmarks in a parallel way\n '''\n\n self.args.update({'index': str(i)})\n\n p = self.parallel(self.args.arenaCompare)\n (pwinsminmax, nwinsminmax, drawsminmax) = p[0] # self.parallel(\"minmax\", self.args.arenaCompare)\n (pwinsgreedy, nwinsgreedy, drawsgreedy) = p[1] # self.parallel(\"greedy\",self.args.arenaCompare)\n (pwinsreandom, nwinsrandom, drawsrandom) = p[2] # self.parallel(\"random\",self.args.arenaCompare)\n\n epochsdrawgreedy.append(drawsgreedy)\n epochsdrawrandom.append(drawsrandom)\n epochswinrandom.append(pwinsreandom)\n epochswingreedy.append(pwinsgreedy)\n epochswinminmax.append(pwinsminmax)\n epochsdrawminmax.append(drawsminmax)\n\n self.writeLogsToFile(epochswingreedy, epochsdrawgreedy, epochswinrandom, epochsdrawrandom, epochswinminmax,\n epochsdrawminmax, training=False)\n\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) <= self.args.updateThreshold:\n print('REJECTING NEW MODEL')\n filename = \"curent\"+str(i)+\"temp:iter\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n filenameBest = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n exists = os.path.isfile(filenameBest)\n if exists:\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\n else:\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\n\n else:\n print('ACCEPTING NEW MODEL')\n\n filename = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\n self.mcts.clear()\n del self.mcts\n self.mcts = MCTS(self.game, self.nnet, self.args, mcts=True) # reset search tree\n print(self.tracker.print_diff())\n self.writeLogsToFile(epochswin, epochdraw, training=True)","def train_one_epoch(self):\n raise NotImplementedError","def train_on_history(self, history):\n \n # Split into episodes\n n_episodes = history[-1][\"episode\"] \n episodes = [list(filter(lambda h: h[\"episode\"]==e , history)\n ) for e in range(n_episodes)\n ]\n\n # Split into game lives\n for episode in episodes:\n \n \n game_lives = [\n list(filter(lambda h: h.get('info').get('ale.lives')==l, episode)\n ) for l in range(5)\n ]\n \n for life in game_lives:\n if life:\n self.train(life)\n else:\n print(\"No ocurrance\")\n return","def train(self,env, iter_n=2000):\n\n\t\tfor i in range(iter_n):\n\t\t\tif i > 50:\n\t\t\t\tif all(reward > 195 for reward in self.step_count[-10:]):\n\t\t\t\t\tprint('solved at episode {}'.format(i))\n\t\t\t\t\tbreak\n\t\t\tstate = self.env.reset()\n\t\t\tstate = np.reshape(state, [1, self.state_size])\n\n\t\t\tepisode_complete = False\n\t\t\tstep = 0\n\t\t\twhile not episode_complete and (step < self.max_steps):\n\t\t\t\taction = self.define_action(state)\n\t\t\t\tnew_state, reward, episode_complete, info = env.step(action)\n\t\t\t\tnew_state = np.reshape(new_state, [1, self.state_size])\n\n\t\t\t\tself.memory.append((state, action, reward, new_state, episode_complete))\n\t\t\t\tself.round_reward += reward\n\t\t\t\tstate = new_state\n\t\t\t\tstep += 1\n\t\t\t\tif episode_complete:\n\t\t\t\t\tself.round_reward += -10\n\t\t\t\t\tself.update_target_model()\n\t\t\t\t\tself.print_results(i, iter_n, step)\n\t\t\t\t\tif i != 0: # Update totals in memory if not the first run\n\t\t\t\t\t\tself.update_totals(i, step)\n\t\t\t\tif len(self.memory) > self.training_iter:\n\t\t\t\t\tself.replay()\n\t\t\tif self.epsilon > self.epsilon_min:\n\t\t\t\tself.epsilon *= self.epsilon_decay\n\n\t\treturn self.all_iterations, self.all_rewards, self.step_count","def train_one_eps(self, env, horizon=1000, lr=0.1):\n\t\tr_ep = 0 # variable to track episode \n\t\tep_len = 0\n\n\t\tstate = env.reset()\n\t\taction = self.select_action(state)\n\n\t\tfor t in range(horizon):\n\t\t\t\n\t\t\tstate2, r, done, _ = env.step(action)\n\t\t\tep_len = ep_len + 1\n\t\t\tr_ep += r\n\n\t\t\taction2 = self.select_action(state2)\n\t\t\tself.update(state, action, r, state2, action2, lr=lr)\n\t\t\taction = action2\n\t\t\t\n\t\t\tif(done):\n\t\t\t\tbreak\n\t\t\tstate = state2\n\n\t\treturn r_ep, ep_len","def train_epoch(self):\n for batch, targets in self.training_dataloader:\n self.training_step(batch, targets)\n self.calculate_training_loss()\n self.epochs_trained += 1\n LOGGER.info(\n \"Training loss after {} epochs: {}\".format(str(self.epochs_trained), str(self.training_average_loss))\n )","def fit(self):\n for i in range(self.current_epoch, self.max_epoch):\n self.current_epoch += 1\n # train\n train_dataloader = self.data_module.get_train_dataloader(\n batch_size=self.train_batch_size, \n shuffle=self.train_dataloader_shuffle, \n num_workers=self.dataloader_num_workers,\n pin_memory=True\n )\n neptune.log_metric(\"learning_rate_vs_epoch\", self.optimizer.param_groups[0]['lr'])\n self.train_one_epoch(train_dataloader)\n\n # validate \n if self.validate_after == 'epoch' and self.train_on_all_data == False and self.run_lr_range_test == False:\n validation_dataloader = self.data_module.get_valid_dataloader(\n batch_size=self.valid_batch_size, \n shuffle=self.train_dataloader_shuffle, \n num_workers=self.dataloader_num_workers, \n pin_memory=True\n )\n self.validate_one_epoch(validation_dataloader)\n\n if self.scheduler:\n if self.step_scheduler_after == 'epoch': \n if self.step_scheduler_metric == 'val_auc':\n self.scheduler.step(self.metrics['valid'][-1]['auc_score'])\n else:\n self.scheduler.step()\n\n if self.run_lr_range_test:\n neptune.log_metric('validation_epoch_end_AUC_vs_LR', \n self.scheduler.get_last_lr()[0], y=self.metrics['valid'][-1]['auc_score'])\n\n # checkpoint model for resuming model\n if (self.current_epoch % self.checkpoint_epochs) == 0:\n self.save_checkpoint()\n\n # sleep the training process\n if self.current_epoch % self.sleep_in_epochs == 0:\n print(f\"SLEEPING FOR {self.sleep_time} at epoch={self.current_epoch}\")\n for i in range(int(self.sleep_time/30)):\n time.sleep(i)\n neptune.log_metric(\"sleeping_status\", y=1)\n\n stop_training = self.stopping_criteria()\n if stop_training:\n if self.fp16:\n self.scaler.step(self.optimizer)\n self.scaler.update()\n self.optimizer.zero_grad()\n else:\n self.optimizer.step()\n self.optimizer.zero_grad()\n # backward all the accumulate gradients\n print(f\"stopped training at {self.current_epoch} epoch\")\n break","def _sp_train(self, max_steps, instances, visualize, plot):\n # Keep track of rewards per episode per instance\n episode_reward_sequences = [[] for i in range(instances)]\n episode_step_sequences = [[] for i in range(instances)]\n episode_rewards = [0] * instances\n\n # Create and initialize environment instances\n envs = [self.create_env() for i in range(instances)]\n envs[0].render(mode='human')\n states = [env.reset()['observation'][0] for env in envs] # get the image\n\n for step in range(max_steps):\n for i in range(instances):\n if visualize: envs[i].render()\n action, angle_index, action_index = self.agent.act(states[i], i)\n\n next_state, reward, done, _ = envs[i].step(action)\n (next_image, next_depth) = next_state['observation']\n self.agent.push(\n Transition(states[i], [angle_index, action_index], reward, None if done else next_image), i)\n episode_rewards[i] += reward\n if done:\n episode_reward_sequences[i].append(episode_rewards[i])\n episode_step_sequences[i].append(step)\n episode_rewards[i] = 0\n if plot: plot(episode_reward_sequences, episode_step_sequences)\n (image, depth) = envs[i].reset()['observation']\n states[i] = image\n else:\n states[i] = next_image\n # Perform one step of the optimization\n self.agent.train(step)\n\n if plot: plot(episode_reward_sequences, episode_step_sequences, done=True)","def train_models(self):\n\n #keep track on the number of iterations (needed to scale lambda)\n nr_iteration = 0\n \n for epoch in range(self.epochs):\n start = time.time()\n print()\n print(epoch + 1)\n print()\n for step, batch in enumerate(self.training_data):\n X_batch = normalize_images(tf.cast(batch[0], 'float32'))\n Y_batch = batch[1]\n Z_batch = self.ae_model.encode(X_batch)\n \n self.train_step_disc(Z_batch, Y_batch)\n # Call only one tf.function when tracing.\n #ADD LAMBDA SCHEDULE ACCORDING TO OUR EXPERIMENTS AND EPOCH LENGTH\n self.scale_lambda(self.lambda_e, nr_iteration)\n self.train_step_ae(X_batch, Y_batch, Z_batch)\n\n nr_iteration += 1\n end = time.time()\n print(\"Epoch \" + str(epoch + 1) + \" takes \" + str(end - start))","def getTrainEpisodes(self):\n print(\"Do you want to train the IA?\")\n while True:\n num_episodes = raw_input(\"Type number iterations to train, [0] to not train: \")\n try:\n if int(num_episodes) >= 0:\n return int(num_episodes)\n print(\"Invalid input, try again\")\n except:\n print(\"Invalid input, try again\")\n return","def train(self):\n tic = time.time()\n means = []\n stds = []\n steps = 0\n scores_window = deque(maxlen=100)\n for e in range(1,self.episodes):\n\n self.noise.step()\n episode_scores = []\n obs = self.env.reset()\n for t in range(self.tmax):\n actions = self.act(obs)\n next_obs,rewards,dones = self.env.step(actions)\n\n # Store experience\n if np.max(rewards) > 0:\n print('hit the ball over the net',rewards)\n self.R.add(obs.reshape(1,48),obs,actions,rewards,next_obs.reshape(1,48),next_obs,dones)\n obs = next_obs\n # Score tracking\n episode_scores.append(np.max(rewards))\n \n # Learn\n if len(self.R) > self.min_buffer_size:\n for _ in range(self.SGD_epoch):\n # Update each agent\n for i in range(self.num_agents):\n self.learn(i)\n # update target networks\n self.update_targets_all()\n \n steps += int(t)\n means.append(np.mean(episode_scores))\n stds.append(np.std(episode_scores))\n scores_window.append(np.sum(episode_scores))\n if e % 4 == 0:\n toc = time.time()\n r_mean = np.mean(scores_window)\n r_max = max(scores_window)\n r_min = min(scores_window)\n r_std = np.std(scores_window)\n plot(self.name,means,stds)\n print(\"\\rEpisode: {} out of {}, Steps {}, Rewards: mean {:.2f}, min {:.2f}, max {:.2f}, std {:.2f}, Elapsed {:.2f}\".format(e,self.episodes,steps,r_mean,r_min,r_max,r_std,(toc-tic)/60))\n if np.mean(scores_window) > self.winning_condition:\n print('Env solved!')\n # save scores\n pickle.dump([means,stds], open(str(self.name)+'_scores.p', 'wb'))\n # save policy\n self.save_weights(self.critic_path,self.actor_path)\n break","def setup_training(self):\n print('setup training called')\n self.steps_done = 0\n self.current_episode_num = 1\n self.total_reward = 0\n\n # self.optimizer = optim.RMSprop(policy_net.parameters())\n self.memory = ReplayMemory(300000)\n self.total_reward_history = []\n # self.loss_history = []\n self.positions = []\n self.n_destroyed_crates = 0\n self.is_in_bomb_range = False","def train_step(self):\n pass","def train(self, x, t):\n for i in range(self.number_model):\n curr_model = self.all_model[i]\n curr_model.fit(x, t)","def train(self):\n total_steps = 0\n scores_history = [deque(maxlen=self.run_settings.averaging_window)\n for a in range(len(self.agents))]\n averages_history = [[] for a in range(len(self.agents))]\n\n for e in range(self.run_settings.num_episodes):\n # Initialize episode\n try:\n env_states, rewards, done, metainfo = self.custom_env.reset()\n except EpisodeCrashException:\n for a in range(len(self.agents)):\n if hasattr(self.agents[a], 'notify_episode_crashed'):\n self.agents[a].notify_episode_crashed(self.run_settings)\n continue\n\n # Initialize scores to starting reward (probably 0)\n scores = rewards\n step = 0\n\n while not done:\n states = [self.agents[a].state_space_converter(env_states[a])\n for a in range(len(self.agents))]\n\n # Train agents\n if total_steps > 0 and total_steps % self.run_settings.train_every == 0:\n for agent in self.agents:\n agent.train(self.run_settings)\n\n # Save agent model\n if total_steps > 0 and total_steps % self.run_settings.save_every == 0:\n for agent in self.agents:\n agent.save()\n\n # Get actions\n actions = [self.agents[a].sample(states[a])\n for a in range(len(self.agents))]\n env_actions = [self.agents[a].action_space_converter(actions[a])\n for a in range(len(self.agents))]\n # Take environment step\n try:\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\n except EpisodeCrashException:\n for a in range(len(self.agents)):\n if hasattr(self.agents[a], 'notify_episode_crashed'):\n self.agents[a].notify_episode_crashed(self.run_settings)\n break\n step += 1\n total_steps += 1\n\n # Update scores\n scores = [scores[a] + rewards[a] for a in range(len(self.agents))]\n # Push to agent Memories\n for a in range(len(self.agents)):\n self.agents[a].push_memory(states[a], actions[a], rewards[a], done)\n\n if done:\n averages = []\n for a in range(len(scores_history)):\n scores_history[a].append(scores[a])\n averages.append(np.mean(scores_history[a]))\n averages_history[a].append(averages[a])\n\n if len(scores) == 1:\n scores = scores[0]\n averages = averages[0]\n if self.run_settings.verbose:\n print(\"Game {} ended after {} steps. Game score: {}. Averages: {}\"\n .format(e+1, step, scores, averages))\n if (self.run_settings.graph_every > 0 and e > 0\n and e % self.run_settings.graph_every == 0):\n self.plot_results(averages_history)","def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()","def train_dqn(self, n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n self.scores = [] # list containing scores from each episode\n scores_window = deque(maxlen=100) # last 100 scores\n eps = eps_start # initialize epsilon\n for i_episode in range(1, n_episodes+1):\n env_info = self.env.reset(train_mode=True)[self.brain_name] # reset the environment\n state = env_info.vector_observations[0] # get the current state\n score = 0 # initialize the score\n for t in range(max_t):\n action = self.agent.act(state, eps)\n env_info = self.env.step(action)[self.brain_name] # send the action to the environment\n next_state = env_info.vector_observations[0] # get the next state\n reward = env_info.rewards[0] # get the reward\n done = env_info.local_done[0] # see if episode has finished\n self.agent.step(state, action, reward, next_state, done)\n state = next_state\n score += reward\n if done:\n break \n scores_window.append(score) # save most recent score\n self.scores.append(score) # save most recent score\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n if i_episode % 100 == 0:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n # we use 15.0 just to be sure\n if np.mean(scores_window)>=self.threshold:\n print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n break\n return self.scores","def train_agent(\n self,\n *,\n env,\n test_env,\n save_name,\n train_every=1,\n max_episodes=1000,\n center_returns=True,\n render=True,\n ):\n\n agent = self.create_agent(env)\n\n for episode in range(1, max_episodes + 1):\n obs = env.reset()\n done = False\n\n episode_return = 0.0\n while not done:\n action = agent.act(obs, deterministic=False)\n next_obs, reward, done, _ = env.step(action)\n episode_return += reward\n agent.store_step(obs, action, reward, next_obs, done)\n obs = next_obs\n\n if render:\n env.render()\n\n if episode % train_every == 0:\n agent.perform_training(\n gamma=self.gamma, center_returns=center_returns\n )\n torch.save(agent, f\"saved_agents/{save_name}\")\n\n print(\"Episode {} -- return={}\".format(episode, episode_return))\n return agent","def train(\n env: DiscreteEnvironment[TState, TAction],\n agent: DiscreteAgent[TState, TAction],\n n_episodes: int,\n on_action: Callable[[TState, TAction, float, int], None] = None,\n on_episode_end: Callable[[int], None] = None,\n) -> None:\n for ep in range(n_episodes):\n t = 0\n while not env.terminated:\n s, a, r = agent.act_and_train(t) # returns (S_t, A_t, R_t)\n if on_action:\n on_action(s, a, r, t)\n t += 1\n agent.episode_end()\n if on_episode_end:\n on_episode_end(t)\n env.reset()","def train(cls,\n training,\n pdf_model,\n t_x,\n t_y):\n batch_size, num_epochs, num_episodes, samples, max_noise, min_noise = training()\n\n h_l = None\n h_vl = None\n\n idx = np.arange(cls.test_set_size)\n np.random.shuffle(idx)\n idx = idx[:samples]\n\n s_x = t_x[idx]\n s_y = t_y[idx]\n for i in range(0, num_episodes):\n print('>>>>>')\n print('EPISODE: ' + str(i))\n if max_noise > 0:\n sp = np.shape(s_y)\n s_y_r = np.random.rand(sp[0], sp[1])\n s_y_n = s_y * s_y_r * cls.noise_factor(epoch=i,\n max_epoch=num_episodes,\n max_noise=max_noise,\n min_noise=min_noise)\n s_y_n = s_y + ((s_y / 2.0) - s_y_n)\n\n history = pdf_model.fit(s_x,\n s_y_n,\n epochs=num_epochs,\n batch_size=batch_size,\n shuffle=True,\n validation_split=0.15,\n verbose=2\n )\n hl = history.history['loss']\n hv = history.history['val_loss']\n if h_l is None:\n h_l = hl\n h_vl = hv\n else:\n h_l = h_l + hl\n h_vl = h_vl + hv\n\n _p = np.zeros((1, cls.action_size))\n _p[0] = s_x[0]\n pr = model.predict(_p)\n cls.kld(s_y[0], pr)\n print('<<<<<')\n\n cls.plot_results(h_l, h_vl, (num_epochs * (i + 1)))\n cls.save_hist(history)\n return","def fit(self, num_iterations, max_episode_length=250, eval_every_nth=1000, save_model_every_nth=1000, log_loss_every_nth=1000, video_every_nth=20000):\n self.compile()\n self.policy = LinearDecayGreedyEpsilonPolicy(start_value=1., end_value=0.1, num_steps=1e6, num_actions=self.num_actions) # for training\n self.replay_memory = ReplayMemory(max_size=1000000)\n self.log_loss_every_nth = log_loss_every_nth\n random_policy = UniformRandomPolicy(num_actions=self.num_actions) # for burn in \n num_episodes = 0\n\n # tf logging\n self.tf_session = K.get_session()\n self.tf_summary_writer = tf.summary.FileWriter(self.log_dir, self.tf_session.graph)\n\n while self.iter_ctr < num_iterations:\n state = self.env.reset()\n self.preprocessor.reset_history_memory()\n\n num_timesteps_in_curr_episode = 0\n total_reward_curr_episode = 0 \n\n while num_timesteps_in_curr_episode < max_episode_length:\n self.iter_ctr+=1 # number of steps overall\n num_timesteps_in_curr_episode += 1 # number of steps in the current episode\n\n # logging\n # if not self.iter_ctr % 1000:\n # print \"iter_ctr {}, num_episodes : {} num_timesteps_in_curr_episode {}\".format(self.iter_ctr, num_episodes, num_timesteps_in_curr_episode)\n\n # this appends to uint8 history and also returns stuff ready to be spit into the network\n state_network = self.preprocessor.process_state_for_network(state) #shape is (4,84,84,1). axis are swapped in cal_q_vals\n # print \"shape {}, max {}, min {}, type {} \".format(state_network.shape, np.max(state_network), np.min(state_network), state_network.dtype)\n\n # burning in \n if self.iter_ctr < self.num_burn_in:\n action = random_policy.select_action() # goes from 0 to n-1\n next_state, reward, is_terminal, _ = self.env.step(action)\n reward_proc = self.preprocessor.process_reward(reward)\n total_reward_curr_episode += reward_proc\n state_proc_memory = self.preprocessor.process_state_for_memory(state)\n # atari_preprocessor.process_state_for_memory converts it to grayscale, resizes it to (84, 84) and converts to uint8\n self.replay_memory.append(state_proc_memory, action, reward_proc, is_terminal)\n\n if is_terminal or (num_timesteps_in_curr_episode > max_episode_length-1):\n state = self.env.reset()\n num_episodes += 1\n with tf.name_scope('summaries'):\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_no_of_episodes', value=total_reward_curr_episode, step=num_episodes)\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_iterations', value=total_reward_curr_episode, step=self.iter_ctr)\n print \"iter_ctr {}, num_episodes : {}, episode_reward : {}, loss : {}, episode_timesteps : {}, epsilon : {}\".format\\\n (self.iter_ctr, num_episodes, total_reward_curr_episode, self.loss_last, num_timesteps_in_curr_episode, self.policy.epsilon)\n num_timesteps_in_curr_episode = 0\n self.dump_train_episode_reward(total_reward_curr_episode)\n # this should be called when num_timesteps_in_curr_episode > max_episode_length, but we can call it in is_terminal as well. \n # it won't change anything as it just sets the last entry's is_terminal to True\n self.replay_memory.end_episode() \n break\n\n # training\n else:\n # print \"iter_ctr {}, num_episodes : {} num_timesteps_in_curr_episode {}\".format(self.iter_ctr, num_episodes, num_timesteps_in_curr_episode)\n q_values = self.calc_q_values(state_network)\n # print \"q_values {} q_values.shape {}\".format(q_values, q_values.shape)\n #print \"q_values.shape \", q_values.shape\n action = self.policy.select_action(q_values=q_values, is_training=True)\n next_state, reward, is_terminal, _ = self.env.step(action)\n reward_proc = self.preprocessor.process_reward(reward)\n total_reward_curr_episode += reward_proc\n state_proc_memory = self.preprocessor.process_state_for_memory(state)\n self.replay_memory.append(state_proc_memory, action, reward_proc, is_terminal)\n\n # validation. keep this clause before the breaks!\n if not(self.iter_ctr%eval_every_nth):\n print \"\\n\\nEvaluating at iter {}\".format(self.iter_ctr)\n if not(self.iter_ctr%video_every_nth):\n self.evaluate(num_episodes=20, max_episode_length=max_episode_length, gen_video=True)\n else:\n self.evaluate(num_episodes=20, max_episode_length=max_episode_length, gen_video=False)\n print \"Done Evaluating\\n\\n\"\n\n # save model\n if not(self.iter_ctr%save_model_every_nth):\n self.q_network.save(os.path.join(self.log_dir, 'weights/q_network_{}.h5'.format(str(self.iter_ctr).zfill(7))))\n\n if is_terminal or (num_timesteps_in_curr_episode > max_episode_length-1):\n state = self.env.reset()\n num_episodes += 1\n with tf.name_scope('summaries'):\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_no_of_episodes', value=total_reward_curr_episode, step=num_episodes)\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_iterations', value=total_reward_curr_episode, step=self.iter_ctr)\n print \"iter_ctr {}, num_episodes : {}, episode_reward : {}, loss : {}, episode_timesteps : {}, epsilon : {}\".format\\\n (self.iter_ctr, num_episodes, total_reward_curr_episode, self.loss_last, num_timesteps_in_curr_episode, self.policy.epsilon)\n num_timesteps_in_curr_episode = 0\n self.dump_train_episode_reward(total_reward_curr_episode)\n self.replay_memory.end_episode() \n break\n\n if not(self.iter_ctr % self.train_freq):\n self.update_policy()\n\n state = next_state","def agents_train(self, game_step, episode_now, args):\n # update all trainers, if not in display or benchmark mode\n if episode_now < args.learning_start_episode: return \n if self.update_cnt > 0 and self.var >= self.min_var: self.var *= args.var_discount\n #if episode_now > self.last_update_episode and (episode_now - args.learning_start_episode) % args.learning_fre == 0:\n if game_step % args.learning_fre_step == 0:\n if self.update_cnt == 0: print('\\r=start training ...'+' '*100)\n self.last_update_episode = episode_now\n self.update_cnt += 1\n\n # update every agent in different memory batch\n for agent_idx, (actor_c, actor_t, critic_c, critic_t, opt_a, opt_c) in \\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, \\\n self.critics_tar, self.optimizers_a, self.optimizers_c)):\n # del if opt_c == None: continue # jump to the next model update\n\n # sample the experience\n _obs_n_o, _action_n, _rew_n, _obs_n_n, _done_n = self.memory.sample( \\\n args.batch_size, agent_idx) # Note_The func is not the same as others\n \n # --use the date to update the CRITIC\n rew = torch.tensor(_rew_n, device=args.device, dtype=torch.float) # set the rew to gpu\n done_n = torch.tensor(~_done_n, dtype=torch.float, device=args.device) # set the rew to gpu\n action_cur_o = torch.from_numpy(_action_n).to(args.device, torch.float)\n obs_n_o = torch.from_numpy(_obs_n_o).to(args.device, torch.float)\n obs_n_n = torch.from_numpy(_obs_n_n).to(args.device, torch.float)\n\n action_tar = torch.cat([a_t(obs_n_n[:, self.obs_size[idx][0]:self.obs_size[idx][1]]).detach() \\\n for idx, a_t in enumerate(self.actors_tar)], dim=1)\n q = critic_c(obs_n_o, action_cur_o).reshape(-1) # q \n q_ = critic_t(obs_n_n, action_tar).reshape(-1) # q_ \n q_ = q_*args.gamma*done_n + rew*torch.tensor(args.reward_scale_par, device=args.device) # q_*gamma*done + reward\n loss_c = torch.nn.MSELoss()(q, q_.detach()) # bellman equation\n opt_c.zero_grad()\n loss_c.backward()\n nn.utils.clip_grad_norm_(critic_c.parameters(), args.max_grad_norm)\n opt_c.step()\n\n # --use the data to update the ACTOR\n # There is no need to cal other agent's action\n opt_c.zero_grad()\n model_out, policy_c_new = actor_c( \\\n obs_n_o[:, self.obs_size[agent_idx][0]:self.obs_size[agent_idx][1]], model_original_out=True)\n # update the aciton of this agent\n action_cur_o[:, self.action_size[agent_idx][0]:self.action_size[agent_idx][1]] = policy_c_new \n loss_pse = torch.mean(torch.pow(model_out, 2))\n loss_a = torch.mul(torch.tensor(-1.0, device=args.device), torch.mean(critic_c(obs_n_o, action_cur_o)))\n\n opt_a.zero_grad()\n (2e-3*loss_pse+loss_a).backward()\n #loss_a.backward()\n nn.utils.clip_grad_norm_(actor_c.parameters(), args.max_grad_norm)\n opt_a.step()\n\n # save the model to the path_dir ---cnt by update number\n #if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model == 0:\n if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model_step == 0:\n time_now = time.strftime('%y%m_%d%H%M')\n print('=time:{} step:{} save'.format(time_now, game_step))\n model_file_dir = os.path.join(args.save_dir, '{}_{}_{}'.format( \\\n args.scenario_name, time_now, game_step))\n if not os.path.exists(model_file_dir): # make the path\n os.mkdir(model_file_dir)\n for agent_idx, (a_c, a_t, c_c, c_t) in \\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, self.critics_tar)):\n torch.save(a_c, os.path.join(model_file_dir, 'a_c_{}.pt'.format(agent_idx)))\n torch.save(a_t, os.path.join(model_file_dir, 'a_t_{}.pt'.format(agent_idx)))\n torch.save(c_c, os.path.join(model_file_dir, 'c_c_{}.pt'.format(agent_idx)))\n torch.save(c_t, os.path.join(model_file_dir, 'c_t_{}.pt'.format(agent_idx)))\n\n # update the tar par\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, args.tao) \n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, args.tao)","def trainNet():","def train(self):\n if len(self.experience) < self.minibatch_size:\n return\n\n # sample a minibatch_size of random episode with a number of transitions >= unrollings_num\n random_episodes_indecies = np.random.choice(len(self.experience), self.minibatch_size)\n random_episodes = []\n for index in random_episodes_indecies:\n episode = self.experience[index]\n\n # 0:random_transitions_space is the range from which a random transition\n # can be picked up while having unrollings_num - 1 transitions after it\n random_transitions_space = len(episode) - self.unrollings_num\n random_start = np.random.choice(random_transitions_space, 1)\n\n random_episodes.append(episode[random_start:random_start + self.unrollings_num])\n\n state_shape = tuple([self.minibatch_size, self.unrollings_num] + self.state_shape)\n\n # prepare the training data\n states = np.empty(state_shape, dtype=np.float32)\n next_states = np.empty(state_shape, dtype=np.float32)\n rewards = np.empty((self.minibatch_size, self.unrollings_num, ), dtype=np.float32)\n transition_action_filters = np.zeros((self.minibatch_size, self.unrollings_num, self.actions_count), dtype=np.float32)\n next_legal_actions_filters = np.zeros((self.minibatch_size, self.unrollings_num, self.actions_count), dtype=np.float32)\n\n for i, episode in enumerate(random_episodes):\n for j, transition in enumerate(episode):\n state, action, reward, nextstate, next_legal_actions = transition\n\n states[i,j], rewards[i,j], next_states[i,j] = state, reward, nextstate\n transition_action_filters[i,j][action] = 1.0\n next_legal_actions_filters[i,j][next_legal_actions] = 1.0\n\n self.prediction_nn.clearLSTMS(self.session)\n self.target_nn.clearLSTMS(self.session)\n\n loss,_ = self.session.run([self.loss, self.finalize], {\n self.states: states,\n self.next_states: next_states,\n self.rewards: np.reshape(rewards, (self.minibatch_size * self.unrollings_num, )),\n self.transition_action_filters: np.reshape(transition_action_filters, (self.minibatch_size * self.unrollings_num, self.actions_count)),\n self.next_legal_actions_filters: np.reshape(next_legal_actions_filters, (self.minibatch_size * self.unrollings_num, self.actions_count))\n })\n\n if self.iteration != 0 and self.iteration % self.freeze_period == 0:\n self.target_nn.assign_to(self.prediction_nn, self.session)\n\n self.iteration += 1\n\n return loss, self.iteration","def train_SN(model, optimizer, scheduler, episodes=1):\n model = model.to(device=device) # move the model parameters to CPU/GPU\n for episode in range(episodes):\n scheduler.step(episode)\n model.train() # set to train mode\n\n # make the samplers \n # make 2 samplers, one for the \"sample/training set\" of a one-shot classifier\n # other sampler is for the \"query/test set\" which provides many comparisons\n train_sample_sampler = SampleSampler(num_cl=NUM_CL)\n sampled_classes = train_sample_sampler.cl_list\n sampled_examples = train_sample_sampler.ex_list\n train_query_sampler = QuerySampler(sampled_classes, sampled_examples, num_inst=NUM_EX)\n\n # make the dataloaders\n s_batch_num = 1 # one shot \"training\" each\n q_batch_num = NUM_EX # pair up number of examples per class in a batch (default 19)\n train_sample_loader = DataLoader(omni_train, batch_size=s_batch_num, sampler=train_sample_sampler)\n train_query_loader = DataLoader(omni_train, batch_size=q_batch_num, sampler=train_query_sampler)\n \n # start training\n scores = torch.zeros(NUM_CL,(NUM_EX+NUM_CL-1)).to(device=device, dtype=dtype)\n targets = torch.zeros(NUM_CL,(NUM_EX+NUM_CL-1)).to(device=device, dtype=dtype)\n sample_count = 0\n for i, (sample, sample_label) in enumerate(train_sample_loader):\n sample_count += 1\n idx = 0\n for j, (batch, batch_labels) in enumerate(train_query_loader):\n if sample_label != batch_labels[0]:\n k = np.random.randint(NUM_EX)\n query = batch[k,:,:,:].to(device=device, dtype=dtype)\n query = query.view(1,1,IMG_SIZE,IMG_SIZE)\n sample = sample.to(device=device, dtype=dtype)\n targets[i,idx] = make_target(sample_label, batch_labels[0])\n scores[i,idx] = model(sample,query)\n idx += 1\n \n elif sample_label == batch_labels[0]:\n for k in range(NUM_EX):\n query = batch[k,:,:,:].to(device=device, dtype=dtype)\n query = query.view(1,1,IMG_SIZE,IMG_SIZE)\n sample = sample.to(device=device, dtype=dtype)\n targets[i,idx] = make_target(sample_label, batch_labels[0])\n scores[i,idx] = model(sample,query)\n idx += 1\n \n targets = targets.view(-1)\n scores = scores.view(-1)\n \n # train and update model\n optimizer.zero_grad()\n #loss = F.binary_cross_entropy(scores, targets)\n loss = F.mse_loss(scores, targets)\n loss.backward()\n #nn.utils.clip_grad_norm_(model.parameters(),0.5)\n optimizer.step()\n\n # episodic updates\n if (episode+1)%100 == 0:\n print(\"episode:\",episode+1,\"loss\",loss.data)\n\n if (episode+1)%1000 == 0:\n ''' Test the model '''\n # make the samplers \n test_sample_sampler = SampleSampler(total_cl=659)\n sampled_classes = test_sample_sampler.cl_list\n sampled_examples = test_sample_sampler.ex_list\n test_query_sampler = QuerySampler(sampled_classes, sampled_examples, num_inst=1)\n\n # make the dataloaders\n s_batch_num = 1 # one shot each\n q_batch_num = 1 # one test each\n test_sample_loader = DataLoader(omni_test, batch_size=s_batch_num, sampler=test_sample_sampler)\n test_query_loader = DataLoader(omni_test, batch_size=q_batch_num, sampler=test_query_sampler)\n check_accuracy(test_sample_loader, test_query_loader, model)\n\n if (episode+1)%100000 == 0:\n \"\"\" Save as a draft model \"\"\"\n torch.save(model.state_dict(), PATH)","def train():\n # YOUR TRAINING CODE GOES HERE","def start_training(self):\n i = 0\n for _ in range(self.train_steps):\n print(f\"Start Training Step {i + 1}\")\n self.model.learn(total_timesteps=self.total_time_steps)\n self.model.save(self.save_path)\n print(f\"Finished Training Step {i + 1}\")\n i += 1","def _train_epoch(self, model, tqdm_data,\n optimizer_disc=None, optimizer_gen=None):","def train_epoch(self):\r\n for loader in self.loaders:\r\n if self.epoch % loader.epoch_interval == 0:\r\n self.cycle_dataset(loader)\r\n\r\n self._stats_new_epoch()\r\n self._write_tensorboard()\r\n print('{}th epoch train / eval done!'.format(self.epoch))","def train_multiple_eps(self, env, no_episodes=200, horizon=1000, lr=0.1):\n\n\t\tr_vec = []\n\t\tep_len_vec = []\n\t\tfor i in range(no_episodes):\n\n\t\t\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\n\t\t\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the information\n\t\t\tr_vec.append(r_ep)\n\t\t\tep_len_vec.append(ep_len)\n\n\t\treturn r_vec, ep_len_vec","def train(self):\r\n\r\n for cur_epoch in range(self.model.cur_epoch_tensor.eval(self.sess), self.config.num_epochs + 1, 1):\r\n self.train_epoch(cur_epoch)\r\n self.model.global_step_assign_op.eval(session=self.sess, feed_dict={\r\n self.model.global_step_input: self.model.global_step_tensor.eval(self.sess) + 1})","def train():\n pass","def train_step(self):\n step_actions = self.get_step_actions()\n *_, dones, _ = tf.numpy_function(\n self.step_envs, [step_actions, True, True], self.batch_dtypes\n )\n for done_idx in tf.where(dones):\n gradient_steps = self.gradient_steps or self.episode_steps[done_idx[0]]\n self.update_weights(gradient_steps)\n self.episode_steps.assign(\n (self.episode_steps + self.step_increment) * (1 - dones)\n )","def train(self, epoches, batch_size):\n def _padding_batch(x_inputs, y_inputs):\n # x_inputs is 2-d array\n max_length = max([len(x) for x in x_inputs])\n real_length = [len(x) for x in x_inputs]\n\n x_outputs = []\n for x in x_inputs:\n padding_size = max_length - len(x)\n x_outputs.append(\n np.concatenate([np.array(x), np.zeros(padding_size,\n dtype=\"int32\")]))\n return np.array(x_outputs), np.array(y_inputs), real_length\n\n\n x_inputs, y_inputs = self.convert_data_to_model_input(self.train_data)\n test_x_inputs, test_y_inputs = self.convert_data_to_model_input(self.test_data, add_unknow_words=False)\n test_x_inputs, test_y_inputs, test_real_length = _padding_batch(test_x_inputs,\n test_y_inputs)\n\n self.save_lexicon(\"log/lexicon\")\n\n train_x_inputs = x_inputs[0:11000]\n train_y_inputs = y_inputs[0:11000]\n\n validate_x_inputs = x_inputs[11000:]\n validate_y_inputs = y_inputs[11000:]\n validate_x_inputs, validate_y_inputs, validate_real_length = _padding_batch(\n validate_x_inputs, validate_y_inputs)\n\n assert len(train_y_inputs) == len(train_x_inputs)\n assert len(validate_y_inputs) == len(validate_x_inputs)\n print(\"train {} validate {} test {}\".format(len(train_y_inputs),\n len(validate_y_inputs), len(test_y_inputs)))\n assert len(self.vocab) == len(self.embeddings)\n\n # do training\n batches = len(train_y_inputs) // batch_size\n\n rnn_model = RnnTextClassifyModel(\n class_number=len(self.labels), learning_rate=0.01,\n gradients_norm=5, keep_rate=0.5, vocab_size=len(self.vocab),\n embedding_size=self.embedding_size, hidden_units_size=128)\n\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n\n # must assigned\n embedding_input = tf.constant(np.array(self.embeddings), dtype=tf.float32)\n assign_embedding_op = tf.assign(rnn_model.embeddings, embedding_input)\n embedding_in_graph = sess.run(assign_embedding_op);\n\n global_step = 0\n for epoch in range(epoches):\n print(\"training @ epoch \", epoch)\n for i in range(batches):\n\n x_inputs_batch = train_x_inputs[i * batch_size:(i+1) *\n batch_size]\n y_inputs_batch = train_y_inputs[i * batch_size:(i+1) *\n batch_size]\n x_inputs_batch, y_inputs_batch, real_length = _padding_batch(\n x_inputs_batch, y_inputs_batch)\n\n loss_val, _ = sess.run(\n [rnn_model.loss, rnn_model.train_op],\n {rnn_model.x_holder:x_inputs_batch,\n rnn_model.y_holder:y_inputs_batch,\n rnn_model.sequence_length: real_length})\n\n print(\"loss {} @ step {}\".format(loss_val, global_step))\n\n #saver.save(sess, \"log/cnn_model\", global_step=global_step)\n global_step += 1\n\n if global_step % 100 == 0:\n print(\"______validating\")\n accuracy_val = sess.run(rnn_model.accuracy,\n {rnn_model.x_holder: validate_x_inputs,\n rnn_model.y_holder: validate_y_inputs,\n rnn_model.sequence_length: validate_real_length,\n rnn_model.keep_rate : 1.0})\n print(\"______valiation_accuracy {} at step {}\".format(accuracy_val,\n global_step))\n\n accuracy_val = sess.run(rnn_model.accuracy,\n {rnn_model.x_holder: x_inputs_batch,\n rnn_model.y_holder: y_inputs_batch,\n rnn_model.sequence_length: real_length,\n rnn_model.keep_rate : 1.0})\n print(\"______train_accuracy {} at step {}\".format(accuracy_val,\n global_step))\n\n\n if batches * batch_size < len(train_y_inputs):\n x_inputs_batch = train_x_inputs[batches * batch_size:]\n y_inputs_batch = train_y_inputs[batches * batch_size:]\n x_inputs_batch, y_inputs_batch, real_length = _padding_batch(\n x_inputs_batch, y_inputs_batch)\n\n loss_val, _ = sess.run(\n [rnn_model.loss, rnn_model.train_op],\n {rnn_model.x_holder:x_inputs_batch,\n rnn_model.y_holder:y_inputs_batch,\n rnn_model.sequence_length: real_length})\n\n print(\"loss {} @ step {}\".format(loss_val, global_step))\n global_step += 1\n\n # do evaluate on test data\n print(\"______test accuracy on epoch \", epoch)\n accuracy_val = sess.run(rnn_model.accuracy,\n {rnn_model.x_holder: test_x_inputs,\n rnn_model.y_holder: test_y_inputs,\n rnn_model.sequence_length: test_real_length,\n rnn_model.keep_rate : 1.0})\n\n print(\"______test_accuracy {} at epoch {}\".format(accuracy_val,\n epoch))","def train_workers(self):\n args = dict(actor=self.actor,\n critic=self.critic,\n gamma=self.gamma,\n lamda=self.lamda or self.gamma / 1.005,\n device=self.device,\n optimizers=[self.actor_optimizer, self.critic_optimizer])\n workers = [Worker(i, self.action_size, self.state_size, **args)\n for i in range(self.n_workers)\n ]\n\n print(f'Worker count: {len(workers)}')\n\n for worker in workers:\n worker.start()\n\n while len(constants.scores) < self.n_steps:\n time.sleep(400) # save checkpoint every 400 ms\n\n print(f'\\nCurrent scores: {constants.scores}')\n\n self.save(constants.episode)\n print(f'\\nCheckpoint saved at episode: {constants.episode}\\n')","def train_fru(model, epochs=EPOCHS):\n train(model, epochs=epochs, dataset=FRUDataset)","def train_multiple_eps_dynamic(self, env, no_episodes=200, ng_int=50, horizon=1000, lr=0.1):\n\n\t\tr_vec = []\n\t\tep_len_vec = []\n\t\ttasks = 0\n\t\tfor i in range(no_episodes):\n\t\t\tif(i % ng_int == 0):\n\t\t\t\tgoal_index = [0, 12, 156, 168]\n\t\t\t\tnew_goal = [goal_index[tasks]]\n\t\t\t\ttasks += 1\n\t\t\t\tenv.reset(loc_r=new_goal, loc_t=new_goal)\n\t\t\t\t# new_goal = sample(env.listGoalStates(), 1)\n\t\t\t\t# env.reset(loc_r=new_goal, loc_t=new_goal)\n\n\t\t\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\n\t\t\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the information\n\t\t\tr_vec.append(r_ep)\n\t\t\tep_len_vec.append(ep_len)\n\n\t\treturn r_vec, ep_len_vec","def train(self, environment, seed=0):\n # set the seeds\n np.random.seed(seed)\n environment.seed(seed)\n # prepare the file for the results\n save_results = SaveResults()\n save_results.set_seed(seed)\n\n # prepare to display the states\n if self.parameters[\"display_environment\"]:\n self.show_render = ShowRender()\n\n for t in tqdm(range(1, self.parameters[\"number_episodes\"] + 1)):\n self._train_simulate(environment, t)\n\n if not t % 200:\n save_results.write_message_in_a_file(\"score\", self.score)","def fit(self, env, env_eval, num_iterations, max_episode_length=None):\n train_counter = 0;\n eval_res_hist = np.zeros((1,3));\n\n time_this, ob_this, is_terminal = env.reset()\n\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\n\n setpoint_this = ob_this[6:8]\n \n this_ep_length = 0;\n flag_print_1 = True;\n flag_print_2 = True;\n action_counter = 0;\n \n for step in range(num_iterations):\n #Check which stage is the agent at. If at the collecting stage,\n #then the actions will be random action.\n if step <= self._num_burn_in:\n if flag_print_1:\n logging.info (\"Collecting samples to fill the replay memory...\");\n flag_print_1 = False;\n\n action_mem = self.select_action(None, stage = 'collecting');\n action = self._policy.process_action(setpoint_this, action_mem)\n\n else:\n if flag_print_2:\n logging.info (\"Start training process...\");\n flag_print_2 = False;\n\n obs_this_net = self._preprocessor.process_observation_for_network(\n ob_this, self._min_array, self._max_array)\n \n state_this_net = np.append(obs_this_net[0:13], obs_this_net[14:]).reshape(1,16)\n\n action_mem = self.select_action(state_this_net, stage = 'training')\n # covert command to setpoint action \n action = self._policy.process_action(setpoint_this, action_mem) \n\n action_counter = action_counter + 1 if action_counter < 4 else 1;\n\n time_next, ob_next, is_terminal = env.step(action)\n ob_next = self._preprocessor.process_observation(time_next, ob_next)\n \n setpoint_next = ob_next[6:8]\n \n #check if exceed the max_episode_length\n if max_episode_length != None and \\\n this_ep_length >= max_episode_length:\n is_terminal = True;\n\n #save sample into memory \n self._memory.append(Sample(ob_this, action_mem, ob_next\n , is_terminal))\n\n \n #Check which stage is the agent at. If at the training stage,\n #then do the training\n if step > self._num_burn_in:\n #Check the train frequency\n if action_counter % self._train_freq == 0 \\\n and action_counter > 0:\n action_counter = 0;\n #Eval the model\n if train_counter % self._eval_freq == 0:\n eval_res = self.evaluate(env_eval, self._eval_epi_num\n , show_detail = True);\n eval_res_hist = np.append(eval_res_hist\n , np.array([step\n , eval_res[0], eval_res[1]]).reshape(1, 3)\n , axis = 0);\n np.savetxt(self._log_dir + '/eval_res_hist.csv'\n , eval_res_hist, delimiter = ',');\n logging.info ('Global Step: %d, '%(step), 'evaluation average \\\n reward is %0.04f, average episode length is %d.'\\\n %eval_res);\n \n \n #Sample from the replay memory\n samples = self._preprocessor.process_batch(\n self._memory.sample(self._batch_size), \n self._min_array, self._max_array);\n #Construct target values, one for each of the sample \n #in the minibatch\n samples_x = None;\n targets = None;\n for sample in samples:\n sample_s = np.append(sample.obs[0:13], sample.obs[14:]).reshape(1,16)\n sample_s_nex = np.append(sample.obs_nex[0:13], \n sample.obs_nex[14:]).reshape(1,16)\n sample_r = self._preprocessor.process_reward(sample.obs_nex[12:15])\n\n target = self.calc_q_values(sample_s);\n a_max = self.select_action(sample_s_nex, stage = 'greedy');\n \n \n\n if sample.is_terminal:\n target[0, sample.a] = sample_r;\n else:\n target[0, sample.a] = (sample_r\n + self._gamma \n * self.calc_q_values_1(\n sample_s_nex)[0, a_max]);\n if targets is None:\n targets = target;\n else:\n targets = np.append(targets, target, axis = 0);\n if samples_x is None:\n samples_x = sample_s;\n else:\n samples_x = np.append(samples_x, sample_s, axis = 0);\n #Run the training\n \n \n feed_dict = {self._state_placeholder:samples_x\n ,self._q_placeholder:targets}\n sess_res = self._sess.run([self._train_op, self._loss]\n , feed_dict = feed_dict);\n \n #Update the target parameters\n if train_counter % self._target_update_freq == 0:\n self.update_policy();\n logging.info('Global Step %d: update target network.' \n %(step));\n #Save the parameters\n if train_counter % self._save_freq == 0 or step + 1 == num_iterations:\n checkpoint_file = os.path.join(self._log_dir\n , 'model_data/model.ckpt');\n self._saver.save(self._sess\n , checkpoint_file, global_step=step);\n \n if train_counter % 100 == 0:\n logging.info (\"Global Step %d: loss %0.04f\"%(step, sess_res[1]));\n # Update the events file.\n summary_str = self._sess.run(self._summary, feed_dict=feed_dict)\n self._summary_writer.add_summary(summary_str, train_counter);\n self._summary_writer.add_graph(self._sess.graph);\n self._summary_writer.flush()\n \n train_counter += 1;\n \n #check whether to start a new episode\n if is_terminal:\n time_this, ob_this, is_terminal = env.reset()\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\n setpoint_this = ob_this[6:8]\n\n this_ep_length = 0;\n action_counter = 0;\n else:\n ob_this = ob_next\n setpoint_this = setpoint_next\n time_this = time_next\n this_ep_length += 1;","def train(self, iterations=1):\n for _ in range(iterations):\n self.trainer.train()\n self.test_network()","def TrainOneStep(self):\n pass","def run(num_epochs, encoded_dim):\n # for patient_ in get_patient_ids():\n for patient_ in ['16']:\n print(\"Starting on index: \" + str(patient_))\n training_ae(num_epochs, encoded_dim, patient_, True)\n print(\"Completed \" + str(patient_) + \" reconstruction and encoding, saved test data to assess performance\")","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def train_by_episode(self, last_value=0):\n # implements A2C training from the last state\n # to the first state\n # discount factor\n gamma = 0.95\n r = last_value\n # the memory is visited in reverse as shown\n # in Algorithm 10.5.1\n for item in self.memory[::-1]:\n [step, state, next_state, reward, done] = item\n # compute the return\n r = reward + gamma*r\n item = [step, state, next_state, r, done]\n # train per step\n # a2c reward has been discounted\n self.train(item)","def train(env, agents, data_log, n_episodes=10000, n_steps=None, generate_val_data=False, record_env=None, trainer=None):\n # Setup logging and start code\n logger = logging.getLogger('root')\n step_tot = 0\n logger.info(env.observation_space[0].high)\n alphas = [agent.alpha for agent in trainer.agents]\n data_log.log_var(\"alphas\", alphas)\n\n ep_generator = range(n_episodes) if n_episodes else itertools.count()\n # Start training\n for i in ep_generator:\n # Do some logging\n logger.info(\"episode:\" + str(i))\n data_log.set_episode(i)\n\n # Periodically store networks\n if i % 250 == 0: #was 25\n store_networks(trainer, agents, data_log)\n\n # Run a single episode\n score, step, extra_data = run_episode(env, agents, render=False, store_data=True, trainer=trainer)\n\n # Do more logging\n logger.info(\"Score: \" + str(score))\n step_tot += step\n data_log.set_step(step_tot)\n data_log.log_var(\"score\", score)\n alphas = [agent.alpha for agent in trainer.agents]\n data_log.log_var(\"alphas\", alphas)\n\n # Break training loop\n if n_steps and step_tot > n_steps:\n break\n\n #Periodically save logs\n if i % 50 == 0: #was 5\n logger.info(\"Saving log...\")\n data_log.save()\n logger.info(\"Saved log\")\n\n # Save logs one last time\n logger.info(\"Saving log...\")\n data_log.save()\n logger.info(\"Saved log\")\n return","def Q_learning_train(env,alpha,gamma,epsilon,episodes):\n %time\n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n if random.uniform(0, 1) < epsilon:\n action = env.action_space.sample() # Explore action space randomly\n else:\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n\n next_state, reward, done, info = env.step(action) \n\n old_value = q_table[state, action]\n next_max = np.max(q_table[next_state])\n\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n q_table[state, action] = new_value\n\n if reward == -10:\n penalties += 1\n \n\n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n rewards.append(np.sum(episode_rewards))\n \n if i % 1000 == 0:\n clear_output(wait=True)\n print(f\"Episode: {i}\")\n \n \n print(\"Training finished.\\n\")\n \n plt.plot(savgol_filter(rewards, 1001, 3, mode = \"interp\"))\n plt.title(\"Smoothened training reward per episode\", pad = 30, size = BIGGER_SIZE)\n plt.legend()\n plt.xlabel('Episodes', labelpad = 20);\n plt.ylabel('Total Reward', labelpad = 20);\n plt.tick_params(axis='both', which='major');\n plt.tick_params(axis='both', which='minor');\n #plt.xlim(0, 60000);\n #plt.ylim(0,50)\n #plt.xticks(np.arange(0, episodes+1, 5000));\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def learn(self):\n\n for i in range(1, self.args.numIters + 1):\n # bookkeeping\n log.info(f'Starting Iter #{i} ...')\n # examples of the iteration\n if not self.skipFirstSelfPlay or i > 1:\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\n\n for _ in tqdm(range(self.args.numEps), desc=\"Self Play\"):\n self.mcts = MCTS(self.game, self.nnet, self.args) # reset search tree\n iterationTrainExamples += self.executeEpisode()\n\n # save the iteration examples to the history \n self.trainExamplesHistory.append(iterationTrainExamples)\n\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\n log.warning(\n f\"Removing the oldest entry in trainExamples. len(trainExamplesHistory) = {len(self.trainExamplesHistory)}\")\n self.trainExamplesHistory.pop(0)\n # backup history to a file\n # NB! the examples were collected using the model from the previous iteration, so (i-1) \n self.saveTrainExamples(i - 1)\n\n # shuffle examples before training\n trainExamples = []\n for e in self.trainExamplesHistory:\n trainExamples.extend(e)\n shuffle(trainExamples)\n\n # training new network, keeping a copy of the old one\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\n pmcts = MCTS(self.game, self.pnet, self.args)\n\n self.nnet.train(trainExamples)\n nmcts = MCTS(self.game, self.nnet, self.args)\n\n log.info('PITTING AGAINST PREVIOUS VERSION')\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game)\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare)\n\n log.info('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) < self.args.updateThreshold:\n log.info('REJECTING NEW MODEL')\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\n else:\n log.info('ACCEPTING NEW MODEL')\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename='best.pth.tar')","def train(nepochs, model): \n if model == 'cnn':\n return gennet.train_cnn(nepochs, 'Resnet50')\n elif model == 'logreg':\n return gennet.train_logreg('Resnet50')","def train(self,\n num_episodes = 100,\n num_steps = 500000,\n max_steps_per_episode = 10000,\n target_interval = 10000,\n learning_interval = 4,\n frame_skip = 1,\n warmup_steps = None,\n pretrain_steps = None,\n output_freq = 50,\n save_freq = 5, \n store_memory = False):\n \n # prefill memory with random transitions if requested\n if warmup_steps is not None:\n self._random_warmup(warmup_steps)\n \n # pretrain the agent on its on own memory\n if pretrain_steps is not None:\n self._pretrain(pretrain_steps, target_interval)\n \n # logging initialization\n self._score, self._q_values, self._losses = 0., [], []\n raw_frames = np.zeros(shape = (max_steps_per_episode, *self.env._unprocessed_frame.shape), dtype = np.uint8)\n\n episode_idx = 0\n while episode_idx < num_episodes or self._step_counter < num_steps:\n # reset environment and get first state\n self._start_episode()\n \n for i in range(max_steps_per_episode):\n \n #-------------------------------------------------------------------------------#\n #####################\n # Interactive Phase #\n #####################\n \n # choose an action, observe reactions of the environment and\n # add this experience to the agent's memory \n if self._step_counter % frame_skip == 0: \n action = self._make_decision()\n new_frame, reward, done, _ = self.env.step(action)\n self.memory.add_experience(action, reward, new_frame, 1, done)\n \n # update current state\n self._current_state[0, :(self.num_stacked_frames-1)] = self._current_state[0, 1:]\n self._current_state[0, self.num_stacked_frames-1] = new_frame\n #-------------------------------------------------------------------------------#\n \n \n #-------------------------------------------------------------------------------#\n ##################\n # Learning Phase #\n ##################\n \n # perform a parameter update of the current policy model\n if self._step_counter % learning_interval == 0:\n self._batch_update()\n \n # update the target model\n if self._step_counter % target_interval == 0:\n self._update_target_model()\n #-------------------------------------------------------------------------------#\n \n # logging\n self._score += self.env._unprocessed_reward\n raw_frames[i] = self.env._unprocessed_frame\n \n \n self._step_counter += 1\n \n if self.env.was_real_done:\n self.logger.add_episode_logs(self._step_counter, self._score, self._q_values, self._losses, raw_frames[:i])\n self._score, self._q_values, self._losses = 0., [], []\n break\n \n if done:\n self.env.reset()\n \n \n if not self.env.was_real_done:\n self.memory.add_experience(action, reward, new_frame, 1, True)\n self.logger.add_episode_logs(self._step_counter, self._score, self._q_values, self._losses, raw_frames[:i])\n self._score, self._q_values, self._losses = 0., [], []\n \n if episode_idx%(num_episodes/output_freq)==0:\n validation_score, validation_frames = self.test(record = True, max_steps_per_episode = max_steps_per_episode)\n #validation_score, validation_frames = 0, []\n lower_idx = int(clip(episode_idx-(num_episodes/output_freq)+1, 0, num_episodes-1))\n self.logger.show_progress(lower_idx, episode_idx, validation_score, validation_frames, self.policy_network.model)\n \n if episode_idx%(num_episodes/save_freq)==0:\n self.logger.make_plots()\n self.logger.save_all(self.policy_network.model, self.memory, store_memory)\n \n \n\n episode_idx += 1 \n print('==========================\\ntraining session completed\\n==========================\\n\\n\\n=======\\nSummary\\n======='\n )\n self.logger.show_progress(0, num_episodes, summary = True)\n self.logger.make_plots()\n self.logger.save_all(self.policy_network.model, self.memory, store_memory)","def _Train(self, limit):\n if len(self.Memory)>BATCH_SIZE: \n # Limit of Agents to Train\n for i in range(limit): \n # 'n' number of rounds to train \n for _ in range(50):\n # Get Batch Data\n experiances = self.Memory.sample()\n # Train Models\n self._Learn(self.Actor[i], self.ActorTarget, self.actorOpt[i], experiances)","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def init_trainers(self, args):\n self.actors_cur = [None for _ in range(self.num_agents)]\n self.critics_cur = [None for _ in range(self.num_agents)]\n self.actors_tar = [None for _ in range(self.num_agents)]\n self.critics_tar = [None for _ in range(self.num_agents)]\n self.optimizers_c = [None for _ in range(self.num_agents)]\n self.optimizers_a = [None for _ in range(self.num_agents)]\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\n\n if args.restore == True: # restore the model\n game_step = int(args.old_model_name.split('_')[-1][:-1])\n for idx in range(self.num_agents):\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\n self.var = self.min_var if self.var < self.min_var else self.var\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\n\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\n for i in range(self.num_agents):\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\n\n # return the old data, no need to update the trainers\n if args.restore == True: return old_data\n\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur","def train_episode(self, max_episode_length):\n\n # Populate the buffer\n self.populate_buffer(max_episode_length)\n\n # weight updates\n replay_samples = self.replay_buffer.sample(self.buffer_sample_size)\n state_batch = torch.from_numpy(replay_samples[0]).to(DEVICE)\n action_batch = torch.from_numpy(replay_samples[1]).to(DEVICE)\n reward_batch = (\n torch.from_numpy(replay_samples[2]).to(DEVICE).unsqueeze(1)\n )\n next_state_batch = torch.from_numpy(replay_samples[3]).to(DEVICE)\n dones = (\n torch.from_numpy(replay_samples[4])\n .type(torch.long)\n .to(DEVICE)\n .unsqueeze(1)\n )\n\n # alpha must be clamped with a minumum of zero, so use exponential.\n alpha = self.log_alpha.exp().detach()\n\n with torch.no_grad():\n # Figure out value function\n next_actions, log_next_actions, _ = self.policy.sample(\n next_state_batch\n )\n target_q1, target_q2 = self.avg_q_net(\n next_state_batch, next_actions\n )\n target_q = torch.min(target_q1, target_q2)\n next_state_values = target_q - alpha * log_next_actions\n\n # Calculate Q network target\n done_floats = dones.type(torch.float)\n q_target = reward_batch.clone()\n q_target += self.gamma * done_floats * next_state_values\n\n # Q net outputs values for all actions, so we index specific actions\n q1, q2 = self.q_net(state_batch, action_batch)\n q1_loss = F.mse_loss(q1, q_target)\n q2_loss = F.mse_loss(q2, q_target)\n\n # policy loss\n actions_pi, log_probs_pi, action_dist = self.policy.sample(state_batch)\n q1_pi, q2_pi = self.q_net(state_batch, actions_pi)\n q_pi = torch.min(q1_pi, q2_pi)\n policy_loss = ((alpha * log_probs_pi) - q_pi).mean()\n\n # update parameters\n self.q_optim.zero_grad()\n q1_loss.backward()\n self.q_optim.step()\n\n self.q_optim.zero_grad()\n q2_loss.backward()\n self.q_optim.step()\n\n self.policy_optim.zero_grad()\n policy_loss.backward()\n self.policy_optim.step()\n\n # automatic entropy tuning\n alpha_loss = (\n self.log_alpha * (log_probs_pi + self.entropy_target).detach()\n )\n alpha_loss = -alpha_loss.mean()\n\n if self.entropy_tuning:\n self.alpha_optim.zero_grad()\n alpha_loss.backward()\n self.alpha_optim.step()\n\n # Step average Q net\n move_average(self.q_net, self.avg_q_net, self.tau)\n\n # logging\n self.tbx_logger(\n {\n \"loss/q1 loss\": q1_loss.item(),\n \"loss/q2 loss\": q2_loss.item(),\n \"loss/pi loss\": policy_loss.item(),\n \"loss/alpha loss\": alpha_loss.item(),\n \"Q/avg_q_target\": q_target.mean().item(),\n \"Q/avg_q1\": q1.mean().item(),\n \"Q/avg_q2\": q2.mean().item(),\n \"Q/avg_reward\": reward_batch.mean().item(),\n \"Q/avg_V\": next_state_values.mean().item(),\n \"H/alpha\": alpha.item(),\n \"H/pi_entropy\": action_dist.entropy().mean(),\n \"H/pi_log_pi\": log_probs_pi.mean(),\n },\n self.training_i,\n )\n\n self.training_i += 1\n self.checkpointer.increment_counter()","def TrainEpoch(ss):\n ss.StopNow = False\n curEpc = ss.TrainEnv.Epoch.Cur\n while True:\n ss.TrainTrial()\n if ss.StopNow or ss.TrainEnv.Epoch.Cur != curEpc:\n break\n ss.Stopped()","def enjoy_model(env, obs_placeholder, epsilon_placeholder, stochastic_placeholder,\n output_actions, sess, num_episodes=1):\n for _ in range(num_episodes):\n obs, done = env.reset(), False\n episode_rew = 0\n while not done:\n env.render()\n time.sleep(0.02)\n feed_dict = {obs_placeholder: np.array(obs).reshape((1,) + obs.shape),\n epsilon_placeholder: 0.0,\n stochastic_placeholder: False}\n action = sess.run(output_actions, feed_dict)[0]\n obs, rew, done, _ = env.step(action)\n episode_rew += rew\n print(\"Episode rew\", episode_rew)\n time.sleep(1)","def _train_epochs(self, data, model, n_epochs, start_epoch, start_step, dev_data, teacher_forcing_ratio, early_stopping_patience):\n print_loss_total = 0 # Reset every print_every\n epoch_loss_total = 0 # Reset every epoch\n\n device = None if torch.cuda.is_available() else -1\n batch_iterator = torchtext.data.BucketIterator(data, batch_size=self.batch_size, repeat=False,\n sort_key=lambda x: len(x.src),\n shuffle=True, device=device, sort=False, sort_within_batch=True)\n\n steps_per_epoch = len(batch_iterator)\n total_steps = steps_per_epoch * n_epochs\n\n step = start_step\n step_elapsed = 0\n previous_dev_loss = 10e6\n dev_loss_increased_epochs = 0\n for epoch in range(start_epoch, n_epochs + 1):\n self.logger.info(\"Epoch: %d, Step: %d\" % (epoch, step))\n\n batch_generator = batch_iterator.__iter__()\n # consuming seen batches from previous training\n for _ in range((epoch - 1) * steps_per_epoch, step):\n next(batch_generator)\n\n model.train(True)\n for batch in batch_generator:\n step += 1\n step_elapsed += 1\n\n input_variables, input_lengths = getattr(batch, UTTERANCE_FIELD_NAME)\n target_variables = getattr(batch, RESPONSE_FIELD_NAME)\n emotion_variables = getattr(batch, EMOTION_FIELD_NAME)\n\n loss = self.train_batch(input_variables, input_lengths.tolist(), target_variables, emotion_variables,\n model, teacher_forcing_ratio)\n\n # Record average loss\n print_loss_total += loss\n epoch_loss_total += loss\n\n if step % self.print_every == 0 and step_elapsed > self.print_every:\n print_loss_avg = print_loss_total / self.print_every\n print_loss_total = 0\n log_msg = 'Progress: %.2f%%, Train %s: %.4f' % (\n step / total_steps * 100,\n self.loss.name,\n print_loss_avg)\n self.logger.info(log_msg)\n beam_search = EmotionSeq2seq(model.encoder, EmotionTopKDecoder(model.decoder, 20))\n predictor = Predictor(beam_search, data.vocabulary, data.emotion_vocabulary)\n seq = \"how are you\".split()\n self.logger.info(\"Happy: \" + \" \".join(predictor.predict(seq, 'happiness')))\n self.logger.info(\"Angry: \" + \" \".join(predictor.predict(seq, 'anger')))\n\n # Checkpoint\n if step % self.checkpoint_every == 0 or step == total_steps:\n Checkpoint(model=model,\n optimizer=self.optimizer,\n epoch=epoch, step=step).save(self.expt_dir)\n\n if step_elapsed == 0:\n continue\n\n epoch_loss_avg = epoch_loss_total / min(steps_per_epoch, step - start_step)\n epoch_loss_total = 0\n log_msg = \"Finished epoch %d: Train %s: %.4f\" % (epoch, self.loss.name, epoch_loss_avg)\n if dev_data is not None:\n dev_loss, accuracy = self.evaluator.evaluate(model, dev_data)\n self.optimizer.update(dev_loss)\n log_msg += \", Dev %s: %.4f, Accuracy: %.4f\" % (self.loss.name, dev_loss, accuracy)\n model.train(mode=True)\n if dev_loss > previous_dev_loss:\n dev_loss_increased_epochs += 1\n if dev_loss_increased_epochs == early_stopping_patience:\n self.logger.info(\"EARLY STOPPING\")\n break\n else:\n dev_loss_increased_epochs = 0\n previous_dev_loss = dev_loss\n Checkpoint(model=model,\n optimizer=self.optimizer,\n epoch=epoch, step=step).save(self.expt_dir)\n else:\n self.optimizer.update(epoch_loss_avg)\n\n self.logger.info(log_msg)","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n player = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, player)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, player, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, player = self.game.getNextState(board, player, action)\n\n r = self.game.getGameEnded(board, player)\n\n if r != 0:\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\n return ex","def train(self):\n self.emission_model(self.train_data)\n self.transition_model(self.train_data)","def training(self, dataset, repeat=1, gamma=1.0, learning_rate=0.1, model='3yo'):\n for _ in range(repeat):\n for episode in dataset:\n # 1- Get the data stored inside the dataset\n image_index = episode[0] # image of the object\n label_index = episode[1] # label given by the informant\n informant_index = episode[2] # a integer representing the informant\n informant_action = episode[3] # 0=reject, 1=accept\n\n # 2- The agent take an action (with softmax) considering is current state-action table\n # [0=cup, 1=book, 2=ball]\n col = (image_index * self.tot_images) + label_index\n action_array = self.actor_matrix[:, col]\n action_distribution = self._softmax(action_array)\n child_action = np.random.choice(self.tot_actions,\n 1,\n p=action_distribution) # select the action through softmax\n\n # 3- (External) New state and reward obtained from the environment\n # u_t = self.critic_vector[0, col] # previous state\n # New state is estimated, in this simple case nothing happen\n # because the next state is terminal\n # u_t1 = u_t # Only in this example they are the same\n\n # 4- (Intrinsic) The informant_reputation is updated:\n # agent_action, agent_confidence, informant_action, reward\n # informant_vector: 0=unreliable, 1=reliable\n # do_actions_agree: False, True\n # Estimating child_confidence\n distance = np.absolute(action_distribution[0] - action_distribution[1])\n child_confidence_distribution = [1 - distance, distance] # non-knowledgeable, knowledgeable\n child_confidence = np.random.choice(2, 1, p=child_confidence_distribution)\n # Check if child and informant agree\n if (child_action == informant_action):\n do_actions_agree = True\n else:\n do_actions_agree = False\n # Increment the counter in the informant_vector.\n # Here we update the counter distribtuion only if\n # the child is confident, because it is only in that\n # case that the child can say if the informant is\n # reliable or not.\n if (do_actions_agree == False and child_confidence == 1):\n self.informant_vector[informant_index][0] += 1 # unreliable\n elif (do_actions_agree == True and child_confidence == 1):\n self.informant_vector[informant_index][1] += 1 # reliable\n elif (do_actions_agree == False and child_confidence == 0):\n self.informant_vector[informant_index][1] += 0 # reliable\n self.informant_vector[informant_index][0] += 0 # unreliable\n elif (do_actions_agree == True and child_confidence == 0):\n self.informant_vector[informant_index][1] += 0 # reliable\n self.informant_vector[informant_index][0] += 0 # unreliable\n else:\n raise ValueError(\"ERROR: anomaly in the IF condition for informant_vector update\")\n # Using the informant_vector given as input it estimates the reputation of the informant\n informant_reputation_distribution = np.true_divide(self.informant_vector[informant_index],\n np.sum(self.informant_vector[informant_index]))\n informant_reputation = np.random.choice(2, 1, p=informant_reputation_distribution)\n\n # 5- (Intrinsic) The Cost is estimated:\n # current_state, agent_action, agent_confidence, informant_action, informant_reputation\n # child_confidence: 0=non-knowledgeable, 1=knowledgeable\n # informant_reputation: 0=non-knowledgeable, 1=knowledgeable\n # action: 0=reject, 1=accept\n # informant_action: 0=reject, 1=accept\n cost = self._return_cost(child_confidence,\n informant_reputation,\n child_action,\n informant_action,\n value=model)\n\n # 6- The utility table is updated using: previous_state, current_state, cost, reward\n # Updating the critic using Temporal Differencing Learning\n # In this simple case there is not a u_t1 state.\n # The current state is considered terminal.\n # We can delete the term (gamma*u_t1)-u_t and considering\n # only (reward-cost) as utility of the state (see Russel Norvig).\n reward = 0 # only for intrinsic learning reward=0\n delta = (reward - cost) # + (gamma*u_t1) - u_t\n self.critic_vector[0, col] += learning_rate * delta\n\n # 7- The actor table is updated using the delta from the critic\n # Update the ACTOR using the delta\n self.actor_matrix[child_action, col] += learning_rate * delta # the current action\n self.actor_matrix[1 - child_action, col] -= learning_rate * delta # the opposite action","def train_ddpg(agent, env, n_episodes=400, max_t=1000, save=True):\n # get the default brain\n brain_name = env.brain_names[0]\n scores_deque = deque(maxlen=100)\n final_scores = []\n not_solved = True\n num_agents = len(env.reset()[brain_name].vector_observations)\n best = 0\n episodes_remaining = n_episodes\n for i_episode in range(1, n_episodes+1):\n env_info = env.reset()[brain_name]\n states = env_info.vector_observations\n agent.reset()\n agent_scores = np.zeros(num_agents)\n for t in range(max_t):\n actions = agent.act(states)\n env_info = env.step(actions)[brain_name]\n next_states = env_info.vector_observations\n rewards = env_info.rewards\n dones = env_info.local_done\n agent.step(states, actions, rewards, next_states, dones)\n states = next_states\n agent_scores += rewards\n if np.any(dones):\n break\n\n max_score = np.max(agent_scores)\n scores_deque.append(max_score)\n final_scores.append(max_score)\n print('\\rEpisode {}\\tAverage Score: {:.2f}\\tScore: {:.2f}'.format(i_episode, np.mean(scores_deque), max_score), end=\"\", flush=True)\n if len(scores_deque) == 100 and np.mean(scores_deque) > SOLVED_SCORE and not_solved:\n not_solved = False\n episodes_remaining = EPISODES_AFTER_SOLVE # try to increase score for some episodes\n print(\"\\nEnvironment solved in {} episodes!\\n\".format(i_episode), flush=True)\n if save:\n torch.save(agent.actor_local.state_dict(), 'saved_models/actor_solved.pth')\n torch.save(agent.critic_local.state_dict(), 'saved_models/critic_solved.pth')\n if i_episode % 100 == 0:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)), flush=True)\n\n if not not_solved and i_episode % 5 == 0 and np.mean(scores_deque) > best:\n best = np.mean(scores_deque)\n if save:\n torch.save(agent.actor_local.state_dict(), 'saved_models/best_actor.pth')\n torch.save(agent.critic_local.state_dict(), 'saved_models/best_critic.pth')\n\n if not not_solved:\n episodes_remaining -= 1\n if episodes_remaining == 0:\n break\n\n return final_scores","def train(self, persist: bool = False, run: int = -1, checkpoint: int = -1):\n self.meta = ICMMetaDataV1(fp=open(os.path.join(MODULE_CONFIG.BaseConfig.BASE_DIR, 'agent_stats.csv'), 'w'),\n args=self.state.config)\n train_start = time.time()\n for episode in range(self.state.episodes):\n start_time = time.time()\n state = self.env.reset()\n state = torch.reshape(tensor(state, dtype=torch.float32), [1, 84, 84, 4]).permute(0, 3, 1, 2).to(\n self.device)\n done = False\n episode_reward = []\n episode_loss = []\n\n # save network\n # if episode % self.state.model_save_interval == 0:\n # save_path = self.state.model_save_path + '/' + self.run_name + '_' + str(episode) + '.pt'\n # torch.save(self.q_network.state_dict(), save_path)\n # print('Successfully saved: ' + save_path)\n\n # Save Model\n self.save(episode)\n # Collect garbage\n # To Do Later\n\n while not done:\n\n # update target network\n if self.state.step % self.state.network_update_interval == 0:\n print('Updating target network')\n self.target_network.load_state_dict(self.q_network.state_dict())\n\n if self.state.step > len(self.replay_memory):\n self.state.epsilon = max(self.state.final_epsilon,\n self.state.initial_epsilon - self.state.epsilon_step * self.state.step)\n if self.state.epsilon > self.state.final_epsilon:\n self.state.mode = 'Explore'\n else:\n self.state.mode = 'Exploit'\n\n action, q = self.take_action(state, test=False, state_count=0)\n next_state, reward, done, _ = self.env.step(action)\n\n next_state = torch.reshape(tensor(next_state, dtype=torch.float32), [1, 84, 84, 4]).permute(0, 3, 1,\n 2).to(\n self.device)\n self.push((state, torch.tensor([int(action)]), torch.tensor([reward], device=self.device), next_state,\n torch.tensor([done], dtype=torch.float32)))\n episode_reward.append(reward)\n self.state.step += 1\n state = next_state\n\n # train network\n if self.state.step >= self.start_to_learn and self.state.step % self.state.network_train_interval == 0:\n loss = self.optimize_network()\n episode_loss.append(loss)\n\n if done:\n # print('Episode:', episode, ' | Steps:', self.state.step, ' | Eps: ', self.state.epsilon,\n # ' | Reward: ',\n # sum(episode_reward),\n # ' | Avg Reward: ', np.mean(self.last_n_rewards), ' | Loss: ',\n # np.mean(episode_loss), ' | Intrinsic Reward: ', sum(self.intrinsic_episode_reward),\n # ' | Avg Intrinsic Reward: ', np.mean(self.last_n_intrinsic_rewards),\n # ' | Mode: ', self.state.mode)\n # print('Episode:', episode, ' | Steps:', self.state.step, ' | Eps: ', self.state.epsilon,\n # ' | Reward: ',\n # sum(episode_reward),\n # ' | Avg Reward: ', np.mean(self.last_n_rewards), ' | Loss: ',\n # np.mean(episode_loss), ' | Intrinsic Reward: ', sum(self.intrinsic_episode_reward),\n # ' | Avg Intrinsic Reward: ', np.mean(self.last_n_intrinsic_rewards),\n # ' | Mode: ', self.state.mode, file=self.log_file)\n # self.log_summary(episode, episode_loss, episode_reward)\n self.last_n_rewards.append(sum(episode_reward))\n self.last_n_intrinsic_rewards.append(sum(self.intrinsic_episode_reward))\n self.meta.update_episode(episode, self.state.step, self.state.epsilon,\n sum(episode_reward), np.mean(self.last_n_rewards),\n np.mean(episode_loss), sum(self.intrinsic_episode_reward),\n np.mean(self.last_n_intrinsic_rewards), self.state.mode)\n\n episode_reward.clear()\n episode_loss.clear()\n self.intrinsic_episode_reward.clear()"],"string":"[\n \"def train(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\\n while self.episodes_done < num_episodes:\\n self.trainOneEpisode(num_episodes, max_episode_steps, save_freq, render)\\n self.saveCheckpoint()\",\n \"def train(self, training_steps=10):\",\n \"def train(\\n self, num_episodes, max_episode_length, reward_network=None,\\n ):\\n\\n for _ in range(num_episodes):\\n self.train_episode(max_episode_length)\\n\\n if self.training_i % self.play_interval == 0:\\n self.play(\\n max_episode_length,\\n self.render,\\n reward_network=reward_network,\\n )\",\n \"def train(self, iters, n_episodes):\\n for i in range(iters):\\n self.self_play(n_episodes)\\n self.learn()\",\n \"def train_epoch(self) -> None:\\n ct = self.config.training\\n total_games = self._get_total_games()\\n print(f\\\"Total Games: {total_games}\\\")\\n train_size = int(0.9 * total_games)\\n dataset_wrapper = DatasetWrapper(self.config)\\n self.agent.model.fit(\\n dataset_wrapper.get_dataset(train_size),\\n epochs=ct.epoch_to_checkpoint,\\n validation_data=dataset_wrapper.get_dataset(train_size, is_training=False),\\n )\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.num_epochs):\\n print(\\\"EPOHA\\\")\\n self.run_epoch()\\n print(\\\"SAVE MODEL\\\")\\n self.save_model()\",\n \"def _train_model(self):\\n self.experiment = EpisodicExperiment(self.task, self.agent)\\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\\n logger.debug(\\\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\\\"\\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\\n for i in range(n_epochs):\\n logger.debug(\\\"RL epoch {}\\\".format(i))\\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\\n self.agent.learn()\\n self.agent.reset() # reset buffers\",\n \"def train_by_episode(self):\\n # only REINFORCE and REINFORCE with baseline\\n # use the ff code\\n # convert the rewards to returns\\n rewards = []\\n gamma = 0.99\\n for item in self.memory:\\n [_, _, _, reward, _] = item\\n rewards.append(reward)\\n # rewards = np.array(self.memory)[:,3].tolist()\\n\\n # compute return per step\\n # return is the sum of rewards from t til end of episode\\n # return replaces reward in the list\\n for i in range(len(rewards)):\\n reward = rewards[i:]\\n horizon = len(reward)\\n discount = [math.pow(gamma, t) for t in range(horizon)]\\n return_ = np.dot(reward, discount)\\n self.memory[i][3] = return_\\n\\n # train every step\\n for item in self.memory:\\n self.train(item, gamma=gamma)\",\n \"def train(n_episodes=1000, max_n_steps=300, eps_start=1.0, eps_end=0.01, eps_decay=0.995, strCheckpointFile='checkpoint.pth'):\\n\\n global env\\n scores = [] # list containing scores from each episode\\n scores_window = deque(maxlen=100) # last 100 scores\\n eps = eps_start # initialize epsilon\\n num_saves = 0\\n for i_episode in range(1, n_episodes + 1):\\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\\n state = env_info.vector_observations[0] # get the current state\\n score = 0 # initialize the score\\n last_t = max_n_steps\\n for t in range(max_n_steps):\\n action = agent.act(state, eps) # agent returns an epsilon-greedy action based on state\\n env_info = env.step(action)[brain_name] # send the action to the environment\\n next_state = env_info.vector_observations[0] # get the next state\\n reward = env_info.rewards[0] # get the reward\\n done = env_info.local_done[0] # see if episode has finished\\n agent.step(state, action, reward, next_state, done) # records experience and learns (depending on settings)\\n state = next_state\\n score += reward\\n if done:\\n last_t = t + 1\\n break\\n scores_window.append(score) # save most recent score\\n scores.append(score) # save most recent score\\n eps = max(eps_end, eps_decay * eps) # decrease epsilon\\n print('\\\\rEpisode {}\\\\tNum steps: {}\\\\tAverage Score: {:.2f}'.format(i_episode, last_t, np.mean(scores_window)))\\n # if i_episode % 100 == 0:\\n # print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\\n if np.mean(scores_window) >= 13: # win condition in course\\n if num_saves == 0:\\n print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode - 100, np.mean(scores_window)))\\n print('\\\\nTraining will continue and the checkpoint will be overwritten every 100 episodes')\\n print('\\\\nSaving a checkpoint now, you may interrupt code execution with eg Ctrl+C')\\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\\n else:\\n if i_episode % 100 == 0:\\n print('\\\\nSaving another checkpoint now, you may interrupt code execution with eg Ctrl+C')\\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\\n num_saves += 1\\n\\n env.close()\\n\\n # plot the scores\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n plt.plot(np.arange(len(scores)), scores)\\n plt.ylabel('Score')\\n plt.xlabel('Episode #')\\n # plt.show()\\n plt.savefig('training_score_by_episode.png')\\n return scores\",\n \"def learn(self, num_episodes=10000):\\n for i in range(num_episodes):\\n self.actor()\\n self.learner()\",\n \"def train_model(num_episodes, model_version, discount_rate, learning_rate):\\n\\n # getting available models\\n with open('model_architectures.yaml', 'r') as file:\\n available_models = yaml.safe_load(stream = file)\\n file.close()\\n\\n # input checks\\n if type(num_episodes) != int:\\n raise TypeError('num_episodes must be of type int')\\n if num_episodes <= 0:\\n raise ValueError('num_episodes must be greater than zero')\\n if type(model_version) != str:\\n raise TypeError('model_version must be of type string')\\n if model_version not in available_models:\\n raise ValueError('model_version not available')\\n if type(discount_rate) != int and type(discount_rate) != float:\\n raise TypeError('discount rate must be of type int or float')\\n if discount_rate <= 0:\\n raise ValueError('discount_rate must be greater than zero')\\n if type(learning_rate) != float:\\n raise TypeError('learning_rate must be of type float')\\n if learning_rate <= 0 or learning_rate >= 1:\\n raise ValueError('learning_rate must be within (0, 1)')\\n\\n # determining model sub-version\\n model_sub_version_write = False\\n sub_version = 0\\n while not model_sub_version_write:\\n if not os.path.exists(os.path.join('trained_models', model_version, model_version + '.' + str(sub_version) + '.0')):\\n model_sub_version_write = True\\n break\\n sub_version += 1\\n\\n # building model\\n model = eval(available_models[model_version])()\\n optimizer = tf.keras.optimizers.Adam(learning_rate = learning_rate)\\n compute_loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits = True)\\n\\n # holding gradients\\n gradient_holder = model.trainable_variables\\n for i, gradient in enumerate(gradient_holder):\\n gradient_holder[i] = gradient * 0\\n\\n # creating gym environment\\n env = gym.make('CartPole-v1')\\n env._max_episode_steps = 15000\\n\\n scores = []\\n every_update = 5\\n\\n # training loop\\n for episode in range(num_episodes + 1):\\n observation = env.reset()\\n\\n episode_memory = []\\n episode_score = 0\\n done = False\\n\\n while not done:\\n\\n # creates vector of form [Position, Velocity, Angle, Angular Velocity]\\n observation = observation.reshape([1, 4])\\n\\n with tf.GradientTape() as tape:\\n\\n # creating loss function and action\\n logits = model(observation)\\n a_dist = logits.numpy()\\n action = np.random.choice(a = a_dist[0], p = a_dist[0])\\n action = np.argmax(a_dist == action)\\n loss = compute_loss([action], logits)\\n\\n # performing action and getting feedback from environment\\n observation, reward, done, info = env.step(action)\\n\\n episode_score += reward\\n\\n # trick for quicker convergence\\n if done:\\n reward -= 10\\n\\n # getting gradients\\n gradients = tape.gradient(target = loss, sources = model.trainable_variables)\\n episode_memory.append([gradients, reward])\\n\\n scores.append(episode_score)\\n\\n # discounting rewards\\n episode_memory = np.array(episode_memory)\\n episode_memory[:, 1] = discount_rewards(rewards = episode_memory[:, 1], discount_rate = discount_rate)\\n\\n # applying rewards to corresponding gradients\\n for grads, reward in episode_memory:\\n for i, grad in enumerate(grads):\\n gradient_holder[i] += grad * reward\\n\\n # back-propagating gradients, resetting gradients\\n if episode % every_update == 0:\\n optimizer.apply_gradients(zip(gradient_holder, model.trainable_variables))\\n for i, grad in enumerate(gradient_holder):\\n gradient_holder[i] = grad * 0\\n\\n if episode % 100 == 0:\\n print('Episode {} Score {}'.format(episode, np.mean(scores[-20:])))\\n tf.keras.models.save_model(model = model,\\n filepath = os.path.join('trained_models', model_version, model_version + '.' +\\n str(sub_version) + '.{}'.format(episode)))\\n\\n final_performance = int(round(np.mean(scores[-20:])))\\n\\n # dumping training results into yaml file\\n yaml_dump = {}\\n yaml_dump['Model Version'] = model_version\\n yaml_dump['Model Sub-version'] = sub_version\\n yaml_dump['Number of Training Episodes'] = num_episodes\\n yaml_dump['Discount Rate'] = discount_rate\\n yaml_dump['Learning Rate'] = learning_rate\\n yaml_dump['Final Performance'] = final_performance\\n\\n with open(os.path.join('trained_models', model_version, model_version + '.' + str(sub_version) + '_training_details.yaml'), 'w') as file:\\n yaml.dump(data = yaml_dump, stream = file)\\n file.close()\",\n \"def train(self, num_episodes=10000):\\n\\n self.game.restart()\\n\\n self.exp_states = defaultdict(int)\\n\\n for i in tqdm(range(num_episodes)):\\n\\n self.game.deal_cards()\\n\\n possible_actions = self.game.get_actions()\\n\\n player_state = self.game.get_player_state()\\n player_action = self.player.get_action(player_state,\\n possible_actions,\\n explore_exploit='explore')\\n\\n # Bookkeep visited states (?)\\n player_state_str = np.array2string(player_state)\\n self.exp_states[player_state_str] += 1\\n\\n opponent_state = self.game.get_opponent_state()\\n opponent_action = self.opponent.get_action(opponent_state,\\n possible_actions)\\n\\n self.game.set_player_action(player_action)\\\\\\n .set_opponent_action(opponent_action)\\n\\n player_score, opponent_score = self.game.get_scores()\\n\\n reward = self._get_reward(player_score, opponent_score)\\n self.player.learn(player_state,\\n player_action,\\n reward)\\n self.player.learn(opponent_state,\\n opponent_action,\\n -reward)\\n \\n print(\\\"Training done!\\\")\",\n \"def train(self, env):\\n\\n\\t\\tmin_average_reward_for_stopping = 195\\n\\t\\tconsecutive_successful_episodes_to_stop = 10\\n\\t\\tlast_10_rewards = deque(maxlen=consecutive_successful_episodes_to_stop)\\n\\n\\t\\tnum_Episodes = []\\n\\t\\tEpisode_Rewards = []\\n\\n\\t\\tfor episode in range(self.episodes):\\n\\t\\t\\tstate = env.reset()\\n\\t\\t\\tstate = np.reshape(state, [1, self.state_size])\\n\\t\\t\\tdone = False\\n\\t\\t\\ttotal_reward = 0\\n\\n\\t\\t\\twhile not done:\\n\\t\\t\\t\\taction = self.act(state)\\n\\t\\t\\t\\tnext_state, reward, done, _ = env.step(action)\\n\\t\\t\\t\\tnext_state = np.reshape(next_state, [1, self.state_size])\\n\\t\\t\\t\\tself.remember(state, action, reward, next_state, done)\\n\\t\\t\\t\\tstate = next_state\\n\\t\\t\\t\\ttotal_reward += reward\\n\\n\\t\\t\\tnum_Episodes.append(episode)\\n\\t\\t\\tEpisode_Rewards.append(total_reward)\\n\\t\\t\\tlast_10_rewards.append(total_reward)\\n\\t\\t\\tlast_10_avg_reward = np.mean(last_10_rewards)\\n\\t\\t\\tprint(episode, last_10_avg_reward)\\n\\n\\t\\t\\t# call experience relay\\n\\t\\t\\tif len(self.memory) >= self.batch_size:\\n\\t\\t\\t\\tself.replay(self.batch_size)\\n\\t\\t\\t# Stopping criteria\\n\\t\\t\\tif len(\\n\\t\\t\\t\\t\\tlast_10_rewards) == consecutive_successful_episodes_to_stop \\\\\\n\\t\\t\\t\\t\\tand last_10_avg_reward > min_average_reward_for_stopping:\\n\\t\\t\\t\\tprint(\\\"Solved after {} epsiodes\\\".format(episode))\\n\\t\\t\\t\\tbreak\",\n \"def train(self, episodes, epsilon_initial, epsilon_min, epsilon_stop_episode,\\n network_update_freq, gamma, memory_capacity, batch_size):\\n\\n memory = ReplayMemory(memory_capacity)\\n\\n tot_steps = 0\\n running_loss = 0\\n\\n depsilon = (epsilon_initial-epsilon_min)/epsilon_stop_episode\\n\\n for episode in range(episodes):\\n\\n if epsilon_initial > epsilon_min:\\n epsilon_initial -= depsilon\\n\\n if episode % network_update_freq == 0:\\n # Update target network\\n self.NN_target.load_state_dict(self.NN.state_dict())\\n\\n if (episode + 1) % 10 == 0:\\n print(f'Episode {episode + 1}/{episodes} completed!')\\n print(f'Average steps per episode: {tot_steps / 10}')\\n writer.add_scalar('training loss', running_loss / tot_steps, episode)\\n self.plotValue()\\n tot_steps = 0\\n running_loss = 0\\n\\n state, done = self.env.reset()\\n\\n\\n while not done:\\n tot_steps += 1\\n\\n action = self.chooseAction(epsilon_initial, state)\\n\\n reward, next_state, done= self.env.transitionState(state, action)\\n\\n #score += reward\\n reward = torch.tensor([[reward]], device=device)\\n done = torch.tensor([[done]], device=device)\\n\\n # Saves the transition\\n memory.push(self.RBF[state], self.RBF[next_state], reward, done)\\n\\n # Perform one step of batch gradient descent\\n running_loss += self.optimizeModel(memory, batch_size, gamma)\\n\\n state = next_state\\n\\n writer.close()\",\n \"def train_prediction(self, episodes=100, batch_size=32, steps=100):\\n hidden_state = None\\n for episode in range(episodes):\\n state_data = self.env.dataset(batch_size=batch_size)\\n state = self.state_to_observation(state_data)\\n\\n prediction = self.model(state, hidden_state)\\n loss = F.mse_loss(prediction['value'], state_data['reward'])\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def train_network(self, batch, episode_nr):\\n global eps, eps_min, eps_decay\\n for exp in batch:\\n S = exp[0]\\n S = process_state(S)\\n action_number = exp[1]\\n r = exp[2]\\n S_new = exp[3]\\n S_new = process_state(S_new)\\n terminal = exp[4]\\n\\n if not terminal: # If agent is not at its final destination\\n target = (r + gamma*np.amax(self.target.predict(S_new)[0]))\\n else:\\n target = r\\n target_f = self.policy.predict(S)\\n\\n target_f[0][action_number] = target # Update something???\\n self.policy.fit(S, target_f, epochs=1, verbose=0) # Train network # Verbose - makes training line?\\n if self.epsilon > self.eps_min and episode_nr > 10:\\n self.epsilon *= self.eps_decay # Decrease exploration rate\",\n \"def train(self, num_tickers=4, episodes_per_ticker=5, **kwargs):\\n num_tickers = min(num_tickers, len(self.filtered_tickers))\\n for i in range(num_tickers):\\n ticker = self.filtered_tickers[i % num_tickers]\\n env = self.ENV_CONSTRUCTOR(ticker=ticker, **kwargs)\\n for j in tqdm(range(episodes_per_ticker)):\\n history = self.run_episode(env)\\n history[\\\"ticker\\\"] = ticker\\n history[\\\"episode\\\"] = j + 1\\n history[\\\"t\\\"] = range(len(history))\\n self.history = pd.concat((self.history, history))\\n self.history = self.history.reset_index(\\\"Date\\\", drop=True)\",\n \"def train(self, num_decisions=350):\\n os.system(\\\"mkdir \\\" + self.folder_name + \\\"Train\\\")\\n for i in range(5000):\\n episode_folder_name = self.folder_name + \\\"Train/\\\" + str(i) + \\\"/\\\"\\n all_system_states = []\\n all_system_rewards = []\\n all_system_states_cluster = []\\n all_grid_states_cluster = []\\n all_surrounding_states_cluster = []\\n os.system(\\\"mkdir \\\" + episode_folder_name)\\n filename = episode_folder_name + str(i) + \\\".h5\\\"\\n self.system.reset_context(filename)\\n self.system.run_decorrelation(20)\\n grid_dist, surrounding_dist, _, _, _, _ = self.system.get_state_reward()\\n state = self._get_state(grid_dist, surrounding_dist)\\n for j in range(num_decisions):\\n action_index = self._get_action(state, i)\\n transition_to_add = [state, action_index]\\n tag = \\\"_train_\\\" + str(j)\\n actions = [self.all_actions[i] for i in action_index]\\n try:\\n self.system.update_action(actions)\\n system_states, system_rewards, system_states_cluster = self.system.run_step(\\n is_detailed=True, tag=tag)\\n all_system_states.append(system_states)\\n all_system_rewards.append(system_rewards)\\n all_system_states_cluster.append(system_states_cluster)\\n\\n except OpenMMException:\\n print(\\\"Broken Simulation at Episode:\\\",\\n str(i), \\\", Decision:\\\", str(j))\\n break\\n\\n grid_dist, surrounding_dist, grid_reward, surrounding_reward, grid_states_cluster, surrounding_states_cluster = self.system.get_state_reward()\\n state = self._get_state(grid_dist, surrounding_dist)\\n reward = self._get_reward(grid_reward, surrounding_reward)\\n\\n all_grid_states_cluster.append(grid_states_cluster)\\n all_surrounding_states_cluster.append(surrounding_states_cluster)\\n\\n # Use len_reward for number of grids\\n done = [False] * len(reward) # Never Done\\n transition_to_add.extend([reward, state, done])\\n rb_decision_samples = 0\\n for rb_tuple in zip(*transition_to_add):\\n self.buffer.push(*list(rb_tuple))\\n\\n for _ in range(self.update_num):\\n self._update()\\n self._save_episode_data(episode_folder_name)\\n np.save(episode_folder_name + \\\"system_states\\\",\\n np.array(all_system_states))\\n np.save(episode_folder_name + \\\"system_rewards\\\",\\n np.array(all_system_rewards))\\n np.save(episode_folder_name + \\\"system_states_cluster\\\",\\n np.array(all_system_states_cluster))\\n np.save(episode_folder_name + \\\"grid_states_cluster\\\",\\n np.array(all_grid_states_cluster, dtype=object))\\n np.save(episode_folder_name + \\\"all_states_cluster\\\",\\n np.array(all_surrounding_states_cluster))\\n self._save_data()\",\n \"def trainOneEpisode(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\\n # tqdm.write('------Episode {} / {}------'.format(self.episodes_done, num_episodes))\\n self.resetEnv()\\n r_total = 0\\n with trange(1, max_episode_steps+1, leave=False) as t:\\n\\n for step in t:\\n if render:\\n self.env.render()\\n state = self.state\\n action, q = self.selectAction(state, require_q=True)\\n obs_, r, done, info = self.takeAction(action.item())\\n # if print_step:\\n # print 'step {}, action: {}, q: {}, reward: {} done: {}' \\\\\\n # .format(step, action.item(), q, r, done)\\n r_total += r\\n # t.set_postfix(step='{:>5}'.format(step), q='{:>5}'.format(round(q, 4)), total_reward='{:>5}'.format(r_total))\\n t.set_postfix_str('step={:>5}, q={:>5}, total_reward={:>5}'.format(step, round(q, 2), r_total))\\n if done or step == max_episode_steps:\\n next_state = None\\n else:\\n next_state = self.getNextState(obs_)\\n reward = torch.tensor([r], device=self.device, dtype=torch.float)\\n self.memory.push(state, action, next_state, reward)\\n self.optimizeModel()\\n if self.steps_done % self.target_update == 0:\\n self.target_net.load_state_dict(self.policy_net.state_dict())\\n\\n if done or step == max_episode_steps - 1:\\n tqdm.write('------Episode {} ended, total reward: {}, step: {}------' \\\\\\n .format(self.episodes_done, r_total, step))\\n tqdm.write('------Total steps done: {}, current e: {} ------' \\\\\\n .format(self.steps_done, self.exploration.value(self.steps_done)))\\n # print '------Episode {} ended, total reward: {}, step: {}------' \\\\\\n # .format(self.episodes_done, r_total, step)\\n # print '------Total steps done: {}, current e: {} ------' \\\\\\n # .format(self.steps_done, self.exploration.value(self.steps_done))\\n self.episodes_done += 1\\n self.episode_rewards.append(r_total)\\n self.episode_lengths.append(step)\\n if self.episodes_done % save_freq == 0:\\n self.saveCheckpoint()\\n break\\n self.state = next_state\",\n \"def train(self, episodes=2000, max_steps=99):\\n\\n for episode in range(episodes):\\n state = self.env.reset()\\n\\n for step in range(max_steps):\\n explore_eploit_tradeoff = np.random.uniform()\\n\\n if explore_eploit_tradeoff > self.epsilon:\\n action = np.argmax(self.q_table[state, :])\\n else:\\n action = self.env.action_space.sample()\\n\\n new_state, reward, done, info = self.env.step(action)\\n\\n self.q_table[state, action] = self.q_table[state, action] \\\\\\n + self.lr * (reward + self.gamma * np.amax(\\n self.q_table[new_state, :]\\n ) - self.q_table[state, action]\\n )\\n\\n state = new_state\\n if done:\\n break\\n exp_ = np.exp(-self.decay_rate * episode)\\n self.epsilon = self.min_eps + exp_ * (self.max_eps - self.min_eps)\",\n \"def on_train_begin(self, logs):\\n print(f\\\"Testing for {self.params['nb_episodes']} episodes ...\\\")\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.opt.num_epochs):\\n self.run_epoch()\\n if (self.epoch + 1) % self.opt.save_frequency == 0:\\n self.save_model()\",\n \"def train(\\r\\n self,\\r\\n max_episodes : int,\\r\\n exploration_rate=0.9,\\r\\n discount=0.9,\\r\\n batch_size=32,\\r\\n timesteps_per_episode=200,\\r\\n warm_start=False,\\r\\n model_alignment_period=100,\\r\\n save_animation_period=100,\\r\\n save_model_period=10,\\r\\n evaluate_model_period=50,\\r\\n evaluation_size=10,\\r\\n exploration_rate_decay=0.99,\\r\\n min_exploration_rate=0.1,\\r\\n epochs=1,\\r\\n log_q_values=False) -> Controller:\\r\\n\\r\\n # Log training parameters\\r\\n params = {\\r\\n \\\"max_episodes\\\": max_episodes,\\r\\n \\\"exploration_rate\\\": exploration_rate,\\r\\n \\\"discount\\\": discount,\\r\\n \\\"batch_size\\\": batch_size,\\r\\n \\\"timesteps_per_episode\\\": timesteps_per_episode,\\r\\n \\\"model_alignment_period\\\": model_alignment_period,\\r\\n \\\"evaluate_model_period\\\": evaluate_model_period,\\r\\n \\\"evaluation_size\\\": evaluation_size,\\r\\n \\\"exploration_rate_decay\\\": exploration_rate_decay,\\r\\n \\\"min_exploration_rate\\\": min_exploration_rate,\\r\\n \\\"epochs\\\": epochs\\r\\n }\\r\\n self.params.update(params)\\r\\n self.Logger.log_params(self.params)\\r\\n\\r\\n # Load existing model for warm start\\r\\n if warm_start:\\r\\n check = self._load_model()\\r\\n if not check:\\r\\n print(\\\"Using default network\\\") # TODO: temp solution\\r\\n\\r\\n max_reward = -100\\r\\n for episode in range(1, max_episodes + 1):\\r\\n t1 = time.time()\\r\\n total_reward = 0\\r\\n eval_score = 0\\r\\n terminated = False\\r\\n steps = 0\\r\\n state = self.environment.reset(random=True) # start from random state\\r\\n\\r\\n # TODO: Check if possible to avoid reshape!!\\r\\n state = state[self.idx].reshape(1, self.state_size)\\r\\n\\r\\n for timestep in range(timesteps_per_episode):\\r\\n # Predict which action will yield the highest reward.\\r\\n action = self._act(state, exploration_rate,log_q_values)\\r\\n\\r\\n # Take the system forward one step in time.\\r\\n next_state = self.environment.step(action)\\r\\n\\r\\n # Compute the actual reward for the new state the system is in.\\r\\n current_time = timestep * self.environment.step_size\\r\\n reward = self.environment.reward(next_state, current_time)\\r\\n\\r\\n # Check whether the system has entered a terminal case.\\r\\n terminated = self.environment.terminated(next_state, current_time)\\r\\n\\r\\n # TODO: Can this be avoided?\\r\\n next_state = next_state[self.idx].reshape(1, self.state_size)\\r\\n\\r\\n # Store results for current step.\\r\\n self._store(state, action, reward, next_state, terminated)\\r\\n\\r\\n # Update statistics.\\r\\n total_reward += reward\\r\\n state = next_state\\r\\n steps = timestep+1\\r\\n\\r\\n if len(self.experience) >= batch_size:\\r\\n self._experience_replay(batch_size, discount, epochs)\\r\\n #exploration_rate *= exploration_rate_decay\\r\\n\\r\\n # Terminate episode if the system has reached a termination state.\\r\\n if terminated:\\r\\n break\\r\\n\\r\\n # Log the average loss for this episode\\r\\n\\r\\n self.Logger.log_loss(np.mean(self.episode_loss), episode)\\r\\n self.episode_loss = []\\r\\n\\r\\n # Log the average Q-values for this episode\\r\\n if log_q_values:\\r\\n self.Logger.log_q_values(self.episode_q_values/steps, episode)\\r\\n self.episode_q_values = np.zeros(len(self.environment.action_space))\\r\\n\\r\\n if exploration_rate > min_exploration_rate:\\r\\n exploration_rate *= exploration_rate_decay\\r\\n else:\\r\\n exploration_rate = min_exploration_rate\\r\\n t2 = time.time()\\r\\n print(\\r\\n f\\\"Episode: {episode:>5}, \\\"\\r\\n f\\\"Score: {total_reward:>10.1f}, \\\"\\r\\n f\\\"Steps: {steps:>4}, \\\"\\r\\n f\\\"Simulation Time: {(steps * self.environment.step_size):>6.2f} Seconds, \\\"\\r\\n f\\\"Computation Time: {(t2-t1):>6.2f} Seconds, \\\"\\r\\n f\\\"Exploration Rate: {exploration_rate:>0.3f}\\\")\\r\\n\\r\\n if episode % model_alignment_period == 0:\\r\\n self._align_target_model()\\r\\n\\r\\n # if episode % save_animation_period == 0:\\r\\n # self.environment.save(episode)\\r\\n\\r\\n\\r\\n if episode % evaluate_model_period == 0:\\r\\n eval_score = self._evaluate(evaluation_size, max_steps=timesteps_per_episode,episode=episode)\\r\\n\\r\\n if eval_score > max_reward:\\r\\n self._save_model(\\\"best\\\")\\r\\n max_reward = eval_score\\r\\n\\r\\n self._save_model(\\\"latest\\\")\\r\\n\\r\\n # Create Controller object\\r\\n controller = Controller(self.environment.get_action_space(), self.q_network, self.idx)\\r\\n print(\\\"Controller Created\\\")\\r\\n return controller\",\n \"def train(self, n_episodes):\\n for episode in trange(n_episodes):\\n policy_loss, entropy, episode_reward = self.train_step()\\n self.writer.add_scalar('policy_loss', policy_loss, episode)\\n self.writer.add_scalar('entropy', entropy, episode)\\n self.writer.add_scalar('episode_reward', episode_reward, episode)\",\n \"def train(self, max_episodes= 1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\\n success = False\\n i_episode = 0\\n eps = eps_start\\n \\n print('Training in progress...')\\n for i in range(max_episodes):\\n score = self.run_training_episode(eps=eps)\\n \\n self.score_window.append(score)\\n self.score_record.append(np.mean(self.score_window))\\n \\n i_episode += 1\\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\\n\\n if i_episode%100 == 0:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\\n \\n if i_episode>100:\\n if np.mean(self.score_window)>self.criteria:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\\n success = True\\n break\\n\\n if success:\\n print('Criteria reached after {} episodes'.format(i_episode))\\n else:\\n print('Failed to reach Criteria after {} episodes'.format(i_episode))\\n\\n self.plot_training_progress()\\n return success\",\n \"def train(self, batch_size=64, n_episodes=100, max_episode_length=3000, save_path=\\\"last_save.h5\\\",\\n load_path=None):\\n\\n self.explore = True # Explore if needed\\n\\n self._play_through(n_episodes=n_episodes, max_episode_length=max_episode_length, save_path=save_path,\\n callbacks=self._train_callbacks_factory())\",\n \"def train(self, num_batches: int):\",\n \"def train(self, num_episodes = 10000, verbose = True):\\n start_time = datetime.now().replace(microsecond=0)\\n for e in range(num_episodes):\\n S_old = self.env.reset()\\n steps = 0\\n # there is an interal limit of 100 steps\\n while steps < 1000:\\n steps += 1\\n A = self.epsilon_greedy(S_old)\\n S_new, reward, done, info = self.env.step(A)\\n self.Q[S_old, A] = self.Q[S_old, A] + self.alpha * \\\\\\n (reward + self.gamma * np.max(self.Q[S_new, :]) - self.Q[S_old, A])\\n if done:\\n break\\n S_old = S_new\\n if verbose:\\n clear_output(wait=True)\\n now_time = datetime.now().replace(microsecond=0)\\n print(\\\"Epoch: {}/{} - Steps: {:4} - Duration: {}\\\".format(e+1, num_episodes, steps, now_time-start_time))\\n\\n return self.Q\",\n \"def train_episode(self):\\n state = self.env.reset()\\n states = []\\n actions = []\\n rewards = []\\n for _ in range(self.options.steps):\\n probs = self.actor_baseline.predict([[state]])[0][0]\\n action = np.random.choice(len(probs), p=probs)\\n\\n next_state, reward, done, _ = self.step(action)\\n states.append(state)\\n actions.append(action)\\n rewards.append(reward)\\n\\n state = next_state\\n\\n if done:\\n break\\n\\n # Compute and store returns in G\\n G = np.zeros_like(rewards)\\n ################################\\n # YOUR IMPLEMENTATION HERE #\\n ################################\\n\\n # One-hot encoding for actions\\n actions_one_hot = np.zeros([len(actions), self.env.action_space.n])\\n actions_one_hot[np.arange(len(actions)), actions] = 1\\n\\n # Compute one-hot encoded deltas\\n ################################\\n # YOUR IMPLEMENTATION HERE #\\n ################################\\n deltas = [[0]]\\n\\n # Update actor and state estimator\\n self.actor_baseline.fit(x=[np.array(states)],\\n y={'actor_output': deltas, 'baseline_output': returns},\\n epochs=1, batch_size=self.options.batch_size, verbose=0)\",\n \"def train(Game, agent, episodes=1000):\\n a = agent\\n # eps_start = a.epsilon\\n # eps_end = a.epsilon_min\\n # eps_dec = np.exp(1/episodes * np.log(eps_end/eps_start))\\n # a.epsilon_decrement = eps_dec\\n times_taken = np.zeros(episodes)\\n print(\\\"Training starting\\\")\\n for n in range(episodes):\\n start_time = time.time()\\n g = Game()\\n print(\\\"EPISODE\\\", n+1)\\n while not g.success:\\n state = 1.0*g.get_state()\\n action = a.action(state)\\n reward = g.play(action)\\n # print(g.success)\\n # print(\\\"reward: \\\", reward)\\n # print(state)\\n # print(action)\\n # print(g.get_state())\\n a.train(state, action, reward, g.get_state(), g.success)\\n end_time = time.time()\\n times_taken[n] = end_time - start_time\\n print(\\\"Training complete ({} episodes)\\\".format(episodes))\\n return times_taken\",\n \"def train_epoch(self):\\n\\n if self._train_data_set is not None and self._train_data_set is not None:\\n self._model.fit_num_epochs(self._train_data_set, self._test_data_set)\\n else:\\n raise RuntimeError(\\\"[Triggerbot]: No training or test set available\\\")\",\n \"def learn(self):\\n epochswin = [] # count the number of wins at every epoch of the network against the preceding version\\n epochdraw = [] # count the number of draws at every epoch of the network against the preceding version\\n epochswingreedy = [] # count the number of wins against greedy at every epoch\\n epochswinrandom = [] # count the number of wins against random at every epoch\\n epochsdrawgreedy = [] # count the number of draws against greedy at every epoch\\n epochsdrawrandom = [] # count the number of wins against random at every epoch\\n epochswinminmax = [] # count the number of wins against minmax at every epoch\\n epochsdrawminmax = [] # count the number of draws against minmax at every epoch\\n\\n\\n if self.args.load_model == True:\\n file = open(self.args.trainExampleCheckpoint + \\\"graphwins:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(\\n self.args.numEps) + \\\":dim\\\" + str(self.game.n) + \\\".txt\\\", \\\"r+\\\")\\n lines = file.readlines()\\n for index, line in enumerate(lines):\\n for word in line.split():\\n if index == 0:\\n epochswin.append(word)\\n elif index == 1:\\n epochdraw.append(word)\\n file.close()\\n\\n file = open(self.args.trainExampleCheckpoint + \\\"graphwins:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(\\n self.args.numEps) + \\\":dim\\\" + str(self.game.n) + \\\":greedyrandom.txt\\\", \\\"r+\\\")\\n lines = file.readlines()\\n for index, line in enumerate(lines):\\n for word in line.split():\\n if index == 0:\\n epochswingreedy.append(word)\\n elif index == 1:\\n epochsdrawgreedy.append(word)\\n elif index == 2:\\n epochswinrandom.append(word)\\n elif index == 3:\\n epochsdrawrandom.append(word)\\n elif index == 4:\\n epochswinminmax.append(word)\\n elif index == 5:\\n epochsdrawminmax.append(word)\\n file.close()\\n self.loadTrainExamples()\\n\\n for i in range(1, self.args.numIters + 1):\\n # bookkeeping\\n print('------ITER ' + str(i) + '------')\\n # examples of the iteration\\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\\n\\n eps_time = AverageMeter()\\n bar = Bar('Self Play', max=self.args.numEps)\\n end = time.time()\\n\\n for eps in range(self.args.numEps):\\n iterationTrainExamples += self.executeEpisode()\\n\\n # bookkeeping + plot progress\\n eps_time.update(time.time() - end)\\n end = time.time()\\n bar.suffix = '({eps}/{maxeps}) Eps Time: {et:.3f}s | Total: {total:} | ETA: {eta:}'.format(eps=eps + 1,\\n maxeps=self.args.numEps,\\n et=eps_time.avg,\\n total=bar.elapsed_td,\\n eta=bar.eta_td)\\n bar.next()\\n bar.finish()\\n\\n # save the iteration examples to the history\\n self.trainExamplesHistory.append(iterationTrainExamples)\\n\\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\\n print(\\\"len(trainExamplesHistory) =\\\", len(self.trainExamplesHistory),\\n \\\" => remove the oldest trainExamples\\\")\\n self.trainExamplesHistory.pop(0)\\n # backup history to a file\\n # NB! the examples were collected using the model from the previous iteration, so (i-1)\\n self.saveTrainExamples(i - 1)\\n\\n # shuffle examlpes before training\\n trainExamples = []\\n for e in self.trainExamplesHistory:\\n trainExamples.extend(e)\\n shuffle(trainExamples)\\n\\n # training new network, keeping a copy of the old one\\n\\n filename = \\\"curent\\\"+str(i)+\\\"temp:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n filenameBest = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\\n exists = os.path.isfile(filenameBest)\\n if exists:\\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\\n else:\\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\\n pmcts = MCTS(self.game, self.pnet, self.args)\\n\\n self.nnet.train(trainExamples)\\n nmcts = MCTS(self.game, self.nnet, self.args)\\n\\n print('PITTING AGAINST PREVIOUS VERSION')\\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game,nmcts,pmcts,evaluate=True)\\n\\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare, False)\\n\\n pmcts.clear()\\n nmcts.clear()\\n del pmcts\\n del nmcts\\n\\n print(' ')\\n print('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\\n if i == 1:\\n epochswin.append(pwins)\\n epochdraw.append(0)\\n\\n epochswin.append(nwins)\\n epochdraw.append(draws)\\n self.writeLogsToFile(epochswin, epochdraw)\\n\\n ''' Get all the players and then pit them against the network. You need to modify here if you implement \\n more players\\n '''\\n (gp, rp, mp) = self.decidePlayers()\\n\\n if self.args.parallel == 0:\\n\\n\\n nmcts1 = MCTS(self.game, self.nnet, self.args)\\n nmcts2 = MCTS(self.game, self.nnet, self.args)\\n nmcts3 = MCTS(self.game, self.nnet, self.args)\\n\\n arenagreedy = Arena(lambda x: np.argmax(nmcts1.getActionProb(x, temp=0)), gp, self.game,nmcts1)\\n arenarandom = Arena(lambda x: np.argmax(nmcts2.getActionProb(x, temp=0)), rp, self.game,nmcts2)\\n arenaminmax = Arena(lambda x: np.argmax(nmcts3.getActionProb(x, temp=0)), mp, self.game,nmcts3,evaluate=True)\\n\\n pwinsminmax, nwinsminmax, drawsminmax = arenaminmax.playGames(self.args.arenaCompare)\\n print(\\\"minmax - \\\"+str(pwinsminmax)+\\\" \\\"+str(nwinsminmax)+\\\" \\\"+str(drawsminmax))\\n pwinsgreedy, nwinsgreedy, drawsgreedy = arenagreedy.playGames(self.args.arenaCompare)\\n print(\\\"greedy - \\\"+str(pwinsgreedy)+\\\" \\\"+str(nwinsgreedy)+\\\" \\\"+str(drawsgreedy))\\n pwinsreandom, nwinsrandom, drawsrandom = arenarandom.playGames(self.args.arenaCompare)\\n print(\\\"random - \\\"+str(pwinsreandom)+\\\" \\\"+str(nwinsrandom)+\\\" \\\"+str(drawsrandom))\\n\\n nmcts1.clear()\\n nmcts2.clear()\\n nmcts3.clear()\\n del nmcts1\\n del nmcts2\\n del nmcts3\\n\\n else:\\n '''\\n This will be used if you want to evaluate the network against the benchmarks in a parallel way\\n '''\\n\\n self.args.update({'index': str(i)})\\n\\n p = self.parallel(self.args.arenaCompare)\\n (pwinsminmax, nwinsminmax, drawsminmax) = p[0] # self.parallel(\\\"minmax\\\", self.args.arenaCompare)\\n (pwinsgreedy, nwinsgreedy, drawsgreedy) = p[1] # self.parallel(\\\"greedy\\\",self.args.arenaCompare)\\n (pwinsreandom, nwinsrandom, drawsrandom) = p[2] # self.parallel(\\\"random\\\",self.args.arenaCompare)\\n\\n epochsdrawgreedy.append(drawsgreedy)\\n epochsdrawrandom.append(drawsrandom)\\n epochswinrandom.append(pwinsreandom)\\n epochswingreedy.append(pwinsgreedy)\\n epochswinminmax.append(pwinsminmax)\\n epochsdrawminmax.append(drawsminmax)\\n\\n self.writeLogsToFile(epochswingreedy, epochsdrawgreedy, epochswinrandom, epochsdrawrandom, epochswinminmax,\\n epochsdrawminmax, training=False)\\n\\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) <= self.args.updateThreshold:\\n print('REJECTING NEW MODEL')\\n filename = \\\"curent\\\"+str(i)+\\\"temp:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n filenameBest = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n exists = os.path.isfile(filenameBest)\\n if exists:\\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\\n else:\\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\\n\\n else:\\n print('ACCEPTING NEW MODEL')\\n\\n filename = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\\n self.mcts.clear()\\n del self.mcts\\n self.mcts = MCTS(self.game, self.nnet, self.args, mcts=True) # reset search tree\\n print(self.tracker.print_diff())\\n self.writeLogsToFile(epochswin, epochdraw, training=True)\",\n \"def train_one_epoch(self):\\n raise NotImplementedError\",\n \"def train_on_history(self, history):\\n \\n # Split into episodes\\n n_episodes = history[-1][\\\"episode\\\"] \\n episodes = [list(filter(lambda h: h[\\\"episode\\\"]==e , history)\\n ) for e in range(n_episodes)\\n ]\\n\\n # Split into game lives\\n for episode in episodes:\\n \\n \\n game_lives = [\\n list(filter(lambda h: h.get('info').get('ale.lives')==l, episode)\\n ) for l in range(5)\\n ]\\n \\n for life in game_lives:\\n if life:\\n self.train(life)\\n else:\\n print(\\\"No ocurrance\\\")\\n return\",\n \"def train(self,env, iter_n=2000):\\n\\n\\t\\tfor i in range(iter_n):\\n\\t\\t\\tif i > 50:\\n\\t\\t\\t\\tif all(reward > 195 for reward in self.step_count[-10:]):\\n\\t\\t\\t\\t\\tprint('solved at episode {}'.format(i))\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\tstate = self.env.reset()\\n\\t\\t\\tstate = np.reshape(state, [1, self.state_size])\\n\\n\\t\\t\\tepisode_complete = False\\n\\t\\t\\tstep = 0\\n\\t\\t\\twhile not episode_complete and (step < self.max_steps):\\n\\t\\t\\t\\taction = self.define_action(state)\\n\\t\\t\\t\\tnew_state, reward, episode_complete, info = env.step(action)\\n\\t\\t\\t\\tnew_state = np.reshape(new_state, [1, self.state_size])\\n\\n\\t\\t\\t\\tself.memory.append((state, action, reward, new_state, episode_complete))\\n\\t\\t\\t\\tself.round_reward += reward\\n\\t\\t\\t\\tstate = new_state\\n\\t\\t\\t\\tstep += 1\\n\\t\\t\\t\\tif episode_complete:\\n\\t\\t\\t\\t\\tself.round_reward += -10\\n\\t\\t\\t\\t\\tself.update_target_model()\\n\\t\\t\\t\\t\\tself.print_results(i, iter_n, step)\\n\\t\\t\\t\\t\\tif i != 0: # Update totals in memory if not the first run\\n\\t\\t\\t\\t\\t\\tself.update_totals(i, step)\\n\\t\\t\\t\\tif len(self.memory) > self.training_iter:\\n\\t\\t\\t\\t\\tself.replay()\\n\\t\\t\\tif self.epsilon > self.epsilon_min:\\n\\t\\t\\t\\tself.epsilon *= self.epsilon_decay\\n\\n\\t\\treturn self.all_iterations, self.all_rewards, self.step_count\",\n \"def train_one_eps(self, env, horizon=1000, lr=0.1):\\n\\t\\tr_ep = 0 # variable to track episode \\n\\t\\tep_len = 0\\n\\n\\t\\tstate = env.reset()\\n\\t\\taction = self.select_action(state)\\n\\n\\t\\tfor t in range(horizon):\\n\\t\\t\\t\\n\\t\\t\\tstate2, r, done, _ = env.step(action)\\n\\t\\t\\tep_len = ep_len + 1\\n\\t\\t\\tr_ep += r\\n\\n\\t\\t\\taction2 = self.select_action(state2)\\n\\t\\t\\tself.update(state, action, r, state2, action2, lr=lr)\\n\\t\\t\\taction = action2\\n\\t\\t\\t\\n\\t\\t\\tif(done):\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tstate = state2\\n\\n\\t\\treturn r_ep, ep_len\",\n \"def train_epoch(self):\\n for batch, targets in self.training_dataloader:\\n self.training_step(batch, targets)\\n self.calculate_training_loss()\\n self.epochs_trained += 1\\n LOGGER.info(\\n \\\"Training loss after {} epochs: {}\\\".format(str(self.epochs_trained), str(self.training_average_loss))\\n )\",\n \"def fit(self):\\n for i in range(self.current_epoch, self.max_epoch):\\n self.current_epoch += 1\\n # train\\n train_dataloader = self.data_module.get_train_dataloader(\\n batch_size=self.train_batch_size, \\n shuffle=self.train_dataloader_shuffle, \\n num_workers=self.dataloader_num_workers,\\n pin_memory=True\\n )\\n neptune.log_metric(\\\"learning_rate_vs_epoch\\\", self.optimizer.param_groups[0]['lr'])\\n self.train_one_epoch(train_dataloader)\\n\\n # validate \\n if self.validate_after == 'epoch' and self.train_on_all_data == False and self.run_lr_range_test == False:\\n validation_dataloader = self.data_module.get_valid_dataloader(\\n batch_size=self.valid_batch_size, \\n shuffle=self.train_dataloader_shuffle, \\n num_workers=self.dataloader_num_workers, \\n pin_memory=True\\n )\\n self.validate_one_epoch(validation_dataloader)\\n\\n if self.scheduler:\\n if self.step_scheduler_after == 'epoch': \\n if self.step_scheduler_metric == 'val_auc':\\n self.scheduler.step(self.metrics['valid'][-1]['auc_score'])\\n else:\\n self.scheduler.step()\\n\\n if self.run_lr_range_test:\\n neptune.log_metric('validation_epoch_end_AUC_vs_LR', \\n self.scheduler.get_last_lr()[0], y=self.metrics['valid'][-1]['auc_score'])\\n\\n # checkpoint model for resuming model\\n if (self.current_epoch % self.checkpoint_epochs) == 0:\\n self.save_checkpoint()\\n\\n # sleep the training process\\n if self.current_epoch % self.sleep_in_epochs == 0:\\n print(f\\\"SLEEPING FOR {self.sleep_time} at epoch={self.current_epoch}\\\")\\n for i in range(int(self.sleep_time/30)):\\n time.sleep(i)\\n neptune.log_metric(\\\"sleeping_status\\\", y=1)\\n\\n stop_training = self.stopping_criteria()\\n if stop_training:\\n if self.fp16:\\n self.scaler.step(self.optimizer)\\n self.scaler.update()\\n self.optimizer.zero_grad()\\n else:\\n self.optimizer.step()\\n self.optimizer.zero_grad()\\n # backward all the accumulate gradients\\n print(f\\\"stopped training at {self.current_epoch} epoch\\\")\\n break\",\n \"def _sp_train(self, max_steps, instances, visualize, plot):\\n # Keep track of rewards per episode per instance\\n episode_reward_sequences = [[] for i in range(instances)]\\n episode_step_sequences = [[] for i in range(instances)]\\n episode_rewards = [0] * instances\\n\\n # Create and initialize environment instances\\n envs = [self.create_env() for i in range(instances)]\\n envs[0].render(mode='human')\\n states = [env.reset()['observation'][0] for env in envs] # get the image\\n\\n for step in range(max_steps):\\n for i in range(instances):\\n if visualize: envs[i].render()\\n action, angle_index, action_index = self.agent.act(states[i], i)\\n\\n next_state, reward, done, _ = envs[i].step(action)\\n (next_image, next_depth) = next_state['observation']\\n self.agent.push(\\n Transition(states[i], [angle_index, action_index], reward, None if done else next_image), i)\\n episode_rewards[i] += reward\\n if done:\\n episode_reward_sequences[i].append(episode_rewards[i])\\n episode_step_sequences[i].append(step)\\n episode_rewards[i] = 0\\n if plot: plot(episode_reward_sequences, episode_step_sequences)\\n (image, depth) = envs[i].reset()['observation']\\n states[i] = image\\n else:\\n states[i] = next_image\\n # Perform one step of the optimization\\n self.agent.train(step)\\n\\n if plot: plot(episode_reward_sequences, episode_step_sequences, done=True)\",\n \"def train_models(self):\\n\\n #keep track on the number of iterations (needed to scale lambda)\\n nr_iteration = 0\\n \\n for epoch in range(self.epochs):\\n start = time.time()\\n print()\\n print(epoch + 1)\\n print()\\n for step, batch in enumerate(self.training_data):\\n X_batch = normalize_images(tf.cast(batch[0], 'float32'))\\n Y_batch = batch[1]\\n Z_batch = self.ae_model.encode(X_batch)\\n \\n self.train_step_disc(Z_batch, Y_batch)\\n # Call only one tf.function when tracing.\\n #ADD LAMBDA SCHEDULE ACCORDING TO OUR EXPERIMENTS AND EPOCH LENGTH\\n self.scale_lambda(self.lambda_e, nr_iteration)\\n self.train_step_ae(X_batch, Y_batch, Z_batch)\\n\\n nr_iteration += 1\\n end = time.time()\\n print(\\\"Epoch \\\" + str(epoch + 1) + \\\" takes \\\" + str(end - start))\",\n \"def getTrainEpisodes(self):\\n print(\\\"Do you want to train the IA?\\\")\\n while True:\\n num_episodes = raw_input(\\\"Type number iterations to train, [0] to not train: \\\")\\n try:\\n if int(num_episodes) >= 0:\\n return int(num_episodes)\\n print(\\\"Invalid input, try again\\\")\\n except:\\n print(\\\"Invalid input, try again\\\")\\n return\",\n \"def train(self):\\n tic = time.time()\\n means = []\\n stds = []\\n steps = 0\\n scores_window = deque(maxlen=100)\\n for e in range(1,self.episodes):\\n\\n self.noise.step()\\n episode_scores = []\\n obs = self.env.reset()\\n for t in range(self.tmax):\\n actions = self.act(obs)\\n next_obs,rewards,dones = self.env.step(actions)\\n\\n # Store experience\\n if np.max(rewards) > 0:\\n print('hit the ball over the net',rewards)\\n self.R.add(obs.reshape(1,48),obs,actions,rewards,next_obs.reshape(1,48),next_obs,dones)\\n obs = next_obs\\n # Score tracking\\n episode_scores.append(np.max(rewards))\\n \\n # Learn\\n if len(self.R) > self.min_buffer_size:\\n for _ in range(self.SGD_epoch):\\n # Update each agent\\n for i in range(self.num_agents):\\n self.learn(i)\\n # update target networks\\n self.update_targets_all()\\n \\n steps += int(t)\\n means.append(np.mean(episode_scores))\\n stds.append(np.std(episode_scores))\\n scores_window.append(np.sum(episode_scores))\\n if e % 4 == 0:\\n toc = time.time()\\n r_mean = np.mean(scores_window)\\n r_max = max(scores_window)\\n r_min = min(scores_window)\\n r_std = np.std(scores_window)\\n plot(self.name,means,stds)\\n print(\\\"\\\\rEpisode: {} out of {}, Steps {}, Rewards: mean {:.2f}, min {:.2f}, max {:.2f}, std {:.2f}, Elapsed {:.2f}\\\".format(e,self.episodes,steps,r_mean,r_min,r_max,r_std,(toc-tic)/60))\\n if np.mean(scores_window) > self.winning_condition:\\n print('Env solved!')\\n # save scores\\n pickle.dump([means,stds], open(str(self.name)+'_scores.p', 'wb'))\\n # save policy\\n self.save_weights(self.critic_path,self.actor_path)\\n break\",\n \"def setup_training(self):\\n print('setup training called')\\n self.steps_done = 0\\n self.current_episode_num = 1\\n self.total_reward = 0\\n\\n # self.optimizer = optim.RMSprop(policy_net.parameters())\\n self.memory = ReplayMemory(300000)\\n self.total_reward_history = []\\n # self.loss_history = []\\n self.positions = []\\n self.n_destroyed_crates = 0\\n self.is_in_bomb_range = False\",\n \"def train_step(self):\\n pass\",\n \"def train(self, x, t):\\n for i in range(self.number_model):\\n curr_model = self.all_model[i]\\n curr_model.fit(x, t)\",\n \"def train(self):\\n total_steps = 0\\n scores_history = [deque(maxlen=self.run_settings.averaging_window)\\n for a in range(len(self.agents))]\\n averages_history = [[] for a in range(len(self.agents))]\\n\\n for e in range(self.run_settings.num_episodes):\\n # Initialize episode\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.reset()\\n except EpisodeCrashException:\\n for a in range(len(self.agents)):\\n if hasattr(self.agents[a], 'notify_episode_crashed'):\\n self.agents[a].notify_episode_crashed(self.run_settings)\\n continue\\n\\n # Initialize scores to starting reward (probably 0)\\n scores = rewards\\n step = 0\\n\\n while not done:\\n states = [self.agents[a].state_space_converter(env_states[a])\\n for a in range(len(self.agents))]\\n\\n # Train agents\\n if total_steps > 0 and total_steps % self.run_settings.train_every == 0:\\n for agent in self.agents:\\n agent.train(self.run_settings)\\n\\n # Save agent model\\n if total_steps > 0 and total_steps % self.run_settings.save_every == 0:\\n for agent in self.agents:\\n agent.save()\\n\\n # Get actions\\n actions = [self.agents[a].sample(states[a])\\n for a in range(len(self.agents))]\\n env_actions = [self.agents[a].action_space_converter(actions[a])\\n for a in range(len(self.agents))]\\n # Take environment step\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\\n except EpisodeCrashException:\\n for a in range(len(self.agents)):\\n if hasattr(self.agents[a], 'notify_episode_crashed'):\\n self.agents[a].notify_episode_crashed(self.run_settings)\\n break\\n step += 1\\n total_steps += 1\\n\\n # Update scores\\n scores = [scores[a] + rewards[a] for a in range(len(self.agents))]\\n # Push to agent Memories\\n for a in range(len(self.agents)):\\n self.agents[a].push_memory(states[a], actions[a], rewards[a], done)\\n\\n if done:\\n averages = []\\n for a in range(len(scores_history)):\\n scores_history[a].append(scores[a])\\n averages.append(np.mean(scores_history[a]))\\n averages_history[a].append(averages[a])\\n\\n if len(scores) == 1:\\n scores = scores[0]\\n averages = averages[0]\\n if self.run_settings.verbose:\\n print(\\\"Game {} ended after {} steps. Game score: {}. Averages: {}\\\"\\n .format(e+1, step, scores, averages))\\n if (self.run_settings.graph_every > 0 and e > 0\\n and e % self.run_settings.graph_every == 0):\\n self.plot_results(averages_history)\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def train_dqn(self, n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\\n self.scores = [] # list containing scores from each episode\\n scores_window = deque(maxlen=100) # last 100 scores\\n eps = eps_start # initialize epsilon\\n for i_episode in range(1, n_episodes+1):\\n env_info = self.env.reset(train_mode=True)[self.brain_name] # reset the environment\\n state = env_info.vector_observations[0] # get the current state\\n score = 0 # initialize the score\\n for t in range(max_t):\\n action = self.agent.act(state, eps)\\n env_info = self.env.step(action)[self.brain_name] # send the action to the environment\\n next_state = env_info.vector_observations[0] # get the next state\\n reward = env_info.rewards[0] # get the reward\\n done = env_info.local_done[0] # see if episode has finished\\n self.agent.step(state, action, reward, next_state, done)\\n state = next_state\\n score += reward\\n if done:\\n break \\n scores_window.append(score) # save most recent score\\n self.scores.append(score) # save most recent score\\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\\\"\\\")\\n if i_episode % 100 == 0:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\\n # we use 15.0 just to be sure\\n if np.mean(scores_window)>=self.threshold:\\n print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\\n break\\n return self.scores\",\n \"def train_agent(\\n self,\\n *,\\n env,\\n test_env,\\n save_name,\\n train_every=1,\\n max_episodes=1000,\\n center_returns=True,\\n render=True,\\n ):\\n\\n agent = self.create_agent(env)\\n\\n for episode in range(1, max_episodes + 1):\\n obs = env.reset()\\n done = False\\n\\n episode_return = 0.0\\n while not done:\\n action = agent.act(obs, deterministic=False)\\n next_obs, reward, done, _ = env.step(action)\\n episode_return += reward\\n agent.store_step(obs, action, reward, next_obs, done)\\n obs = next_obs\\n\\n if render:\\n env.render()\\n\\n if episode % train_every == 0:\\n agent.perform_training(\\n gamma=self.gamma, center_returns=center_returns\\n )\\n torch.save(agent, f\\\"saved_agents/{save_name}\\\")\\n\\n print(\\\"Episode {} -- return={}\\\".format(episode, episode_return))\\n return agent\",\n \"def train(\\n env: DiscreteEnvironment[TState, TAction],\\n agent: DiscreteAgent[TState, TAction],\\n n_episodes: int,\\n on_action: Callable[[TState, TAction, float, int], None] = None,\\n on_episode_end: Callable[[int], None] = None,\\n) -> None:\\n for ep in range(n_episodes):\\n t = 0\\n while not env.terminated:\\n s, a, r = agent.act_and_train(t) # returns (S_t, A_t, R_t)\\n if on_action:\\n on_action(s, a, r, t)\\n t += 1\\n agent.episode_end()\\n if on_episode_end:\\n on_episode_end(t)\\n env.reset()\",\n \"def train(cls,\\n training,\\n pdf_model,\\n t_x,\\n t_y):\\n batch_size, num_epochs, num_episodes, samples, max_noise, min_noise = training()\\n\\n h_l = None\\n h_vl = None\\n\\n idx = np.arange(cls.test_set_size)\\n np.random.shuffle(idx)\\n idx = idx[:samples]\\n\\n s_x = t_x[idx]\\n s_y = t_y[idx]\\n for i in range(0, num_episodes):\\n print('>>>>>')\\n print('EPISODE: ' + str(i))\\n if max_noise > 0:\\n sp = np.shape(s_y)\\n s_y_r = np.random.rand(sp[0], sp[1])\\n s_y_n = s_y * s_y_r * cls.noise_factor(epoch=i,\\n max_epoch=num_episodes,\\n max_noise=max_noise,\\n min_noise=min_noise)\\n s_y_n = s_y + ((s_y / 2.0) - s_y_n)\\n\\n history = pdf_model.fit(s_x,\\n s_y_n,\\n epochs=num_epochs,\\n batch_size=batch_size,\\n shuffle=True,\\n validation_split=0.15,\\n verbose=2\\n )\\n hl = history.history['loss']\\n hv = history.history['val_loss']\\n if h_l is None:\\n h_l = hl\\n h_vl = hv\\n else:\\n h_l = h_l + hl\\n h_vl = h_vl + hv\\n\\n _p = np.zeros((1, cls.action_size))\\n _p[0] = s_x[0]\\n pr = model.predict(_p)\\n cls.kld(s_y[0], pr)\\n print('<<<<<')\\n\\n cls.plot_results(h_l, h_vl, (num_epochs * (i + 1)))\\n cls.save_hist(history)\\n return\",\n \"def fit(self, num_iterations, max_episode_length=250, eval_every_nth=1000, save_model_every_nth=1000, log_loss_every_nth=1000, video_every_nth=20000):\\n self.compile()\\n self.policy = LinearDecayGreedyEpsilonPolicy(start_value=1., end_value=0.1, num_steps=1e6, num_actions=self.num_actions) # for training\\n self.replay_memory = ReplayMemory(max_size=1000000)\\n self.log_loss_every_nth = log_loss_every_nth\\n random_policy = UniformRandomPolicy(num_actions=self.num_actions) # for burn in \\n num_episodes = 0\\n\\n # tf logging\\n self.tf_session = K.get_session()\\n self.tf_summary_writer = tf.summary.FileWriter(self.log_dir, self.tf_session.graph)\\n\\n while self.iter_ctr < num_iterations:\\n state = self.env.reset()\\n self.preprocessor.reset_history_memory()\\n\\n num_timesteps_in_curr_episode = 0\\n total_reward_curr_episode = 0 \\n\\n while num_timesteps_in_curr_episode < max_episode_length:\\n self.iter_ctr+=1 # number of steps overall\\n num_timesteps_in_curr_episode += 1 # number of steps in the current episode\\n\\n # logging\\n # if not self.iter_ctr % 1000:\\n # print \\\"iter_ctr {}, num_episodes : {} num_timesteps_in_curr_episode {}\\\".format(self.iter_ctr, num_episodes, num_timesteps_in_curr_episode)\\n\\n # this appends to uint8 history and also returns stuff ready to be spit into the network\\n state_network = self.preprocessor.process_state_for_network(state) #shape is (4,84,84,1). axis are swapped in cal_q_vals\\n # print \\\"shape {}, max {}, min {}, type {} \\\".format(state_network.shape, np.max(state_network), np.min(state_network), state_network.dtype)\\n\\n # burning in \\n if self.iter_ctr < self.num_burn_in:\\n action = random_policy.select_action() # goes from 0 to n-1\\n next_state, reward, is_terminal, _ = self.env.step(action)\\n reward_proc = self.preprocessor.process_reward(reward)\\n total_reward_curr_episode += reward_proc\\n state_proc_memory = self.preprocessor.process_state_for_memory(state)\\n # atari_preprocessor.process_state_for_memory converts it to grayscale, resizes it to (84, 84) and converts to uint8\\n self.replay_memory.append(state_proc_memory, action, reward_proc, is_terminal)\\n\\n if is_terminal or (num_timesteps_in_curr_episode > max_episode_length-1):\\n state = self.env.reset()\\n num_episodes += 1\\n with tf.name_scope('summaries'):\\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_no_of_episodes', value=total_reward_curr_episode, step=num_episodes)\\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_iterations', value=total_reward_curr_episode, step=self.iter_ctr)\\n print \\\"iter_ctr {}, num_episodes : {}, episode_reward : {}, loss : {}, episode_timesteps : {}, epsilon : {}\\\".format\\\\\\n (self.iter_ctr, num_episodes, total_reward_curr_episode, self.loss_last, num_timesteps_in_curr_episode, self.policy.epsilon)\\n num_timesteps_in_curr_episode = 0\\n self.dump_train_episode_reward(total_reward_curr_episode)\\n # this should be called when num_timesteps_in_curr_episode > max_episode_length, but we can call it in is_terminal as well. \\n # it won't change anything as it just sets the last entry's is_terminal to True\\n self.replay_memory.end_episode() \\n break\\n\\n # training\\n else:\\n # print \\\"iter_ctr {}, num_episodes : {} num_timesteps_in_curr_episode {}\\\".format(self.iter_ctr, num_episodes, num_timesteps_in_curr_episode)\\n q_values = self.calc_q_values(state_network)\\n # print \\\"q_values {} q_values.shape {}\\\".format(q_values, q_values.shape)\\n #print \\\"q_values.shape \\\", q_values.shape\\n action = self.policy.select_action(q_values=q_values, is_training=True)\\n next_state, reward, is_terminal, _ = self.env.step(action)\\n reward_proc = self.preprocessor.process_reward(reward)\\n total_reward_curr_episode += reward_proc\\n state_proc_memory = self.preprocessor.process_state_for_memory(state)\\n self.replay_memory.append(state_proc_memory, action, reward_proc, is_terminal)\\n\\n # validation. keep this clause before the breaks!\\n if not(self.iter_ctr%eval_every_nth):\\n print \\\"\\\\n\\\\nEvaluating at iter {}\\\".format(self.iter_ctr)\\n if not(self.iter_ctr%video_every_nth):\\n self.evaluate(num_episodes=20, max_episode_length=max_episode_length, gen_video=True)\\n else:\\n self.evaluate(num_episodes=20, max_episode_length=max_episode_length, gen_video=False)\\n print \\\"Done Evaluating\\\\n\\\\n\\\"\\n\\n # save model\\n if not(self.iter_ctr%save_model_every_nth):\\n self.q_network.save(os.path.join(self.log_dir, 'weights/q_network_{}.h5'.format(str(self.iter_ctr).zfill(7))))\\n\\n if is_terminal or (num_timesteps_in_curr_episode > max_episode_length-1):\\n state = self.env.reset()\\n num_episodes += 1\\n with tf.name_scope('summaries'):\\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_no_of_episodes', value=total_reward_curr_episode, step=num_episodes)\\n self.tf_log_scaler(tag='train_reward_per_episode_wrt_iterations', value=total_reward_curr_episode, step=self.iter_ctr)\\n print \\\"iter_ctr {}, num_episodes : {}, episode_reward : {}, loss : {}, episode_timesteps : {}, epsilon : {}\\\".format\\\\\\n (self.iter_ctr, num_episodes, total_reward_curr_episode, self.loss_last, num_timesteps_in_curr_episode, self.policy.epsilon)\\n num_timesteps_in_curr_episode = 0\\n self.dump_train_episode_reward(total_reward_curr_episode)\\n self.replay_memory.end_episode() \\n break\\n\\n if not(self.iter_ctr % self.train_freq):\\n self.update_policy()\\n\\n state = next_state\",\n \"def agents_train(self, game_step, episode_now, args):\\n # update all trainers, if not in display or benchmark mode\\n if episode_now < args.learning_start_episode: return \\n if self.update_cnt > 0 and self.var >= self.min_var: self.var *= args.var_discount\\n #if episode_now > self.last_update_episode and (episode_now - args.learning_start_episode) % args.learning_fre == 0:\\n if game_step % args.learning_fre_step == 0:\\n if self.update_cnt == 0: print('\\\\r=start training ...'+' '*100)\\n self.last_update_episode = episode_now\\n self.update_cnt += 1\\n\\n # update every agent in different memory batch\\n for agent_idx, (actor_c, actor_t, critic_c, critic_t, opt_a, opt_c) in \\\\\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, \\\\\\n self.critics_tar, self.optimizers_a, self.optimizers_c)):\\n # del if opt_c == None: continue # jump to the next model update\\n\\n # sample the experience\\n _obs_n_o, _action_n, _rew_n, _obs_n_n, _done_n = self.memory.sample( \\\\\\n args.batch_size, agent_idx) # Note_The func is not the same as others\\n \\n # --use the date to update the CRITIC\\n rew = torch.tensor(_rew_n, device=args.device, dtype=torch.float) # set the rew to gpu\\n done_n = torch.tensor(~_done_n, dtype=torch.float, device=args.device) # set the rew to gpu\\n action_cur_o = torch.from_numpy(_action_n).to(args.device, torch.float)\\n obs_n_o = torch.from_numpy(_obs_n_o).to(args.device, torch.float)\\n obs_n_n = torch.from_numpy(_obs_n_n).to(args.device, torch.float)\\n\\n action_tar = torch.cat([a_t(obs_n_n[:, self.obs_size[idx][0]:self.obs_size[idx][1]]).detach() \\\\\\n for idx, a_t in enumerate(self.actors_tar)], dim=1)\\n q = critic_c(obs_n_o, action_cur_o).reshape(-1) # q \\n q_ = critic_t(obs_n_n, action_tar).reshape(-1) # q_ \\n q_ = q_*args.gamma*done_n + rew*torch.tensor(args.reward_scale_par, device=args.device) # q_*gamma*done + reward\\n loss_c = torch.nn.MSELoss()(q, q_.detach()) # bellman equation\\n opt_c.zero_grad()\\n loss_c.backward()\\n nn.utils.clip_grad_norm_(critic_c.parameters(), args.max_grad_norm)\\n opt_c.step()\\n\\n # --use the data to update the ACTOR\\n # There is no need to cal other agent's action\\n opt_c.zero_grad()\\n model_out, policy_c_new = actor_c( \\\\\\n obs_n_o[:, self.obs_size[agent_idx][0]:self.obs_size[agent_idx][1]], model_original_out=True)\\n # update the aciton of this agent\\n action_cur_o[:, self.action_size[agent_idx][0]:self.action_size[agent_idx][1]] = policy_c_new \\n loss_pse = torch.mean(torch.pow(model_out, 2))\\n loss_a = torch.mul(torch.tensor(-1.0, device=args.device), torch.mean(critic_c(obs_n_o, action_cur_o)))\\n\\n opt_a.zero_grad()\\n (2e-3*loss_pse+loss_a).backward()\\n #loss_a.backward()\\n nn.utils.clip_grad_norm_(actor_c.parameters(), args.max_grad_norm)\\n opt_a.step()\\n\\n # save the model to the path_dir ---cnt by update number\\n #if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model == 0:\\n if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model_step == 0:\\n time_now = time.strftime('%y%m_%d%H%M')\\n print('=time:{} step:{} save'.format(time_now, game_step))\\n model_file_dir = os.path.join(args.save_dir, '{}_{}_{}'.format( \\\\\\n args.scenario_name, time_now, game_step))\\n if not os.path.exists(model_file_dir): # make the path\\n os.mkdir(model_file_dir)\\n for agent_idx, (a_c, a_t, c_c, c_t) in \\\\\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, self.critics_tar)):\\n torch.save(a_c, os.path.join(model_file_dir, 'a_c_{}.pt'.format(agent_idx)))\\n torch.save(a_t, os.path.join(model_file_dir, 'a_t_{}.pt'.format(agent_idx)))\\n torch.save(c_c, os.path.join(model_file_dir, 'c_c_{}.pt'.format(agent_idx)))\\n torch.save(c_t, os.path.join(model_file_dir, 'c_t_{}.pt'.format(agent_idx)))\\n\\n # update the tar par\\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, args.tao) \\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, args.tao)\",\n \"def trainNet():\",\n \"def train(self):\\n if len(self.experience) < self.minibatch_size:\\n return\\n\\n # sample a minibatch_size of random episode with a number of transitions >= unrollings_num\\n random_episodes_indecies = np.random.choice(len(self.experience), self.minibatch_size)\\n random_episodes = []\\n for index in random_episodes_indecies:\\n episode = self.experience[index]\\n\\n # 0:random_transitions_space is the range from which a random transition\\n # can be picked up while having unrollings_num - 1 transitions after it\\n random_transitions_space = len(episode) - self.unrollings_num\\n random_start = np.random.choice(random_transitions_space, 1)\\n\\n random_episodes.append(episode[random_start:random_start + self.unrollings_num])\\n\\n state_shape = tuple([self.minibatch_size, self.unrollings_num] + self.state_shape)\\n\\n # prepare the training data\\n states = np.empty(state_shape, dtype=np.float32)\\n next_states = np.empty(state_shape, dtype=np.float32)\\n rewards = np.empty((self.minibatch_size, self.unrollings_num, ), dtype=np.float32)\\n transition_action_filters = np.zeros((self.minibatch_size, self.unrollings_num, self.actions_count), dtype=np.float32)\\n next_legal_actions_filters = np.zeros((self.minibatch_size, self.unrollings_num, self.actions_count), dtype=np.float32)\\n\\n for i, episode in enumerate(random_episodes):\\n for j, transition in enumerate(episode):\\n state, action, reward, nextstate, next_legal_actions = transition\\n\\n states[i,j], rewards[i,j], next_states[i,j] = state, reward, nextstate\\n transition_action_filters[i,j][action] = 1.0\\n next_legal_actions_filters[i,j][next_legal_actions] = 1.0\\n\\n self.prediction_nn.clearLSTMS(self.session)\\n self.target_nn.clearLSTMS(self.session)\\n\\n loss,_ = self.session.run([self.loss, self.finalize], {\\n self.states: states,\\n self.next_states: next_states,\\n self.rewards: np.reshape(rewards, (self.minibatch_size * self.unrollings_num, )),\\n self.transition_action_filters: np.reshape(transition_action_filters, (self.minibatch_size * self.unrollings_num, self.actions_count)),\\n self.next_legal_actions_filters: np.reshape(next_legal_actions_filters, (self.minibatch_size * self.unrollings_num, self.actions_count))\\n })\\n\\n if self.iteration != 0 and self.iteration % self.freeze_period == 0:\\n self.target_nn.assign_to(self.prediction_nn, self.session)\\n\\n self.iteration += 1\\n\\n return loss, self.iteration\",\n \"def train_SN(model, optimizer, scheduler, episodes=1):\\n model = model.to(device=device) # move the model parameters to CPU/GPU\\n for episode in range(episodes):\\n scheduler.step(episode)\\n model.train() # set to train mode\\n\\n # make the samplers \\n # make 2 samplers, one for the \\\"sample/training set\\\" of a one-shot classifier\\n # other sampler is for the \\\"query/test set\\\" which provides many comparisons\\n train_sample_sampler = SampleSampler(num_cl=NUM_CL)\\n sampled_classes = train_sample_sampler.cl_list\\n sampled_examples = train_sample_sampler.ex_list\\n train_query_sampler = QuerySampler(sampled_classes, sampled_examples, num_inst=NUM_EX)\\n\\n # make the dataloaders\\n s_batch_num = 1 # one shot \\\"training\\\" each\\n q_batch_num = NUM_EX # pair up number of examples per class in a batch (default 19)\\n train_sample_loader = DataLoader(omni_train, batch_size=s_batch_num, sampler=train_sample_sampler)\\n train_query_loader = DataLoader(omni_train, batch_size=q_batch_num, sampler=train_query_sampler)\\n \\n # start training\\n scores = torch.zeros(NUM_CL,(NUM_EX+NUM_CL-1)).to(device=device, dtype=dtype)\\n targets = torch.zeros(NUM_CL,(NUM_EX+NUM_CL-1)).to(device=device, dtype=dtype)\\n sample_count = 0\\n for i, (sample, sample_label) in enumerate(train_sample_loader):\\n sample_count += 1\\n idx = 0\\n for j, (batch, batch_labels) in enumerate(train_query_loader):\\n if sample_label != batch_labels[0]:\\n k = np.random.randint(NUM_EX)\\n query = batch[k,:,:,:].to(device=device, dtype=dtype)\\n query = query.view(1,1,IMG_SIZE,IMG_SIZE)\\n sample = sample.to(device=device, dtype=dtype)\\n targets[i,idx] = make_target(sample_label, batch_labels[0])\\n scores[i,idx] = model(sample,query)\\n idx += 1\\n \\n elif sample_label == batch_labels[0]:\\n for k in range(NUM_EX):\\n query = batch[k,:,:,:].to(device=device, dtype=dtype)\\n query = query.view(1,1,IMG_SIZE,IMG_SIZE)\\n sample = sample.to(device=device, dtype=dtype)\\n targets[i,idx] = make_target(sample_label, batch_labels[0])\\n scores[i,idx] = model(sample,query)\\n idx += 1\\n \\n targets = targets.view(-1)\\n scores = scores.view(-1)\\n \\n # train and update model\\n optimizer.zero_grad()\\n #loss = F.binary_cross_entropy(scores, targets)\\n loss = F.mse_loss(scores, targets)\\n loss.backward()\\n #nn.utils.clip_grad_norm_(model.parameters(),0.5)\\n optimizer.step()\\n\\n # episodic updates\\n if (episode+1)%100 == 0:\\n print(\\\"episode:\\\",episode+1,\\\"loss\\\",loss.data)\\n\\n if (episode+1)%1000 == 0:\\n ''' Test the model '''\\n # make the samplers \\n test_sample_sampler = SampleSampler(total_cl=659)\\n sampled_classes = test_sample_sampler.cl_list\\n sampled_examples = test_sample_sampler.ex_list\\n test_query_sampler = QuerySampler(sampled_classes, sampled_examples, num_inst=1)\\n\\n # make the dataloaders\\n s_batch_num = 1 # one shot each\\n q_batch_num = 1 # one test each\\n test_sample_loader = DataLoader(omni_test, batch_size=s_batch_num, sampler=test_sample_sampler)\\n test_query_loader = DataLoader(omni_test, batch_size=q_batch_num, sampler=test_query_sampler)\\n check_accuracy(test_sample_loader, test_query_loader, model)\\n\\n if (episode+1)%100000 == 0:\\n \\\"\\\"\\\" Save as a draft model \\\"\\\"\\\"\\n torch.save(model.state_dict(), PATH)\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def start_training(self):\\n i = 0\\n for _ in range(self.train_steps):\\n print(f\\\"Start Training Step {i + 1}\\\")\\n self.model.learn(total_timesteps=self.total_time_steps)\\n self.model.save(self.save_path)\\n print(f\\\"Finished Training Step {i + 1}\\\")\\n i += 1\",\n \"def _train_epoch(self, model, tqdm_data,\\n optimizer_disc=None, optimizer_gen=None):\",\n \"def train_epoch(self):\\r\\n for loader in self.loaders:\\r\\n if self.epoch % loader.epoch_interval == 0:\\r\\n self.cycle_dataset(loader)\\r\\n\\r\\n self._stats_new_epoch()\\r\\n self._write_tensorboard()\\r\\n print('{}th epoch train / eval done!'.format(self.epoch))\",\n \"def train_multiple_eps(self, env, no_episodes=200, horizon=1000, lr=0.1):\\n\\n\\t\\tr_vec = []\\n\\t\\tep_len_vec = []\\n\\t\\tfor i in range(no_episodes):\\n\\n\\t\\t\\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\\n\\t\\t\\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the information\\n\\t\\t\\tr_vec.append(r_ep)\\n\\t\\t\\tep_len_vec.append(ep_len)\\n\\n\\t\\treturn r_vec, ep_len_vec\",\n \"def train(self):\\r\\n\\r\\n for cur_epoch in range(self.model.cur_epoch_tensor.eval(self.sess), self.config.num_epochs + 1, 1):\\r\\n self.train_epoch(cur_epoch)\\r\\n self.model.global_step_assign_op.eval(session=self.sess, feed_dict={\\r\\n self.model.global_step_input: self.model.global_step_tensor.eval(self.sess) + 1})\",\n \"def train():\\n pass\",\n \"def train_step(self):\\n step_actions = self.get_step_actions()\\n *_, dones, _ = tf.numpy_function(\\n self.step_envs, [step_actions, True, True], self.batch_dtypes\\n )\\n for done_idx in tf.where(dones):\\n gradient_steps = self.gradient_steps or self.episode_steps[done_idx[0]]\\n self.update_weights(gradient_steps)\\n self.episode_steps.assign(\\n (self.episode_steps + self.step_increment) * (1 - dones)\\n )\",\n \"def train(self, epoches, batch_size):\\n def _padding_batch(x_inputs, y_inputs):\\n # x_inputs is 2-d array\\n max_length = max([len(x) for x in x_inputs])\\n real_length = [len(x) for x in x_inputs]\\n\\n x_outputs = []\\n for x in x_inputs:\\n padding_size = max_length - len(x)\\n x_outputs.append(\\n np.concatenate([np.array(x), np.zeros(padding_size,\\n dtype=\\\"int32\\\")]))\\n return np.array(x_outputs), np.array(y_inputs), real_length\\n\\n\\n x_inputs, y_inputs = self.convert_data_to_model_input(self.train_data)\\n test_x_inputs, test_y_inputs = self.convert_data_to_model_input(self.test_data, add_unknow_words=False)\\n test_x_inputs, test_y_inputs, test_real_length = _padding_batch(test_x_inputs,\\n test_y_inputs)\\n\\n self.save_lexicon(\\\"log/lexicon\\\")\\n\\n train_x_inputs = x_inputs[0:11000]\\n train_y_inputs = y_inputs[0:11000]\\n\\n validate_x_inputs = x_inputs[11000:]\\n validate_y_inputs = y_inputs[11000:]\\n validate_x_inputs, validate_y_inputs, validate_real_length = _padding_batch(\\n validate_x_inputs, validate_y_inputs)\\n\\n assert len(train_y_inputs) == len(train_x_inputs)\\n assert len(validate_y_inputs) == len(validate_x_inputs)\\n print(\\\"train {} validate {} test {}\\\".format(len(train_y_inputs),\\n len(validate_y_inputs), len(test_y_inputs)))\\n assert len(self.vocab) == len(self.embeddings)\\n\\n # do training\\n batches = len(train_y_inputs) // batch_size\\n\\n rnn_model = RnnTextClassifyModel(\\n class_number=len(self.labels), learning_rate=0.01,\\n gradients_norm=5, keep_rate=0.5, vocab_size=len(self.vocab),\\n embedding_size=self.embedding_size, hidden_units_size=128)\\n\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n\\n # must assigned\\n embedding_input = tf.constant(np.array(self.embeddings), dtype=tf.float32)\\n assign_embedding_op = tf.assign(rnn_model.embeddings, embedding_input)\\n embedding_in_graph = sess.run(assign_embedding_op);\\n\\n global_step = 0\\n for epoch in range(epoches):\\n print(\\\"training @ epoch \\\", epoch)\\n for i in range(batches):\\n\\n x_inputs_batch = train_x_inputs[i * batch_size:(i+1) *\\n batch_size]\\n y_inputs_batch = train_y_inputs[i * batch_size:(i+1) *\\n batch_size]\\n x_inputs_batch, y_inputs_batch, real_length = _padding_batch(\\n x_inputs_batch, y_inputs_batch)\\n\\n loss_val, _ = sess.run(\\n [rnn_model.loss, rnn_model.train_op],\\n {rnn_model.x_holder:x_inputs_batch,\\n rnn_model.y_holder:y_inputs_batch,\\n rnn_model.sequence_length: real_length})\\n\\n print(\\\"loss {} @ step {}\\\".format(loss_val, global_step))\\n\\n #saver.save(sess, \\\"log/cnn_model\\\", global_step=global_step)\\n global_step += 1\\n\\n if global_step % 100 == 0:\\n print(\\\"______validating\\\")\\n accuracy_val = sess.run(rnn_model.accuracy,\\n {rnn_model.x_holder: validate_x_inputs,\\n rnn_model.y_holder: validate_y_inputs,\\n rnn_model.sequence_length: validate_real_length,\\n rnn_model.keep_rate : 1.0})\\n print(\\\"______valiation_accuracy {} at step {}\\\".format(accuracy_val,\\n global_step))\\n\\n accuracy_val = sess.run(rnn_model.accuracy,\\n {rnn_model.x_holder: x_inputs_batch,\\n rnn_model.y_holder: y_inputs_batch,\\n rnn_model.sequence_length: real_length,\\n rnn_model.keep_rate : 1.0})\\n print(\\\"______train_accuracy {} at step {}\\\".format(accuracy_val,\\n global_step))\\n\\n\\n if batches * batch_size < len(train_y_inputs):\\n x_inputs_batch = train_x_inputs[batches * batch_size:]\\n y_inputs_batch = train_y_inputs[batches * batch_size:]\\n x_inputs_batch, y_inputs_batch, real_length = _padding_batch(\\n x_inputs_batch, y_inputs_batch)\\n\\n loss_val, _ = sess.run(\\n [rnn_model.loss, rnn_model.train_op],\\n {rnn_model.x_holder:x_inputs_batch,\\n rnn_model.y_holder:y_inputs_batch,\\n rnn_model.sequence_length: real_length})\\n\\n print(\\\"loss {} @ step {}\\\".format(loss_val, global_step))\\n global_step += 1\\n\\n # do evaluate on test data\\n print(\\\"______test accuracy on epoch \\\", epoch)\\n accuracy_val = sess.run(rnn_model.accuracy,\\n {rnn_model.x_holder: test_x_inputs,\\n rnn_model.y_holder: test_y_inputs,\\n rnn_model.sequence_length: test_real_length,\\n rnn_model.keep_rate : 1.0})\\n\\n print(\\\"______test_accuracy {} at epoch {}\\\".format(accuracy_val,\\n epoch))\",\n \"def train_workers(self):\\n args = dict(actor=self.actor,\\n critic=self.critic,\\n gamma=self.gamma,\\n lamda=self.lamda or self.gamma / 1.005,\\n device=self.device,\\n optimizers=[self.actor_optimizer, self.critic_optimizer])\\n workers = [Worker(i, self.action_size, self.state_size, **args)\\n for i in range(self.n_workers)\\n ]\\n\\n print(f'Worker count: {len(workers)}')\\n\\n for worker in workers:\\n worker.start()\\n\\n while len(constants.scores) < self.n_steps:\\n time.sleep(400) # save checkpoint every 400 ms\\n\\n print(f'\\\\nCurrent scores: {constants.scores}')\\n\\n self.save(constants.episode)\\n print(f'\\\\nCheckpoint saved at episode: {constants.episode}\\\\n')\",\n \"def train_fru(model, epochs=EPOCHS):\\n train(model, epochs=epochs, dataset=FRUDataset)\",\n \"def train_multiple_eps_dynamic(self, env, no_episodes=200, ng_int=50, horizon=1000, lr=0.1):\\n\\n\\t\\tr_vec = []\\n\\t\\tep_len_vec = []\\n\\t\\ttasks = 0\\n\\t\\tfor i in range(no_episodes):\\n\\t\\t\\tif(i % ng_int == 0):\\n\\t\\t\\t\\tgoal_index = [0, 12, 156, 168]\\n\\t\\t\\t\\tnew_goal = [goal_index[tasks]]\\n\\t\\t\\t\\ttasks += 1\\n\\t\\t\\t\\tenv.reset(loc_r=new_goal, loc_t=new_goal)\\n\\t\\t\\t\\t# new_goal = sample(env.listGoalStates(), 1)\\n\\t\\t\\t\\t# env.reset(loc_r=new_goal, loc_t=new_goal)\\n\\n\\t\\t\\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\\n\\t\\t\\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the information\\n\\t\\t\\tr_vec.append(r_ep)\\n\\t\\t\\tep_len_vec.append(ep_len)\\n\\n\\t\\treturn r_vec, ep_len_vec\",\n \"def train(self, environment, seed=0):\\n # set the seeds\\n np.random.seed(seed)\\n environment.seed(seed)\\n # prepare the file for the results\\n save_results = SaveResults()\\n save_results.set_seed(seed)\\n\\n # prepare to display the states\\n if self.parameters[\\\"display_environment\\\"]:\\n self.show_render = ShowRender()\\n\\n for t in tqdm(range(1, self.parameters[\\\"number_episodes\\\"] + 1)):\\n self._train_simulate(environment, t)\\n\\n if not t % 200:\\n save_results.write_message_in_a_file(\\\"score\\\", self.score)\",\n \"def fit(self, env, env_eval, num_iterations, max_episode_length=None):\\n train_counter = 0;\\n eval_res_hist = np.zeros((1,3));\\n\\n time_this, ob_this, is_terminal = env.reset()\\n\\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\\n\\n setpoint_this = ob_this[6:8]\\n \\n this_ep_length = 0;\\n flag_print_1 = True;\\n flag_print_2 = True;\\n action_counter = 0;\\n \\n for step in range(num_iterations):\\n #Check which stage is the agent at. If at the collecting stage,\\n #then the actions will be random action.\\n if step <= self._num_burn_in:\\n if flag_print_1:\\n logging.info (\\\"Collecting samples to fill the replay memory...\\\");\\n flag_print_1 = False;\\n\\n action_mem = self.select_action(None, stage = 'collecting');\\n action = self._policy.process_action(setpoint_this, action_mem)\\n\\n else:\\n if flag_print_2:\\n logging.info (\\\"Start training process...\\\");\\n flag_print_2 = False;\\n\\n obs_this_net = self._preprocessor.process_observation_for_network(\\n ob_this, self._min_array, self._max_array)\\n \\n state_this_net = np.append(obs_this_net[0:13], obs_this_net[14:]).reshape(1,16)\\n\\n action_mem = self.select_action(state_this_net, stage = 'training')\\n # covert command to setpoint action \\n action = self._policy.process_action(setpoint_this, action_mem) \\n\\n action_counter = action_counter + 1 if action_counter < 4 else 1;\\n\\n time_next, ob_next, is_terminal = env.step(action)\\n ob_next = self._preprocessor.process_observation(time_next, ob_next)\\n \\n setpoint_next = ob_next[6:8]\\n \\n #check if exceed the max_episode_length\\n if max_episode_length != None and \\\\\\n this_ep_length >= max_episode_length:\\n is_terminal = True;\\n\\n #save sample into memory \\n self._memory.append(Sample(ob_this, action_mem, ob_next\\n , is_terminal))\\n\\n \\n #Check which stage is the agent at. If at the training stage,\\n #then do the training\\n if step > self._num_burn_in:\\n #Check the train frequency\\n if action_counter % self._train_freq == 0 \\\\\\n and action_counter > 0:\\n action_counter = 0;\\n #Eval the model\\n if train_counter % self._eval_freq == 0:\\n eval_res = self.evaluate(env_eval, self._eval_epi_num\\n , show_detail = True);\\n eval_res_hist = np.append(eval_res_hist\\n , np.array([step\\n , eval_res[0], eval_res[1]]).reshape(1, 3)\\n , axis = 0);\\n np.savetxt(self._log_dir + '/eval_res_hist.csv'\\n , eval_res_hist, delimiter = ',');\\n logging.info ('Global Step: %d, '%(step), 'evaluation average \\\\\\n reward is %0.04f, average episode length is %d.'\\\\\\n %eval_res);\\n \\n \\n #Sample from the replay memory\\n samples = self._preprocessor.process_batch(\\n self._memory.sample(self._batch_size), \\n self._min_array, self._max_array);\\n #Construct target values, one for each of the sample \\n #in the minibatch\\n samples_x = None;\\n targets = None;\\n for sample in samples:\\n sample_s = np.append(sample.obs[0:13], sample.obs[14:]).reshape(1,16)\\n sample_s_nex = np.append(sample.obs_nex[0:13], \\n sample.obs_nex[14:]).reshape(1,16)\\n sample_r = self._preprocessor.process_reward(sample.obs_nex[12:15])\\n\\n target = self.calc_q_values(sample_s);\\n a_max = self.select_action(sample_s_nex, stage = 'greedy');\\n \\n \\n\\n if sample.is_terminal:\\n target[0, sample.a] = sample_r;\\n else:\\n target[0, sample.a] = (sample_r\\n + self._gamma \\n * self.calc_q_values_1(\\n sample_s_nex)[0, a_max]);\\n if targets is None:\\n targets = target;\\n else:\\n targets = np.append(targets, target, axis = 0);\\n if samples_x is None:\\n samples_x = sample_s;\\n else:\\n samples_x = np.append(samples_x, sample_s, axis = 0);\\n #Run the training\\n \\n \\n feed_dict = {self._state_placeholder:samples_x\\n ,self._q_placeholder:targets}\\n sess_res = self._sess.run([self._train_op, self._loss]\\n , feed_dict = feed_dict);\\n \\n #Update the target parameters\\n if train_counter % self._target_update_freq == 0:\\n self.update_policy();\\n logging.info('Global Step %d: update target network.' \\n %(step));\\n #Save the parameters\\n if train_counter % self._save_freq == 0 or step + 1 == num_iterations:\\n checkpoint_file = os.path.join(self._log_dir\\n , 'model_data/model.ckpt');\\n self._saver.save(self._sess\\n , checkpoint_file, global_step=step);\\n \\n if train_counter % 100 == 0:\\n logging.info (\\\"Global Step %d: loss %0.04f\\\"%(step, sess_res[1]));\\n # Update the events file.\\n summary_str = self._sess.run(self._summary, feed_dict=feed_dict)\\n self._summary_writer.add_summary(summary_str, train_counter);\\n self._summary_writer.add_graph(self._sess.graph);\\n self._summary_writer.flush()\\n \\n train_counter += 1;\\n \\n #check whether to start a new episode\\n if is_terminal:\\n time_this, ob_this, is_terminal = env.reset()\\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\\n setpoint_this = ob_this[6:8]\\n\\n this_ep_length = 0;\\n action_counter = 0;\\n else:\\n ob_this = ob_next\\n setpoint_this = setpoint_next\\n time_this = time_next\\n this_ep_length += 1;\",\n \"def train(self, iterations=1):\\n for _ in range(iterations):\\n self.trainer.train()\\n self.test_network()\",\n \"def TrainOneStep(self):\\n pass\",\n \"def run(num_epochs, encoded_dim):\\n # for patient_ in get_patient_ids():\\n for patient_ in ['16']:\\n print(\\\"Starting on index: \\\" + str(patient_))\\n training_ae(num_epochs, encoded_dim, patient_, True)\\n print(\\\"Completed \\\" + str(patient_) + \\\" reconstruction and encoding, saved test data to assess performance\\\")\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def train_by_episode(self, last_value=0):\\n # implements A2C training from the last state\\n # to the first state\\n # discount factor\\n gamma = 0.95\\n r = last_value\\n # the memory is visited in reverse as shown\\n # in Algorithm 10.5.1\\n for item in self.memory[::-1]:\\n [step, state, next_state, reward, done] = item\\n # compute the return\\n r = reward + gamma*r\\n item = [step, state, next_state, r, done]\\n # train per step\\n # a2c reward has been discounted\\n self.train(item)\",\n \"def train(env, agents, data_log, n_episodes=10000, n_steps=None, generate_val_data=False, record_env=None, trainer=None):\\n # Setup logging and start code\\n logger = logging.getLogger('root')\\n step_tot = 0\\n logger.info(env.observation_space[0].high)\\n alphas = [agent.alpha for agent in trainer.agents]\\n data_log.log_var(\\\"alphas\\\", alphas)\\n\\n ep_generator = range(n_episodes) if n_episodes else itertools.count()\\n # Start training\\n for i in ep_generator:\\n # Do some logging\\n logger.info(\\\"episode:\\\" + str(i))\\n data_log.set_episode(i)\\n\\n # Periodically store networks\\n if i % 250 == 0: #was 25\\n store_networks(trainer, agents, data_log)\\n\\n # Run a single episode\\n score, step, extra_data = run_episode(env, agents, render=False, store_data=True, trainer=trainer)\\n\\n # Do more logging\\n logger.info(\\\"Score: \\\" + str(score))\\n step_tot += step\\n data_log.set_step(step_tot)\\n data_log.log_var(\\\"score\\\", score)\\n alphas = [agent.alpha for agent in trainer.agents]\\n data_log.log_var(\\\"alphas\\\", alphas)\\n\\n # Break training loop\\n if n_steps and step_tot > n_steps:\\n break\\n\\n #Periodically save logs\\n if i % 50 == 0: #was 5\\n logger.info(\\\"Saving log...\\\")\\n data_log.save()\\n logger.info(\\\"Saved log\\\")\\n\\n # Save logs one last time\\n logger.info(\\\"Saving log...\\\")\\n data_log.save()\\n logger.info(\\\"Saved log\\\")\\n return\",\n \"def Q_learning_train(env,alpha,gamma,epsilon,episodes):\\n %time\\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n if random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample() # Explore action space randomly\\n else:\\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n\\n next_state, reward, done, info = env.step(action) \\n\\n old_value = q_table[state, action]\\n next_max = np.max(q_table[next_state])\\n\\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\\n q_table[state, action] = new_value\\n\\n if reward == -10:\\n penalties += 1\\n \\n\\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n rewards.append(np.sum(episode_rewards))\\n \\n if i % 1000 == 0:\\n clear_output(wait=True)\\n print(f\\\"Episode: {i}\\\")\\n \\n \\n print(\\\"Training finished.\\\\n\\\")\\n \\n plt.plot(savgol_filter(rewards, 1001, 3, mode = \\\"interp\\\"))\\n plt.title(\\\"Smoothened training reward per episode\\\", pad = 30, size = BIGGER_SIZE)\\n plt.legend()\\n plt.xlabel('Episodes', labelpad = 20);\\n plt.ylabel('Total Reward', labelpad = 20);\\n plt.tick_params(axis='both', which='major');\\n plt.tick_params(axis='both', which='minor');\\n #plt.xlim(0, 60000);\\n #plt.ylim(0,50)\\n #plt.xticks(np.arange(0, episodes+1, 5000));\\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def learn(self):\\n\\n for i in range(1, self.args.numIters + 1):\\n # bookkeeping\\n log.info(f'Starting Iter #{i} ...')\\n # examples of the iteration\\n if not self.skipFirstSelfPlay or i > 1:\\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\\n\\n for _ in tqdm(range(self.args.numEps), desc=\\\"Self Play\\\"):\\n self.mcts = MCTS(self.game, self.nnet, self.args) # reset search tree\\n iterationTrainExamples += self.executeEpisode()\\n\\n # save the iteration examples to the history \\n self.trainExamplesHistory.append(iterationTrainExamples)\\n\\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\\n log.warning(\\n f\\\"Removing the oldest entry in trainExamples. len(trainExamplesHistory) = {len(self.trainExamplesHistory)}\\\")\\n self.trainExamplesHistory.pop(0)\\n # backup history to a file\\n # NB! the examples were collected using the model from the previous iteration, so (i-1) \\n self.saveTrainExamples(i - 1)\\n\\n # shuffle examples before training\\n trainExamples = []\\n for e in self.trainExamplesHistory:\\n trainExamples.extend(e)\\n shuffle(trainExamples)\\n\\n # training new network, keeping a copy of the old one\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\\n pmcts = MCTS(self.game, self.pnet, self.args)\\n\\n self.nnet.train(trainExamples)\\n nmcts = MCTS(self.game, self.nnet, self.args)\\n\\n log.info('PITTING AGAINST PREVIOUS VERSION')\\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game)\\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare)\\n\\n log.info('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) < self.args.updateThreshold:\\n log.info('REJECTING NEW MODEL')\\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename='temp.pth.tar')\\n else:\\n log.info('ACCEPTING NEW MODEL')\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename='best.pth.tar')\",\n \"def train(nepochs, model): \\n if model == 'cnn':\\n return gennet.train_cnn(nepochs, 'Resnet50')\\n elif model == 'logreg':\\n return gennet.train_logreg('Resnet50')\",\n \"def train(self,\\n num_episodes = 100,\\n num_steps = 500000,\\n max_steps_per_episode = 10000,\\n target_interval = 10000,\\n learning_interval = 4,\\n frame_skip = 1,\\n warmup_steps = None,\\n pretrain_steps = None,\\n output_freq = 50,\\n save_freq = 5, \\n store_memory = False):\\n \\n # prefill memory with random transitions if requested\\n if warmup_steps is not None:\\n self._random_warmup(warmup_steps)\\n \\n # pretrain the agent on its on own memory\\n if pretrain_steps is not None:\\n self._pretrain(pretrain_steps, target_interval)\\n \\n # logging initialization\\n self._score, self._q_values, self._losses = 0., [], []\\n raw_frames = np.zeros(shape = (max_steps_per_episode, *self.env._unprocessed_frame.shape), dtype = np.uint8)\\n\\n episode_idx = 0\\n while episode_idx < num_episodes or self._step_counter < num_steps:\\n # reset environment and get first state\\n self._start_episode()\\n \\n for i in range(max_steps_per_episode):\\n \\n #-------------------------------------------------------------------------------#\\n #####################\\n # Interactive Phase #\\n #####################\\n \\n # choose an action, observe reactions of the environment and\\n # add this experience to the agent's memory \\n if self._step_counter % frame_skip == 0: \\n action = self._make_decision()\\n new_frame, reward, done, _ = self.env.step(action)\\n self.memory.add_experience(action, reward, new_frame, 1, done)\\n \\n # update current state\\n self._current_state[0, :(self.num_stacked_frames-1)] = self._current_state[0, 1:]\\n self._current_state[0, self.num_stacked_frames-1] = new_frame\\n #-------------------------------------------------------------------------------#\\n \\n \\n #-------------------------------------------------------------------------------#\\n ##################\\n # Learning Phase #\\n ##################\\n \\n # perform a parameter update of the current policy model\\n if self._step_counter % learning_interval == 0:\\n self._batch_update()\\n \\n # update the target model\\n if self._step_counter % target_interval == 0:\\n self._update_target_model()\\n #-------------------------------------------------------------------------------#\\n \\n # logging\\n self._score += self.env._unprocessed_reward\\n raw_frames[i] = self.env._unprocessed_frame\\n \\n \\n self._step_counter += 1\\n \\n if self.env.was_real_done:\\n self.logger.add_episode_logs(self._step_counter, self._score, self._q_values, self._losses, raw_frames[:i])\\n self._score, self._q_values, self._losses = 0., [], []\\n break\\n \\n if done:\\n self.env.reset()\\n \\n \\n if not self.env.was_real_done:\\n self.memory.add_experience(action, reward, new_frame, 1, True)\\n self.logger.add_episode_logs(self._step_counter, self._score, self._q_values, self._losses, raw_frames[:i])\\n self._score, self._q_values, self._losses = 0., [], []\\n \\n if episode_idx%(num_episodes/output_freq)==0:\\n validation_score, validation_frames = self.test(record = True, max_steps_per_episode = max_steps_per_episode)\\n #validation_score, validation_frames = 0, []\\n lower_idx = int(clip(episode_idx-(num_episodes/output_freq)+1, 0, num_episodes-1))\\n self.logger.show_progress(lower_idx, episode_idx, validation_score, validation_frames, self.policy_network.model)\\n \\n if episode_idx%(num_episodes/save_freq)==0:\\n self.logger.make_plots()\\n self.logger.save_all(self.policy_network.model, self.memory, store_memory)\\n \\n \\n\\n episode_idx += 1 \\n print('==========================\\\\ntraining session completed\\\\n==========================\\\\n\\\\n\\\\n=======\\\\nSummary\\\\n======='\\n )\\n self.logger.show_progress(0, num_episodes, summary = True)\\n self.logger.make_plots()\\n self.logger.save_all(self.policy_network.model, self.memory, store_memory)\",\n \"def _Train(self, limit):\\n if len(self.Memory)>BATCH_SIZE: \\n # Limit of Agents to Train\\n for i in range(limit): \\n # 'n' number of rounds to train \\n for _ in range(50):\\n # Get Batch Data\\n experiances = self.Memory.sample()\\n # Train Models\\n self._Learn(self.Actor[i], self.ActorTarget, self.actorOpt[i], experiances)\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def init_trainers(self, args):\\n self.actors_cur = [None for _ in range(self.num_agents)]\\n self.critics_cur = [None for _ in range(self.num_agents)]\\n self.actors_tar = [None for _ in range(self.num_agents)]\\n self.critics_tar = [None for _ in range(self.num_agents)]\\n self.optimizers_c = [None for _ in range(self.num_agents)]\\n self.optimizers_a = [None for _ in range(self.num_agents)]\\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\\n\\n if args.restore == True: # restore the model\\n game_step = int(args.old_model_name.split('_')[-1][:-1])\\n for idx in range(self.num_agents):\\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\\n self.var = self.min_var if self.var < self.min_var else self.var\\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\\n\\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\\n for i in range(self.num_agents):\\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\\n\\n # return the old data, no need to update the trainers\\n if args.restore == True: return old_data\\n\\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur\",\n \"def train_episode(self, max_episode_length):\\n\\n # Populate the buffer\\n self.populate_buffer(max_episode_length)\\n\\n # weight updates\\n replay_samples = self.replay_buffer.sample(self.buffer_sample_size)\\n state_batch = torch.from_numpy(replay_samples[0]).to(DEVICE)\\n action_batch = torch.from_numpy(replay_samples[1]).to(DEVICE)\\n reward_batch = (\\n torch.from_numpy(replay_samples[2]).to(DEVICE).unsqueeze(1)\\n )\\n next_state_batch = torch.from_numpy(replay_samples[3]).to(DEVICE)\\n dones = (\\n torch.from_numpy(replay_samples[4])\\n .type(torch.long)\\n .to(DEVICE)\\n .unsqueeze(1)\\n )\\n\\n # alpha must be clamped with a minumum of zero, so use exponential.\\n alpha = self.log_alpha.exp().detach()\\n\\n with torch.no_grad():\\n # Figure out value function\\n next_actions, log_next_actions, _ = self.policy.sample(\\n next_state_batch\\n )\\n target_q1, target_q2 = self.avg_q_net(\\n next_state_batch, next_actions\\n )\\n target_q = torch.min(target_q1, target_q2)\\n next_state_values = target_q - alpha * log_next_actions\\n\\n # Calculate Q network target\\n done_floats = dones.type(torch.float)\\n q_target = reward_batch.clone()\\n q_target += self.gamma * done_floats * next_state_values\\n\\n # Q net outputs values for all actions, so we index specific actions\\n q1, q2 = self.q_net(state_batch, action_batch)\\n q1_loss = F.mse_loss(q1, q_target)\\n q2_loss = F.mse_loss(q2, q_target)\\n\\n # policy loss\\n actions_pi, log_probs_pi, action_dist = self.policy.sample(state_batch)\\n q1_pi, q2_pi = self.q_net(state_batch, actions_pi)\\n q_pi = torch.min(q1_pi, q2_pi)\\n policy_loss = ((alpha * log_probs_pi) - q_pi).mean()\\n\\n # update parameters\\n self.q_optim.zero_grad()\\n q1_loss.backward()\\n self.q_optim.step()\\n\\n self.q_optim.zero_grad()\\n q2_loss.backward()\\n self.q_optim.step()\\n\\n self.policy_optim.zero_grad()\\n policy_loss.backward()\\n self.policy_optim.step()\\n\\n # automatic entropy tuning\\n alpha_loss = (\\n self.log_alpha * (log_probs_pi + self.entropy_target).detach()\\n )\\n alpha_loss = -alpha_loss.mean()\\n\\n if self.entropy_tuning:\\n self.alpha_optim.zero_grad()\\n alpha_loss.backward()\\n self.alpha_optim.step()\\n\\n # Step average Q net\\n move_average(self.q_net, self.avg_q_net, self.tau)\\n\\n # logging\\n self.tbx_logger(\\n {\\n \\\"loss/q1 loss\\\": q1_loss.item(),\\n \\\"loss/q2 loss\\\": q2_loss.item(),\\n \\\"loss/pi loss\\\": policy_loss.item(),\\n \\\"loss/alpha loss\\\": alpha_loss.item(),\\n \\\"Q/avg_q_target\\\": q_target.mean().item(),\\n \\\"Q/avg_q1\\\": q1.mean().item(),\\n \\\"Q/avg_q2\\\": q2.mean().item(),\\n \\\"Q/avg_reward\\\": reward_batch.mean().item(),\\n \\\"Q/avg_V\\\": next_state_values.mean().item(),\\n \\\"H/alpha\\\": alpha.item(),\\n \\\"H/pi_entropy\\\": action_dist.entropy().mean(),\\n \\\"H/pi_log_pi\\\": log_probs_pi.mean(),\\n },\\n self.training_i,\\n )\\n\\n self.training_i += 1\\n self.checkpointer.increment_counter()\",\n \"def TrainEpoch(ss):\\n ss.StopNow = False\\n curEpc = ss.TrainEnv.Epoch.Cur\\n while True:\\n ss.TrainTrial()\\n if ss.StopNow or ss.TrainEnv.Epoch.Cur != curEpc:\\n break\\n ss.Stopped()\",\n \"def enjoy_model(env, obs_placeholder, epsilon_placeholder, stochastic_placeholder,\\n output_actions, sess, num_episodes=1):\\n for _ in range(num_episodes):\\n obs, done = env.reset(), False\\n episode_rew = 0\\n while not done:\\n env.render()\\n time.sleep(0.02)\\n feed_dict = {obs_placeholder: np.array(obs).reshape((1,) + obs.shape),\\n epsilon_placeholder: 0.0,\\n stochastic_placeholder: False}\\n action = sess.run(output_actions, feed_dict)[0]\\n obs, rew, done, _ = env.step(action)\\n episode_rew += rew\\n print(\\\"Episode rew\\\", episode_rew)\\n time.sleep(1)\",\n \"def _train_epochs(self, data, model, n_epochs, start_epoch, start_step, dev_data, teacher_forcing_ratio, early_stopping_patience):\\n print_loss_total = 0 # Reset every print_every\\n epoch_loss_total = 0 # Reset every epoch\\n\\n device = None if torch.cuda.is_available() else -1\\n batch_iterator = torchtext.data.BucketIterator(data, batch_size=self.batch_size, repeat=False,\\n sort_key=lambda x: len(x.src),\\n shuffle=True, device=device, sort=False, sort_within_batch=True)\\n\\n steps_per_epoch = len(batch_iterator)\\n total_steps = steps_per_epoch * n_epochs\\n\\n step = start_step\\n step_elapsed = 0\\n previous_dev_loss = 10e6\\n dev_loss_increased_epochs = 0\\n for epoch in range(start_epoch, n_epochs + 1):\\n self.logger.info(\\\"Epoch: %d, Step: %d\\\" % (epoch, step))\\n\\n batch_generator = batch_iterator.__iter__()\\n # consuming seen batches from previous training\\n for _ in range((epoch - 1) * steps_per_epoch, step):\\n next(batch_generator)\\n\\n model.train(True)\\n for batch in batch_generator:\\n step += 1\\n step_elapsed += 1\\n\\n input_variables, input_lengths = getattr(batch, UTTERANCE_FIELD_NAME)\\n target_variables = getattr(batch, RESPONSE_FIELD_NAME)\\n emotion_variables = getattr(batch, EMOTION_FIELD_NAME)\\n\\n loss = self.train_batch(input_variables, input_lengths.tolist(), target_variables, emotion_variables,\\n model, teacher_forcing_ratio)\\n\\n # Record average loss\\n print_loss_total += loss\\n epoch_loss_total += loss\\n\\n if step % self.print_every == 0 and step_elapsed > self.print_every:\\n print_loss_avg = print_loss_total / self.print_every\\n print_loss_total = 0\\n log_msg = 'Progress: %.2f%%, Train %s: %.4f' % (\\n step / total_steps * 100,\\n self.loss.name,\\n print_loss_avg)\\n self.logger.info(log_msg)\\n beam_search = EmotionSeq2seq(model.encoder, EmotionTopKDecoder(model.decoder, 20))\\n predictor = Predictor(beam_search, data.vocabulary, data.emotion_vocabulary)\\n seq = \\\"how are you\\\".split()\\n self.logger.info(\\\"Happy: \\\" + \\\" \\\".join(predictor.predict(seq, 'happiness')))\\n self.logger.info(\\\"Angry: \\\" + \\\" \\\".join(predictor.predict(seq, 'anger')))\\n\\n # Checkpoint\\n if step % self.checkpoint_every == 0 or step == total_steps:\\n Checkpoint(model=model,\\n optimizer=self.optimizer,\\n epoch=epoch, step=step).save(self.expt_dir)\\n\\n if step_elapsed == 0:\\n continue\\n\\n epoch_loss_avg = epoch_loss_total / min(steps_per_epoch, step - start_step)\\n epoch_loss_total = 0\\n log_msg = \\\"Finished epoch %d: Train %s: %.4f\\\" % (epoch, self.loss.name, epoch_loss_avg)\\n if dev_data is not None:\\n dev_loss, accuracy = self.evaluator.evaluate(model, dev_data)\\n self.optimizer.update(dev_loss)\\n log_msg += \\\", Dev %s: %.4f, Accuracy: %.4f\\\" % (self.loss.name, dev_loss, accuracy)\\n model.train(mode=True)\\n if dev_loss > previous_dev_loss:\\n dev_loss_increased_epochs += 1\\n if dev_loss_increased_epochs == early_stopping_patience:\\n self.logger.info(\\\"EARLY STOPPING\\\")\\n break\\n else:\\n dev_loss_increased_epochs = 0\\n previous_dev_loss = dev_loss\\n Checkpoint(model=model,\\n optimizer=self.optimizer,\\n epoch=epoch, step=step).save(self.expt_dir)\\n else:\\n self.optimizer.update(epoch_loss_avg)\\n\\n self.logger.info(log_msg)\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n player = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, player)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, player, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, player = self.game.getNextState(board, player, action)\\n\\n r = self.game.getGameEnded(board, player)\\n\\n if r != 0:\\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\\n return ex\",\n \"def train(self):\\n self.emission_model(self.train_data)\\n self.transition_model(self.train_data)\",\n \"def training(self, dataset, repeat=1, gamma=1.0, learning_rate=0.1, model='3yo'):\\n for _ in range(repeat):\\n for episode in dataset:\\n # 1- Get the data stored inside the dataset\\n image_index = episode[0] # image of the object\\n label_index = episode[1] # label given by the informant\\n informant_index = episode[2] # a integer representing the informant\\n informant_action = episode[3] # 0=reject, 1=accept\\n\\n # 2- The agent take an action (with softmax) considering is current state-action table\\n # [0=cup, 1=book, 2=ball]\\n col = (image_index * self.tot_images) + label_index\\n action_array = self.actor_matrix[:, col]\\n action_distribution = self._softmax(action_array)\\n child_action = np.random.choice(self.tot_actions,\\n 1,\\n p=action_distribution) # select the action through softmax\\n\\n # 3- (External) New state and reward obtained from the environment\\n # u_t = self.critic_vector[0, col] # previous state\\n # New state is estimated, in this simple case nothing happen\\n # because the next state is terminal\\n # u_t1 = u_t # Only in this example they are the same\\n\\n # 4- (Intrinsic) The informant_reputation is updated:\\n # agent_action, agent_confidence, informant_action, reward\\n # informant_vector: 0=unreliable, 1=reliable\\n # do_actions_agree: False, True\\n # Estimating child_confidence\\n distance = np.absolute(action_distribution[0] - action_distribution[1])\\n child_confidence_distribution = [1 - distance, distance] # non-knowledgeable, knowledgeable\\n child_confidence = np.random.choice(2, 1, p=child_confidence_distribution)\\n # Check if child and informant agree\\n if (child_action == informant_action):\\n do_actions_agree = True\\n else:\\n do_actions_agree = False\\n # Increment the counter in the informant_vector.\\n # Here we update the counter distribtuion only if\\n # the child is confident, because it is only in that\\n # case that the child can say if the informant is\\n # reliable or not.\\n if (do_actions_agree == False and child_confidence == 1):\\n self.informant_vector[informant_index][0] += 1 # unreliable\\n elif (do_actions_agree == True and child_confidence == 1):\\n self.informant_vector[informant_index][1] += 1 # reliable\\n elif (do_actions_agree == False and child_confidence == 0):\\n self.informant_vector[informant_index][1] += 0 # reliable\\n self.informant_vector[informant_index][0] += 0 # unreliable\\n elif (do_actions_agree == True and child_confidence == 0):\\n self.informant_vector[informant_index][1] += 0 # reliable\\n self.informant_vector[informant_index][0] += 0 # unreliable\\n else:\\n raise ValueError(\\\"ERROR: anomaly in the IF condition for informant_vector update\\\")\\n # Using the informant_vector given as input it estimates the reputation of the informant\\n informant_reputation_distribution = np.true_divide(self.informant_vector[informant_index],\\n np.sum(self.informant_vector[informant_index]))\\n informant_reputation = np.random.choice(2, 1, p=informant_reputation_distribution)\\n\\n # 5- (Intrinsic) The Cost is estimated:\\n # current_state, agent_action, agent_confidence, informant_action, informant_reputation\\n # child_confidence: 0=non-knowledgeable, 1=knowledgeable\\n # informant_reputation: 0=non-knowledgeable, 1=knowledgeable\\n # action: 0=reject, 1=accept\\n # informant_action: 0=reject, 1=accept\\n cost = self._return_cost(child_confidence,\\n informant_reputation,\\n child_action,\\n informant_action,\\n value=model)\\n\\n # 6- The utility table is updated using: previous_state, current_state, cost, reward\\n # Updating the critic using Temporal Differencing Learning\\n # In this simple case there is not a u_t1 state.\\n # The current state is considered terminal.\\n # We can delete the term (gamma*u_t1)-u_t and considering\\n # only (reward-cost) as utility of the state (see Russel Norvig).\\n reward = 0 # only for intrinsic learning reward=0\\n delta = (reward - cost) # + (gamma*u_t1) - u_t\\n self.critic_vector[0, col] += learning_rate * delta\\n\\n # 7- The actor table is updated using the delta from the critic\\n # Update the ACTOR using the delta\\n self.actor_matrix[child_action, col] += learning_rate * delta # the current action\\n self.actor_matrix[1 - child_action, col] -= learning_rate * delta # the opposite action\",\n \"def train_ddpg(agent, env, n_episodes=400, max_t=1000, save=True):\\n # get the default brain\\n brain_name = env.brain_names[0]\\n scores_deque = deque(maxlen=100)\\n final_scores = []\\n not_solved = True\\n num_agents = len(env.reset()[brain_name].vector_observations)\\n best = 0\\n episodes_remaining = n_episodes\\n for i_episode in range(1, n_episodes+1):\\n env_info = env.reset()[brain_name]\\n states = env_info.vector_observations\\n agent.reset()\\n agent_scores = np.zeros(num_agents)\\n for t in range(max_t):\\n actions = agent.act(states)\\n env_info = env.step(actions)[brain_name]\\n next_states = env_info.vector_observations\\n rewards = env_info.rewards\\n dones = env_info.local_done\\n agent.step(states, actions, rewards, next_states, dones)\\n states = next_states\\n agent_scores += rewards\\n if np.any(dones):\\n break\\n\\n max_score = np.max(agent_scores)\\n scores_deque.append(max_score)\\n final_scores.append(max_score)\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}\\\\tScore: {:.2f}'.format(i_episode, np.mean(scores_deque), max_score), end=\\\"\\\", flush=True)\\n if len(scores_deque) == 100 and np.mean(scores_deque) > SOLVED_SCORE and not_solved:\\n not_solved = False\\n episodes_remaining = EPISODES_AFTER_SOLVE # try to increase score for some episodes\\n print(\\\"\\\\nEnvironment solved in {} episodes!\\\\n\\\".format(i_episode), flush=True)\\n if save:\\n torch.save(agent.actor_local.state_dict(), 'saved_models/actor_solved.pth')\\n torch.save(agent.critic_local.state_dict(), 'saved_models/critic_solved.pth')\\n if i_episode % 100 == 0:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)), flush=True)\\n\\n if not not_solved and i_episode % 5 == 0 and np.mean(scores_deque) > best:\\n best = np.mean(scores_deque)\\n if save:\\n torch.save(agent.actor_local.state_dict(), 'saved_models/best_actor.pth')\\n torch.save(agent.critic_local.state_dict(), 'saved_models/best_critic.pth')\\n\\n if not not_solved:\\n episodes_remaining -= 1\\n if episodes_remaining == 0:\\n break\\n\\n return final_scores\",\n \"def train(self, persist: bool = False, run: int = -1, checkpoint: int = -1):\\n self.meta = ICMMetaDataV1(fp=open(os.path.join(MODULE_CONFIG.BaseConfig.BASE_DIR, 'agent_stats.csv'), 'w'),\\n args=self.state.config)\\n train_start = time.time()\\n for episode in range(self.state.episodes):\\n start_time = time.time()\\n state = self.env.reset()\\n state = torch.reshape(tensor(state, dtype=torch.float32), [1, 84, 84, 4]).permute(0, 3, 1, 2).to(\\n self.device)\\n done = False\\n episode_reward = []\\n episode_loss = []\\n\\n # save network\\n # if episode % self.state.model_save_interval == 0:\\n # save_path = self.state.model_save_path + '/' + self.run_name + '_' + str(episode) + '.pt'\\n # torch.save(self.q_network.state_dict(), save_path)\\n # print('Successfully saved: ' + save_path)\\n\\n # Save Model\\n self.save(episode)\\n # Collect garbage\\n # To Do Later\\n\\n while not done:\\n\\n # update target network\\n if self.state.step % self.state.network_update_interval == 0:\\n print('Updating target network')\\n self.target_network.load_state_dict(self.q_network.state_dict())\\n\\n if self.state.step > len(self.replay_memory):\\n self.state.epsilon = max(self.state.final_epsilon,\\n self.state.initial_epsilon - self.state.epsilon_step * self.state.step)\\n if self.state.epsilon > self.state.final_epsilon:\\n self.state.mode = 'Explore'\\n else:\\n self.state.mode = 'Exploit'\\n\\n action, q = self.take_action(state, test=False, state_count=0)\\n next_state, reward, done, _ = self.env.step(action)\\n\\n next_state = torch.reshape(tensor(next_state, dtype=torch.float32), [1, 84, 84, 4]).permute(0, 3, 1,\\n 2).to(\\n self.device)\\n self.push((state, torch.tensor([int(action)]), torch.tensor([reward], device=self.device), next_state,\\n torch.tensor([done], dtype=torch.float32)))\\n episode_reward.append(reward)\\n self.state.step += 1\\n state = next_state\\n\\n # train network\\n if self.state.step >= self.start_to_learn and self.state.step % self.state.network_train_interval == 0:\\n loss = self.optimize_network()\\n episode_loss.append(loss)\\n\\n if done:\\n # print('Episode:', episode, ' | Steps:', self.state.step, ' | Eps: ', self.state.epsilon,\\n # ' | Reward: ',\\n # sum(episode_reward),\\n # ' | Avg Reward: ', np.mean(self.last_n_rewards), ' | Loss: ',\\n # np.mean(episode_loss), ' | Intrinsic Reward: ', sum(self.intrinsic_episode_reward),\\n # ' | Avg Intrinsic Reward: ', np.mean(self.last_n_intrinsic_rewards),\\n # ' | Mode: ', self.state.mode)\\n # print('Episode:', episode, ' | Steps:', self.state.step, ' | Eps: ', self.state.epsilon,\\n # ' | Reward: ',\\n # sum(episode_reward),\\n # ' | Avg Reward: ', np.mean(self.last_n_rewards), ' | Loss: ',\\n # np.mean(episode_loss), ' | Intrinsic Reward: ', sum(self.intrinsic_episode_reward),\\n # ' | Avg Intrinsic Reward: ', np.mean(self.last_n_intrinsic_rewards),\\n # ' | Mode: ', self.state.mode, file=self.log_file)\\n # self.log_summary(episode, episode_loss, episode_reward)\\n self.last_n_rewards.append(sum(episode_reward))\\n self.last_n_intrinsic_rewards.append(sum(self.intrinsic_episode_reward))\\n self.meta.update_episode(episode, self.state.step, self.state.epsilon,\\n sum(episode_reward), np.mean(self.last_n_rewards),\\n np.mean(episode_loss), sum(self.intrinsic_episode_reward),\\n np.mean(self.last_n_intrinsic_rewards), self.state.mode)\\n\\n episode_reward.clear()\\n episode_loss.clear()\\n self.intrinsic_episode_reward.clear()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75523275","0.743832","0.74258286","0.7422637","0.7364126","0.73365295","0.73187625","0.72586364","0.7242011","0.7233209","0.72105044","0.7161378","0.71507365","0.713142","0.71212167","0.71001995","0.7051916","0.7029939","0.7000444","0.6976201","0.69314533","0.6915431","0.69015545","0.6894078","0.68907684","0.68884885","0.6881044","0.68423784","0.679889","0.67598325","0.67593294","0.6724972","0.6722011","0.67207557","0.668557","0.66777647","0.6665364","0.6660342","0.6654145","0.6651742","0.66388226","0.663298","0.66253185","0.66232175","0.66160107","0.6615185","0.6581718","0.65808004","0.65801597","0.65799236","0.6573005","0.6571938","0.6570316","0.65682286","0.654321","0.6539214","0.6538776","0.65385246","0.65346813","0.6527291","0.65263265","0.6517368","0.65134066","0.6510297","0.65061164","0.6503084","0.64991164","0.6496695","0.6493429","0.6487343","0.64844394","0.64721686","0.647178","0.6454772","0.6454772","0.6454772","0.6454772","0.643299","0.6431333","0.64186037","0.6416292","0.6410764","0.6408612","0.64061856","0.64039975","0.6397238","0.6397238","0.6397238","0.6397238","0.6397238","0.638773","0.6385073","0.6384868","0.637654","0.63701266","0.63694817","0.6364117","0.63626534","0.6361415","0.6353743"],"string":"[\n \"0.75523275\",\n \"0.743832\",\n \"0.74258286\",\n \"0.7422637\",\n \"0.7364126\",\n \"0.73365295\",\n \"0.73187625\",\n \"0.72586364\",\n \"0.7242011\",\n \"0.7233209\",\n \"0.72105044\",\n \"0.7161378\",\n \"0.71507365\",\n \"0.713142\",\n \"0.71212167\",\n \"0.71001995\",\n \"0.7051916\",\n \"0.7029939\",\n \"0.7000444\",\n \"0.6976201\",\n \"0.69314533\",\n \"0.6915431\",\n \"0.69015545\",\n \"0.6894078\",\n \"0.68907684\",\n \"0.68884885\",\n \"0.6881044\",\n \"0.68423784\",\n \"0.679889\",\n \"0.67598325\",\n \"0.67593294\",\n \"0.6724972\",\n \"0.6722011\",\n \"0.67207557\",\n \"0.668557\",\n \"0.66777647\",\n \"0.6665364\",\n \"0.6660342\",\n \"0.6654145\",\n \"0.6651742\",\n \"0.66388226\",\n \"0.663298\",\n \"0.66253185\",\n \"0.66232175\",\n \"0.66160107\",\n \"0.6615185\",\n \"0.6581718\",\n \"0.65808004\",\n \"0.65801597\",\n \"0.65799236\",\n \"0.6573005\",\n \"0.6571938\",\n \"0.6570316\",\n \"0.65682286\",\n \"0.654321\",\n \"0.6539214\",\n \"0.6538776\",\n \"0.65385246\",\n \"0.65346813\",\n \"0.6527291\",\n \"0.65263265\",\n \"0.6517368\",\n \"0.65134066\",\n \"0.6510297\",\n \"0.65061164\",\n \"0.6503084\",\n \"0.64991164\",\n \"0.6496695\",\n \"0.6493429\",\n \"0.6487343\",\n \"0.64844394\",\n \"0.64721686\",\n \"0.647178\",\n \"0.6454772\",\n \"0.6454772\",\n \"0.6454772\",\n \"0.6454772\",\n \"0.643299\",\n \"0.6431333\",\n \"0.64186037\",\n \"0.6416292\",\n \"0.6410764\",\n \"0.6408612\",\n \"0.64061856\",\n \"0.64039975\",\n \"0.6397238\",\n \"0.6397238\",\n \"0.6397238\",\n \"0.6397238\",\n \"0.6397238\",\n \"0.638773\",\n \"0.6385073\",\n \"0.6384868\",\n \"0.637654\",\n \"0.63701266\",\n \"0.63694817\",\n \"0.6364117\",\n \"0.63626534\",\n \"0.6361415\",\n \"0.6353743\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66573066"},"document_rank":{"kind":"string","value":"38"}}},{"rowIdx":6880,"cells":{"query":{"kind":"string","value":"Test the agen and watch it play for one episode."},"document":{"kind":"string","value":"def simulate(self):\r\n\t\tprint(\"##################################\")\r\n\t\tprint(\"SIMULATING GAME - SpaceInvaders..\")\r\n\t\tprint(\"##################################\")\r\n\t\t\r\n\t\t# Play 3 episodes:\r\n\t\tfor i in range(3):\r\n\t\t\tprint(\"Playing Episode %d\" % i)\r\n\t\t\tstate = self.env.reset()\r\n\t\t\t#self.env.render()\r\n\t\t\tdone = False\r\n\t\t\ttot_reward = 0\r\n\t\t\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \r\n\t\t\t\t\t\t\t\t\t\tstate, True)\r\n\t\t\t# play until dead.\t\t\t\r\n\t\t\twhile not done:\r\n\t\t\t\t# get the value predicted by the model and perform that action.\r\n\t\t\t\t# keras conv2d expects a 4D input. So add an empty axis. \r\n\t\t\t\tstate = np.expand_dims(state, axis=0)\r\n\t\t\t\t# predict action directly from the saved neural network.\r\n\t\t\t\taction = np.argmax(self.dqn.getModel().predict(state)[0])\r\n\t\t\t\t# perform that action.\r\n\t\t\t\tstate, reward, done, _ = self.env.step(action)\r\n\t\t\t\tself.env.render()\r\n\t\t\t\tstate,_ = stack_frames(self.stack_size,self.stacked_frames, \r\n\t\t\t\t\t\t\t\t\t\tstate, False)\r\n\t\t\t\ttot_reward+=reward\r\n\t\t\tprint(\"Reward: \", tot_reward)\r\n\t\tself.env.close() # to avoid sys.meta_path error\r"},"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 test():\n env = gym.make('CartPole-v1')\n\n results = []\n for _ in range(100):\n results.append(episode(env, render=False, verbose=False))\n\n print(f'average={sum(results) / len(results)} '\n f'max={max(results)} '\n f'min={min(results)}')","def test_scraper(self):\n scrap = ScraperModule(url=self.anime_link, host=\"mixdrop\")\n pages = scrap.pages\n print(f\"pages: {pages}\")\n get_pages = scrap.get_pages()\n first_link = scrap.get_links(pages[0])\n print(first_link)\n episodes = scrap.get_episodes()\n print(episodes)","def play(self, test_ep=0., n_step=10000, n_episode=1000):\n\n # If not training, clear log of old data, initialize TF variables, and load model.\n if self.stat and not self.is_train:\n tf.initialize_all_variables().run()\n self.stat.load_model()\n\n self.target_network.run_copy()\n\n rewards = []\n game_lengths = []\n\n # Play at least n_episode episodes.\n while np.sum(game_lengths) < n_episode:\n\n # Start a new game.\n observation, reward, terminal = self.new_game()\n current_reward = 0\n\n # Add initial frames to history.\n for _ in range(self.history_length):\n self.history.add(observation)\n\n # Play game until 'terminal.'\n for t in range(n_step):\n # 1. Predict.\n action = self.predict(self.history.get(), test_ep)\n # 2. Act.\n observation, reward, terminal, _ = self.env.step(action, is_training=False)\n # 3. Observe.\n self.history.add(observation)\n \n current_reward += reward\n\n if terminal:\n break\n\n # Set tqdm range description.\n if self.t_range and not self.chtc:\n self.t_range.set_description('PLAY: %d/%d' % (np.sum(game_lengths), n_episode))\n\n # After game, add game length and rewards.\n rewards.append(float(current_reward))\n game_lengths.append(terminal)\n\n if self.t_range and not self.chtc:\n self.t_range.set_description()\n \n self.compute_statistics(rewards, game_lengths)","def OnEnterEpisode(self):\n pass","def run_episode(self):\n self.pygame_clock = pygame.time.Clock()\n while True:\n pygame.event.pump()\n is_human_agent = isinstance(self.agents[self.env.turn], HumanAgent)\n\n # handle exit event\n self.handle_input_event()\n\n # pick the next action\n if is_human_agent:\n self.handle_input_event()\n else:\n self.ai_event()\n self.place_a_disk()\n self.render()\n\n if self.event == Event.END_GAME:\n pygame.time.wait(self.END_GAME_DELAY)\n\n if self.event == Event.END_GAME_VIEW:\n pygame.time.wait(self.END_GAME_VIEW_DELAY)\n break","def set_episode_check(self, alias, epi, check):\n re_m = re.match(r's(\\d{1,2})e(\\d{1,2})', epi.lower())\n if not re_m:\n print('Bad format for check - \"{0}\"'.format(epi))\n else:\n season = int(re_m.group(1))\n episode = int(re_m.group(2))\n show_id = self.id_by_title(self.title_by_alias(alias, no_exit=True))\n epis = self.load_episodes(show_id)\n watched = self.load_watched(show_id)\n episodes = epis['episodes']\n for epi_id in episodes:\n next_episode = episodes[epi_id]\n if (\n next_episode['seasonNumber'] == season and\n next_episode['episodeNumber'] == episode\n ):\n valid_op = False\n old_date = ''\n if check:\n msg = 'checked'\n if epi_id in watched:\n old_date = watched[epi_id]['watchDate']\n else:\n url = self.config['url']['check_episode'].format(epi_id)\n valid_op = True\n else:\n msg = 'unchecked'\n if epi_id in watched:\n url = self.config['url']['uncheck_episode'].format(epi_id)\n valid_op = True\n\n if not valid_op:\n print()\n print('Episode \"{0}\" (s{1:02d}e{2:02d}) of \"{3}\" already {4} {5}'\n .format(\n tr_out(next_episode['title']),\n next_episode['seasonNumber'],\n next_episode['episodeNumber'],\n tr_out(epis['title']),\n msg,\n old_date\n ))\n else:\n logging.debug('Set checked: %s%s', self.api_url, url)\n request = urllib.request.Request(self.api_url + url)\n self.opener.open(request)\n print()\n print(\n 'Episode \"{0}\" (s{1:02d}e{2:02d}) of \"{3}\" set {4}'\n .format(\n tr_out(next_episode['title']),\n next_episode['seasonNumber'],\n next_episode['episodeNumber'],\n tr_out(epis['title']),\n msg\n ))\n break","def test_create_episode(self):\n episode = self._create_sample_episode()\n\n self.assertEqual(\n self.storage.get_episode(episode.study_id, episode.session_id,\n episode.id), episode)","def test(self):\n total_steps = 0\n running_scores = np.zeros(len(self.agents))\n\n for e in range(self.run_settings.test_episodes):\n # Initialize episode\n try:\n env_states, rewards, done, metainfo = self.custom_env.reset()\n except EpisodeCrashException:\n print('Episode crashed, resetting.')\n continue\n\n # Initialize scores to starting reward (probably 0)\n scores = np.array(rewards)\n step = 0\n\n while not done:\n states = [self.agents[a].state_space_converter(env_states[a])\n for a in range(len(self.agents))]\n\n # Get actions\n actions = [self.agents[a].sample(states[a])\n for a in range(len(self.agents))]\n env_actions = [self.agents[a].action_space_converter(actions[a])\n for a in range(len(self.agents))]\n if self.run_settings.verbose:\n self.print_action(env_actions)\n # Take environment step\n try:\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\n except EpisodeCrashException:\n print('Episode crashed, resetting.')\n break\n step += 1\n total_steps += 1\n\n # Update scores\n scores += np.array(rewards)\n\n if done:\n running_scores += scores\n\n if len(scores) == 1:\n scores = scores[0]\n if self.run_settings.verbose:\n print(\"Game {} ended after {} steps. Game score: {}\"\n .format(e+1, step, scores))\n if self.run_settings.verbose:\n print(\"Average game scores: {}\".format(running_scores / self.run_settings.test_episodes))","def OnEpisodeStart(self):\n pass","def test_get_episode_overview(self):\n self.assertEquals(\n self.t['Battlestar Galactica (2003)'][1][6]['overview'].startswith(\n 'When a new copy of Doral, a Cylon who had been previously'),\n True\n )","def new_episode(self):\n self.game.new_episode()","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n player = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, player)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, player, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, player = self.game.getNextState(board, player, action)\n\n r = self.game.getGameEnded(board, player)\n\n if r != 0:\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\n return ex","def testBeginEpisode(self):\n with tf.compat.v1.Session() as sess:\n agent = self._create_test_agent(sess)\n # We fill up the state with 9s. On calling agent.begin_episode the state\n # should be reset to all 0s.\n agent.state.fill(9)\n first_observation = np.ones(self.observation_shape + (1,))\n self.assertEqual(agent.begin_episode(first_observation), 0)\n # When the all-1s observation is received, it will be placed at the end of\n # the state.\n expected_state = self.zero_state\n expected_state[:, :, :, -1] = np.ones((1,) + self.observation_shape)\n self.assertAllEqual(agent.state, expected_state)\n self.assertAllEqual(agent._observation, first_observation[:, :, 0])\n # No training happens in eval mode.\n self.assertEqual(agent.training_steps, 0)\n\n # This will now cause training to happen.\n agent.eval_mode = False\n # Having a low replay memory add_count will prevent any of the\n # train/prefetch/sync ops from being called.\n agent._replay.memory.add_count = 0\n second_observation = np.ones(self.observation_shape + (1,)) * 2\n agent.begin_episode(second_observation)\n # The agent's state will be reset, so we will only be left with the all-2s\n # observation.\n expected_state[:, :, :, -1] = np.full((1,) + self.observation_shape, 2)\n self.assertAllEqual(agent.state, expected_state)\n self.assertAllEqual(agent._observation, second_observation[:, :, 0])\n # training_steps is incremented since we set eval_mode to False.\n self.assertEqual(agent.training_steps, 1)","def run(self) -> None:\n for episode in range(1, self.episodes + 1):\n print('Episode:', episode)\n steps, state_action_history = self.run_one_episode()\n self.steps_per_episode.append(steps)\n if episode % parameters.CACHING_INTERVAL == 0 or steps < 1000:\n visualize.animate_track(state_action_history, f'agent-{episode}')\n\n print('Training completed.')\n visualize.plot_steps_per_episode(self.steps_per_episode)\n visualize.plot_epsilon(self.agent.epsilon_history)\n\n if parameters.VISUALIZE_FINAL_GAME:\n print('Showing one episode with the greedy strategy.')\n self.agent.epsilon = 0\n steps, state_action_history = self.run_one_episode()\n print(f'Episode completed in {steps} steps.')\n visualize.animate_track(state_action_history)","def test_plays_get(self):\n pass","def startEpisode(self):\n self.lastState = None\n self.lastAction = None\n self.episodeRewards = 0.0\n\n print(\"Agent Start Episode #\" + str(self.episodesSoFar+1))","def watch_episode(logger, n_episodes: int = 1):\n\n # play match\n for episode in logger.observations:\n for steps in logger.observations[episode]:\n clear_output(wait=True)\n plt.imshow(steps)\n plt.show()\n if n_episodes - 1 >= episode:\n break","def run_episode(self, mode=0, eps=0.):\n if mode==0:\n eps = 0.\n done = False\n score = 0 \n \n while not done:\n state = self.env_info.vector_observations[0] # get the current state\n action = self.agent.act(state, eps=eps) # get an action using epsilon greedy policy\n self.env_info = self.env.step(action)[self.brain_name] # send the action to the environment\n next_state = self.env_info.vector_observations[0] # get the next state\n reward = self.env_info.rewards[0] # get the reward\n done = self.env_info.local_done[0] # see if episode has finished\n \n if mode == 1:\n self.agent.step(state, action, reward, next_state, done)\n \n score += reward\n \n self.reset_env() # reset the environment\n \n return score","def testPlayback(self):\n \n pass","def start_episode(self):\n self.last_sensation = self.env()\n self.next_action = self.agent(self.last_sensation)","def test_single_track_ep(self):\n self.add_mp3()\n (added, status) = self.app.add_album(self.filenames, 'ep')\n self.assertEqual(added, True)\n self.assertEqual(self.get_album_count(), 1)\n album = Album.get_by_artist_album(self.app.curs, 'Artist', 'Album')\n self.assertNotEqual(album, None)\n self.assertEqual(album.artist, 'Artist')\n self.assertEqual(album.album, 'Album')\n self.assertEqual(album.album_type, 'ep')\n self.assertEqual(album.totalseconds, 2)\n self.assertEqual(album.totaltracks, 1)","def show_next_for_watch(self, alias):\n show_id = self.id_by_title(self.title_by_alias(alias, no_exit=True))\n epis = self.load_episodes(show_id)\n episode_id = self.get_first_unwatched(show_id)\n if episode_id is None:\n print(\"\\nCannot find first watch for {0}\\n\".format(tr_out(epis['title'])))\n else:\n episode = epis['episodes'][episode_id]\n print('\\nFirst watch for {0} is s{1:02d}e{2:02d} (\"{3}\")\\n'.format(\n tr_out(epis['title']),\n episode['seasonNumber'], episode['episodeNumber'],\n tr_out(episode['title']),\n ))","def OnEpisodeOver(self):\n pass","def run(self):\n time.sleep(np.random.rand())\n np.random.seed(np.int32(time.time() % 1000 * self.id))\n \n # Put this in a while loop that checks a shared variable\n # Will keep running episodes until the shared variable reports False\n while(self.exit_flag == 0):\n for experience in self.run_episode():\n print(experience.state, experience.reward)\n self.training_q.put(experience)","def add_episode(self, ep):\n #make da season\n ses = self._add_season(ep)\n dvdses = self._add_season(ep, dvd=True) \n self._add_episode(ep, ses)\n self._add_episode(ep, dvdses, dvd=True)","def test_seasons(self):\n response = Tmdb.season(tmdb_show_id = 69740, season_number = 1)\n self.assertTrue(int(response.status_code) == 200)\n data = response.json()\n self.assertTrue(isinstance(data['episodes'], list))\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)","def testGetEpisodeName(self):\n\t\tfor case in self.testCases:\n\t\t\tassert case['title'] == getEpisodeName( case['show'], case['season'], case['episode'])","def begin_episode(self):\n self.action = PlayerAction.STAND_STILL","def play_episodes(env, policy, render_option, num_eps, pause_time, min_steps):\n env.reset()\n if pause_time != 0:\n for _ in range(int(pause_time / 0.01)):\n env.render()\n time.sleep(0.01)\n total_reward = 0.0\n for _ in range(num_eps):\n episode_reward = play_episode(env, policy, render_option, min_steps)\n total_reward += episode_reward\n avg_reward = total_reward / num_eps\n print('finished {0} episodes with average reward {1}'.format(num_eps, avg_reward))\n return avg_reward","def run(self, num_episodes=1):\n pygame.display.update()\n self.fps_clock = pygame.time.Clock()\n\n try:\n for episode in range(num_episodes):\n self.run_episode()\n self.env.new_episode()\n self.event = Event.next(self.event)\n except QuitRequestedError:\n print(\"Exit Program\")\n\n pygame.quit()","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n self.curPlayer = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, self.curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\n\n r = self.game.getGameEnded(board, self.curPlayer)\n\n if r != 0:\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n self.curPlayer = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, self.curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\n\n r = self.game.getGameEnded(board, self.curPlayer)\n\n if r != 0:\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]","def play(self):\n if not self.tiempos.esta_vacia():\n self._reproducir(self.tiempos.actual())","def terminal_test(self):\n\n for self.cur_ep in tqdm.tqdm(range(1, self.episodes + 1), ascii=True, unit='episodes'):\n\n # Nombre de passages dans la boucle principale\n step = 1\n\n cur_state = self.env.reset()\n\n done = False\n\n while not done:\n\n # Choix au hasard entre :\n if np.random.random() > self.epsilon:\n # Action à partir de la q-table\n action = np.argmax(self.agent.get_q_values(np.array(cur_state)))\n\n else:\n # Action random\n action = np.random.randint(0, self.env.ACTION_SPACE_SIZE)\n\n # On effectue une action avec le serpent\n new_state, reward, done = self.env.step(action)\n\n # Ajout d'un exemple dans la mémoire\n self.agent.update_training_set((cur_state, action, reward, new_state, done))\n\n # Entrainement éventuel\n self.agent.train()\n\n cur_state = new_state\n step += 1\n\n if self.epsilon > self.MIN_EPSILON:\n self.epsilon *= self.EPSILON_DECAY\n self.epsilon = max(self.MIN_EPSILON, self.epsilon)\n\n if self.save_model:\n self.agent.save_model(self.model_file_name)","def debug():\n env = gym.make('CartPole-v1')\n env = gym.wrappers.Monitor(env, 'videos/', force=True)\n reward = episode(env, render=True, verbose=True)\n print(f'Reward: {reward}')","def play(self):\n observation = self.env.reset()\n count = 0\n reward_sum = 0\n random_episodes = 0\n\n while random_episodes < 10:\n self.env.render()\n x = observation.reshape(-1, 4)\n q_values = self.model.predict(x)[0]\n action = np.argmax(q_values)\n observation, reward, done, _ = self.env.step(action)\n count += 1\n reward_sum += reward\n\n if done:\n print(\"Reward for this episode was: {}, turns was: {}\".format(reward_sum, count))\n random_episodes += 1\n reward_sum = 0\n count = 0\n observation = self.env.reset()\n\n self.env.close()","def run_episode(self):\n self.reset_episode()\n obs = self.env.reset()\n while True:\n action = self.Policy[self.env.stateDict[obs]]\n new_obs, reward, done, _ = self.env.step(action)\n if self.mode=='debug':\n print(\"PrevObs:{}, Action:{}, Obs:{}, Reward:{}, Done:{}\"\n .format(obs, action, new_obs,reward,done))\n self.totalReward += reward\n self.totalSteps += 1\n if done:\n break\n else:\n obs = new_obs\n return self.totalReward","def episode_step(self):\n self.nsteps += 1","def play_against_random(env, q_value, n_episodes = 100,\n play_as = 'O', render = False, self_play = False):\n \n assert play_as in ['X','O'], \"Player should be X or O\"\n \n \n running_reward = []\n \n for episode in range(n_episodes):\n \n #start episode\n state = env.reset()\n done = False\n \n while not done:\n \n if play_as == state[1] :\n #print(\"q learner\")\n action = e_greedy(state,env,q_value, inference = True)[0]\n \n else:\n if self_play:\n action = e_greedy(state,env,q_value, inference = True)[0]\n else:\n action = random_player(env)\n \n state,reward,done, _ = env.step(action)\n \n if render:\n env.render()\n print(reward, \"\\n\\n\")\n running_reward.append(reward)\n \n if play_as == 'X':\n running_reward = [-i for i in running_reward] \n \n performance = np.mean(running_reward)\n \n won = sum([1 if i == 1 else 0 for i in running_reward])\n lost = sum([1 if i == -1 else 0 for i in running_reward])\n draw = sum([1 if i == 0 else 0 for i in running_reward])\n \n #print(f\"Player : {play_as} | Performance : {performance} | Won: {won} | Lost: {lost} | Draw: {draw} | Total : {n_episodes}\")\n \n return (won,lost,draw)","def play(self):\n p1 = self.player()\n p2 = axelrod.Player()\n p1.reset()\n p1.strategy(p2)\n # Genome contains only valid responses.\n self.assertEqual(p1.genome.count(C) + p1.genome.count(D), len(p1.genome))","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 0.0 # no exploration\n self.alpha = 0.0 # no learning","def run_episode(self):\n # Reset environment\n self.agent.env.reset()\n done = False\n step_count = 0\n total_reward = 0\n\n while not done:\n reward, done = self.agent.explore()\n step_count += 1\n if step_count % 100 == 0:\n print('step count {}'.format(step_count))\n total_reward += self.agent.params['gamma']**step_count * reward\n return step_count, total_reward","def _start_episode(self, test = False):\n self.env.true_reset()\n new_frame = self.env.reset()\n if not test:\n self.memory.add_experience(0, 0.0, new_frame, False)\n for i in range(self.num_stacked_frames):\n self._current_state[0, i] = new_frame\n new_frame, reward, done, _ = self.env.step(0)\n if not test:\n self.memory.add_experience(0, reward, new_frame, done)","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 1.0 # no exploration\n self.lr = 0.0 # no learning","def test_download_specific_episode(self):\n episode = self._get_episode()\n torrent_filename = self.fetcher.download_specific_episode(episode)\n self.assertEqual(torrent_filename, FILENAME_2)","def nukePlay():\n nuke.activeViewer().play(1)","def test_save_unwatched_episodes(self):\n save_episodes(self.schedule.episodes)\n for show in FollowedShows.objects.filter(user_id=self.user.id):\n self.assertTrue(show.unwatchedepisode_set.all().count() > 0)","def test_selecting_only_audio_episodes(\n only_audio_episodes: List[LepEpisode],\n) -> None:\n assert len(only_audio_episodes) == 14 # Without duplicates","def play_game():\n pass","def self_play(self, n_episodes): \n eps = self.eps(self.agent.learning_iters)\n experiences = self_play_episodes(self.mdp, self.agent, n_episodes, eps) \n for state, action, reward, next_state, done in experiences:\n self.agent.replay_buffer.push(state, action, reward, next_state, done)","def test_episode_data(self):\n self.assertEquals(\n self.t['lost']['firstaired'],\n '2004-09-22'\n )","def startEpisode(self):\n self.lastState = None\n self.lastAction = None\n self.episodeRewards = 0.0","def explore(self, episode_count):\n # single agent, always use the `run_one_episode` api.\n # multi agent with `standalone` api_type, use the `run_one_episode` api.\n if self.env_info[\"api_type\"] == \"standalone\":\n # (use_explore, collect)\n _paras = [\n (True, False if _ag.alg.async_flag else True) for _ag in self.agents\n ]\n job_funcs = [agent.run_one_episode for agent in self.agents]\n for _epi_index in range(episode_count):\n _start2 = time()\n self.env.reset()\n for agent in self.agents:\n agent.reset()\n\n trajectory_list = self.bot.do_multi_job(job_funcs, _paras)\n for agent, trajectory in zip(self.agents, trajectory_list):\n if not agent.alg.async_flag:\n # self.trajectories.append(trajectory)\n self.send_explorer.send(trajectory)\n\n self._post_processes()\n self.ag_stats.explore_time_in_epi = time() - _start2\n\n if _epi_index == episode_count - 1:\n self.ag_stats.update_with_agent_stats(\n [agent.get_perf_stats() for agent in self.agents]\n )\n\n elif self.env_info[\"api_type\"] == \"unified\":\n for _ in range(episode_count):\n _start2 = time()\n trajectories = self._run_one_unified_episode(\n use_explore=True, collect=True)\n\n for _ag, trajectory in zip(self.agents, trajectories):\n if not _ag.alg.async_flag:\n # self.trajectories.append(trajectory)\n self.send_explorer.send(trajectory)\n\n self._post_processes()\n self.ag_stats.explore_time_in_epi = time() - _start2\n else:\n pass\n\n self.clear_trajectories()\n return self.ag_stats.get()","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 0.0 # no exploration\n self.alpha = 0.0 # no learning\n\n print(\"Agent Stop Episode\")\n print(self.episodeRewards)\n for feature, weight in self.weights.iteritems():\n print(\"\\t\" + str(feature) + \" - \" + str(weight))\n self.episodeRewardsList.append(self.episodeRewards)","def play(self):\n pass","def run_episode(env, agent, deterministic, do_training=True, rendering=False, max_timesteps=1000):\n\n stats = EpisodeStats() # save statistics like episode reward or action usage\n state = env.reset()\n\n step = 0\n while True:\n\n action_id = agent.act(state=state, deterministic=deterministic)\n next_state, reward, terminal, info = env.step(action_id)\n\n if do_training:\n agent.train(state, action_id, next_state, reward, terminal)\n\n state = next_state\n\n # # NOTE reward shaping...\n # if terminal:\n # reward += -1\n # if step < 20:\n # reward += -10\n # if step > 100:\n # reward += 10\n\n stats.step(reward, action_id)\n\n if rendering:\n env.render()\n\n if terminal or step > max_timesteps:\n break\n\n step += 1\n\n return stats","def test_atomic_update_episode(self):\n episode = self._create_sample_episode()\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\n episode.id)\n\n def callback(read_episode):\n # Read episode should match the stored one.\n self.assertEqual(read_episode, episode)\n self.assertEqual(read_episode.num_steps, 100)\n # Make a change.\n read_episode.num_steps = 200\n return True\n\n self.assertTrue(\n self.storage.atomic_update_episode(study_id, session_id, episode_id,\n callback))\n # Check that the change was applied.\n episode.num_steps = 200\n self.assertEqual(\n self.storage.get_episode(study_id, session_id, episode_id), episode)","def train(self, max_episodes= 1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n success = False\n i_episode = 0\n eps = eps_start\n \n print('Training in progress...')\n for i in range(max_episodes):\n score = self.run_training_episode(eps=eps)\n \n self.score_window.append(score)\n self.score_record.append(np.mean(self.score_window))\n \n i_episode += 1\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\n\n if i_episode%100 == 0:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\n \n if i_episode>100:\n if np.mean(self.score_window)>self.criteria:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\n success = True\n break\n\n if success:\n print('Criteria reached after {} episodes'.format(i_episode))\n else:\n print('Failed to reach Criteria after {} episodes'.format(i_episode))\n\n self.plot_training_progress()\n return success","def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=True, max_timesteps=10000,\n history_length=0, manual=False):\n\n stats = utils.EpisodeStats()\n\n # Save history\n image_hist = []\n\n step = 0\n state = env.reset()\n\n env.viewer.window.on_key_press = utils.key_press\n env.viewer.window.on_key_release = utils.key_release\n # fix bug of corrupted states without rendering in gym environment\n env.viewer.window.dispatch_events()\n\n # append image history to first state\n state = state_preprocessing(state)\n image_hist.extend([state] * (history_length + 1))\n state = np.array(image_hist).reshape(96, 96, history_length + 1)\n while True:\n #skip intro zoom frames\n if step < 48:\n step += 1\n env.step(utils.id_to_action(0))\n continue\n \n # TODO: get action_id from agent\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly.\n if do_training and manual:\n action_id = utils.manual_action\n else:\n action_id = agent.act(state, deterministic)\n action = utils.id_to_action(action_id)\n\n # Hint: frame skipping might help you to get better results.\n reward = 0\n for _ in range(skip_frames + 1):\n next_state, r, terminal, info = env.step(action)\n reward += r\n\n if rendering:\n env.render()\n\n if terminal:\n break\n\n next_state = state_preprocessing(next_state)\n \n image_hist.append(next_state)\n image_hist.pop(0)\n next_state = np.array(image_hist).reshape(96, 96, history_length + 1)\n\n if do_training and (next_state[:82, :, -1].sum() > 5000): #track out of sight\n print('Track gone; finish this episode')\n agent.add(state, action_id, next_state, reward=-(skip_frames + 1), terminal=True) #punish\n break\n\n if do_training:\n agent.add(state, action_id, next_state, reward, terminal)\n if not manual:\n agent.train()\n\n stats.step(reward, action_id)\n\n state = next_state\n \n if terminal or (step * (skip_frames + 1)) > max_timesteps:\n break\n\n step += 1\n\n return stats","def test_search_torrent(self):\n episode = self._get_episode()\n search_results = self.fetcher.jackett.search(episode.indexed_name)\n best_result = self.fetcher.best_search_result(search_results)\n self.assertEqual(best_result.get(\"id\"), 2)","def test_search_torrent(self):\n episode = self._get_episode()\n search_results = self.fetcher.jackett.search(episode.indexed_name)\n best_result = self.fetcher.best_search_result(search_results)\n self.assertEqual(best_result.get(\"id\"), 2)","def run_episode(env, gamma = 1.0, render = False):\n actions = 4\n obs = env.reset()\n total_reward = 0\n step_idx = 0\n\n while True:\n if render:\n env.render()\n obs, reward, done , _ = env.step(random.randint(0, actions - 1))\n x1, x2, x3, x4, x5, x6, x7, x8 = obs\n x1s.append(x1)\n x2s.append(x2)\n x3s.append(x3)\n x4s.append(x4)\n x5s.append(x5)\n x6s.append(x6)\n x7s.append(x7)\n x8s.append(x8)\n total_reward += (gamma ** step_idx * reward)\n step_idx += 1\n if done:\n break\n return total_reward, step_idx","def _run_single(self, thread_id, agent, environment, deterministic=False,\n max_episode_timesteps=-1, episode_finished=None, testing=False, sleep=None):\n\n # figure out whether we are using the deprecated way of \"episode_finished\" reporting\n old_episode_finished = False\n if episode_finished is not None and len(getargspec(episode_finished).args) == 1:\n old_episode_finished = True\n\n episode = 0\n # Run this single worker (episode loop) as long as global count thresholds have not been reached.\n while not self.should_stop:\n state = environment.reset()\n agent.reset()\n self.global_timestep, self.global_episode = agent.timestep, agent.episode\n episode_reward = 0\n\n # Time step (within episode) loop\n time_step = 0\n time_start = time.time()\n while True:\n action, internals, states = agent.act(states=state, deterministic=deterministic, buffered=False)\n reward = 0\n for repeat in xrange(self.repeat_actions):\n state, terminal, step_reward = environment.execute(action=action)\n reward += step_reward\n if terminal:\n break\n\n if not testing:\n # agent.observe(reward=reward, terminal=terminal)\n # Insert everything at once.\n agent.atomic_observe(\n states=state,\n actions=action,\n internals=internals,\n reward=reward,\n terminal=terminal\n )\n\n if sleep is not None:\n time.sleep(sleep)\n\n time_step += 1\n episode_reward += reward\n\n if terminal or time_step == max_episode_timesteps:\n break\n\n # Abort the episode (discard its results) when global says so.\n if self.should_stop:\n return\n\n self.global_timestep += time_step\n\n # Avoid race condition where order in episode_rewards won't match order in episode_timesteps.\n self.episode_list_lock.acquire()\n self.episode_rewards.append(episode_reward)\n self.episode_timesteps.append(time_step)\n self.episode_times.append(time.time() - time_start)\n self.episode_list_lock.release()\n\n if episode_finished is not None:\n # old way of calling episode_finished\n if old_episode_finished:\n summary_data = {\n \"thread_id\": thread_id,\n \"episode\": episode,\n \"timestep\": time_step,\n \"episode_reward\": episode_reward\n }\n if not episode_finished(summary_data):\n return\n # New way with BasicRunner (self) and thread-id.\n elif not episode_finished(self, thread_id):\n return\n\n episode += 1","def send_music_play_event_and_validate(self):\n play_detection_timeout = 1\n if self.dut.is_streaming():\n self.logger.info('Music already streaming. Skipping play event..')\n return\n self.logger.info('Playing video...')\n is_played = self.dut.music_control_events(\n AVRCPSTATUS, self.dut.apollo_log_regex.AVRCP_PLAY_REGEX)\n if not is_played:\n self.logger.error('AVRCP Played status not found')\n raise TestActsError('AVRCP Played status not found.')\n wait_until(\n lambda: self.dut.is_streaming(),\n play_detection_timeout,\n sleep_s=0.25)\n if not self.dut.is_streaming():\n self.logger.error('Device is NOT in a deviceA2DPStreaming state')\n raise TestActsError(\n 'Device is NOT in a deviceA2DPStreaming state.')","def play_one_episode(self, func, stat='score'):\n if not isinstance(stat, list):\n stat = [stat]\n while True:\n s = self.current_state()\n act = func(s)\n act, r, isOver = self.action(act)\n # print r\n if isOver:\n s = [self.stats[k] for k in stat]\n self.reset_stat()\n return s if len(s) > 1 else s[0]","def test_atomic_update_episode_no_update(self):\n episode = self._create_sample_episode()\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\n episode.id)\n\n def callback(read_episode):\n # Make a change but return false.\n read_episode.num_steps = 200\n return False\n\n self.assertFalse(\n self.storage.atomic_update_episode(study_id, session_id, episode_id,\n callback))\n self.assertEqual(\n self.storage.get_episode(study_id, session_id, episode_id), episode)","def on_train_begin(self, logs):\n print(f\"Testing for {self.params['nb_episodes']} episodes ...\")","def begin_episode(self, observation):\n self._reset_state()\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn)\n self.action = onp.asarray(self.action)\n return self.action","def begin_episode(self, observation):\n self._reset_state()\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_quantile_samples,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn,\n self._tau,\n self.optimizer)\n self.action = onp.asarray(self.action)\n return self.action","def run(agent, env, num_episodes = 20000, mode = 'train'):\n\t scores=[]\n\t max_avg_score=-np.inf\n\t for i_episode in range(1, num_episodes + 1):\n\t # Initialize episode\n\t state=env.reset()\n\t action=agent.reset_episode(state)\n\t total_reward=0\n\t done=False\n\n\t # Roll out steps until done\n\t while not done:\n\t state, reward, done, info=env.step(action)\n\t total_reward += reward\n\t action=agent.act(state, reward, done, mode)\n\n\t # Save final score\n\t scores.append(total_reward)\n\n\t # Print episode stats\n\t if mode == 'train':\n\t if len(scores) > 100:\n\t avg_score=np.mean(scores[-100:])\n\t if avg_score > max_avg_score:\n\t max_avg_score=avg_score\n\n\t if i_episode % 100 == 0:\n\t print(\"\\rEpisode {}/{} | Max Average Score: {}\".format(i_episode,\n\t num_episodes, max_avg_score), end = \"\")\n\t sys.stdout.flush()\n\n\t return scores\n\n\tscores=run(q_agent, env)\n\n\t# Plot scores obtained per episode\n\tplt.plot(scores); plt.title(\"Scores\")\n\n\tdef plot_scores(scores, rolling_window = 100):\n\t\t\"\"\"Plot scores and optional rolling mean using specified window.\"\"\"\n\t\tplt.plot(scores); plt.title(\"Scores\");\n\t\trolling_mean=pd.Series(scores).rolling(rolling_window).mean()\n\t\tplt.plot(rolling_mean);\n\t\treturn rolling_mean\n\n\trolling_mean=plot_scores(scores)\n\n\t# Run in test mode and analyze socres obtained\n\ttest_scores=run(q_agent, env, num_episodes = 100, mode = 'test')\n\tprint(\"[TEST] Completed {} episodes with avg. score = {}\".format(\n\t len(test_scores), np.mean(test_scores)))\n\t_=plot_scores(test_scores, rolling_window = 10)\n\n\n\tdef plot_q_table(q_table):\n \"\"\"Visualize max Q-value for each state and corresponding action.\"\"\"\n\t q_image=np.max(q_table, axis = 2) # max Q-value for each state\n\t q_actions=np.argmax(q_table, axis = 2) # best action for each state\n\n\t fig, ax=plt.subplots(figsize = (10, 10))\n\t cax=ax.imshow(q_image, cmap = 'jet');\n\t cbar=fig.colorbar(cax)\n\t for x in range(q_image.shape[0]):\n\t for y in range(q_image.shape[1]):\n\t ax.text(x, y, q_actions[x, y], color = 'white',\n\t horizontalalignment = 'center', verticalalignment = 'center')\n\t ax.grid(False)\n\t ax.set_title(\"Q-table, size: {}\".format(q_table.shape))\n\t ax.set_xlabel('position')\n\t ax.set_ylabel('velocity')\n\n\n\tplot_q_table(q_agent.q_table)\n\n\n\tstate_grid_new=create_uniform_grid(\n\t env.observation_space.low, env.observation_space.high, bins = (20, 20))\n\tq_agent_new=QLearningAgent(env, state_grid_new)\n\tq_agent_new.scores=[]\n\n\n\tq_agent_new.scores += run(q_agent_new, env,\n\t num_episodes = 50000) # accumulate scores\n\trolling_mean_new=plot_scores(q_agent_new.scores)\n\n\ttest_scores= run(q_agent_new, env, num_episodes = 100, mode = 'test')\n\tprint(\"[TEST] Completed {} episodes with avg. score = {}\".format(\n\t len(test_scores), np.mean(test_scores)))\n\t_=plot_scores(test_scores)\n\n\tplot_q_table(q_agent_new.q_table)\n\n\tstate=env.reset()\n\tscore=0\n\timg=plt.imshow(env.render(mode='rgb_array'))\n\tfor t in range(1000):\n\t\taction=q_agent_new.act(state, mode = 'test')\n\t\timg.set_data(env.render(mode='rgb_array'))\n\t\tplt.axis('off')\n\t\tdisplay.display(plt.gcf())\n\t\tdisplay.clear_output(wait = True)\n\t\tstate, reward, done, _=env.step(action)\n\t\tsocre += reward\n\t\tif done:\n\t\t\tprint('Score: ', socre)\n\t\t\tbreak\n\tenv.close()","def begin_episode(self, observation: np.ndarray, a: int) -> int:\n del observation\n del a\n return -1","def test_start(self):\n magic_hat = Game()\n result = Game.start(magic_hat)\n self.assertEqual(result, game.STATUS_PLAYING)","def test_atomic_update_missing_episode(self):\n\n def callback(unused_episode):\n # Callback should not be called.\n assert False\n\n self.assertFalse(\n self.storage.atomic_update_episode('study', 'session', 'missing',\n callback))","def execute_and_get_episodes(self, num_episodes, max_timesteps_per_episode=0, deterministic=False):\n pass","def run_episode(self, environment):\n state = environment.reset()\n self.steps_done = 0\n while True:\n state_tensor = FloatTensor([state])\n position = self.Q.sample_from_softmax_policy(state_tensor)\n action = position + 1\n next_state, reward, done, _ = environment.step(position.item())\n self.memory.push((state_tensor, action,))\n self.learn(state_tensor, action, next_state, reward)\n state = next_state\n self.steps_done += 1\n if done:\n break\n history = environment.close()\n return history","def test_delete_episode(self):\n episode = self._create_sample_episode()\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\n episode.id)\n self.assertIsNotNone(\n self.storage.get_episode(study_id, session_id, episode_id))\n\n self.assertTrue(\n self.storage.delete_episode(episode.study_id, episode.session_id,\n episode.id))\n self.assertIsNone(\n self.storage.get_episode(study_id, session_id, episode_id))","def podcast_show(url, name):\n for recording in scraper.get_podcast_episodes(url):\n INTERFACE.add_item(recording['title'],\n 'play_podcast',\n recording['url'],\n extra_info=recording)","def test_save_repeat_unwatched_episodes_should_not_be(self):\n episode = self.schedule.episodes[0]\n all_episodes = self.schedule.episodes\n followed_show = FollowedShows.objects.get(user=self.user, show_id=episode.show.id)\n UnwatchedEpisode(\n followed_show=followed_show,\n episode_id=episode.id,\n episode_name=episode.name,\n season=episode.season,\n episode_number=episode.number or 0,\n air_date=episode.airdate,\n air_time=episode.airtime,\n air_stamp=episode.airstamp,\n summary=episode.summary or \"no summary\"\n ).save()\n save_episodes(self.schedule.episodes)\n # make sure all episodes are saved to both users unwatched episodes despite the integrity error in bulk_create\n self.assertEqual(len(all_episodes) * 2, len(UnwatchedEpisode.objects.all()))","def execute_episodes(self, num_episodes, max_timesteps_per_episode=0, update_spec=None, deterministic=False):\n pass","def _update_episode(self):\n if self.episode_num > 0:\n self._publish_reward_topic(\n self.accumulated_episode_reward,\n self.episode_steps,\n self.episode_num\n )\n\n self.episode_num += 1\n self.accumulated_episode_reward = 0\n self.episode_steps = 0","def _create_sample_episode(self) -> study_pb2.Episode:\n study_id, session_id = self.init_session()\n episode = sample_episode(study_id=study_id, session_id=session_id)\n self.storage.create_episode(episode)\n return episode","def run(self):\n # Observe the game by randomly sampling actions from the environment\n # and performing those actions\n self.__observe__()\n for i in xrange(self.num_epochs):\n self.environment.resetStatistics()\n time_now = time.time()\n for j in xrange(self.train_steps_per_epoch):\n # Get action using epsilon-greedy strategy\n action = self.__sample_epsilon_action__()\n # Perform action based on epsilon-greedy search and store the transitions\n # in experience replay\n self.__supply_action_to_environment__(action)\n # If the environment is in the terminal state, reset the environment, and\n # perform self.stack_num actions to reset the environment\n self.isGameOver()\n if j % self.train_frequency == 0:\n # print \"Started training\"\n # Sample minibatch of size self.minibatch_size from experience replay\n minibatch = self.experience_replay.sample()\n minibatch_states, minibatch_action, minibatch_reward, minibatch_next_states, \\\n minibatch_terminals = minibatch\n cost = self.network.train_network(minibatch_states,\n minibatch_action,\n minibatch_reward,\n minibatch_terminals,\n minibatch_next_states)\n if j % self.record_frequency == 0:\n total_score, num_games = self.environment.getStatistics()\n avg_score = total_score / num_games\n self.network.record_average_qvalue(\n self.experience_replay.getCurrentState(),\n i * self.train_steps_per_epoch + j,\n self.epsilon, avg_score)\n # Epsilon annealing\n self.__anneal_epsilon__()\n # if self.time_step % 1000 == 0:\n # print \"Cost at iteration\", self.time_step, \" is\", cost\n # print \"Value of epsilon is\", self.epsilon\n self.steps += 1\n if j % self.copy_steps == 0:\n self.network.copy_weights()\n total_score, num_games = self.environment.getStatistics()\n time_taken = (time.time() - time_now)\n logger.info(\"Finished epoch %d: Steps=%d; Time taken=%.2f\",\n i, j, time_taken)\n logger.info(\"\\tNumber of games: %d; Average reward: %.2f\", num_games, (total_score / num_games))\n logger.info(\"\\tFinal epsilon value for epoch: %f\", self.epsilon)\n self.network.create_checkpoint()","def trainOneEpisode(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\n # tqdm.write('------Episode {} / {}------'.format(self.episodes_done, num_episodes))\n self.resetEnv()\n r_total = 0\n with trange(1, max_episode_steps+1, leave=False) as t:\n\n for step in t:\n if render:\n self.env.render()\n state = self.state\n action, q = self.selectAction(state, require_q=True)\n obs_, r, done, info = self.takeAction(action.item())\n # if print_step:\n # print 'step {}, action: {}, q: {}, reward: {} done: {}' \\\n # .format(step, action.item(), q, r, done)\n r_total += r\n # t.set_postfix(step='{:>5}'.format(step), q='{:>5}'.format(round(q, 4)), total_reward='{:>5}'.format(r_total))\n t.set_postfix_str('step={:>5}, q={:>5}, total_reward={:>5}'.format(step, round(q, 2), r_total))\n if done or step == max_episode_steps:\n next_state = None\n else:\n next_state = self.getNextState(obs_)\n reward = torch.tensor([r], device=self.device, dtype=torch.float)\n self.memory.push(state, action, next_state, reward)\n self.optimizeModel()\n if self.steps_done % self.target_update == 0:\n self.target_net.load_state_dict(self.policy_net.state_dict())\n\n if done or step == max_episode_steps - 1:\n tqdm.write('------Episode {} ended, total reward: {}, step: {}------' \\\n .format(self.episodes_done, r_total, step))\n tqdm.write('------Total steps done: {}, current e: {} ------' \\\n .format(self.steps_done, self.exploration.value(self.steps_done)))\n # print '------Episode {} ended, total reward: {}, step: {}------' \\\n # .format(self.episodes_done, r_total, step)\n # print '------Total steps done: {}, current e: {} ------' \\\n # .format(self.steps_done, self.exploration.value(self.steps_done))\n self.episodes_done += 1\n self.episode_rewards.append(r_total)\n self.episode_lengths.append(step)\n if self.episodes_done % save_freq == 0:\n self.saveCheckpoint()\n break\n self.state = next_state","async def discover(loop, artwork=False, hosts=None):\n if hosts:\n discovered = await pyatv.scan(loop, hosts=hosts, timeout=5)\n else:\n discovered = await pyatv.scan(loop, timeout=5)\n atvs = []\n\n for device in discovered:\n atv = {}\n atv['playing'] = False\n\n atv['name'] = device.name\n atv['address'] = device.address\n atv['identifier'] = device.identifier\n atv['device_type'] = 'apple-tv'\n\n for service in device.services:\n if service.protocol.name == 'MRP':\n try:\n connect_device = await pyatv.connect(device, loop)\n now_playing = await connect_device.metadata.playing()\n # 'album', 'artist', 'device_state', 'genre', 'hash', 'media_type', 'position', 'repeat', 'shuffle', 'title', 'total_time'\n if 'idle' not in str(now_playing.device_state).lower():\n atv['now_playing'] = now_playing.title\n atv['playing'] = True\n\n if 'paused' in str(now_playing.device_state).lower():\n atv['playing'] = 'Paused'\n\n if now_playing.total_time:\n atv['playing_percent'] = (now_playing.position / now_playing.total_time) * 100\n\n atv['current_position'] = now_playing.position\n atv['time_remaining'] = now_playing.total_time - now_playing.position\n atv['total_time'] = now_playing.total_time\n \n # print('current: ' + str(now_playing.position))\n # print('total: ' + str(now_playing.total_time))\n # print(str(atv['playing_percent']))\n elif now_playing.position and not now_playing.total_time:\n atv['playing_percent'] = 200\n\n ## TO DO Artwork\n # if artwork:\n # artwork = await connect_device.metadata.artwork()\n # print(artwork)\n\n finally:\n await connect_device.close()\n atvs.append(atv)\n\n return atvs","def play_episode(env, policy, render_option, min_steps):\n state = env.reset()\n done = False\n episode_reward = 0.0\n step_cnt = 0\n while not done or step_cnt < min_steps:\n if render_option == 'collect':\n env.render()\n action = policy(state)\n next_state, reward, done, _ = env.step(action)\n episode_reward += reward\n state = next_state\n step_cnt += 1\n print('episode finished with reward {0}'.format(episode_reward))\n return episode_reward","def play(self):\r\n self.perform_strategy()","def test_songs_played(self):\n self.assertEqual(self.show.song_booleans, {\n 'you-enjoy-myself': 1,\n 'tweezer': 0\n })","def test(config, alg, checkpoint=None, testdelay=0, render=False, envcreator=None, maxepisodelen=10000000):\n if alg == \"random\":\n env = envcreator()\n else:\n agent = get_agent_class(alg)(config=config, env=\"retro-v0\")\n if checkpoint is None:\n raise ValueError(f\"A previously trained checkpoint must be provided for algorithm {alg}\")\n agent.restore(checkpoint)\n env = agent.local_evaluator.env\n\n while True:\n state = env.reset()\n done = False\n reward_total = 0.0\n step = 0\n while not done and step < maxepisodelen:\n if alg == \"random\":\n action = np.random.choice(range(env.action_space.n))\n else:\n action = agent.compute_action(state)\n next_state, reward, done, _ = env.step(action)\n time.sleep(testdelay)\n reward_total += reward\n if render:\n env.render()\n state = next_state\n step = step + 1\n print(\"Episode reward\", reward_total)","def test_play(self):\n self.assertTrue(len(self.player.valid_callers)>0)\n \"\"\"...and should allow round_robin.play to call\"\"\"\n self.assertTrue(\"play\" in self.player.valid_callers)\n self.play()\n self.play()","def play(self, n_episodes=100, max_episode_length=3000, load_path=\"last_save.h5\"):\n\n self.explore = False # Explore if needed\n\n self._play_through(n_episodes=n_episodes, max_episode_length=max_episode_length, load_path=load_path,\n callbacks=self._play_callbacks_factory())","def on_episode_start(self, agent, **kwargs):\n self.episode_start[agent.brain.episode] = timeit.default_timer()\n self.observations[agent.brain.episode] = []\n self.rewards[agent.brain.episode] = []\n self.actions[agent.brain.episode] = []\n self.metrics[agent.brain.episode] = {}","def track_03():\n sonos.play_uri('http://nrj.de/sachsen', title='Energy Sachsen', force_radio=True)\n return \"Ok\"","def test_runGame(self):\n # this is tested by playing the game. No good way to unit test this.\n pass","def run_aqi(self):\r\n while True:\r\n self.get_aqi()\r\n time.sleep(30 - time.time() % 30)","def media_episode(self):\n media_status = self._media_status()[0]\n return media_status.episode if media_status else None","def evaluate(self, env, num_episodes, max_episode_length=None\n , show_detail = False):\n episode_counter = 1;\n average_reward = 0;\n average_episode_length = 0;\n time_this, ob_this, is_terminal = env.reset()\n\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\n\n obs_this_net = self._preprocessor.process_observation_for_network(\n ob_this, self._min_array, self._max_array)\n\n state_this_net = np.append(obs_this_net[0:13], obs_this_net[14:]).reshape(1,16)\n setpoint_this = ob_this[6:8]\n \n this_ep_reward = 0;\n this_ep_length = 0;\n while episode_counter <= num_episodes:\n action_mem = self.select_action(state_this_net, stage = 'testing');\n # covert command to setpoint action \n action = self._policy.process_action(setpoint_this, action_mem)\n\n time_next, ob_next, is_terminal = env.step(action)\n \n ob_next = self._preprocessor.process_observation(time_next, ob_next)\n\n setpoint_next = ob_next[6:8]\n\n obs_next_net = self._preprocessor.process_observation_for_network(\n ob_next, self._min_array, self._max_array)\n \n state_next_net = np.append(obs_next_net[0:13], obs_next_net[14:]).reshape(1,16)\n \n #10:PMV, 11: Occupant number , -2: power\n reward = self._preprocessor.process_reward(obs_next_net[12:15])\n \n this_ep_reward += reward;\n \n #Check if exceed the max_episode_length\n if max_episode_length is not None and \\\n this_ep_length >= max_episode_length:\n is_terminal = True;\n #Check whether to start a new episode\n if is_terminal:\n time_this, ob_this, is_terminal = env.reset()\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\n setpoint_this = ob_this[6:8]\n obs_this_net = self._preprocessor.process_observation_for_network(\n ob_this, self._min_array, self._max_array)\n\n state_this_net = np.append(obs_this_net[0:13], \n obs_this_net[14:]).reshape(1,16)\n\n average_reward = (average_reward * (episode_counter - 1) \n + this_ep_reward) / episode_counter;\n average_episode_length = (average_episode_length \n * (episode_counter - 1) \n + this_ep_length) / episode_counter;\n \n episode_counter += 1;\n if show_detail:\n logging.info ('Episode ends. Cumulative reward is %0.04f '\n 'episode length is %d, average reward by now is %0.04f,'\n ' average episode length by now is %d.' %(this_ep_reward,\n this_ep_length,\n average_reward,\n average_episode_length));\n this_ep_length = 0;\n this_ep_reward = 0;\n \n else:\n ob_this = ob_next\n setpoint_this = setpoint_next\n state_this_net = state_next_net\n time_this = time_next\n this_ep_length += 1;\n return (average_reward, average_episode_length);","def executeEpisode(self, mcts, game, args):\n trainExamples = []\n board = game.getInitBoard()\n curPlayer = 1\n episodeStep = 0\n state_counter = Counter()\n\n moves = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = game.getCanonicalForm(board, curPlayer)\n temp = int(episodeStep < self.args['tempThreshold'])\n\n pi = mcts.getActionProb(canonicalBoard, temp=temp)\n sym = game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n state_counter.update(game.stringRepresentation(board)) #count the visit to the board\n\n board, curPlayer = game.getNextState(board, curPlayer, action)\n\n r = game.getGameEnded(board, curPlayer)\n \n moves += 1\n\n if moves >= self.args['maxMoves']:\n r = 1e-4\n\n if r != 0:\n return ([(x[0], x[2], r * ((-1) ** (x[1] != curPlayer))) for x in trainExamples], state_counter)","def run(self):\n self.ae.start()","def test(net, env, total_episodes, test_seeds=None, cuda=False, log=False, render=False, max_actions=10000):\n net.eval()\n total_reward = 0\n with torch.no_grad():\n for ep in range(total_episodes):\n obs = env.reset()\n done, ep_reward, ep_actions = False, 0, []\n hx = Variable(net.init_hidden())\n all_obs = [obs]\n action_count = 0\n while not done:\n if render:\n env.render()\n obs = Variable(torch.Tensor(obs)).unsqueeze(0)\n if cuda:\n obs, hx = obs.cuda(), hx.cuda()\n critic, logit, hx = net((obs, hx))\n prob = F.softmax(logit, dim=1)\n action = int(prob.max(1)[1].data.cpu().numpy())\n obs, reward, done, _ = env.step(action)\n action_count += 1\n done = done if action_count <= max_actions else True\n ep_actions.append(action)\n # A quick hack to prevent the agent from stucking\n max_same_action = 5000\n if action_count > max_same_action:\n actions_to_consider = ep_actions[-max_same_action:]\n if actions_to_consider.count(actions_to_consider[0]) == max_same_action:\n done = True\n ep_reward += reward\n if not done:\n all_obs.append(obs)\n total_reward += ep_reward\n if log:\n logger.info('Episode =>{} Score=> {} Actions=> {} ActionCount=> {}'.format(ep, ep_reward, ep_actions,\n action_count))\n return total_reward / total_episodes","def main():\n global repeat\n regime = collect()\n start = int(raw_input(\"Which line of the exercise script would you like to begin with? \")) - 1\n regime = regime[start:]\n say(\"Ready?\")\n time.sleep(1)\n for exercise in regime:\n coach(exercise[:-1])\n while repeat:\n repeat = False\n coach(exercise[:-1])\n say(\"Session complete.\")","def testOneShow(self):\n\t\t# for line in self.file:\n\t\t# \tprint line\n\t\tline = self.file.readline()\n\t\tinfo = scrapeFilename( line )\n\t\tassert info['show'] == \"Chuck\""],"string":"[\n \"def test():\\n env = gym.make('CartPole-v1')\\n\\n results = []\\n for _ in range(100):\\n results.append(episode(env, render=False, verbose=False))\\n\\n print(f'average={sum(results) / len(results)} '\\n f'max={max(results)} '\\n f'min={min(results)}')\",\n \"def test_scraper(self):\\n scrap = ScraperModule(url=self.anime_link, host=\\\"mixdrop\\\")\\n pages = scrap.pages\\n print(f\\\"pages: {pages}\\\")\\n get_pages = scrap.get_pages()\\n first_link = scrap.get_links(pages[0])\\n print(first_link)\\n episodes = scrap.get_episodes()\\n print(episodes)\",\n \"def play(self, test_ep=0., n_step=10000, n_episode=1000):\\n\\n # If not training, clear log of old data, initialize TF variables, and load model.\\n if self.stat and not self.is_train:\\n tf.initialize_all_variables().run()\\n self.stat.load_model()\\n\\n self.target_network.run_copy()\\n\\n rewards = []\\n game_lengths = []\\n\\n # Play at least n_episode episodes.\\n while np.sum(game_lengths) < n_episode:\\n\\n # Start a new game.\\n observation, reward, terminal = self.new_game()\\n current_reward = 0\\n\\n # Add initial frames to history.\\n for _ in range(self.history_length):\\n self.history.add(observation)\\n\\n # Play game until 'terminal.'\\n for t in range(n_step):\\n # 1. Predict.\\n action = self.predict(self.history.get(), test_ep)\\n # 2. Act.\\n observation, reward, terminal, _ = self.env.step(action, is_training=False)\\n # 3. Observe.\\n self.history.add(observation)\\n \\n current_reward += reward\\n\\n if terminal:\\n break\\n\\n # Set tqdm range description.\\n if self.t_range and not self.chtc:\\n self.t_range.set_description('PLAY: %d/%d' % (np.sum(game_lengths), n_episode))\\n\\n # After game, add game length and rewards.\\n rewards.append(float(current_reward))\\n game_lengths.append(terminal)\\n\\n if self.t_range and not self.chtc:\\n self.t_range.set_description()\\n \\n self.compute_statistics(rewards, game_lengths)\",\n \"def OnEnterEpisode(self):\\n pass\",\n \"def run_episode(self):\\n self.pygame_clock = pygame.time.Clock()\\n while True:\\n pygame.event.pump()\\n is_human_agent = isinstance(self.agents[self.env.turn], HumanAgent)\\n\\n # handle exit event\\n self.handle_input_event()\\n\\n # pick the next action\\n if is_human_agent:\\n self.handle_input_event()\\n else:\\n self.ai_event()\\n self.place_a_disk()\\n self.render()\\n\\n if self.event == Event.END_GAME:\\n pygame.time.wait(self.END_GAME_DELAY)\\n\\n if self.event == Event.END_GAME_VIEW:\\n pygame.time.wait(self.END_GAME_VIEW_DELAY)\\n break\",\n \"def set_episode_check(self, alias, epi, check):\\n re_m = re.match(r's(\\\\d{1,2})e(\\\\d{1,2})', epi.lower())\\n if not re_m:\\n print('Bad format for check - \\\"{0}\\\"'.format(epi))\\n else:\\n season = int(re_m.group(1))\\n episode = int(re_m.group(2))\\n show_id = self.id_by_title(self.title_by_alias(alias, no_exit=True))\\n epis = self.load_episodes(show_id)\\n watched = self.load_watched(show_id)\\n episodes = epis['episodes']\\n for epi_id in episodes:\\n next_episode = episodes[epi_id]\\n if (\\n next_episode['seasonNumber'] == season and\\n next_episode['episodeNumber'] == episode\\n ):\\n valid_op = False\\n old_date = ''\\n if check:\\n msg = 'checked'\\n if epi_id in watched:\\n old_date = watched[epi_id]['watchDate']\\n else:\\n url = self.config['url']['check_episode'].format(epi_id)\\n valid_op = True\\n else:\\n msg = 'unchecked'\\n if epi_id in watched:\\n url = self.config['url']['uncheck_episode'].format(epi_id)\\n valid_op = True\\n\\n if not valid_op:\\n print()\\n print('Episode \\\"{0}\\\" (s{1:02d}e{2:02d}) of \\\"{3}\\\" already {4} {5}'\\n .format(\\n tr_out(next_episode['title']),\\n next_episode['seasonNumber'],\\n next_episode['episodeNumber'],\\n tr_out(epis['title']),\\n msg,\\n old_date\\n ))\\n else:\\n logging.debug('Set checked: %s%s', self.api_url, url)\\n request = urllib.request.Request(self.api_url + url)\\n self.opener.open(request)\\n print()\\n print(\\n 'Episode \\\"{0}\\\" (s{1:02d}e{2:02d}) of \\\"{3}\\\" set {4}'\\n .format(\\n tr_out(next_episode['title']),\\n next_episode['seasonNumber'],\\n next_episode['episodeNumber'],\\n tr_out(epis['title']),\\n msg\\n ))\\n break\",\n \"def test_create_episode(self):\\n episode = self._create_sample_episode()\\n\\n self.assertEqual(\\n self.storage.get_episode(episode.study_id, episode.session_id,\\n episode.id), episode)\",\n \"def test(self):\\n total_steps = 0\\n running_scores = np.zeros(len(self.agents))\\n\\n for e in range(self.run_settings.test_episodes):\\n # Initialize episode\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.reset()\\n except EpisodeCrashException:\\n print('Episode crashed, resetting.')\\n continue\\n\\n # Initialize scores to starting reward (probably 0)\\n scores = np.array(rewards)\\n step = 0\\n\\n while not done:\\n states = [self.agents[a].state_space_converter(env_states[a])\\n for a in range(len(self.agents))]\\n\\n # Get actions\\n actions = [self.agents[a].sample(states[a])\\n for a in range(len(self.agents))]\\n env_actions = [self.agents[a].action_space_converter(actions[a])\\n for a in range(len(self.agents))]\\n if self.run_settings.verbose:\\n self.print_action(env_actions)\\n # Take environment step\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\\n except EpisodeCrashException:\\n print('Episode crashed, resetting.')\\n break\\n step += 1\\n total_steps += 1\\n\\n # Update scores\\n scores += np.array(rewards)\\n\\n if done:\\n running_scores += scores\\n\\n if len(scores) == 1:\\n scores = scores[0]\\n if self.run_settings.verbose:\\n print(\\\"Game {} ended after {} steps. Game score: {}\\\"\\n .format(e+1, step, scores))\\n if self.run_settings.verbose:\\n print(\\\"Average game scores: {}\\\".format(running_scores / self.run_settings.test_episodes))\",\n \"def OnEpisodeStart(self):\\n pass\",\n \"def test_get_episode_overview(self):\\n self.assertEquals(\\n self.t['Battlestar Galactica (2003)'][1][6]['overview'].startswith(\\n 'When a new copy of Doral, a Cylon who had been previously'),\\n True\\n )\",\n \"def new_episode(self):\\n self.game.new_episode()\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n player = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, player)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, player, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, player = self.game.getNextState(board, player, action)\\n\\n r = self.game.getGameEnded(board, player)\\n\\n if r != 0:\\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\\n return ex\",\n \"def testBeginEpisode(self):\\n with tf.compat.v1.Session() as sess:\\n agent = self._create_test_agent(sess)\\n # We fill up the state with 9s. On calling agent.begin_episode the state\\n # should be reset to all 0s.\\n agent.state.fill(9)\\n first_observation = np.ones(self.observation_shape + (1,))\\n self.assertEqual(agent.begin_episode(first_observation), 0)\\n # When the all-1s observation is received, it will be placed at the end of\\n # the state.\\n expected_state = self.zero_state\\n expected_state[:, :, :, -1] = np.ones((1,) + self.observation_shape)\\n self.assertAllEqual(agent.state, expected_state)\\n self.assertAllEqual(agent._observation, first_observation[:, :, 0])\\n # No training happens in eval mode.\\n self.assertEqual(agent.training_steps, 0)\\n\\n # This will now cause training to happen.\\n agent.eval_mode = False\\n # Having a low replay memory add_count will prevent any of the\\n # train/prefetch/sync ops from being called.\\n agent._replay.memory.add_count = 0\\n second_observation = np.ones(self.observation_shape + (1,)) * 2\\n agent.begin_episode(second_observation)\\n # The agent's state will be reset, so we will only be left with the all-2s\\n # observation.\\n expected_state[:, :, :, -1] = np.full((1,) + self.observation_shape, 2)\\n self.assertAllEqual(agent.state, expected_state)\\n self.assertAllEqual(agent._observation, second_observation[:, :, 0])\\n # training_steps is incremented since we set eval_mode to False.\\n self.assertEqual(agent.training_steps, 1)\",\n \"def run(self) -> None:\\n for episode in range(1, self.episodes + 1):\\n print('Episode:', episode)\\n steps, state_action_history = self.run_one_episode()\\n self.steps_per_episode.append(steps)\\n if episode % parameters.CACHING_INTERVAL == 0 or steps < 1000:\\n visualize.animate_track(state_action_history, f'agent-{episode}')\\n\\n print('Training completed.')\\n visualize.plot_steps_per_episode(self.steps_per_episode)\\n visualize.plot_epsilon(self.agent.epsilon_history)\\n\\n if parameters.VISUALIZE_FINAL_GAME:\\n print('Showing one episode with the greedy strategy.')\\n self.agent.epsilon = 0\\n steps, state_action_history = self.run_one_episode()\\n print(f'Episode completed in {steps} steps.')\\n visualize.animate_track(state_action_history)\",\n \"def test_plays_get(self):\\n pass\",\n \"def startEpisode(self):\\n self.lastState = None\\n self.lastAction = None\\n self.episodeRewards = 0.0\\n\\n print(\\\"Agent Start Episode #\\\" + str(self.episodesSoFar+1))\",\n \"def watch_episode(logger, n_episodes: int = 1):\\n\\n # play match\\n for episode in logger.observations:\\n for steps in logger.observations[episode]:\\n clear_output(wait=True)\\n plt.imshow(steps)\\n plt.show()\\n if n_episodes - 1 >= episode:\\n break\",\n \"def run_episode(self, mode=0, eps=0.):\\n if mode==0:\\n eps = 0.\\n done = False\\n score = 0 \\n \\n while not done:\\n state = self.env_info.vector_observations[0] # get the current state\\n action = self.agent.act(state, eps=eps) # get an action using epsilon greedy policy\\n self.env_info = self.env.step(action)[self.brain_name] # send the action to the environment\\n next_state = self.env_info.vector_observations[0] # get the next state\\n reward = self.env_info.rewards[0] # get the reward\\n done = self.env_info.local_done[0] # see if episode has finished\\n \\n if mode == 1:\\n self.agent.step(state, action, reward, next_state, done)\\n \\n score += reward\\n \\n self.reset_env() # reset the environment\\n \\n return score\",\n \"def testPlayback(self):\\n \\n pass\",\n \"def start_episode(self):\\n self.last_sensation = self.env()\\n self.next_action = self.agent(self.last_sensation)\",\n \"def test_single_track_ep(self):\\n self.add_mp3()\\n (added, status) = self.app.add_album(self.filenames, 'ep')\\n self.assertEqual(added, True)\\n self.assertEqual(self.get_album_count(), 1)\\n album = Album.get_by_artist_album(self.app.curs, 'Artist', 'Album')\\n self.assertNotEqual(album, None)\\n self.assertEqual(album.artist, 'Artist')\\n self.assertEqual(album.album, 'Album')\\n self.assertEqual(album.album_type, 'ep')\\n self.assertEqual(album.totalseconds, 2)\\n self.assertEqual(album.totaltracks, 1)\",\n \"def show_next_for_watch(self, alias):\\n show_id = self.id_by_title(self.title_by_alias(alias, no_exit=True))\\n epis = self.load_episodes(show_id)\\n episode_id = self.get_first_unwatched(show_id)\\n if episode_id is None:\\n print(\\\"\\\\nCannot find first watch for {0}\\\\n\\\".format(tr_out(epis['title'])))\\n else:\\n episode = epis['episodes'][episode_id]\\n print('\\\\nFirst watch for {0} is s{1:02d}e{2:02d} (\\\"{3}\\\")\\\\n'.format(\\n tr_out(epis['title']),\\n episode['seasonNumber'], episode['episodeNumber'],\\n tr_out(episode['title']),\\n ))\",\n \"def OnEpisodeOver(self):\\n pass\",\n \"def run(self):\\n time.sleep(np.random.rand())\\n np.random.seed(np.int32(time.time() % 1000 * self.id))\\n \\n # Put this in a while loop that checks a shared variable\\n # Will keep running episodes until the shared variable reports False\\n while(self.exit_flag == 0):\\n for experience in self.run_episode():\\n print(experience.state, experience.reward)\\n self.training_q.put(experience)\",\n \"def add_episode(self, ep):\\n #make da season\\n ses = self._add_season(ep)\\n dvdses = self._add_season(ep, dvd=True) \\n self._add_episode(ep, ses)\\n self._add_episode(ep, dvdses, dvd=True)\",\n \"def test_seasons(self):\\n response = Tmdb.season(tmdb_show_id = 69740, season_number = 1)\\n self.assertTrue(int(response.status_code) == 200)\\n data = response.json()\\n self.assertTrue(isinstance(data['episodes'], list))\\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)\",\n \"def testGetEpisodeName(self):\\n\\t\\tfor case in self.testCases:\\n\\t\\t\\tassert case['title'] == getEpisodeName( case['show'], case['season'], case['episode'])\",\n \"def begin_episode(self):\\n self.action = PlayerAction.STAND_STILL\",\n \"def play_episodes(env, policy, render_option, num_eps, pause_time, min_steps):\\n env.reset()\\n if pause_time != 0:\\n for _ in range(int(pause_time / 0.01)):\\n env.render()\\n time.sleep(0.01)\\n total_reward = 0.0\\n for _ in range(num_eps):\\n episode_reward = play_episode(env, policy, render_option, min_steps)\\n total_reward += episode_reward\\n avg_reward = total_reward / num_eps\\n print('finished {0} episodes with average reward {1}'.format(num_eps, avg_reward))\\n return avg_reward\",\n \"def run(self, num_episodes=1):\\n pygame.display.update()\\n self.fps_clock = pygame.time.Clock()\\n\\n try:\\n for episode in range(num_episodes):\\n self.run_episode()\\n self.env.new_episode()\\n self.event = Event.next(self.event)\\n except QuitRequestedError:\\n print(\\\"Exit Program\\\")\\n\\n pygame.quit()\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n self.curPlayer = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, self.curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\\n\\n r = self.game.getGameEnded(board, self.curPlayer)\\n\\n if r != 0:\\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n self.curPlayer = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, self.curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\\n\\n r = self.game.getGameEnded(board, self.curPlayer)\\n\\n if r != 0:\\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]\",\n \"def play(self):\\n if not self.tiempos.esta_vacia():\\n self._reproducir(self.tiempos.actual())\",\n \"def terminal_test(self):\\n\\n for self.cur_ep in tqdm.tqdm(range(1, self.episodes + 1), ascii=True, unit='episodes'):\\n\\n # Nombre de passages dans la boucle principale\\n step = 1\\n\\n cur_state = self.env.reset()\\n\\n done = False\\n\\n while not done:\\n\\n # Choix au hasard entre :\\n if np.random.random() > self.epsilon:\\n # Action à partir de la q-table\\n action = np.argmax(self.agent.get_q_values(np.array(cur_state)))\\n\\n else:\\n # Action random\\n action = np.random.randint(0, self.env.ACTION_SPACE_SIZE)\\n\\n # On effectue une action avec le serpent\\n new_state, reward, done = self.env.step(action)\\n\\n # Ajout d'un exemple dans la mémoire\\n self.agent.update_training_set((cur_state, action, reward, new_state, done))\\n\\n # Entrainement éventuel\\n self.agent.train()\\n\\n cur_state = new_state\\n step += 1\\n\\n if self.epsilon > self.MIN_EPSILON:\\n self.epsilon *= self.EPSILON_DECAY\\n self.epsilon = max(self.MIN_EPSILON, self.epsilon)\\n\\n if self.save_model:\\n self.agent.save_model(self.model_file_name)\",\n \"def debug():\\n env = gym.make('CartPole-v1')\\n env = gym.wrappers.Monitor(env, 'videos/', force=True)\\n reward = episode(env, render=True, verbose=True)\\n print(f'Reward: {reward}')\",\n \"def play(self):\\n observation = self.env.reset()\\n count = 0\\n reward_sum = 0\\n random_episodes = 0\\n\\n while random_episodes < 10:\\n self.env.render()\\n x = observation.reshape(-1, 4)\\n q_values = self.model.predict(x)[0]\\n action = np.argmax(q_values)\\n observation, reward, done, _ = self.env.step(action)\\n count += 1\\n reward_sum += reward\\n\\n if done:\\n print(\\\"Reward for this episode was: {}, turns was: {}\\\".format(reward_sum, count))\\n random_episodes += 1\\n reward_sum = 0\\n count = 0\\n observation = self.env.reset()\\n\\n self.env.close()\",\n \"def run_episode(self):\\n self.reset_episode()\\n obs = self.env.reset()\\n while True:\\n action = self.Policy[self.env.stateDict[obs]]\\n new_obs, reward, done, _ = self.env.step(action)\\n if self.mode=='debug':\\n print(\\\"PrevObs:{}, Action:{}, Obs:{}, Reward:{}, Done:{}\\\"\\n .format(obs, action, new_obs,reward,done))\\n self.totalReward += reward\\n self.totalSteps += 1\\n if done:\\n break\\n else:\\n obs = new_obs\\n return self.totalReward\",\n \"def episode_step(self):\\n self.nsteps += 1\",\n \"def play_against_random(env, q_value, n_episodes = 100,\\n play_as = 'O', render = False, self_play = False):\\n \\n assert play_as in ['X','O'], \\\"Player should be X or O\\\"\\n \\n \\n running_reward = []\\n \\n for episode in range(n_episodes):\\n \\n #start episode\\n state = env.reset()\\n done = False\\n \\n while not done:\\n \\n if play_as == state[1] :\\n #print(\\\"q learner\\\")\\n action = e_greedy(state,env,q_value, inference = True)[0]\\n \\n else:\\n if self_play:\\n action = e_greedy(state,env,q_value, inference = True)[0]\\n else:\\n action = random_player(env)\\n \\n state,reward,done, _ = env.step(action)\\n \\n if render:\\n env.render()\\n print(reward, \\\"\\\\n\\\\n\\\")\\n running_reward.append(reward)\\n \\n if play_as == 'X':\\n running_reward = [-i for i in running_reward] \\n \\n performance = np.mean(running_reward)\\n \\n won = sum([1 if i == 1 else 0 for i in running_reward])\\n lost = sum([1 if i == -1 else 0 for i in running_reward])\\n draw = sum([1 if i == 0 else 0 for i in running_reward])\\n \\n #print(f\\\"Player : {play_as} | Performance : {performance} | Won: {won} | Lost: {lost} | Draw: {draw} | Total : {n_episodes}\\\")\\n \\n return (won,lost,draw)\",\n \"def play(self):\\n p1 = self.player()\\n p2 = axelrod.Player()\\n p1.reset()\\n p1.strategy(p2)\\n # Genome contains only valid responses.\\n self.assertEqual(p1.genome.count(C) + p1.genome.count(D), len(p1.genome))\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 0.0 # no exploration\\n self.alpha = 0.0 # no learning\",\n \"def run_episode(self):\\n # Reset environment\\n self.agent.env.reset()\\n done = False\\n step_count = 0\\n total_reward = 0\\n\\n while not done:\\n reward, done = self.agent.explore()\\n step_count += 1\\n if step_count % 100 == 0:\\n print('step count {}'.format(step_count))\\n total_reward += self.agent.params['gamma']**step_count * reward\\n return step_count, total_reward\",\n \"def _start_episode(self, test = False):\\n self.env.true_reset()\\n new_frame = self.env.reset()\\n if not test:\\n self.memory.add_experience(0, 0.0, new_frame, False)\\n for i in range(self.num_stacked_frames):\\n self._current_state[0, i] = new_frame\\n new_frame, reward, done, _ = self.env.step(0)\\n if not test:\\n self.memory.add_experience(0, reward, new_frame, done)\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 1.0 # no exploration\\n self.lr = 0.0 # no learning\",\n \"def test_download_specific_episode(self):\\n episode = self._get_episode()\\n torrent_filename = self.fetcher.download_specific_episode(episode)\\n self.assertEqual(torrent_filename, FILENAME_2)\",\n \"def nukePlay():\\n nuke.activeViewer().play(1)\",\n \"def test_save_unwatched_episodes(self):\\n save_episodes(self.schedule.episodes)\\n for show in FollowedShows.objects.filter(user_id=self.user.id):\\n self.assertTrue(show.unwatchedepisode_set.all().count() > 0)\",\n \"def test_selecting_only_audio_episodes(\\n only_audio_episodes: List[LepEpisode],\\n) -> None:\\n assert len(only_audio_episodes) == 14 # Without duplicates\",\n \"def play_game():\\n pass\",\n \"def self_play(self, n_episodes): \\n eps = self.eps(self.agent.learning_iters)\\n experiences = self_play_episodes(self.mdp, self.agent, n_episodes, eps) \\n for state, action, reward, next_state, done in experiences:\\n self.agent.replay_buffer.push(state, action, reward, next_state, done)\",\n \"def test_episode_data(self):\\n self.assertEquals(\\n self.t['lost']['firstaired'],\\n '2004-09-22'\\n )\",\n \"def startEpisode(self):\\n self.lastState = None\\n self.lastAction = None\\n self.episodeRewards = 0.0\",\n \"def explore(self, episode_count):\\n # single agent, always use the `run_one_episode` api.\\n # multi agent with `standalone` api_type, use the `run_one_episode` api.\\n if self.env_info[\\\"api_type\\\"] == \\\"standalone\\\":\\n # (use_explore, collect)\\n _paras = [\\n (True, False if _ag.alg.async_flag else True) for _ag in self.agents\\n ]\\n job_funcs = [agent.run_one_episode for agent in self.agents]\\n for _epi_index in range(episode_count):\\n _start2 = time()\\n self.env.reset()\\n for agent in self.agents:\\n agent.reset()\\n\\n trajectory_list = self.bot.do_multi_job(job_funcs, _paras)\\n for agent, trajectory in zip(self.agents, trajectory_list):\\n if not agent.alg.async_flag:\\n # self.trajectories.append(trajectory)\\n self.send_explorer.send(trajectory)\\n\\n self._post_processes()\\n self.ag_stats.explore_time_in_epi = time() - _start2\\n\\n if _epi_index == episode_count - 1:\\n self.ag_stats.update_with_agent_stats(\\n [agent.get_perf_stats() for agent in self.agents]\\n )\\n\\n elif self.env_info[\\\"api_type\\\"] == \\\"unified\\\":\\n for _ in range(episode_count):\\n _start2 = time()\\n trajectories = self._run_one_unified_episode(\\n use_explore=True, collect=True)\\n\\n for _ag, trajectory in zip(self.agents, trajectories):\\n if not _ag.alg.async_flag:\\n # self.trajectories.append(trajectory)\\n self.send_explorer.send(trajectory)\\n\\n self._post_processes()\\n self.ag_stats.explore_time_in_epi = time() - _start2\\n else:\\n pass\\n\\n self.clear_trajectories()\\n return self.ag_stats.get()\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 0.0 # no exploration\\n self.alpha = 0.0 # no learning\\n\\n print(\\\"Agent Stop Episode\\\")\\n print(self.episodeRewards)\\n for feature, weight in self.weights.iteritems():\\n print(\\\"\\\\t\\\" + str(feature) + \\\" - \\\" + str(weight))\\n self.episodeRewardsList.append(self.episodeRewards)\",\n \"def play(self):\\n pass\",\n \"def run_episode(env, agent, deterministic, do_training=True, rendering=False, max_timesteps=1000):\\n\\n stats = EpisodeStats() # save statistics like episode reward or action usage\\n state = env.reset()\\n\\n step = 0\\n while True:\\n\\n action_id = agent.act(state=state, deterministic=deterministic)\\n next_state, reward, terminal, info = env.step(action_id)\\n\\n if do_training:\\n agent.train(state, action_id, next_state, reward, terminal)\\n\\n state = next_state\\n\\n # # NOTE reward shaping...\\n # if terminal:\\n # reward += -1\\n # if step < 20:\\n # reward += -10\\n # if step > 100:\\n # reward += 10\\n\\n stats.step(reward, action_id)\\n\\n if rendering:\\n env.render()\\n\\n if terminal or step > max_timesteps:\\n break\\n\\n step += 1\\n\\n return stats\",\n \"def test_atomic_update_episode(self):\\n episode = self._create_sample_episode()\\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\\n episode.id)\\n\\n def callback(read_episode):\\n # Read episode should match the stored one.\\n self.assertEqual(read_episode, episode)\\n self.assertEqual(read_episode.num_steps, 100)\\n # Make a change.\\n read_episode.num_steps = 200\\n return True\\n\\n self.assertTrue(\\n self.storage.atomic_update_episode(study_id, session_id, episode_id,\\n callback))\\n # Check that the change was applied.\\n episode.num_steps = 200\\n self.assertEqual(\\n self.storage.get_episode(study_id, session_id, episode_id), episode)\",\n \"def train(self, max_episodes= 1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\\n success = False\\n i_episode = 0\\n eps = eps_start\\n \\n print('Training in progress...')\\n for i in range(max_episodes):\\n score = self.run_training_episode(eps=eps)\\n \\n self.score_window.append(score)\\n self.score_record.append(np.mean(self.score_window))\\n \\n i_episode += 1\\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\\n\\n if i_episode%100 == 0:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\\n \\n if i_episode>100:\\n if np.mean(self.score_window)>self.criteria:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, self.score_record[-1]))\\n success = True\\n break\\n\\n if success:\\n print('Criteria reached after {} episodes'.format(i_episode))\\n else:\\n print('Failed to reach Criteria after {} episodes'.format(i_episode))\\n\\n self.plot_training_progress()\\n return success\",\n \"def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=True, max_timesteps=10000,\\n history_length=0, manual=False):\\n\\n stats = utils.EpisodeStats()\\n\\n # Save history\\n image_hist = []\\n\\n step = 0\\n state = env.reset()\\n\\n env.viewer.window.on_key_press = utils.key_press\\n env.viewer.window.on_key_release = utils.key_release\\n # fix bug of corrupted states without rendering in gym environment\\n env.viewer.window.dispatch_events()\\n\\n # append image history to first state\\n state = state_preprocessing(state)\\n image_hist.extend([state] * (history_length + 1))\\n state = np.array(image_hist).reshape(96, 96, history_length + 1)\\n while True:\\n #skip intro zoom frames\\n if step < 48:\\n step += 1\\n env.step(utils.id_to_action(0))\\n continue\\n \\n # TODO: get action_id from agent\\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly.\\n if do_training and manual:\\n action_id = utils.manual_action\\n else:\\n action_id = agent.act(state, deterministic)\\n action = utils.id_to_action(action_id)\\n\\n # Hint: frame skipping might help you to get better results.\\n reward = 0\\n for _ in range(skip_frames + 1):\\n next_state, r, terminal, info = env.step(action)\\n reward += r\\n\\n if rendering:\\n env.render()\\n\\n if terminal:\\n break\\n\\n next_state = state_preprocessing(next_state)\\n \\n image_hist.append(next_state)\\n image_hist.pop(0)\\n next_state = np.array(image_hist).reshape(96, 96, history_length + 1)\\n\\n if do_training and (next_state[:82, :, -1].sum() > 5000): #track out of sight\\n print('Track gone; finish this episode')\\n agent.add(state, action_id, next_state, reward=-(skip_frames + 1), terminal=True) #punish\\n break\\n\\n if do_training:\\n agent.add(state, action_id, next_state, reward, terminal)\\n if not manual:\\n agent.train()\\n\\n stats.step(reward, action_id)\\n\\n state = next_state\\n \\n if terminal or (step * (skip_frames + 1)) > max_timesteps:\\n break\\n\\n step += 1\\n\\n return stats\",\n \"def test_search_torrent(self):\\n episode = self._get_episode()\\n search_results = self.fetcher.jackett.search(episode.indexed_name)\\n best_result = self.fetcher.best_search_result(search_results)\\n self.assertEqual(best_result.get(\\\"id\\\"), 2)\",\n \"def test_search_torrent(self):\\n episode = self._get_episode()\\n search_results = self.fetcher.jackett.search(episode.indexed_name)\\n best_result = self.fetcher.best_search_result(search_results)\\n self.assertEqual(best_result.get(\\\"id\\\"), 2)\",\n \"def run_episode(env, gamma = 1.0, render = False):\\n actions = 4\\n obs = env.reset()\\n total_reward = 0\\n step_idx = 0\\n\\n while True:\\n if render:\\n env.render()\\n obs, reward, done , _ = env.step(random.randint(0, actions - 1))\\n x1, x2, x3, x4, x5, x6, x7, x8 = obs\\n x1s.append(x1)\\n x2s.append(x2)\\n x3s.append(x3)\\n x4s.append(x4)\\n x5s.append(x5)\\n x6s.append(x6)\\n x7s.append(x7)\\n x8s.append(x8)\\n total_reward += (gamma ** step_idx * reward)\\n step_idx += 1\\n if done:\\n break\\n return total_reward, step_idx\",\n \"def _run_single(self, thread_id, agent, environment, deterministic=False,\\n max_episode_timesteps=-1, episode_finished=None, testing=False, sleep=None):\\n\\n # figure out whether we are using the deprecated way of \\\"episode_finished\\\" reporting\\n old_episode_finished = False\\n if episode_finished is not None and len(getargspec(episode_finished).args) == 1:\\n old_episode_finished = True\\n\\n episode = 0\\n # Run this single worker (episode loop) as long as global count thresholds have not been reached.\\n while not self.should_stop:\\n state = environment.reset()\\n agent.reset()\\n self.global_timestep, self.global_episode = agent.timestep, agent.episode\\n episode_reward = 0\\n\\n # Time step (within episode) loop\\n time_step = 0\\n time_start = time.time()\\n while True:\\n action, internals, states = agent.act(states=state, deterministic=deterministic, buffered=False)\\n reward = 0\\n for repeat in xrange(self.repeat_actions):\\n state, terminal, step_reward = environment.execute(action=action)\\n reward += step_reward\\n if terminal:\\n break\\n\\n if not testing:\\n # agent.observe(reward=reward, terminal=terminal)\\n # Insert everything at once.\\n agent.atomic_observe(\\n states=state,\\n actions=action,\\n internals=internals,\\n reward=reward,\\n terminal=terminal\\n )\\n\\n if sleep is not None:\\n time.sleep(sleep)\\n\\n time_step += 1\\n episode_reward += reward\\n\\n if terminal or time_step == max_episode_timesteps:\\n break\\n\\n # Abort the episode (discard its results) when global says so.\\n if self.should_stop:\\n return\\n\\n self.global_timestep += time_step\\n\\n # Avoid race condition where order in episode_rewards won't match order in episode_timesteps.\\n self.episode_list_lock.acquire()\\n self.episode_rewards.append(episode_reward)\\n self.episode_timesteps.append(time_step)\\n self.episode_times.append(time.time() - time_start)\\n self.episode_list_lock.release()\\n\\n if episode_finished is not None:\\n # old way of calling episode_finished\\n if old_episode_finished:\\n summary_data = {\\n \\\"thread_id\\\": thread_id,\\n \\\"episode\\\": episode,\\n \\\"timestep\\\": time_step,\\n \\\"episode_reward\\\": episode_reward\\n }\\n if not episode_finished(summary_data):\\n return\\n # New way with BasicRunner (self) and thread-id.\\n elif not episode_finished(self, thread_id):\\n return\\n\\n episode += 1\",\n \"def send_music_play_event_and_validate(self):\\n play_detection_timeout = 1\\n if self.dut.is_streaming():\\n self.logger.info('Music already streaming. Skipping play event..')\\n return\\n self.logger.info('Playing video...')\\n is_played = self.dut.music_control_events(\\n AVRCPSTATUS, self.dut.apollo_log_regex.AVRCP_PLAY_REGEX)\\n if not is_played:\\n self.logger.error('AVRCP Played status not found')\\n raise TestActsError('AVRCP Played status not found.')\\n wait_until(\\n lambda: self.dut.is_streaming(),\\n play_detection_timeout,\\n sleep_s=0.25)\\n if not self.dut.is_streaming():\\n self.logger.error('Device is NOT in a deviceA2DPStreaming state')\\n raise TestActsError(\\n 'Device is NOT in a deviceA2DPStreaming state.')\",\n \"def play_one_episode(self, func, stat='score'):\\n if not isinstance(stat, list):\\n stat = [stat]\\n while True:\\n s = self.current_state()\\n act = func(s)\\n act, r, isOver = self.action(act)\\n # print r\\n if isOver:\\n s = [self.stats[k] for k in stat]\\n self.reset_stat()\\n return s if len(s) > 1 else s[0]\",\n \"def test_atomic_update_episode_no_update(self):\\n episode = self._create_sample_episode()\\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\\n episode.id)\\n\\n def callback(read_episode):\\n # Make a change but return false.\\n read_episode.num_steps = 200\\n return False\\n\\n self.assertFalse(\\n self.storage.atomic_update_episode(study_id, session_id, episode_id,\\n callback))\\n self.assertEqual(\\n self.storage.get_episode(study_id, session_id, episode_id), episode)\",\n \"def on_train_begin(self, logs):\\n print(f\\\"Testing for {self.params['nb_episodes']} episodes ...\\\")\",\n \"def begin_episode(self, observation):\\n self._reset_state()\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def begin_episode(self, observation):\\n self._reset_state()\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_quantile_samples,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn,\\n self._tau,\\n self.optimizer)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def run(agent, env, num_episodes = 20000, mode = 'train'):\\n\\t scores=[]\\n\\t max_avg_score=-np.inf\\n\\t for i_episode in range(1, num_episodes + 1):\\n\\t # Initialize episode\\n\\t state=env.reset()\\n\\t action=agent.reset_episode(state)\\n\\t total_reward=0\\n\\t done=False\\n\\n\\t # Roll out steps until done\\n\\t while not done:\\n\\t state, reward, done, info=env.step(action)\\n\\t total_reward += reward\\n\\t action=agent.act(state, reward, done, mode)\\n\\n\\t # Save final score\\n\\t scores.append(total_reward)\\n\\n\\t # Print episode stats\\n\\t if mode == 'train':\\n\\t if len(scores) > 100:\\n\\t avg_score=np.mean(scores[-100:])\\n\\t if avg_score > max_avg_score:\\n\\t max_avg_score=avg_score\\n\\n\\t if i_episode % 100 == 0:\\n\\t print(\\\"\\\\rEpisode {}/{} | Max Average Score: {}\\\".format(i_episode,\\n\\t num_episodes, max_avg_score), end = \\\"\\\")\\n\\t sys.stdout.flush()\\n\\n\\t return scores\\n\\n\\tscores=run(q_agent, env)\\n\\n\\t# Plot scores obtained per episode\\n\\tplt.plot(scores); plt.title(\\\"Scores\\\")\\n\\n\\tdef plot_scores(scores, rolling_window = 100):\\n\\t\\t\\\"\\\"\\\"Plot scores and optional rolling mean using specified window.\\\"\\\"\\\"\\n\\t\\tplt.plot(scores); plt.title(\\\"Scores\\\");\\n\\t\\trolling_mean=pd.Series(scores).rolling(rolling_window).mean()\\n\\t\\tplt.plot(rolling_mean);\\n\\t\\treturn rolling_mean\\n\\n\\trolling_mean=plot_scores(scores)\\n\\n\\t# Run in test mode and analyze socres obtained\\n\\ttest_scores=run(q_agent, env, num_episodes = 100, mode = 'test')\\n\\tprint(\\\"[TEST] Completed {} episodes with avg. score = {}\\\".format(\\n\\t len(test_scores), np.mean(test_scores)))\\n\\t_=plot_scores(test_scores, rolling_window = 10)\\n\\n\\n\\tdef plot_q_table(q_table):\\n \\\"\\\"\\\"Visualize max Q-value for each state and corresponding action.\\\"\\\"\\\"\\n\\t q_image=np.max(q_table, axis = 2) # max Q-value for each state\\n\\t q_actions=np.argmax(q_table, axis = 2) # best action for each state\\n\\n\\t fig, ax=plt.subplots(figsize = (10, 10))\\n\\t cax=ax.imshow(q_image, cmap = 'jet');\\n\\t cbar=fig.colorbar(cax)\\n\\t for x in range(q_image.shape[0]):\\n\\t for y in range(q_image.shape[1]):\\n\\t ax.text(x, y, q_actions[x, y], color = 'white',\\n\\t horizontalalignment = 'center', verticalalignment = 'center')\\n\\t ax.grid(False)\\n\\t ax.set_title(\\\"Q-table, size: {}\\\".format(q_table.shape))\\n\\t ax.set_xlabel('position')\\n\\t ax.set_ylabel('velocity')\\n\\n\\n\\tplot_q_table(q_agent.q_table)\\n\\n\\n\\tstate_grid_new=create_uniform_grid(\\n\\t env.observation_space.low, env.observation_space.high, bins = (20, 20))\\n\\tq_agent_new=QLearningAgent(env, state_grid_new)\\n\\tq_agent_new.scores=[]\\n\\n\\n\\tq_agent_new.scores += run(q_agent_new, env,\\n\\t num_episodes = 50000) # accumulate scores\\n\\trolling_mean_new=plot_scores(q_agent_new.scores)\\n\\n\\ttest_scores= run(q_agent_new, env, num_episodes = 100, mode = 'test')\\n\\tprint(\\\"[TEST] Completed {} episodes with avg. score = {}\\\".format(\\n\\t len(test_scores), np.mean(test_scores)))\\n\\t_=plot_scores(test_scores)\\n\\n\\tplot_q_table(q_agent_new.q_table)\\n\\n\\tstate=env.reset()\\n\\tscore=0\\n\\timg=plt.imshow(env.render(mode='rgb_array'))\\n\\tfor t in range(1000):\\n\\t\\taction=q_agent_new.act(state, mode = 'test')\\n\\t\\timg.set_data(env.render(mode='rgb_array'))\\n\\t\\tplt.axis('off')\\n\\t\\tdisplay.display(plt.gcf())\\n\\t\\tdisplay.clear_output(wait = True)\\n\\t\\tstate, reward, done, _=env.step(action)\\n\\t\\tsocre += reward\\n\\t\\tif done:\\n\\t\\t\\tprint('Score: ', socre)\\n\\t\\t\\tbreak\\n\\tenv.close()\",\n \"def begin_episode(self, observation: np.ndarray, a: int) -> int:\\n del observation\\n del a\\n return -1\",\n \"def test_start(self):\\n magic_hat = Game()\\n result = Game.start(magic_hat)\\n self.assertEqual(result, game.STATUS_PLAYING)\",\n \"def test_atomic_update_missing_episode(self):\\n\\n def callback(unused_episode):\\n # Callback should not be called.\\n assert False\\n\\n self.assertFalse(\\n self.storage.atomic_update_episode('study', 'session', 'missing',\\n callback))\",\n \"def execute_and_get_episodes(self, num_episodes, max_timesteps_per_episode=0, deterministic=False):\\n pass\",\n \"def run_episode(self, environment):\\n state = environment.reset()\\n self.steps_done = 0\\n while True:\\n state_tensor = FloatTensor([state])\\n position = self.Q.sample_from_softmax_policy(state_tensor)\\n action = position + 1\\n next_state, reward, done, _ = environment.step(position.item())\\n self.memory.push((state_tensor, action,))\\n self.learn(state_tensor, action, next_state, reward)\\n state = next_state\\n self.steps_done += 1\\n if done:\\n break\\n history = environment.close()\\n return history\",\n \"def test_delete_episode(self):\\n episode = self._create_sample_episode()\\n study_id, session_id, episode_id = (episode.study_id, episode.session_id,\\n episode.id)\\n self.assertIsNotNone(\\n self.storage.get_episode(study_id, session_id, episode_id))\\n\\n self.assertTrue(\\n self.storage.delete_episode(episode.study_id, episode.session_id,\\n episode.id))\\n self.assertIsNone(\\n self.storage.get_episode(study_id, session_id, episode_id))\",\n \"def podcast_show(url, name):\\n for recording in scraper.get_podcast_episodes(url):\\n INTERFACE.add_item(recording['title'],\\n 'play_podcast',\\n recording['url'],\\n extra_info=recording)\",\n \"def test_save_repeat_unwatched_episodes_should_not_be(self):\\n episode = self.schedule.episodes[0]\\n all_episodes = self.schedule.episodes\\n followed_show = FollowedShows.objects.get(user=self.user, show_id=episode.show.id)\\n UnwatchedEpisode(\\n followed_show=followed_show,\\n episode_id=episode.id,\\n episode_name=episode.name,\\n season=episode.season,\\n episode_number=episode.number or 0,\\n air_date=episode.airdate,\\n air_time=episode.airtime,\\n air_stamp=episode.airstamp,\\n summary=episode.summary or \\\"no summary\\\"\\n ).save()\\n save_episodes(self.schedule.episodes)\\n # make sure all episodes are saved to both users unwatched episodes despite the integrity error in bulk_create\\n self.assertEqual(len(all_episodes) * 2, len(UnwatchedEpisode.objects.all()))\",\n \"def execute_episodes(self, num_episodes, max_timesteps_per_episode=0, update_spec=None, deterministic=False):\\n pass\",\n \"def _update_episode(self):\\n if self.episode_num > 0:\\n self._publish_reward_topic(\\n self.accumulated_episode_reward,\\n self.episode_steps,\\n self.episode_num\\n )\\n\\n self.episode_num += 1\\n self.accumulated_episode_reward = 0\\n self.episode_steps = 0\",\n \"def _create_sample_episode(self) -> study_pb2.Episode:\\n study_id, session_id = self.init_session()\\n episode = sample_episode(study_id=study_id, session_id=session_id)\\n self.storage.create_episode(episode)\\n return episode\",\n \"def run(self):\\n # Observe the game by randomly sampling actions from the environment\\n # and performing those actions\\n self.__observe__()\\n for i in xrange(self.num_epochs):\\n self.environment.resetStatistics()\\n time_now = time.time()\\n for j in xrange(self.train_steps_per_epoch):\\n # Get action using epsilon-greedy strategy\\n action = self.__sample_epsilon_action__()\\n # Perform action based on epsilon-greedy search and store the transitions\\n # in experience replay\\n self.__supply_action_to_environment__(action)\\n # If the environment is in the terminal state, reset the environment, and\\n # perform self.stack_num actions to reset the environment\\n self.isGameOver()\\n if j % self.train_frequency == 0:\\n # print \\\"Started training\\\"\\n # Sample minibatch of size self.minibatch_size from experience replay\\n minibatch = self.experience_replay.sample()\\n minibatch_states, minibatch_action, minibatch_reward, minibatch_next_states, \\\\\\n minibatch_terminals = minibatch\\n cost = self.network.train_network(minibatch_states,\\n minibatch_action,\\n minibatch_reward,\\n minibatch_terminals,\\n minibatch_next_states)\\n if j % self.record_frequency == 0:\\n total_score, num_games = self.environment.getStatistics()\\n avg_score = total_score / num_games\\n self.network.record_average_qvalue(\\n self.experience_replay.getCurrentState(),\\n i * self.train_steps_per_epoch + j,\\n self.epsilon, avg_score)\\n # Epsilon annealing\\n self.__anneal_epsilon__()\\n # if self.time_step % 1000 == 0:\\n # print \\\"Cost at iteration\\\", self.time_step, \\\" is\\\", cost\\n # print \\\"Value of epsilon is\\\", self.epsilon\\n self.steps += 1\\n if j % self.copy_steps == 0:\\n self.network.copy_weights()\\n total_score, num_games = self.environment.getStatistics()\\n time_taken = (time.time() - time_now)\\n logger.info(\\\"Finished epoch %d: Steps=%d; Time taken=%.2f\\\",\\n i, j, time_taken)\\n logger.info(\\\"\\\\tNumber of games: %d; Average reward: %.2f\\\", num_games, (total_score / num_games))\\n logger.info(\\\"\\\\tFinal epsilon value for epoch: %f\\\", self.epsilon)\\n self.network.create_checkpoint()\",\n \"def trainOneEpisode(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\\n # tqdm.write('------Episode {} / {}------'.format(self.episodes_done, num_episodes))\\n self.resetEnv()\\n r_total = 0\\n with trange(1, max_episode_steps+1, leave=False) as t:\\n\\n for step in t:\\n if render:\\n self.env.render()\\n state = self.state\\n action, q = self.selectAction(state, require_q=True)\\n obs_, r, done, info = self.takeAction(action.item())\\n # if print_step:\\n # print 'step {}, action: {}, q: {}, reward: {} done: {}' \\\\\\n # .format(step, action.item(), q, r, done)\\n r_total += r\\n # t.set_postfix(step='{:>5}'.format(step), q='{:>5}'.format(round(q, 4)), total_reward='{:>5}'.format(r_total))\\n t.set_postfix_str('step={:>5}, q={:>5}, total_reward={:>5}'.format(step, round(q, 2), r_total))\\n if done or step == max_episode_steps:\\n next_state = None\\n else:\\n next_state = self.getNextState(obs_)\\n reward = torch.tensor([r], device=self.device, dtype=torch.float)\\n self.memory.push(state, action, next_state, reward)\\n self.optimizeModel()\\n if self.steps_done % self.target_update == 0:\\n self.target_net.load_state_dict(self.policy_net.state_dict())\\n\\n if done or step == max_episode_steps - 1:\\n tqdm.write('------Episode {} ended, total reward: {}, step: {}------' \\\\\\n .format(self.episodes_done, r_total, step))\\n tqdm.write('------Total steps done: {}, current e: {} ------' \\\\\\n .format(self.steps_done, self.exploration.value(self.steps_done)))\\n # print '------Episode {} ended, total reward: {}, step: {}------' \\\\\\n # .format(self.episodes_done, r_total, step)\\n # print '------Total steps done: {}, current e: {} ------' \\\\\\n # .format(self.steps_done, self.exploration.value(self.steps_done))\\n self.episodes_done += 1\\n self.episode_rewards.append(r_total)\\n self.episode_lengths.append(step)\\n if self.episodes_done % save_freq == 0:\\n self.saveCheckpoint()\\n break\\n self.state = next_state\",\n \"async def discover(loop, artwork=False, hosts=None):\\n if hosts:\\n discovered = await pyatv.scan(loop, hosts=hosts, timeout=5)\\n else:\\n discovered = await pyatv.scan(loop, timeout=5)\\n atvs = []\\n\\n for device in discovered:\\n atv = {}\\n atv['playing'] = False\\n\\n atv['name'] = device.name\\n atv['address'] = device.address\\n atv['identifier'] = device.identifier\\n atv['device_type'] = 'apple-tv'\\n\\n for service in device.services:\\n if service.protocol.name == 'MRP':\\n try:\\n connect_device = await pyatv.connect(device, loop)\\n now_playing = await connect_device.metadata.playing()\\n # 'album', 'artist', 'device_state', 'genre', 'hash', 'media_type', 'position', 'repeat', 'shuffle', 'title', 'total_time'\\n if 'idle' not in str(now_playing.device_state).lower():\\n atv['now_playing'] = now_playing.title\\n atv['playing'] = True\\n\\n if 'paused' in str(now_playing.device_state).lower():\\n atv['playing'] = 'Paused'\\n\\n if now_playing.total_time:\\n atv['playing_percent'] = (now_playing.position / now_playing.total_time) * 100\\n\\n atv['current_position'] = now_playing.position\\n atv['time_remaining'] = now_playing.total_time - now_playing.position\\n atv['total_time'] = now_playing.total_time\\n \\n # print('current: ' + str(now_playing.position))\\n # print('total: ' + str(now_playing.total_time))\\n # print(str(atv['playing_percent']))\\n elif now_playing.position and not now_playing.total_time:\\n atv['playing_percent'] = 200\\n\\n ## TO DO Artwork\\n # if artwork:\\n # artwork = await connect_device.metadata.artwork()\\n # print(artwork)\\n\\n finally:\\n await connect_device.close()\\n atvs.append(atv)\\n\\n return atvs\",\n \"def play_episode(env, policy, render_option, min_steps):\\n state = env.reset()\\n done = False\\n episode_reward = 0.0\\n step_cnt = 0\\n while not done or step_cnt < min_steps:\\n if render_option == 'collect':\\n env.render()\\n action = policy(state)\\n next_state, reward, done, _ = env.step(action)\\n episode_reward += reward\\n state = next_state\\n step_cnt += 1\\n print('episode finished with reward {0}'.format(episode_reward))\\n return episode_reward\",\n \"def play(self):\\r\\n self.perform_strategy()\",\n \"def test_songs_played(self):\\n self.assertEqual(self.show.song_booleans, {\\n 'you-enjoy-myself': 1,\\n 'tweezer': 0\\n })\",\n \"def test(config, alg, checkpoint=None, testdelay=0, render=False, envcreator=None, maxepisodelen=10000000):\\n if alg == \\\"random\\\":\\n env = envcreator()\\n else:\\n agent = get_agent_class(alg)(config=config, env=\\\"retro-v0\\\")\\n if checkpoint is None:\\n raise ValueError(f\\\"A previously trained checkpoint must be provided for algorithm {alg}\\\")\\n agent.restore(checkpoint)\\n env = agent.local_evaluator.env\\n\\n while True:\\n state = env.reset()\\n done = False\\n reward_total = 0.0\\n step = 0\\n while not done and step < maxepisodelen:\\n if alg == \\\"random\\\":\\n action = np.random.choice(range(env.action_space.n))\\n else:\\n action = agent.compute_action(state)\\n next_state, reward, done, _ = env.step(action)\\n time.sleep(testdelay)\\n reward_total += reward\\n if render:\\n env.render()\\n state = next_state\\n step = step + 1\\n print(\\\"Episode reward\\\", reward_total)\",\n \"def test_play(self):\\n self.assertTrue(len(self.player.valid_callers)>0)\\n \\\"\\\"\\\"...and should allow round_robin.play to call\\\"\\\"\\\"\\n self.assertTrue(\\\"play\\\" in self.player.valid_callers)\\n self.play()\\n self.play()\",\n \"def play(self, n_episodes=100, max_episode_length=3000, load_path=\\\"last_save.h5\\\"):\\n\\n self.explore = False # Explore if needed\\n\\n self._play_through(n_episodes=n_episodes, max_episode_length=max_episode_length, load_path=load_path,\\n callbacks=self._play_callbacks_factory())\",\n \"def on_episode_start(self, agent, **kwargs):\\n self.episode_start[agent.brain.episode] = timeit.default_timer()\\n self.observations[agent.brain.episode] = []\\n self.rewards[agent.brain.episode] = []\\n self.actions[agent.brain.episode] = []\\n self.metrics[agent.brain.episode] = {}\",\n \"def track_03():\\n sonos.play_uri('http://nrj.de/sachsen', title='Energy Sachsen', force_radio=True)\\n return \\\"Ok\\\"\",\n \"def test_runGame(self):\\n # this is tested by playing the game. No good way to unit test this.\\n pass\",\n \"def run_aqi(self):\\r\\n while True:\\r\\n self.get_aqi()\\r\\n time.sleep(30 - time.time() % 30)\",\n \"def media_episode(self):\\n media_status = self._media_status()[0]\\n return media_status.episode if media_status else None\",\n \"def evaluate(self, env, num_episodes, max_episode_length=None\\n , show_detail = False):\\n episode_counter = 1;\\n average_reward = 0;\\n average_episode_length = 0;\\n time_this, ob_this, is_terminal = env.reset()\\n\\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\\n\\n obs_this_net = self._preprocessor.process_observation_for_network(\\n ob_this, self._min_array, self._max_array)\\n\\n state_this_net = np.append(obs_this_net[0:13], obs_this_net[14:]).reshape(1,16)\\n setpoint_this = ob_this[6:8]\\n \\n this_ep_reward = 0;\\n this_ep_length = 0;\\n while episode_counter <= num_episodes:\\n action_mem = self.select_action(state_this_net, stage = 'testing');\\n # covert command to setpoint action \\n action = self._policy.process_action(setpoint_this, action_mem)\\n\\n time_next, ob_next, is_terminal = env.step(action)\\n \\n ob_next = self._preprocessor.process_observation(time_next, ob_next)\\n\\n setpoint_next = ob_next[6:8]\\n\\n obs_next_net = self._preprocessor.process_observation_for_network(\\n ob_next, self._min_array, self._max_array)\\n \\n state_next_net = np.append(obs_next_net[0:13], obs_next_net[14:]).reshape(1,16)\\n \\n #10:PMV, 11: Occupant number , -2: power\\n reward = self._preprocessor.process_reward(obs_next_net[12:15])\\n \\n this_ep_reward += reward;\\n \\n #Check if exceed the max_episode_length\\n if max_episode_length is not None and \\\\\\n this_ep_length >= max_episode_length:\\n is_terminal = True;\\n #Check whether to start a new episode\\n if is_terminal:\\n time_this, ob_this, is_terminal = env.reset()\\n ob_this = self._preprocessor.process_observation(time_this, ob_this)\\n setpoint_this = ob_this[6:8]\\n obs_this_net = self._preprocessor.process_observation_for_network(\\n ob_this, self._min_array, self._max_array)\\n\\n state_this_net = np.append(obs_this_net[0:13], \\n obs_this_net[14:]).reshape(1,16)\\n\\n average_reward = (average_reward * (episode_counter - 1) \\n + this_ep_reward) / episode_counter;\\n average_episode_length = (average_episode_length \\n * (episode_counter - 1) \\n + this_ep_length) / episode_counter;\\n \\n episode_counter += 1;\\n if show_detail:\\n logging.info ('Episode ends. Cumulative reward is %0.04f '\\n 'episode length is %d, average reward by now is %0.04f,'\\n ' average episode length by now is %d.' %(this_ep_reward,\\n this_ep_length,\\n average_reward,\\n average_episode_length));\\n this_ep_length = 0;\\n this_ep_reward = 0;\\n \\n else:\\n ob_this = ob_next\\n setpoint_this = setpoint_next\\n state_this_net = state_next_net\\n time_this = time_next\\n this_ep_length += 1;\\n return (average_reward, average_episode_length);\",\n \"def executeEpisode(self, mcts, game, args):\\n trainExamples = []\\n board = game.getInitBoard()\\n curPlayer = 1\\n episodeStep = 0\\n state_counter = Counter()\\n\\n moves = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = game.getCanonicalForm(board, curPlayer)\\n temp = int(episodeStep < self.args['tempThreshold'])\\n\\n pi = mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n state_counter.update(game.stringRepresentation(board)) #count the visit to the board\\n\\n board, curPlayer = game.getNextState(board, curPlayer, action)\\n\\n r = game.getGameEnded(board, curPlayer)\\n \\n moves += 1\\n\\n if moves >= self.args['maxMoves']:\\n r = 1e-4\\n\\n if r != 0:\\n return ([(x[0], x[2], r * ((-1) ** (x[1] != curPlayer))) for x in trainExamples], state_counter)\",\n \"def run(self):\\n self.ae.start()\",\n \"def test(net, env, total_episodes, test_seeds=None, cuda=False, log=False, render=False, max_actions=10000):\\n net.eval()\\n total_reward = 0\\n with torch.no_grad():\\n for ep in range(total_episodes):\\n obs = env.reset()\\n done, ep_reward, ep_actions = False, 0, []\\n hx = Variable(net.init_hidden())\\n all_obs = [obs]\\n action_count = 0\\n while not done:\\n if render:\\n env.render()\\n obs = Variable(torch.Tensor(obs)).unsqueeze(0)\\n if cuda:\\n obs, hx = obs.cuda(), hx.cuda()\\n critic, logit, hx = net((obs, hx))\\n prob = F.softmax(logit, dim=1)\\n action = int(prob.max(1)[1].data.cpu().numpy())\\n obs, reward, done, _ = env.step(action)\\n action_count += 1\\n done = done if action_count <= max_actions else True\\n ep_actions.append(action)\\n # A quick hack to prevent the agent from stucking\\n max_same_action = 5000\\n if action_count > max_same_action:\\n actions_to_consider = ep_actions[-max_same_action:]\\n if actions_to_consider.count(actions_to_consider[0]) == max_same_action:\\n done = True\\n ep_reward += reward\\n if not done:\\n all_obs.append(obs)\\n total_reward += ep_reward\\n if log:\\n logger.info('Episode =>{} Score=> {} Actions=> {} ActionCount=> {}'.format(ep, ep_reward, ep_actions,\\n action_count))\\n return total_reward / total_episodes\",\n \"def main():\\n global repeat\\n regime = collect()\\n start = int(raw_input(\\\"Which line of the exercise script would you like to begin with? \\\")) - 1\\n regime = regime[start:]\\n say(\\\"Ready?\\\")\\n time.sleep(1)\\n for exercise in regime:\\n coach(exercise[:-1])\\n while repeat:\\n repeat = False\\n coach(exercise[:-1])\\n say(\\\"Session complete.\\\")\",\n \"def testOneShow(self):\\n\\t\\t# for line in self.file:\\n\\t\\t# \\tprint line\\n\\t\\tline = self.file.readline()\\n\\t\\tinfo = scrapeFilename( line )\\n\\t\\tassert info['show'] == \\\"Chuck\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6574454","0.64675266","0.6428111","0.6335772","0.6264014","0.6199133","0.6197816","0.6196485","0.6193701","0.6170308","0.6169579","0.61569935","0.61476463","0.60803","0.6072124","0.60470563","0.6037859","0.6029739","0.60170627","0.60096955","0.59748065","0.59707355","0.5963511","0.59322083","0.59228396","0.5851858","0.58473396","0.5810563","0.57973063","0.578185","0.57710165","0.57710165","0.5756667","0.5745298","0.5743211","0.57393086","0.5732825","0.5720216","0.5720091","0.5709835","0.5686379","0.5680427","0.56635785","0.5652328","0.5649652","0.5646747","0.5639988","0.5622973","0.56028414","0.56004894","0.55840844","0.55737025","0.55662376","0.5563632","0.55522877","0.5519451","0.5503489","0.5495842","0.54956967","0.549453","0.549453","0.54773414","0.54767877","0.54634607","0.545317","0.5449681","0.54422206","0.5441044","0.54401726","0.5436172","0.5429962","0.54276985","0.54268545","0.5407996","0.53915906","0.5387836","0.5382639","0.5381958","0.5375536","0.53732413","0.53729206","0.5360793","0.53601396","0.5357626","0.5356289","0.534783","0.53447163","0.53445154","0.53328073","0.5324535","0.53142214","0.5312247","0.5303467","0.53029424","0.5299989","0.5298545","0.5298279","0.52856714","0.5283042","0.5282711","0.52821326"],"string":"[\n \"0.6574454\",\n \"0.64675266\",\n \"0.6428111\",\n \"0.6335772\",\n \"0.6264014\",\n \"0.6199133\",\n \"0.6197816\",\n \"0.6196485\",\n \"0.6193701\",\n \"0.6170308\",\n \"0.6169579\",\n \"0.61569935\",\n \"0.61476463\",\n \"0.60803\",\n \"0.6072124\",\n \"0.60470563\",\n \"0.6037859\",\n \"0.6029739\",\n \"0.60170627\",\n \"0.60096955\",\n \"0.59748065\",\n \"0.59707355\",\n \"0.5963511\",\n \"0.59322083\",\n \"0.59228396\",\n \"0.5851858\",\n \"0.58473396\",\n \"0.5810563\",\n \"0.57973063\",\n \"0.578185\",\n \"0.57710165\",\n \"0.57710165\",\n \"0.5756667\",\n \"0.5745298\",\n \"0.5743211\",\n \"0.57393086\",\n \"0.5732825\",\n \"0.5720216\",\n \"0.5720091\",\n \"0.5709835\",\n \"0.5686379\",\n \"0.5680427\",\n \"0.56635785\",\n \"0.5652328\",\n \"0.5649652\",\n \"0.5646747\",\n \"0.5639988\",\n \"0.5622973\",\n \"0.56028414\",\n \"0.56004894\",\n \"0.55840844\",\n \"0.55737025\",\n \"0.55662376\",\n \"0.5563632\",\n \"0.55522877\",\n \"0.5519451\",\n \"0.5503489\",\n \"0.5495842\",\n \"0.54956967\",\n \"0.549453\",\n \"0.549453\",\n \"0.54773414\",\n \"0.54767877\",\n \"0.54634607\",\n \"0.545317\",\n \"0.5449681\",\n \"0.54422206\",\n \"0.5441044\",\n \"0.54401726\",\n \"0.5436172\",\n \"0.5429962\",\n \"0.54276985\",\n \"0.54268545\",\n \"0.5407996\",\n \"0.53915906\",\n \"0.5387836\",\n \"0.5382639\",\n \"0.5381958\",\n \"0.5375536\",\n \"0.53732413\",\n \"0.53729206\",\n \"0.5360793\",\n \"0.53601396\",\n \"0.5357626\",\n \"0.5356289\",\n \"0.534783\",\n \"0.53447163\",\n \"0.53445154\",\n \"0.53328073\",\n \"0.5324535\",\n \"0.53142214\",\n \"0.5312247\",\n \"0.5303467\",\n \"0.53029424\",\n \"0.5299989\",\n \"0.5298545\",\n \"0.5298279\",\n \"0.52856714\",\n \"0.5283042\",\n \"0.5282711\",\n \"0.52821326\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6881,"cells":{"query":{"kind":"string","value":"This function is called to check if a username / password combination is valid."},"document":{"kind":"string","value":"def check_auth(username, password):\n return (username == app.config['USERNAME'] and\n password == app.config['PASSWORD'])"},"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_auth(username, password, expected_user, expected_pw):\n return username == expected_user and password == expected_pw","def validate_authentication(self, username, password):\n return self.user_table[username]['pwd'] == password","def check_auth(username, password):\n return username == USERNAME and password == PASSWORD","def check_valid(self, username, password):\n con = self.connect()\n cursor = con.cursor()\n cursor.execute(\"SELECT username,password \\\n FROM users WHERE username = %s\", (username,))\n credentials = cursor.fetchone()\n cursor.close()\n con.commit()\n con.close()\n if credentials is None:\n return False\n if username != credentials[0]:\n return False\n if sha256_crypt.verify(password, credentials[1]):\n return True\n return False","def check_auth(username, password):\n return username == 'aweber' and password == 'aweber1100'","def check_auth(username, password):\n return username == 'nicholas' and password == ADMIN_PASS","def check_auth(username, password):\n return username == 'admin' and password == 'worcester'","def validate_login(self, username, password):\n user = User(self).get(username)\n return user and user['Password'] == password","def check_auth(username, password):\n return username == 'admin' and password == 'pebble'","def check_auth(username, password):\n return username == 'jeffkoons' and password == 'likesweirdbaloons'","def check_auth(username, password):\n return username == 'admin' and password == 'Passw0rd'","def check_auth(username, password):\n return username == 'asimov' and password == 'tagada72'","def check_auth(username, password):\n return username == 'sammy' and password == 'BasicPassword!'","def is_valid_password(password, username):\n import string\n if len(password) < 4 or ' ' in password:\n return False\n if username:\n if string.lower(username) in string.lower(password):\n return False\n return True","def check_auth_password(self, username, password):\n return AUTH_FAILED","def check_auth(username, password):\n return username == app.config['USERNAME'] and (\n password == app.config['PASSWORD'])","def check_auth(username, password):\n return username == 'admin' and password == 'password'","def _credentials_are_valid(self, username, password):\n LDAP_SERVER = 'ldap://xxx.xxx.xxx' # EDIT THIS\n LDAP_USERNAME = '%s@xxx.com' % username # EDIT THIS\n LDAP_PASSWORD = password\n\n try:\n # build a client\n ldap_client = ldap.initialize(LDAP_SERVER)\n # perform a synchronous bind\n ldap_client.set_option(ldap.OPT_REFERRALS, 0)\n ldap_client.simple_bind_s(LDAP_USERNAME, LDAP_PASSWORD)\n except ldap.INVALID_CREDENTIALS:\n ldap_client.unbind()\n # Wrong username or password\n return False\n except ldap.SERVER_DOWN:\n # AD server not available\n return False\n # all is well\n ldap_client.unbind()\n # Login successful\n return True","def username_is_valid(username):\n\n if len(username) < MINIMUM_PASSWORD_LENGTH:\n return False\n else:\n return True","def check_auth(username, password):\n return username == c.id and password == c.pw","def check_auth(username, password):\n return username == 'admin' and password == 'root'","def check_auth(username, password):\n return username == 'admin' and password == 'secret'","def check_auth(username, password):\n return username == 'admin' and password == 'secret'","def password_validator(username, password):\n digits = re.search(r'\\d+', password)\n capital_letters = re.search(r'[A-Z]+', password)\n lenght = len(password) > PASSWORD_MIN_LENGTH\n special_symbol = re.search(r'[\\-\\/\\@\\?\\!\\,\\.\\#\\&\\*]+', password)\n\n statement = digits and capital_letters and lenght and special_symbol\n\n if statement:\n return True\n return False","def check_auth(username, password):\n return username == 'admin' and password == 'admin'","def check_auth(username, password):\n ADMIN_USER = config.CONFIG_VARS['ADMIN_USER']\n ADMIN_PASS = config.CONFIG_VARS['ADMIN_PASS']\n return username == ADMIN_USER and password == ADMIN_PASS","def check_auth(username, password):\n # return username == app.config['USER'] and password == app.config['PASS']\n\n return username == app.config['USER'] and password == app.config['PASS']","def check_auth(username, password):\r\n return username == current_app.config['ADMIN_USERNAME'] \\\r\n and password == current_app.config['ADMIN_PASSWORD']","def check_credentials(username, password):\n if not validate_username(username) or not validate_password(password):\n return False\n sql = \"SELECT password \" \\\n \"FROM users \" \\\n \"WHERE username=:username AND is_active=TRUE\"\n result = db.session.execute(sql, {\"username\": username})\n user = result.fetchone()\n if user is None:\n return False\n password_hash = user[0]\n if check_password_hash(password_hash, password):\n return True\n return False","def is_logged_in_user_valid(user_name, password):\n if user_name.upper() == \"HELLO\" and password == \"World\":\n return True # User input matches user name and password.\n else:\n return False # User input does not match user name and password.s","def check_auth(username, password):\n\n config = get_app_configurations()\n\n with open(config[\"credentials\"], \"r\") as fh:\n u, p = fh.readline().rstrip().split(\",\")\n\n return username == u and password == p","def verify_pw(username, password):\n credentials = HtpasswdFile(app.config[\"CREDENTIAL_FILE\"])\n if not credentials.check_password(username, password):\n logging.warning(\"%s tried to login with wrong password\", username)\n return False\n return True","def check_auth(username, password):\n return password == os.getenv('PASSWORD')","def validate_user(self, username, password, client, request, *args, **kwargs):\n log.debug('Validating username %r and its password', username)\n if self._usergetter is not None:\n user = self._usergetter(username, password, client, request, *args, **kwargs)\n if user:\n log.debug('Successfully validated username %r', username)\n request.user = user\n return True\n return False\n log.debug('Password credential authorization is disabled.')\n return False","def _validate_password_works_with_username(password, username=None):\n if password == username:\n raise errors.AccountPasswordInvalid(accounts.PASSWORD_CANT_EQUAL_USERNAME_MSG) # lint-amnesty, pylint: disable=no-member","def check_auth(username, password):\n return username == os.environ['USERNAME'] and password == os.environ['PASSWORD']","def is_valid_login(self, username, password):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)","def authenticate(self):\n rv = Form.validate(self)\n if not rv:\n return False\n\n user = self.username.data\n\n cur = get_cursor()\n if email_exists(cur, user):\n user = get_username(cur, user)\n\n if username_exists(cur, user):\n pw_hash = get_pw_hash(cur, user)\n\n if check_password(self.password.data, pw_hash):\n self.username.data = user\n return True\n\n return False","def is_valid_user(self, username, password): # WORKS\n done1 = self.cur.execute(\"SELECT password FROM users WHERE username=\\\"{}\\\"\".format(username))\n done2 = self.cur.execute(\"SELECT username FROM admins WHERE username=\\\"{}\\\"\".format(username))\n if done1 == 0 and done2 == 0: # If both queries are unsuccessful, username doesn't exist in both tables.\n return False\n else:\n if done1 == 1: # If username exists in USERS table.\n self.cur.execute(\"SELECT password FROM users WHERE username=\\\"{}\\\"\".format(username))\n stored_password = self.cur.fetchone()[0]\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\n else: # If username exists in ADMINS table.\n self.cur.execute(\"SELECT password FROM admins WHERE username=\\\"{}\\\"\".format(username))\n stored_password = self.cur.fetchone()[0]\n return check_password_hash(stored_password, password) # Returns True if the hashes match.","def check_user(self,username, password):\n safe_input = (username, password)\n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\",safe_input).fetchone()\n if vals:\n logging.info('%s was authenticated', username)\n return True\n else:\n logging.info('Failed login for %s', username)\n return False","def valid_login(username, password):\n db = get_db()\n db.ping(True)\n cur = db.cursor()\n\n try:\n sql = \"SELECT password FROM users WHERE user_name = '{}';\".format(username)\n cur.execute(sql)\n for i in cur:\n return check_password_hash(i[0], password)\n return False\n except mysql.connector.Error as err:\n flash(err, \"set\")\n return False\n finally:\n cur.close()\n db.close()","def check_credentials(self, username, password):\n user = None\n if username != \"\":\n # Calling DB and fetching userdetails\n user = userdetails_API_query(username)\n print \"id \", user['_id']\n if user != None:\n #u = app.config['BASIC_AUTH_USERNAME'] = user['username']\n #pwd = app.config['BASIC_AUTH_PASSWORD'] = user['pw_hash']\n # print \" u & pwd\",username\n if user['username'] == username and check_password_hash(user['pw_hash'], password):\n g.user = user['_id'], username, user['email']\n return True\n print \"g.user\", g.user\n return False","def test_credentials(self):\r\n data = self._deep_clean('zekebarge@gmail.com')\r\n error = data.get(ERROR_CODE, None)\r\n if error in (1,2):\r\n raise InvalidCredentialsError(\"Credentials are invalid for user '{}'\".format(self._username))\r\n return True","def check_auth(username, password):\n return get_ct_object(username, password) is not None","def check_user(self):\n try:\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\n return True\n else:\n return False\n except:\n return False","def check_auth(username, password):\n return username == 'daniel' and password == config['redis_auth_key']","def validate_authentication(self, username, password, handler):\n hash = md5(password).hexdigest()\n msg = \"Authentication failed.\"\n if not self.has_user(username):\n if username == 'anonymous':\n msg = \"Anonymous access not allowed.\"\n raise AuthenticationFailed(msg)\n if username != 'anonymous':\n if self.user_table[username]['pwd'] != hash:\n raise AuthenticationFailed(msg)","def is_correct_user(self, login, password):\n pass","def check_auth(username, password):\n return username == get_env('UPLOAD_USER') and password == get_env('UPLOAD_PASSWORD')","def verify_password(self, username, password):\n\n try:\n self.c.execute('SELECT password FROM profiles WHERE name=(?)', (username,))\n\n db_pw = self.c.fetchone()[0]\n print(password)\n\n return db_pw == password\n\n except TypeError:\n return False","def check_credentials(username, password):\n\n return db.auth_user(username, password)","def check_auth(_, http_password):\n return (password is not None) and (password == http_password)","def check_user(self, username, password):\n user = [user for user in self.db if user['username'] == username]\n if user:\n if check_password_hash(user[0][\"password\"], password):\n return True\n return False\n return False","def validate(self) -> bool:\n if not super().validate():\n return False\n\n # Does the user exist\n user = User.query.filter_by(username=self.username.data).first()\n if not user:\n self.username.errors.append('Invalid username or password')\n return False\n\n # Does given password match user's password\n if not user.check_password(self.password.data):\n self.username.errors.append('Invalid username or password')\n return False\n\n return True","def check_credentials(username, password):\n\t\n\tconn = sqlite3.connect('db/user_task.db')\n\tcursor = conn.execute(\"SELECT password from user WHERE username == \\'%s\\'\" % (username))\n\tdata = cursor.fetchall()\n\tconn.close()\n\n\tif len(data) == 0:\n\t\treturn u\"Incorrect username\"\n\n\tfor row in data:\n\t\tencoded_password = hashlib.sha1(password.encode('utf-8')).hexdigest()\n\t\tif row[0] == encoded_password:\n\t\t\treturn None\n\n\treturn u\"Incorrect password\"\n\t\n\t# An example implementation which uses an ORM could be:\n\t# u = User.get(username)\n\t# if u is None:\n\t# return u\"Username %s is unknown to me.\" % username\n\t# if u.password != md5.new(password).hexdigest():\n\t# return u\"Incorrect password\"","def check_auth(username, password):\n try:\n locust_username = os.environ['LOCUST_USER_NAME']\n locust_password = os.environ['LOCUST_PASSWORD']\n return username == locust_username and password == locust_password\n except:\n return True","def validate_password(data):\n\n if \"password\" not in data:\n return False\n password = data[\"password\"]\n if len(password) < 4 or len(password) > 16:\n return False\n\n return True","def _check_user_pass(self):\n if not self.username:\n self.username = input(' 请输入手机号：')\n if self.username.isdigit() and '+86' not in self.username:\n self.username = '+86' + self.username\n\n if not self.password:\n self.password = input(' 请输入密码：')","def check_password(self, username, password): # tested\r\n conn = self.get_db()\r\n with conn:\r\n c = conn.cursor()\r\n sql = ('select password from gameuser where username=%s')\r\n c.execute(sql,(username,))\r\n hashedpass = md5.new(password).hexdigest()\r\n u = c.fetchone()\r\n if u == None:\r\n raise NoUserExistsException(username)\r\n # print 'database contains {}, entered password was {}'.format(u[0],hashedpass)\r\n return u[0] == hashedpass","def valid_login_password(username, password, pw_hash):\n salt = pw_hash.split(',')[1]\n return pw_hash == make_pw_hash(username, password, salt)","def check_auth(username, password):\n return username == 'admin' and password in app.config[\"CLAIM_SECRETS\"]","def validate_password(self, field):\n username = self.username.data\n if platform.system().lower() == 'linux':\n g.logger.debug('use pam for authenticate.')\n from pam import authenticate\n if authenticate(username, field.data):\n g.logger.info('session opened for user %s.' % username)\n return username\n else:\n raise ValueError('Authentication failure.')\n return username","def check_credentials_typo(credentials):\n regex_username = r'^[\\w\\.\\-]{2,}$'\n regex_password = r'[^.]{4,10}$'\n\n if not match(regex_username, credentials['username']):\n raise ValueError('invalid username typo')\n\n if not match(regex_password, credentials['password']):\n raise ValueError('invalid password typo')","def username_and_password_check(username: str, password: str) -> bool:\n table = metadata.tables['users']\n s = select(\n [\n func.count(table.c.id)\n ]).where(tuple_(table.c['username'], table.c['password'])\n .in_([(username, password)]))\n result = conn.execute(s).scalar()\n return bool(result)","def check_auth(username, password):\n user = User.query.filter(User.username == username).first()\n\n if user:\n return user.password == password\n else:\n return False","def verify_password(username, password):\n if username in user_auth and check_password_hash(user_auth.get(username), password):\n return username","def authentication_validation(username, password, access_token):\n if bool(username) is not bool(password):\n raise Exception(\"Basic authentication requires a username AND\" \" password.\")\n if (username and access_token) or (password and access_token):\n raise Exception(\n \"Cannot use both Basic Authentication and\"\n \" OAuth2.0. Please use only one authentication\"\n \" method.\"\n )","def invalid_credentials( form , field ): \n\tusername_entered = form.username.data\n\tpassword_entered = field.data \n\tuser_object = User.query.filter_by(username = username_entered).first()\n\tif user_object is None : \n\t\traise ValidationError(\"Username or Password is incorrect !\")\n\telif not pbkdf2_sha256.verify(password_entered , user_object.password) : \n\t\traise ValidationError(\"Username or Password is incorrect !\")","def is_password_valid(password):\n #TODO : This should also be handled by the front_end\n pass","def check_password(username, password, htpasswd_fn):\n entries = parse_htpasswd(htpasswd_fn, username)\n if not entries.has_key(username):\n raise NoSuchUser('No user: %r' % username)\n return check_entry_password(\n username, password, entries[username])","def auth(username, password):\n return username == password","def _check_password(self, password):\n if self.password_regex.search(password) is not None:\n print(\"Correct password\")\n return True\n else:\n print(\"Wrong password\")\n return False","def check_auth(username, password):\n return username == current_app.config['DOC_USERNAME'] and password == current_app.config['DOC_PASSWORD']","def _check_username(self, username):\n if self.username_regex.search(username) is not None:\n print(\"Correct username\")\n return True\n else: \n print(\"Wrong username\")\n return False","def check_auth_password(self, username, password):\n if username == self.username and password == self.password:\n return paramiko.AUTH_SUCCESSFUL\n return paramiko.AUTH_FAILED","def check_credentials(input_password, real_password):\n return pwd_context.verify(input_password, real_password)","def test_valid_username_invalid_password(self):\n response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})\n self.assertEqual(response.status_code, 200)\n self.assertFormError(response, 'form', None, ERROR_MSG)","def authorise_login(self, username, password):\n con = self.connect()\n cursor = con.cursor()\n cursor.execute(\"SELECT username,password \\\n FROM users WHERE password = %s\", (password,))\n credentials = cursor.fetchone()\n cursor.close()\n con.commit()\n con.close()\n if credentials is None:\n return False\n if username != credentials[0]:\n return False\n if password != credentials[1]:\n return False\n return True","def clean(self):\n cleaned_data = super().clean()\n username = cleaned_data['username']\n password = cleaned_data['password']\n\n if authenticate(username=username, password=password) is None:\n raise ValidationError('Your username or password is incorrect.')","def _check_password(self, password):\n rule = re.compile(constant.password_regex)\n if not rule.match(password):\n return False\n # disallow password from azure guide, yes, it's hard code.\n disallowed = constant.password_disallowed\n return password not in disallowed","def validate(username: str, password: str) -> dict:\n validation_check = {}\n \n # Check to see if the username was left blank\n if username.strip() == \"\":\n validation_check[\"success\"] = False\n validation_check[\"username\"] = \"Username cannot be left blank.\"\n\n # Check to see if the username is taken\n elif not sql.is_username_taken(username):\n validation_check[\"success\"] = False\n validation_check[\"username\"] = \"Username is incorrect\"\n\n # Check to see if the password was left blank\n if password.strip() == \"\":\n validation_check[\"success\"] = False\n validation_check[\"password\"] = \"Password cannot be left blank.\"\n\n\n if not validation_check.get(\"success\", True):\n return validation_check\n\n else:\n return sql.verify_credentials(username, password)","def check_friend(self, username):\n if (self.isBlank(username) or self.isValidLen(username)):\n return False\n\n safe_input = (username,)\n \n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=?\" ,safe_input).fetchone()\n if vals:\n return True\n else:\n return False","def test_check_password():\n assert check_password('Longpassword') == False\n assert check_password('123456') == False\n assert check_password('short') == False\n assert check_password('C0rect') == False\n assert check_password('Correct8') == True","def check_password(self, password):\n return self.password == password","def test_validate_credentials(self):\n pass","def check_my_users(user):\n user_data = my_users.get(user['username'])\n if not user_data:\n return False # <--- invalid credentials\n elif user_data.get('password') == user['password']:\n return True # <--- user is logged in!\n\n return False # <--- invalid credentials","def valid_login(username: str, password: str):\n\n try:\n LoginHandler.login(username, password)\n global validLogin\n validLogin = True\n except:\n validLogin = False","def checkLogin(username, password):\n\n # Query database for username\n cur = initialise(2)\n cur.execute(\"SELECT * FROM users WHERE username = ?\", [username])\n users = cur.fetchall()\n\n # Ensure username exists and password is correct\n if len(users) != 1 or not check_password_hash(users[0][\"hash\"], password):\n return False, username\n else:\n return True, users[0][\"id\"]","def validate_login(name,password):\n\t\n\t#Read the attendance excelsheet check if username and password matched\n\tdf_atten=pd.read_csv(\"datasrc/People.csv\")\n\t# 10006 ultbjxu\n\t\n\tif (df_atten.Username.astype(str).str.contains(name).any() and df_atten.Password.astype(str).str.contains(password).any()):\t\t\n\t\treturn True\n\telse: \n\t\treturn False","def isUSER(username, password):\n usr = UserData[\"username\"].to_dict()\n listofUsers = list(UserData[\"username\"])\n if username in listofUsers:\n # print('Is a User')\n getindex = listofUsers.index(username)\n listofPasswords = list(UserData[\"password\"])\n # print(getindex)\n if listofPasswords[getindex] == password:\n # print('Password Correct')\n return True, True\n return True, False\n return False, False","def _input(self):\n\t\tself.username = input(\"Username:\")\n\t\tself.password = input(\"password:\")\n\t\tret = re.match(r\"^\\w{1,20}$\", self.username)\n\t\tprint(\"------>input string\", self.username)\n\t\tprint(\"------>matched string\",ret)\t\n\t\ttime.sleep(1)\n\t\tif ret == None:\n\t\t\treturn True\n\t\telse:\n\t\t\tpass\n\n\t\tsql = f\"\"\"select name, password from users where name='{self.username}';\"\"\"\n\t\tprint(\"----------->\", sql)\n\t\ttime.sleep(1)\n\t\tcount = self.cs.execute(sql)\n\t\tprint(count)\n\t\tif (self.username, self.password) == self.cs.fetchone():\n\t\t\tprint(\"Login Successfully\")\n\t\t\ttime.sleep(1)\n\t\t\treturn False\n\t\telse:\n\t\t\tprint(\"Wrong username or password\")\n\t\t\ttime.sleep(1)\n\t\t\treturn True","def is_valid_login(username, password):\n with open(PASSFILE, \"r\") as passfile:\n for record in passfile:\n try:\n valid_user, valid_password = False, False\n r_username, r_salt_hash = record.split()\n if username == r_username:\n valid_user = True\n if sha256_crypt.verify(password, r_salt_hash):\n valid_password = True\n if valid_user and valid_password:\n return True\n except ValueError:\n pass\n return False","def check_auth(username, password):\n session.pop('username', None)\n session.pop('password', None)\n session['username'] = username\n session['password'] = password\n # Test if we can connect to a region\n connect_to_region()\n return True","def check_credentials_validation(credentials):\n spec = {'_id': credentials['username'], 'password': credentials['password']}\n if not current_app.mongo.observer.users.find_one(spec):\n raise Unauthorized('invalid credentials')","def username_check(username):\n\n try: \n pwd.getpwnam(username)\n print(\"User %s DOES EXIST. Try a different username.\" % (username)) \n return False\n\n except KeyError: \n print(\"User %s DOES NOT exist. Continuing...\" % (username)) \n return True","def test_invalid_username_valid_password(self):\n response = self.client.post(reverse('users:login'), {'username': 'xyzabe', 'password': self.user['password1']})\n self.assertEqual(response.status_code, 200)\n self.assertFormError(response, 'form', None, ERROR_MSG)","def test_valid_password(self):\n pass_field = Field(\"\".join(['x' * (int(self.app.config['MAX_PWD_LEN']))]))\n\n valid_password(None, pass_field)","def authenticate(username, password):\n test = User.load(username)\n test_password = test.password\n input_password = md5.new(\n password + config.get('security', 'salt')).digest()\n if input_password == test_password:\n return True\n else:\n return False","def test_authenticate_invalid_username(self):\r\n print(\"Authenticate user invalid username\")\r\n username = \"test9999user\"\r\n password = \"password\"\r\n\r\n self.assertEqual(self.system.authenticate(username, password), False)","def verify_pw(username, password):\n global password_store\n logger = logging.getLogger('verify_pw')\n if not password_store:\n logger.error(\"No password store specified\")\n return False\n logger.debug(\"Verifying password for %s\" % username)\n return password_store.verify(username, password)"],"string":"[\n \"def check_auth(username, password, expected_user, expected_pw):\\n return username == expected_user and password == expected_pw\",\n \"def validate_authentication(self, username, password):\\n return self.user_table[username]['pwd'] == password\",\n \"def check_auth(username, password):\\n return username == USERNAME and password == PASSWORD\",\n \"def check_valid(self, username, password):\\n con = self.connect()\\n cursor = con.cursor()\\n cursor.execute(\\\"SELECT username,password \\\\\\n FROM users WHERE username = %s\\\", (username,))\\n credentials = cursor.fetchone()\\n cursor.close()\\n con.commit()\\n con.close()\\n if credentials is None:\\n return False\\n if username != credentials[0]:\\n return False\\n if sha256_crypt.verify(password, credentials[1]):\\n return True\\n return False\",\n \"def check_auth(username, password):\\n return username == 'aweber' and password == 'aweber1100'\",\n \"def check_auth(username, password):\\n return username == 'nicholas' and password == ADMIN_PASS\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'worcester'\",\n \"def validate_login(self, username, password):\\n user = User(self).get(username)\\n return user and user['Password'] == password\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'pebble'\",\n \"def check_auth(username, password):\\n return username == 'jeffkoons' and password == 'likesweirdbaloons'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'Passw0rd'\",\n \"def check_auth(username, password):\\n return username == 'asimov' and password == 'tagada72'\",\n \"def check_auth(username, password):\\n return username == 'sammy' and password == 'BasicPassword!'\",\n \"def is_valid_password(password, username):\\n import string\\n if len(password) < 4 or ' ' in password:\\n return False\\n if username:\\n if string.lower(username) in string.lower(password):\\n return False\\n return True\",\n \"def check_auth_password(self, username, password):\\n return AUTH_FAILED\",\n \"def check_auth(username, password):\\n return username == app.config['USERNAME'] and (\\n password == app.config['PASSWORD'])\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'password'\",\n \"def _credentials_are_valid(self, username, password):\\n LDAP_SERVER = 'ldap://xxx.xxx.xxx' # EDIT THIS\\n LDAP_USERNAME = '%s@xxx.com' % username # EDIT THIS\\n LDAP_PASSWORD = password\\n\\n try:\\n # build a client\\n ldap_client = ldap.initialize(LDAP_SERVER)\\n # perform a synchronous bind\\n ldap_client.set_option(ldap.OPT_REFERRALS, 0)\\n ldap_client.simple_bind_s(LDAP_USERNAME, LDAP_PASSWORD)\\n except ldap.INVALID_CREDENTIALS:\\n ldap_client.unbind()\\n # Wrong username or password\\n return False\\n except ldap.SERVER_DOWN:\\n # AD server not available\\n return False\\n # all is well\\n ldap_client.unbind()\\n # Login successful\\n return True\",\n \"def username_is_valid(username):\\n\\n if len(username) < MINIMUM_PASSWORD_LENGTH:\\n return False\\n else:\\n return True\",\n \"def check_auth(username, password):\\n return username == c.id and password == c.pw\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'root'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'secret'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'secret'\",\n \"def password_validator(username, password):\\n digits = re.search(r'\\\\d+', password)\\n capital_letters = re.search(r'[A-Z]+', password)\\n lenght = len(password) > PASSWORD_MIN_LENGTH\\n special_symbol = re.search(r'[\\\\-\\\\/\\\\@\\\\?\\\\!\\\\,\\\\.\\\\#\\\\&\\\\*]+', password)\\n\\n statement = digits and capital_letters and lenght and special_symbol\\n\\n if statement:\\n return True\\n return False\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'admin'\",\n \"def check_auth(username, password):\\n ADMIN_USER = config.CONFIG_VARS['ADMIN_USER']\\n ADMIN_PASS = config.CONFIG_VARS['ADMIN_PASS']\\n return username == ADMIN_USER and password == ADMIN_PASS\",\n \"def check_auth(username, password):\\n # return username == app.config['USER'] and password == app.config['PASS']\\n\\n return username == app.config['USER'] and password == app.config['PASS']\",\n \"def check_auth(username, password):\\r\\n return username == current_app.config['ADMIN_USERNAME'] \\\\\\r\\n and password == current_app.config['ADMIN_PASSWORD']\",\n \"def check_credentials(username, password):\\n if not validate_username(username) or not validate_password(password):\\n return False\\n sql = \\\"SELECT password \\\" \\\\\\n \\\"FROM users \\\" \\\\\\n \\\"WHERE username=:username AND is_active=TRUE\\\"\\n result = db.session.execute(sql, {\\\"username\\\": username})\\n user = result.fetchone()\\n if user is None:\\n return False\\n password_hash = user[0]\\n if check_password_hash(password_hash, password):\\n return True\\n return False\",\n \"def is_logged_in_user_valid(user_name, password):\\n if user_name.upper() == \\\"HELLO\\\" and password == \\\"World\\\":\\n return True # User input matches user name and password.\\n else:\\n return False # User input does not match user name and password.s\",\n \"def check_auth(username, password):\\n\\n config = get_app_configurations()\\n\\n with open(config[\\\"credentials\\\"], \\\"r\\\") as fh:\\n u, p = fh.readline().rstrip().split(\\\",\\\")\\n\\n return username == u and password == p\",\n \"def verify_pw(username, password):\\n credentials = HtpasswdFile(app.config[\\\"CREDENTIAL_FILE\\\"])\\n if not credentials.check_password(username, password):\\n logging.warning(\\\"%s tried to login with wrong password\\\", username)\\n return False\\n return True\",\n \"def check_auth(username, password):\\n return password == os.getenv('PASSWORD')\",\n \"def validate_user(self, username, password, client, request, *args, **kwargs):\\n log.debug('Validating username %r and its password', username)\\n if self._usergetter is not None:\\n user = self._usergetter(username, password, client, request, *args, **kwargs)\\n if user:\\n log.debug('Successfully validated username %r', username)\\n request.user = user\\n return True\\n return False\\n log.debug('Password credential authorization is disabled.')\\n return False\",\n \"def _validate_password_works_with_username(password, username=None):\\n if password == username:\\n raise errors.AccountPasswordInvalid(accounts.PASSWORD_CANT_EQUAL_USERNAME_MSG) # lint-amnesty, pylint: disable=no-member\",\n \"def check_auth(username, password):\\n return username == os.environ['USERNAME'] and password == os.environ['PASSWORD']\",\n \"def is_valid_login(self, username, password):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)\",\n \"def authenticate(self):\\n rv = Form.validate(self)\\n if not rv:\\n return False\\n\\n user = self.username.data\\n\\n cur = get_cursor()\\n if email_exists(cur, user):\\n user = get_username(cur, user)\\n\\n if username_exists(cur, user):\\n pw_hash = get_pw_hash(cur, user)\\n\\n if check_password(self.password.data, pw_hash):\\n self.username.data = user\\n return True\\n\\n return False\",\n \"def is_valid_user(self, username, password): # WORKS\\n done1 = self.cur.execute(\\\"SELECT password FROM users WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n done2 = self.cur.execute(\\\"SELECT username FROM admins WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n if done1 == 0 and done2 == 0: # If both queries are unsuccessful, username doesn't exist in both tables.\\n return False\\n else:\\n if done1 == 1: # If username exists in USERS table.\\n self.cur.execute(\\\"SELECT password FROM users WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n stored_password = self.cur.fetchone()[0]\\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\\n else: # If username exists in ADMINS table.\\n self.cur.execute(\\\"SELECT password FROM admins WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n stored_password = self.cur.fetchone()[0]\\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\",\n \"def check_user(self,username, password):\\n safe_input = (username, password)\\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\\\",safe_input).fetchone()\\n if vals:\\n logging.info('%s was authenticated', username)\\n return True\\n else:\\n logging.info('Failed login for %s', username)\\n return False\",\n \"def valid_login(username, password):\\n db = get_db()\\n db.ping(True)\\n cur = db.cursor()\\n\\n try:\\n sql = \\\"SELECT password FROM users WHERE user_name = '{}';\\\".format(username)\\n cur.execute(sql)\\n for i in cur:\\n return check_password_hash(i[0], password)\\n return False\\n except mysql.connector.Error as err:\\n flash(err, \\\"set\\\")\\n return False\\n finally:\\n cur.close()\\n db.close()\",\n \"def check_credentials(self, username, password):\\n user = None\\n if username != \\\"\\\":\\n # Calling DB and fetching userdetails\\n user = userdetails_API_query(username)\\n print \\\"id \\\", user['_id']\\n if user != None:\\n #u = app.config['BASIC_AUTH_USERNAME'] = user['username']\\n #pwd = app.config['BASIC_AUTH_PASSWORD'] = user['pw_hash']\\n # print \\\" u & pwd\\\",username\\n if user['username'] == username and check_password_hash(user['pw_hash'], password):\\n g.user = user['_id'], username, user['email']\\n return True\\n print \\\"g.user\\\", g.user\\n return False\",\n \"def test_credentials(self):\\r\\n data = self._deep_clean('zekebarge@gmail.com')\\r\\n error = data.get(ERROR_CODE, None)\\r\\n if error in (1,2):\\r\\n raise InvalidCredentialsError(\\\"Credentials are invalid for user '{}'\\\".format(self._username))\\r\\n return True\",\n \"def check_auth(username, password):\\n return get_ct_object(username, password) is not None\",\n \"def check_user(self):\\n try:\\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check_auth(username, password):\\n return username == 'daniel' and password == config['redis_auth_key']\",\n \"def validate_authentication(self, username, password, handler):\\n hash = md5(password).hexdigest()\\n msg = \\\"Authentication failed.\\\"\\n if not self.has_user(username):\\n if username == 'anonymous':\\n msg = \\\"Anonymous access not allowed.\\\"\\n raise AuthenticationFailed(msg)\\n if username != 'anonymous':\\n if self.user_table[username]['pwd'] != hash:\\n raise AuthenticationFailed(msg)\",\n \"def is_correct_user(self, login, password):\\n pass\",\n \"def check_auth(username, password):\\n return username == get_env('UPLOAD_USER') and password == get_env('UPLOAD_PASSWORD')\",\n \"def verify_password(self, username, password):\\n\\n try:\\n self.c.execute('SELECT password FROM profiles WHERE name=(?)', (username,))\\n\\n db_pw = self.c.fetchone()[0]\\n print(password)\\n\\n return db_pw == password\\n\\n except TypeError:\\n return False\",\n \"def check_credentials(username, password):\\n\\n return db.auth_user(username, password)\",\n \"def check_auth(_, http_password):\\n return (password is not None) and (password == http_password)\",\n \"def check_user(self, username, password):\\n user = [user for user in self.db if user['username'] == username]\\n if user:\\n if check_password_hash(user[0][\\\"password\\\"], password):\\n return True\\n return False\\n return False\",\n \"def validate(self) -> bool:\\n if not super().validate():\\n return False\\n\\n # Does the user exist\\n user = User.query.filter_by(username=self.username.data).first()\\n if not user:\\n self.username.errors.append('Invalid username or password')\\n return False\\n\\n # Does given password match user's password\\n if not user.check_password(self.password.data):\\n self.username.errors.append('Invalid username or password')\\n return False\\n\\n return True\",\n \"def check_credentials(username, password):\\n\\t\\n\\tconn = sqlite3.connect('db/user_task.db')\\n\\tcursor = conn.execute(\\\"SELECT password from user WHERE username == \\\\'%s\\\\'\\\" % (username))\\n\\tdata = cursor.fetchall()\\n\\tconn.close()\\n\\n\\tif len(data) == 0:\\n\\t\\treturn u\\\"Incorrect username\\\"\\n\\n\\tfor row in data:\\n\\t\\tencoded_password = hashlib.sha1(password.encode('utf-8')).hexdigest()\\n\\t\\tif row[0] == encoded_password:\\n\\t\\t\\treturn None\\n\\n\\treturn u\\\"Incorrect password\\\"\\n\\t\\n\\t# An example implementation which uses an ORM could be:\\n\\t# u = User.get(username)\\n\\t# if u is None:\\n\\t# return u\\\"Username %s is unknown to me.\\\" % username\\n\\t# if u.password != md5.new(password).hexdigest():\\n\\t# return u\\\"Incorrect password\\\"\",\n \"def check_auth(username, password):\\n try:\\n locust_username = os.environ['LOCUST_USER_NAME']\\n locust_password = os.environ['LOCUST_PASSWORD']\\n return username == locust_username and password == locust_password\\n except:\\n return True\",\n \"def validate_password(data):\\n\\n if \\\"password\\\" not in data:\\n return False\\n password = data[\\\"password\\\"]\\n if len(password) < 4 or len(password) > 16:\\n return False\\n\\n return True\",\n \"def _check_user_pass(self):\\n if not self.username:\\n self.username = input(' 请输入手机号：')\\n if self.username.isdigit() and '+86' not in self.username:\\n self.username = '+86' + self.username\\n\\n if not self.password:\\n self.password = input(' 请输入密码：')\",\n \"def check_password(self, username, password): # tested\\r\\n conn = self.get_db()\\r\\n with conn:\\r\\n c = conn.cursor()\\r\\n sql = ('select password from gameuser where username=%s')\\r\\n c.execute(sql,(username,))\\r\\n hashedpass = md5.new(password).hexdigest()\\r\\n u = c.fetchone()\\r\\n if u == None:\\r\\n raise NoUserExistsException(username)\\r\\n # print 'database contains {}, entered password was {}'.format(u[0],hashedpass)\\r\\n return u[0] == hashedpass\",\n \"def valid_login_password(username, password, pw_hash):\\n salt = pw_hash.split(',')[1]\\n return pw_hash == make_pw_hash(username, password, salt)\",\n \"def check_auth(username, password):\\n return username == 'admin' and password in app.config[\\\"CLAIM_SECRETS\\\"]\",\n \"def validate_password(self, field):\\n username = self.username.data\\n if platform.system().lower() == 'linux':\\n g.logger.debug('use pam for authenticate.')\\n from pam import authenticate\\n if authenticate(username, field.data):\\n g.logger.info('session opened for user %s.' % username)\\n return username\\n else:\\n raise ValueError('Authentication failure.')\\n return username\",\n \"def check_credentials_typo(credentials):\\n regex_username = r'^[\\\\w\\\\.\\\\-]{2,}$'\\n regex_password = r'[^.]{4,10}$'\\n\\n if not match(regex_username, credentials['username']):\\n raise ValueError('invalid username typo')\\n\\n if not match(regex_password, credentials['password']):\\n raise ValueError('invalid password typo')\",\n \"def username_and_password_check(username: str, password: str) -> bool:\\n table = metadata.tables['users']\\n s = select(\\n [\\n func.count(table.c.id)\\n ]).where(tuple_(table.c['username'], table.c['password'])\\n .in_([(username, password)]))\\n result = conn.execute(s).scalar()\\n return bool(result)\",\n \"def check_auth(username, password):\\n user = User.query.filter(User.username == username).first()\\n\\n if user:\\n return user.password == password\\n else:\\n return False\",\n \"def verify_password(username, password):\\n if username in user_auth and check_password_hash(user_auth.get(username), password):\\n return username\",\n \"def authentication_validation(username, password, access_token):\\n if bool(username) is not bool(password):\\n raise Exception(\\\"Basic authentication requires a username AND\\\" \\\" password.\\\")\\n if (username and access_token) or (password and access_token):\\n raise Exception(\\n \\\"Cannot use both Basic Authentication and\\\"\\n \\\" OAuth2.0. Please use only one authentication\\\"\\n \\\" method.\\\"\\n )\",\n \"def invalid_credentials( form , field ): \\n\\tusername_entered = form.username.data\\n\\tpassword_entered = field.data \\n\\tuser_object = User.query.filter_by(username = username_entered).first()\\n\\tif user_object is None : \\n\\t\\traise ValidationError(\\\"Username or Password is incorrect !\\\")\\n\\telif not pbkdf2_sha256.verify(password_entered , user_object.password) : \\n\\t\\traise ValidationError(\\\"Username or Password is incorrect !\\\")\",\n \"def is_password_valid(password):\\n #TODO : This should also be handled by the front_end\\n pass\",\n \"def check_password(username, password, htpasswd_fn):\\n entries = parse_htpasswd(htpasswd_fn, username)\\n if not entries.has_key(username):\\n raise NoSuchUser('No user: %r' % username)\\n return check_entry_password(\\n username, password, entries[username])\",\n \"def auth(username, password):\\n return username == password\",\n \"def _check_password(self, password):\\n if self.password_regex.search(password) is not None:\\n print(\\\"Correct password\\\")\\n return True\\n else:\\n print(\\\"Wrong password\\\")\\n return False\",\n \"def check_auth(username, password):\\n return username == current_app.config['DOC_USERNAME'] and password == current_app.config['DOC_PASSWORD']\",\n \"def _check_username(self, username):\\n if self.username_regex.search(username) is not None:\\n print(\\\"Correct username\\\")\\n return True\\n else: \\n print(\\\"Wrong username\\\")\\n return False\",\n \"def check_auth_password(self, username, password):\\n if username == self.username and password == self.password:\\n return paramiko.AUTH_SUCCESSFUL\\n return paramiko.AUTH_FAILED\",\n \"def check_credentials(input_password, real_password):\\n return pwd_context.verify(input_password, real_password)\",\n \"def test_valid_username_invalid_password(self):\\n response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})\\n self.assertEqual(response.status_code, 200)\\n self.assertFormError(response, 'form', None, ERROR_MSG)\",\n \"def authorise_login(self, username, password):\\n con = self.connect()\\n cursor = con.cursor()\\n cursor.execute(\\\"SELECT username,password \\\\\\n FROM users WHERE password = %s\\\", (password,))\\n credentials = cursor.fetchone()\\n cursor.close()\\n con.commit()\\n con.close()\\n if credentials is None:\\n return False\\n if username != credentials[0]:\\n return False\\n if password != credentials[1]:\\n return False\\n return True\",\n \"def clean(self):\\n cleaned_data = super().clean()\\n username = cleaned_data['username']\\n password = cleaned_data['password']\\n\\n if authenticate(username=username, password=password) is None:\\n raise ValidationError('Your username or password is incorrect.')\",\n \"def _check_password(self, password):\\n rule = re.compile(constant.password_regex)\\n if not rule.match(password):\\n return False\\n # disallow password from azure guide, yes, it's hard code.\\n disallowed = constant.password_disallowed\\n return password not in disallowed\",\n \"def validate(username: str, password: str) -> dict:\\n validation_check = {}\\n \\n # Check to see if the username was left blank\\n if username.strip() == \\\"\\\":\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"username\\\"] = \\\"Username cannot be left blank.\\\"\\n\\n # Check to see if the username is taken\\n elif not sql.is_username_taken(username):\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"username\\\"] = \\\"Username is incorrect\\\"\\n\\n # Check to see if the password was left blank\\n if password.strip() == \\\"\\\":\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"password\\\"] = \\\"Password cannot be left blank.\\\"\\n\\n\\n if not validation_check.get(\\\"success\\\", True):\\n return validation_check\\n\\n else:\\n return sql.verify_credentials(username, password)\",\n \"def check_friend(self, username):\\n if (self.isBlank(username) or self.isValidLen(username)):\\n return False\\n\\n safe_input = (username,)\\n \\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=?\\\" ,safe_input).fetchone()\\n if vals:\\n return True\\n else:\\n return False\",\n \"def test_check_password():\\n assert check_password('Longpassword') == False\\n assert check_password('123456') == False\\n assert check_password('short') == False\\n assert check_password('C0rect') == False\\n assert check_password('Correct8') == True\",\n \"def check_password(self, password):\\n return self.password == password\",\n \"def test_validate_credentials(self):\\n pass\",\n \"def check_my_users(user):\\n user_data = my_users.get(user['username'])\\n if not user_data:\\n return False # <--- invalid credentials\\n elif user_data.get('password') == user['password']:\\n return True # <--- user is logged in!\\n\\n return False # <--- invalid credentials\",\n \"def valid_login(username: str, password: str):\\n\\n try:\\n LoginHandler.login(username, password)\\n global validLogin\\n validLogin = True\\n except:\\n validLogin = False\",\n \"def checkLogin(username, password):\\n\\n # Query database for username\\n cur = initialise(2)\\n cur.execute(\\\"SELECT * FROM users WHERE username = ?\\\", [username])\\n users = cur.fetchall()\\n\\n # Ensure username exists and password is correct\\n if len(users) != 1 or not check_password_hash(users[0][\\\"hash\\\"], password):\\n return False, username\\n else:\\n return True, users[0][\\\"id\\\"]\",\n \"def validate_login(name,password):\\n\\t\\n\\t#Read the attendance excelsheet check if username and password matched\\n\\tdf_atten=pd.read_csv(\\\"datasrc/People.csv\\\")\\n\\t# 10006 ultbjxu\\n\\t\\n\\tif (df_atten.Username.astype(str).str.contains(name).any() and df_atten.Password.astype(str).str.contains(password).any()):\\t\\t\\n\\t\\treturn True\\n\\telse: \\n\\t\\treturn False\",\n \"def isUSER(username, password):\\n usr = UserData[\\\"username\\\"].to_dict()\\n listofUsers = list(UserData[\\\"username\\\"])\\n if username in listofUsers:\\n # print('Is a User')\\n getindex = listofUsers.index(username)\\n listofPasswords = list(UserData[\\\"password\\\"])\\n # print(getindex)\\n if listofPasswords[getindex] == password:\\n # print('Password Correct')\\n return True, True\\n return True, False\\n return False, False\",\n \"def _input(self):\\n\\t\\tself.username = input(\\\"Username:\\\")\\n\\t\\tself.password = input(\\\"password:\\\")\\n\\t\\tret = re.match(r\\\"^\\\\w{1,20}$\\\", self.username)\\n\\t\\tprint(\\\"------>input string\\\", self.username)\\n\\t\\tprint(\\\"------>matched string\\\",ret)\\t\\n\\t\\ttime.sleep(1)\\n\\t\\tif ret == None:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\tpass\\n\\n\\t\\tsql = f\\\"\\\"\\\"select name, password from users where name='{self.username}';\\\"\\\"\\\"\\n\\t\\tprint(\\\"----------->\\\", sql)\\n\\t\\ttime.sleep(1)\\n\\t\\tcount = self.cs.execute(sql)\\n\\t\\tprint(count)\\n\\t\\tif (self.username, self.password) == self.cs.fetchone():\\n\\t\\t\\tprint(\\\"Login Successfully\\\")\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\treturn False\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Wrong username or password\\\")\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\treturn True\",\n \"def is_valid_login(username, password):\\n with open(PASSFILE, \\\"r\\\") as passfile:\\n for record in passfile:\\n try:\\n valid_user, valid_password = False, False\\n r_username, r_salt_hash = record.split()\\n if username == r_username:\\n valid_user = True\\n if sha256_crypt.verify(password, r_salt_hash):\\n valid_password = True\\n if valid_user and valid_password:\\n return True\\n except ValueError:\\n pass\\n return False\",\n \"def check_auth(username, password):\\n session.pop('username', None)\\n session.pop('password', None)\\n session['username'] = username\\n session['password'] = password\\n # Test if we can connect to a region\\n connect_to_region()\\n return True\",\n \"def check_credentials_validation(credentials):\\n spec = {'_id': credentials['username'], 'password': credentials['password']}\\n if not current_app.mongo.observer.users.find_one(spec):\\n raise Unauthorized('invalid credentials')\",\n \"def username_check(username):\\n\\n try: \\n pwd.getpwnam(username)\\n print(\\\"User %s DOES EXIST. Try a different username.\\\" % (username)) \\n return False\\n\\n except KeyError: \\n print(\\\"User %s DOES NOT exist. Continuing...\\\" % (username)) \\n return True\",\n \"def test_invalid_username_valid_password(self):\\n response = self.client.post(reverse('users:login'), {'username': 'xyzabe', 'password': self.user['password1']})\\n self.assertEqual(response.status_code, 200)\\n self.assertFormError(response, 'form', None, ERROR_MSG)\",\n \"def test_valid_password(self):\\n pass_field = Field(\\\"\\\".join(['x' * (int(self.app.config['MAX_PWD_LEN']))]))\\n\\n valid_password(None, pass_field)\",\n \"def authenticate(username, password):\\n test = User.load(username)\\n test_password = test.password\\n input_password = md5.new(\\n password + config.get('security', 'salt')).digest()\\n if input_password == test_password:\\n return True\\n else:\\n return False\",\n \"def test_authenticate_invalid_username(self):\\r\\n print(\\\"Authenticate user invalid username\\\")\\r\\n username = \\\"test9999user\\\"\\r\\n password = \\\"password\\\"\\r\\n\\r\\n self.assertEqual(self.system.authenticate(username, password), False)\",\n \"def verify_pw(username, password):\\n global password_store\\n logger = logging.getLogger('verify_pw')\\n if not password_store:\\n logger.error(\\\"No password store specified\\\")\\n return False\\n logger.debug(\\\"Verifying password for %s\\\" % username)\\n return password_store.verify(username, password)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82211864","0.8146436","0.7975914","0.7962432","0.7885527","0.78588223","0.78382313","0.78288996","0.7815222","0.7798579","0.77856815","0.77700555","0.7760794","0.7754975","0.77548647","0.7750886","0.7749223","0.77322245","0.7715806","0.7685904","0.7673684","0.766307","0.766307","0.76620096","0.76567376","0.7652723","0.765255","0.7611541","0.75952524","0.7564781","0.7557824","0.7547461","0.75408834","0.75314397","0.7506924","0.75042623","0.74691737","0.7442317","0.741009","0.740618","0.73972464","0.7394501","0.7389306","0.73495054","0.7336364","0.7299509","0.7276375","0.7247304","0.7230579","0.7205749","0.7199119","0.71977973","0.7193516","0.71885014","0.71854734","0.71695465","0.7169254","0.7159132","0.7140503","0.7135009","0.71116257","0.7110569","0.7108786","0.709969","0.7093436","0.7031712","0.7030077","0.7026029","0.7025823","0.69905216","0.6989299","0.69882464","0.69840413","0.696945","0.69658744","0.69613117","0.6940676","0.6931497","0.6914118","0.6901826","0.68954366","0.68901163","0.68864787","0.6883074","0.68827283","0.68799317","0.68769723","0.68669415","0.6864661","0.68634623","0.68553925","0.6848534","0.6846545","0.6840525","0.6836461","0.6829205","0.6827091","0.682658","0.68223697","0.6813599"],"string":"[\n \"0.82211864\",\n \"0.8146436\",\n \"0.7975914\",\n \"0.7962432\",\n \"0.7885527\",\n \"0.78588223\",\n \"0.78382313\",\n \"0.78288996\",\n \"0.7815222\",\n \"0.7798579\",\n \"0.77856815\",\n \"0.77700555\",\n \"0.7760794\",\n \"0.7754975\",\n \"0.77548647\",\n \"0.7750886\",\n \"0.7749223\",\n \"0.77322245\",\n \"0.7715806\",\n \"0.7685904\",\n \"0.7673684\",\n \"0.766307\",\n \"0.766307\",\n \"0.76620096\",\n \"0.76567376\",\n \"0.7652723\",\n \"0.765255\",\n \"0.7611541\",\n \"0.75952524\",\n \"0.7564781\",\n \"0.7557824\",\n \"0.7547461\",\n \"0.75408834\",\n \"0.75314397\",\n \"0.7506924\",\n \"0.75042623\",\n \"0.74691737\",\n \"0.7442317\",\n \"0.741009\",\n \"0.740618\",\n \"0.73972464\",\n \"0.7394501\",\n \"0.7389306\",\n \"0.73495054\",\n \"0.7336364\",\n \"0.7299509\",\n \"0.7276375\",\n \"0.7247304\",\n \"0.7230579\",\n \"0.7205749\",\n \"0.7199119\",\n \"0.71977973\",\n \"0.7193516\",\n \"0.71885014\",\n \"0.71854734\",\n \"0.71695465\",\n \"0.7169254\",\n \"0.7159132\",\n \"0.7140503\",\n \"0.7135009\",\n \"0.71116257\",\n \"0.7110569\",\n \"0.7108786\",\n \"0.709969\",\n \"0.7093436\",\n \"0.7031712\",\n \"0.7030077\",\n \"0.7026029\",\n \"0.7025823\",\n \"0.69905216\",\n \"0.6989299\",\n \"0.69882464\",\n \"0.69840413\",\n \"0.696945\",\n \"0.69658744\",\n \"0.69613117\",\n \"0.6940676\",\n \"0.6931497\",\n \"0.6914118\",\n \"0.6901826\",\n \"0.68954366\",\n \"0.68901163\",\n \"0.68864787\",\n \"0.6883074\",\n \"0.68827283\",\n \"0.68799317\",\n \"0.68769723\",\n \"0.68669415\",\n \"0.6864661\",\n \"0.68634623\",\n \"0.68553925\",\n \"0.6848534\",\n \"0.6846545\",\n \"0.6840525\",\n \"0.6836461\",\n \"0.6829205\",\n \"0.6827091\",\n \"0.682658\",\n \"0.68223697\",\n \"0.6813599\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7687129"},"document_rank":{"kind":"string","value":"19"}}},{"rowIdx":6882,"cells":{"query":{"kind":"string","value":"Sends a 401 response that enables basic auth"},"document":{"kind":"string","value":"def authenticate():\n return Response(render_template('index.html', auth=False), 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})"},"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 authenticate():\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\"api\"'})","def authenticate():\n return Response(\n '', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate(self):\n abort(\n 401,\n description=self.exception,\n www_authenticate=(\"WWW-Authenticate\", 'Basic realm=\"%s\"' % __package__),\n )","def authenticate():\n return Response(\n 'Could not verify your credentials for that url', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\r\n return Response(\r\n 'Could not verify your access level for that URL.\\n'\r\n 'You have to login with proper credentials', 401,\r\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n\treturn Response(\n\t'Could not verify your access level for that URL.\\n'\n\t'You have to login with proper credentials', 401,\n\t{'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials.', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response('Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials',\n 401,\n {\n 'WWW-Authenticate': 'Basic realm=\"Login Required\"'\n }\n )","def authenticate():\n return send_msg(\n 401,\n 'Must be connected',\n headers={'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return flask.Response('Login required.', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL, need token.\\n', 403,\n {'WWW-Authenticate': 'Basic realm=\"token Required\"'})","def authenticate(self):\n return Response(\n 'Could not verify your access level for that URL.\\nYou have to login with proper credentials',\n 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def user_must_authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with Web Manager credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def unauthorized():\n return HttpError(401)","def basic_auth_error():\n logger.debug(\"Basic authentication failed.\")\n return unauthorized(\"Invalid credentials.\")","def response_unauthorised():\n\n response = {\n 'status': 'failed',\n 'error': 'Not Authorised'\n }\n\n return response_json(response, status=401)","def challenge(self, environ, status, app_headers=(), forget_headers=()):\n resp = Response()\n resp.status = 401\n resp.headers = self.forget(environ, {})\n for headers in (app_headers, forget_headers):\n for name, value in headers:\n resp.headers[name] = value\n resp.content_type = \"text/plain\"\n resp.body = \"Unauthorized\"\n return resp","def authenticate(self):\n resp = Response(None, 401)\n abort(401, description='Please provide proper credentials', response=resp)","def _login(self, environ, start_response):\n response = HTTPUnauthorized()\n response.www_authenticate = ('Basic', {'realm': self._realm})\n return response(environ, start_response)","def add_basic_auth(blueprint: Blueprint, username, password, realm='api'):\n\n @blueprint.before_request\n def basic_http_auth(*args, **kwargs):\n auth = request.authorization\n if auth is None or auth.password != password or auth.username != username:\n return Response('Please login', 401, {'WWW-Authenticate': f'Basic realm=\"{realm}\"'})","def authenticate():\n return abort(401)","def unauthorized():\n return {'errors': ['Unauthorized']}, 401","def forget(self, request):\n return [('WWW-Authenticate', 'Basic realm=\"%s\"' % self.realm)]","def _respond_unauthorized(self, request, message=\"Unauthorized\"):\n resp = Response()\n resp.status = 401\n resp.headers = self.forget(request.environ, {})\n resp.content_type = \"text/plain\"\n resp.body = message\n request.environ[\"repoze.who.application\"] = resp\n return None","def authenticate():\n resp = {\"status\": 401, \"message\": \"Could not verify your access level for that URL\"}\n return Response(dumps(resp), status=404, mimetype='application/json')","def hidden_basic_auth(user=\"user\", passwd=\"passwd\"):\n\n if not check_basic_auth(user, passwd):\n return status_code(404)\n return jsonify(authenticated=True, user=user)","def CR_authentication():\n \n # create a random 10 character string\n choices = string.letters + string.digits + string.punctuation;\n randomString = ''.join(random.choice(choices) for i in range(10))\n session['challenge'] = randomString\n \n return Response('Access failed.', 401, {'WWW-Authenticate': str.format('Basic realm=\\\"Protected iStreet event data; Challenge: {0}\\\"', randomString)})","def authenticate():\n return Response(\n '''Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or\n with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide\n a linkedin or twitter account showing as much)\n You have to login with proper credentials''', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide a linkedin or twitter account showing as much)\"'})","def auth_failure():\n return \"Request denied due to failed authorization\", 201, {'Content-Type': 'text/html'}","def unauthorized(self, error):\n return jsonify({'error': \"NOT AUTHORIZED\"}), 401","def _handle_authentication_error(self):\n response = make_response('Access Denied')\n response.headers['WWW-Authenticate'] = self.auth.get_authenticate_header()\n response.status_code = 401\n return response","def authenticate():\n\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n get_auth_headers())","def test_unauthorized_exception(exception_app):\n request, response = exception_app.test_client.get('/401')\n assert response.status == 401\n\n request, response = exception_app.test_client.get('/401/basic')\n assert response.status == 401\n assert response.headers.get('WWW-Authenticate') is not None\n assert response.headers.get('WWW-Authenticate') == \"Basic realm='Sanic'\"\n\n request, response = exception_app.test_client.get('/401/digest')\n assert response.status == 401\n\n auth_header = response.headers.get('WWW-Authenticate')\n assert auth_header is not None\n assert auth_header.startswith('Digest')\n assert \"qop='auth, auth-int'\" in auth_header\n assert \"algorithm='MD5'\" in auth_header\n assert \"nonce='abcdef'\" in auth_header\n assert \"opaque='zyxwvu'\" in auth_header\n\n request, response = exception_app.test_client.get('/401/bearer')\n assert response.status == 401\n assert response.headers.get('WWW-Authenticate') == \"Bearer\"","def display_401(error):\n return render_template('/error401.html'), 401","def test_unauthorized(self):\n self._error_test(fitbit_exceptions.HTTPUnauthorized)","def basic_auth(user=\"user\", passwd=\"passwd\"):\n\n if not check_basic_auth(user, passwd):\n return status_code(401)\n\n return jsonify(authenticated=True, user=user)","def test_unauthenticated_request(self):\n url = self.get_url(self.active_user.id)\n response = self.client.get(url)\n\n expected_status_code = 401\n self.assertEqual(response.status_code, expected_status_code)","def basic_http_auth(f):\n def wrap(request, *args, **kwargs):\n if request.META.get('HTTP_AUTHORIZATION', False):\n authtype, auth = request.META['HTTP_AUTHORIZATION'].split(' ')\n auth = base64.b64decode(auth)\n username, password = auth.split(':')\n user = authenticate(username=username, password=password)\n if user is not None:\n if user.is_active:\n login(request, user)\n return f(request, *args, **kwargs)\n else:\n r = HttpResponse(\"Auth Required\", status = 401)\n r['WWW-Authenticate'] = 'Basic realm=\"ThatPanda DDNS\"'\n return r\n r = HttpResponse(\"Auth Required\", status = 401)\n r['WWW-Authenticate'] = 'Basic realm=\"ThatPanda DDNS\"'\n return r\n \n return wrap","def auth_error():\n return unauthorized('Invalid credentials')","def require_http_auth(request):\n\n if http_auth_allowed(request) and not request.user.is_authenticated:\n site = get_current_site(request)\n response = HttpResponse(status=401)\n response['WWW-Authenticate'] = (\n 'Basic realm=\"{}\", charset=\"UTF-8\"'.format(site.name)\n )\n # Check whether the client supports cookies.\n response.set_cookie('testcookie', '1', secure=(not settings.DEBUG),\n httponly=True, samesite='Lax')\n return response\n else:\n raise PermissionDenied()","def response_401(description=None):\n resp_def = dict(util.RESPONSE_404)\n if description is not None:\n resp_def['description'] = description\n\n return response(401, resp_def)","def http_basic_auth():\n users = ['administrator', 'admin']\n passwords = ['administrator', 'admin']\n protectedResource = 'http://localhost/secured_path'\n foundPass = False\n for user in users:\n if foundPass:\n break\n for passwd in passwords:\n encoded = base64.encodestring(user + ':' + passwd)\n response = requests.get(protectedResource, auth=(user, passwd))\n if response.status_code != 401:\n print('User Found!')\n print('User: %s, Pass: %s' % (user, passwd))\n foundPass = True\n break","def assertHttpUnauthorized(self, resp):\r\n return self.assertEqual(resp.status_code, 401)","def basic_auth_required(view_func):\n # http://djangosnippets.org/snippets/448/\n def _auth(request, *args, **kwargs):\n if 'HTTP_AUTHORIZATION' in request.META:\n auth = request.META['HTTP_AUTHORIZATION'].split()\n if len(auth) == 2:\n if auth[0].lower() == \"basic\":\n uname, passwd = base64.b64decode(auth[1]).split(':')\n user = authenticate(username=uname, password=passwd)\n if user is not None:\n if user.is_active:\n return view_func(request, *args, **kwargs)\n response = HttpResponse(\"Authorization Required\", status=401)\n response['WWW-Authenticate'] = 'Basic realm=\"Secure Area\"'\n return response\n return _auth","def http_basic_auth(func):\r\n\t@wraps(func)\r\n\tdef _decorator(request, *args, **kwargs):\r\n\r\n\t\tif request.META.has_key('HTTP_AUTHORIZATION'):\r\n\t\t\ttry:\r\n\t\t\t\tauthmeth, auth = request.META['HTTP_AUTHORIZATION'].split(' ', 1)\r\n\t\t\t\tif authmeth.lower() == 'basic':\r\n\t\t\t\t\tauth = auth.strip().decode('base64')\r\n\t\t\t\t\tusername, password = auth.split(':', 1)\r\n\t\t\t\t\tuser = authenticate(username=username, password=password)\r\n\r\n\t\t\t\t\tif user:\r\n\r\n\t\t\t\t\t\tlogin(request, user)\r\n\t\t\t\t\t\r\n\t\t\t\t\telse:\r\n\r\n\t\t\t\t\t\treturn HttpResponseForbidden()\r\n\r\n\t\t\texcept ValueError:\r\n\t\t\t\t# Bad HTTP_AUTHORIZATION header\r\n\t\t\t\treturn HttpResponseForbidden()\r\n\t\t\t\t\r\n\t\treturn func(request, *args, **kwargs)\r\n\treturn _decorator","def unauthorized(self, message=None):\n return self.send_message(message, status=401)","def basic_auth_required(fn):\n @wraps(fn)\n def _wrapper(request, *args, **kwargs):\n authentication = request.headers.get('Authentication', None)\n\n if authentication:\n if not authentication.startswith(\"Basic \"):\n request.response.status = 401\n\n return {\n 'error': \"Authentication failed!\"\n }\n\n auth_data = authentication[6:]\n\n try:\n username, password = base64.urlsafe_b64decode(auth_data).decode(\"UTF8\").split(\":\")\n\n user = request.dbsession.query(User).filter(\n User.email == username\n ).one()\n\n if user.is_password(password.encode(\"UTF8\")):\n return fn(request, *args, **kwargs)\n except (ValueError, NoResultFound):\n pass\n\n request.response.status = 401\n\n return {\n 'error': 'Authentication failed!'\n }\n\n return _wrapper","def test_user_get_failure_using_basic_auth(self):\n # setup\n user = self.generate_username_password()\n resp = self.create_user(user)\n resp_body = resp.json()\n try:\n assert resp.status_code == 201\n assert resp.headers[\"Content-Type\"] == \"application/json; charset=utf-8\"\n assert resp_body[\"username\"] == user[\"userName\"]\n assert resp_body[\"userID\"] != \"\"\n except AssertionError:\n raise\n finally:\n self.pprint_request(resp.request)\n self.pprint_response(resp)\n uuid_ = str(uuid.uuid4())\n\n # test\n resp2 = self.get_user_basic_auth(uuid_, user)\n resp_body2 = resp2.json()\n assert resp2.status_code == 401\n assert resp2.headers[\"Content-Type\"] == \"application/json; charset=utf-8\"\n assert resp_body2[\"code\"] == \"1207\"\n assert resp_body2[\"message\"] == \"User not found!\"\n\n # teardown:\n resp3 = self.delete_user_basic_auth(resp_body[\"userID\"], user)\n try:\n assert resp3.status_code == 204\n except AssertionError:\n raise\n finally:\n self.pprint_request(resp3.request)\n self.pprint_response(resp3)","def test_unhappy_path_unauthorized(self):\n\n response = self.client.get(self.url)\n expected_data = {\"detail\": \"Authentication credentials were not provided.\"}\n\n self.assertDictEqual(response.data, expected_data)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_no_auth(self):\n url = 'https://domain.com/project/objects.inv'\n expected = 'https://domain.com/project/objects.inv'\n actual = _strip_basic_auth(url)\n assert expected == actual","def test_unauthorized_access(flask_test_client, http_method, endpoint):\n response = flask_test_client.open(\n method=http_method, path=endpoint, headers=get_headers()\n )\n assert response.status == \"401 UNAUTHORIZED\"\n assert response.content_type == \"application/json\"\n assert response.json[\"message\"] == \"Access token is invalid or expired.\"","def test_get_unauthenticated(self):\n del self.client.request_kwargs['auth']\n self.verify_get_response(self.client.get(STATUS_PATH))","def get_authenticate_header(self):\n return f'Basic realm=\"{self.www_authenticate_realm}\"'","def test_retrieve_user_unauthorized(self):\r\n res = self.client.get(ME_URL)\r\n\r\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def basic_header(self):\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\n', '')\n return { \n #\"Authorization\" : \"Basic %s\" % self.auth, \n \"Content-type\": \"text/plain\" }","def test_retrieve_unauthorized_user(self):\n\n response = self.client.get(URL_ME)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_user_unauthorized(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_user_unauthorized(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def challenge_view(self, request):\n headerlist = [(\"Content-Type\", \"text/plain\")]\n headerlist.extend(self._get_challenge_headers(request))\n return Response(\"Unauthorized\", status=\"401 Unauthorized\",\n headerlist=headerlist)","def denied_response(self, req):\n if req.remote_user:\n return HTTPForbidden(request=req)\n else:\n return HTTPUnauthorized(request=req)","def test_401_unauthorized(app, client):\n\n @app.route(\"/401\")\n def unauthorized():\n abort(401)\n\n response = client.get(\"/401\")\n assert response.status_code == 401\n assert \"401 Unauthorized\" in str(response.data)","def test_status_unauthenticated(self):\n rv = self.client.post('/statusize/', data={'message': 'foo'},\n follow_redirects=True)\n eq_(rv.status_code, 403)","def test_call_unauthenticated(self):\n\n with Client('username', 'password') as client:\n self.setSessionResponse(401)\n with self.assertRaises(APIError):\n data = client.call(**self.build_parameters)","def test_unhappy_path_unauthorized(self):\n\n response = self.client.post(self.url)\n expected_data = {\"detail\": \"Authentication credentials were not provided.\"}\n\n self.assertDictEqual(response.data, expected_data)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_users_unauthorized(setup_client):\n client = setup_client\n res = client.get(ME_URL)\n assert res.status_code == status.HTTP_401_UNAUTHORIZED","def __call__(self, resp):\r\n if not self.auth_token:\r\n self.auth()\r\n resp.register_hook('response', self.handle_error)\r\n resp.headers['X-Auth-Token'] = self.auth_token\r\n return resp","def _handle_401(self, response, **kwargs):\n if not response.status_code == 401 and not response.status_code == 403:\n return response\n\n # Free the original connection\n response.content\n response.close()\n\n # copy the request to resend\n newreq = response.request.copy()\n\n self._access_token = None\n self._logger.debug(\"_handle_401, cleared _access_token, retrying with new token\")\n\n newreq.headers[\"Authorization\"] = self._get_auth_value()\n\n _response = response.connection.send(newreq, **kwargs)\n _response.history.append(response)\n _response.request = newreq\n\n return _response"],"string":"[\n \"def authenticate():\\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\\\"api\\\"'})\",\n \"def authenticate():\\n return Response(\\n '', 401, {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate(self):\\n abort(\\n 401,\\n description=self.exception,\\n www_authenticate=(\\\"WWW-Authenticate\\\", 'Basic realm=\\\"%s\\\"' % __package__),\\n )\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your credentials for that url', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\r\\n return Response(\\r\\n 'Could not verify your access level for that URL.\\\\n'\\r\\n 'You have to login with proper credentials', 401,\\r\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n\\treturn Response(\\n\\t'Could not verify your access level for that URL.\\\\n'\\n\\t'You have to login with proper credentials', 401,\\n\\t{'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials.', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response('Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials',\\n 401,\\n {\\n 'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'\\n }\\n )\",\n \"def authenticate():\\n return send_msg(\\n 401,\\n 'Must be connected',\\n headers={'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return flask.Response('Login required.', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL, need token.\\\\n', 403,\\n {'WWW-Authenticate': 'Basic realm=\\\"token Required\\\"'})\",\n \"def authenticate(self):\\n return Response(\\n 'Could not verify your access level for that URL.\\\\nYou have to login with proper credentials',\\n 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def user_must_authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with Web Manager credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def unauthorized():\\n return HttpError(401)\",\n \"def basic_auth_error():\\n logger.debug(\\\"Basic authentication failed.\\\")\\n return unauthorized(\\\"Invalid credentials.\\\")\",\n \"def response_unauthorised():\\n\\n response = {\\n 'status': 'failed',\\n 'error': 'Not Authorised'\\n }\\n\\n return response_json(response, status=401)\",\n \"def challenge(self, environ, status, app_headers=(), forget_headers=()):\\n resp = Response()\\n resp.status = 401\\n resp.headers = self.forget(environ, {})\\n for headers in (app_headers, forget_headers):\\n for name, value in headers:\\n resp.headers[name] = value\\n resp.content_type = \\\"text/plain\\\"\\n resp.body = \\\"Unauthorized\\\"\\n return resp\",\n \"def authenticate(self):\\n resp = Response(None, 401)\\n abort(401, description='Please provide proper credentials', response=resp)\",\n \"def _login(self, environ, start_response):\\n response = HTTPUnauthorized()\\n response.www_authenticate = ('Basic', {'realm': self._realm})\\n return response(environ, start_response)\",\n \"def add_basic_auth(blueprint: Blueprint, username, password, realm='api'):\\n\\n @blueprint.before_request\\n def basic_http_auth(*args, **kwargs):\\n auth = request.authorization\\n if auth is None or auth.password != password or auth.username != username:\\n return Response('Please login', 401, {'WWW-Authenticate': f'Basic realm=\\\"{realm}\\\"'})\",\n \"def authenticate():\\n return abort(401)\",\n \"def unauthorized():\\n return {'errors': ['Unauthorized']}, 401\",\n \"def forget(self, request):\\n return [('WWW-Authenticate', 'Basic realm=\\\"%s\\\"' % self.realm)]\",\n \"def _respond_unauthorized(self, request, message=\\\"Unauthorized\\\"):\\n resp = Response()\\n resp.status = 401\\n resp.headers = self.forget(request.environ, {})\\n resp.content_type = \\\"text/plain\\\"\\n resp.body = message\\n request.environ[\\\"repoze.who.application\\\"] = resp\\n return None\",\n \"def authenticate():\\n resp = {\\\"status\\\": 401, \\\"message\\\": \\\"Could not verify your access level for that URL\\\"}\\n return Response(dumps(resp), status=404, mimetype='application/json')\",\n \"def hidden_basic_auth(user=\\\"user\\\", passwd=\\\"passwd\\\"):\\n\\n if not check_basic_auth(user, passwd):\\n return status_code(404)\\n return jsonify(authenticated=True, user=user)\",\n \"def CR_authentication():\\n \\n # create a random 10 character string\\n choices = string.letters + string.digits + string.punctuation;\\n randomString = ''.join(random.choice(choices) for i in range(10))\\n session['challenge'] = randomString\\n \\n return Response('Access failed.', 401, {'WWW-Authenticate': str.format('Basic realm=\\\\\\\"Protected iStreet event data; Challenge: {0}\\\\\\\"', randomString)})\",\n \"def authenticate():\\n return Response(\\n '''Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or\\n with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide\\n a linkedin or twitter account showing as much)\\n You have to login with proper credentials''', 401, {'WWW-Authenticate': 'Basic realm=\\\"Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide a linkedin or twitter account showing as much)\\\"'})\",\n \"def auth_failure():\\n return \\\"Request denied due to failed authorization\\\", 201, {'Content-Type': 'text/html'}\",\n \"def unauthorized(self, error):\\n return jsonify({'error': \\\"NOT AUTHORIZED\\\"}), 401\",\n \"def _handle_authentication_error(self):\\n response = make_response('Access Denied')\\n response.headers['WWW-Authenticate'] = self.auth.get_authenticate_header()\\n response.status_code = 401\\n return response\",\n \"def authenticate():\\n\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n get_auth_headers())\",\n \"def test_unauthorized_exception(exception_app):\\n request, response = exception_app.test_client.get('/401')\\n assert response.status == 401\\n\\n request, response = exception_app.test_client.get('/401/basic')\\n assert response.status == 401\\n assert response.headers.get('WWW-Authenticate') is not None\\n assert response.headers.get('WWW-Authenticate') == \\\"Basic realm='Sanic'\\\"\\n\\n request, response = exception_app.test_client.get('/401/digest')\\n assert response.status == 401\\n\\n auth_header = response.headers.get('WWW-Authenticate')\\n assert auth_header is not None\\n assert auth_header.startswith('Digest')\\n assert \\\"qop='auth, auth-int'\\\" in auth_header\\n assert \\\"algorithm='MD5'\\\" in auth_header\\n assert \\\"nonce='abcdef'\\\" in auth_header\\n assert \\\"opaque='zyxwvu'\\\" in auth_header\\n\\n request, response = exception_app.test_client.get('/401/bearer')\\n assert response.status == 401\\n assert response.headers.get('WWW-Authenticate') == \\\"Bearer\\\"\",\n \"def display_401(error):\\n return render_template('/error401.html'), 401\",\n \"def test_unauthorized(self):\\n self._error_test(fitbit_exceptions.HTTPUnauthorized)\",\n \"def basic_auth(user=\\\"user\\\", passwd=\\\"passwd\\\"):\\n\\n if not check_basic_auth(user, passwd):\\n return status_code(401)\\n\\n return jsonify(authenticated=True, user=user)\",\n \"def test_unauthenticated_request(self):\\n url = self.get_url(self.active_user.id)\\n response = self.client.get(url)\\n\\n expected_status_code = 401\\n self.assertEqual(response.status_code, expected_status_code)\",\n \"def basic_http_auth(f):\\n def wrap(request, *args, **kwargs):\\n if request.META.get('HTTP_AUTHORIZATION', False):\\n authtype, auth = request.META['HTTP_AUTHORIZATION'].split(' ')\\n auth = base64.b64decode(auth)\\n username, password = auth.split(':')\\n user = authenticate(username=username, password=password)\\n if user is not None:\\n if user.is_active:\\n login(request, user)\\n return f(request, *args, **kwargs)\\n else:\\n r = HttpResponse(\\\"Auth Required\\\", status = 401)\\n r['WWW-Authenticate'] = 'Basic realm=\\\"ThatPanda DDNS\\\"'\\n return r\\n r = HttpResponse(\\\"Auth Required\\\", status = 401)\\n r['WWW-Authenticate'] = 'Basic realm=\\\"ThatPanda DDNS\\\"'\\n return r\\n \\n return wrap\",\n \"def auth_error():\\n return unauthorized('Invalid credentials')\",\n \"def require_http_auth(request):\\n\\n if http_auth_allowed(request) and not request.user.is_authenticated:\\n site = get_current_site(request)\\n response = HttpResponse(status=401)\\n response['WWW-Authenticate'] = (\\n 'Basic realm=\\\"{}\\\", charset=\\\"UTF-8\\\"'.format(site.name)\\n )\\n # Check whether the client supports cookies.\\n response.set_cookie('testcookie', '1', secure=(not settings.DEBUG),\\n httponly=True, samesite='Lax')\\n return response\\n else:\\n raise PermissionDenied()\",\n \"def response_401(description=None):\\n resp_def = dict(util.RESPONSE_404)\\n if description is not None:\\n resp_def['description'] = description\\n\\n return response(401, resp_def)\",\n \"def http_basic_auth():\\n users = ['administrator', 'admin']\\n passwords = ['administrator', 'admin']\\n protectedResource = 'http://localhost/secured_path'\\n foundPass = False\\n for user in users:\\n if foundPass:\\n break\\n for passwd in passwords:\\n encoded = base64.encodestring(user + ':' + passwd)\\n response = requests.get(protectedResource, auth=(user, passwd))\\n if response.status_code != 401:\\n print('User Found!')\\n print('User: %s, Pass: %s' % (user, passwd))\\n foundPass = True\\n break\",\n \"def assertHttpUnauthorized(self, resp):\\r\\n return self.assertEqual(resp.status_code, 401)\",\n \"def basic_auth_required(view_func):\\n # http://djangosnippets.org/snippets/448/\\n def _auth(request, *args, **kwargs):\\n if 'HTTP_AUTHORIZATION' in request.META:\\n auth = request.META['HTTP_AUTHORIZATION'].split()\\n if len(auth) == 2:\\n if auth[0].lower() == \\\"basic\\\":\\n uname, passwd = base64.b64decode(auth[1]).split(':')\\n user = authenticate(username=uname, password=passwd)\\n if user is not None:\\n if user.is_active:\\n return view_func(request, *args, **kwargs)\\n response = HttpResponse(\\\"Authorization Required\\\", status=401)\\n response['WWW-Authenticate'] = 'Basic realm=\\\"Secure Area\\\"'\\n return response\\n return _auth\",\n \"def http_basic_auth(func):\\r\\n\\t@wraps(func)\\r\\n\\tdef _decorator(request, *args, **kwargs):\\r\\n\\r\\n\\t\\tif request.META.has_key('HTTP_AUTHORIZATION'):\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tauthmeth, auth = request.META['HTTP_AUTHORIZATION'].split(' ', 1)\\r\\n\\t\\t\\t\\tif authmeth.lower() == 'basic':\\r\\n\\t\\t\\t\\t\\tauth = auth.strip().decode('base64')\\r\\n\\t\\t\\t\\t\\tusername, password = auth.split(':', 1)\\r\\n\\t\\t\\t\\t\\tuser = authenticate(username=username, password=password)\\r\\n\\r\\n\\t\\t\\t\\t\\tif user:\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tlogin(request, user)\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\r\\n\\t\\t\\t\\t\\t\\treturn HttpResponseForbidden()\\r\\n\\r\\n\\t\\t\\texcept ValueError:\\r\\n\\t\\t\\t\\t# Bad HTTP_AUTHORIZATION header\\r\\n\\t\\t\\t\\treturn HttpResponseForbidden()\\r\\n\\t\\t\\t\\t\\r\\n\\t\\treturn func(request, *args, **kwargs)\\r\\n\\treturn _decorator\",\n \"def unauthorized(self, message=None):\\n return self.send_message(message, status=401)\",\n \"def basic_auth_required(fn):\\n @wraps(fn)\\n def _wrapper(request, *args, **kwargs):\\n authentication = request.headers.get('Authentication', None)\\n\\n if authentication:\\n if not authentication.startswith(\\\"Basic \\\"):\\n request.response.status = 401\\n\\n return {\\n 'error': \\\"Authentication failed!\\\"\\n }\\n\\n auth_data = authentication[6:]\\n\\n try:\\n username, password = base64.urlsafe_b64decode(auth_data).decode(\\\"UTF8\\\").split(\\\":\\\")\\n\\n user = request.dbsession.query(User).filter(\\n User.email == username\\n ).one()\\n\\n if user.is_password(password.encode(\\\"UTF8\\\")):\\n return fn(request, *args, **kwargs)\\n except (ValueError, NoResultFound):\\n pass\\n\\n request.response.status = 401\\n\\n return {\\n 'error': 'Authentication failed!'\\n }\\n\\n return _wrapper\",\n \"def test_user_get_failure_using_basic_auth(self):\\n # setup\\n user = self.generate_username_password()\\n resp = self.create_user(user)\\n resp_body = resp.json()\\n try:\\n assert resp.status_code == 201\\n assert resp.headers[\\\"Content-Type\\\"] == \\\"application/json; charset=utf-8\\\"\\n assert resp_body[\\\"username\\\"] == user[\\\"userName\\\"]\\n assert resp_body[\\\"userID\\\"] != \\\"\\\"\\n except AssertionError:\\n raise\\n finally:\\n self.pprint_request(resp.request)\\n self.pprint_response(resp)\\n uuid_ = str(uuid.uuid4())\\n\\n # test\\n resp2 = self.get_user_basic_auth(uuid_, user)\\n resp_body2 = resp2.json()\\n assert resp2.status_code == 401\\n assert resp2.headers[\\\"Content-Type\\\"] == \\\"application/json; charset=utf-8\\\"\\n assert resp_body2[\\\"code\\\"] == \\\"1207\\\"\\n assert resp_body2[\\\"message\\\"] == \\\"User not found!\\\"\\n\\n # teardown:\\n resp3 = self.delete_user_basic_auth(resp_body[\\\"userID\\\"], user)\\n try:\\n assert resp3.status_code == 204\\n except AssertionError:\\n raise\\n finally:\\n self.pprint_request(resp3.request)\\n self.pprint_response(resp3)\",\n \"def test_unhappy_path_unauthorized(self):\\n\\n response = self.client.get(self.url)\\n expected_data = {\\\"detail\\\": \\\"Authentication credentials were not provided.\\\"}\\n\\n self.assertDictEqual(response.data, expected_data)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_no_auth(self):\\n url = 'https://domain.com/project/objects.inv'\\n expected = 'https://domain.com/project/objects.inv'\\n actual = _strip_basic_auth(url)\\n assert expected == actual\",\n \"def test_unauthorized_access(flask_test_client, http_method, endpoint):\\n response = flask_test_client.open(\\n method=http_method, path=endpoint, headers=get_headers()\\n )\\n assert response.status == \\\"401 UNAUTHORIZED\\\"\\n assert response.content_type == \\\"application/json\\\"\\n assert response.json[\\\"message\\\"] == \\\"Access token is invalid or expired.\\\"\",\n \"def test_get_unauthenticated(self):\\n del self.client.request_kwargs['auth']\\n self.verify_get_response(self.client.get(STATUS_PATH))\",\n \"def get_authenticate_header(self):\\n return f'Basic realm=\\\"{self.www_authenticate_realm}\\\"'\",\n \"def test_retrieve_user_unauthorized(self):\\r\\n res = self.client.get(ME_URL)\\r\\n\\r\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def basic_header(self):\\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\\\n', '')\\n return { \\n #\\\"Authorization\\\" : \\\"Basic %s\\\" % self.auth, \\n \\\"Content-type\\\": \\\"text/plain\\\" }\",\n \"def test_retrieve_unauthorized_user(self):\\n\\n response = self.client.get(URL_ME)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_user_unauthorized(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_user_unauthorized(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def challenge_view(self, request):\\n headerlist = [(\\\"Content-Type\\\", \\\"text/plain\\\")]\\n headerlist.extend(self._get_challenge_headers(request))\\n return Response(\\\"Unauthorized\\\", status=\\\"401 Unauthorized\\\",\\n headerlist=headerlist)\",\n \"def denied_response(self, req):\\n if req.remote_user:\\n return HTTPForbidden(request=req)\\n else:\\n return HTTPUnauthorized(request=req)\",\n \"def test_401_unauthorized(app, client):\\n\\n @app.route(\\\"/401\\\")\\n def unauthorized():\\n abort(401)\\n\\n response = client.get(\\\"/401\\\")\\n assert response.status_code == 401\\n assert \\\"401 Unauthorized\\\" in str(response.data)\",\n \"def test_status_unauthenticated(self):\\n rv = self.client.post('/statusize/', data={'message': 'foo'},\\n follow_redirects=True)\\n eq_(rv.status_code, 403)\",\n \"def test_call_unauthenticated(self):\\n\\n with Client('username', 'password') as client:\\n self.setSessionResponse(401)\\n with self.assertRaises(APIError):\\n data = client.call(**self.build_parameters)\",\n \"def test_unhappy_path_unauthorized(self):\\n\\n response = self.client.post(self.url)\\n expected_data = {\\\"detail\\\": \\\"Authentication credentials were not provided.\\\"}\\n\\n self.assertDictEqual(response.data, expected_data)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_users_unauthorized(setup_client):\\n client = setup_client\\n res = client.get(ME_URL)\\n assert res.status_code == status.HTTP_401_UNAUTHORIZED\",\n \"def __call__(self, resp):\\r\\n if not self.auth_token:\\r\\n self.auth()\\r\\n resp.register_hook('response', self.handle_error)\\r\\n resp.headers['X-Auth-Token'] = self.auth_token\\r\\n return resp\",\n \"def _handle_401(self, response, **kwargs):\\n if not response.status_code == 401 and not response.status_code == 403:\\n return response\\n\\n # Free the original connection\\n response.content\\n response.close()\\n\\n # copy the request to resend\\n newreq = response.request.copy()\\n\\n self._access_token = None\\n self._logger.debug(\\\"_handle_401, cleared _access_token, retrying with new token\\\")\\n\\n newreq.headers[\\\"Authorization\\\"] = self._get_auth_value()\\n\\n _response = response.connection.send(newreq, **kwargs)\\n _response.history.append(response)\\n _response.request = newreq\\n\\n return _response\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8093736","0.80926424","0.7958403","0.7852648","0.7843114","0.7824419","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.776624","0.7754693","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.771945","0.7667712","0.7664151","0.76493174","0.7613103","0.7591923","0.74499536","0.74152935","0.7389793","0.73102117","0.72994584","0.70069116","0.6989699","0.6985984","0.69489896","0.69403917","0.69043815","0.6843354","0.6842244","0.6816229","0.67638755","0.6701405","0.6700694","0.6666637","0.66607744","0.66428447","0.66164446","0.66088307","0.6551196","0.6548378","0.64217687","0.6410419","0.6393135","0.6381609","0.6327866","0.629943","0.6287014","0.62427884","0.6242011","0.6230159","0.62130815","0.6168915","0.61408406","0.6088527","0.60420007","0.6041198","0.6029272","0.6020013","0.601565","0.5991479","0.59679294","0.5945756","0.59284157","0.59284157","0.5922706","0.59027636","0.58849794","0.58700204","0.58687663","0.5866924","0.58479726","0.58452344","0.5829068"],"string":"[\n \"0.8093736\",\n \"0.80926424\",\n \"0.7958403\",\n \"0.7852648\",\n \"0.7843114\",\n \"0.7824419\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.776624\",\n \"0.7754693\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.771945\",\n \"0.7667712\",\n \"0.7664151\",\n \"0.76493174\",\n \"0.7613103\",\n \"0.7591923\",\n \"0.74499536\",\n \"0.74152935\",\n \"0.7389793\",\n \"0.73102117\",\n \"0.72994584\",\n \"0.70069116\",\n \"0.6989699\",\n \"0.6985984\",\n \"0.69489896\",\n \"0.69403917\",\n \"0.69043815\",\n \"0.6843354\",\n \"0.6842244\",\n \"0.6816229\",\n \"0.67638755\",\n \"0.6701405\",\n \"0.6700694\",\n \"0.6666637\",\n \"0.66607744\",\n \"0.66428447\",\n \"0.66164446\",\n \"0.66088307\",\n \"0.6551196\",\n \"0.6548378\",\n \"0.64217687\",\n \"0.6410419\",\n \"0.6393135\",\n \"0.6381609\",\n \"0.6327866\",\n \"0.629943\",\n \"0.6287014\",\n \"0.62427884\",\n \"0.6242011\",\n \"0.6230159\",\n \"0.62130815\",\n \"0.6168915\",\n \"0.61408406\",\n \"0.6088527\",\n \"0.60420007\",\n \"0.6041198\",\n \"0.6029272\",\n \"0.6020013\",\n \"0.601565\",\n \"0.5991479\",\n \"0.59679294\",\n \"0.5945756\",\n \"0.59284157\",\n \"0.59284157\",\n \"0.5922706\",\n \"0.59027636\",\n \"0.58849794\",\n \"0.58700204\",\n \"0.58687663\",\n \"0.5866924\",\n \"0.58479726\",\n \"0.58452344\",\n \"0.5829068\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76140213"},"document_rank":{"kind":"string","value":"41"}}},{"rowIdx":6883,"cells":{"query":{"kind":"string","value":"Check if no user login"},"document":{"kind":"string","value":"def require_visitor(func):\n\n @wraps(func)\n def decorator(*args, **kwargs):\n if g.user:\n return redirect(url_for('site.home'))\n return func(*args, **kwargs)\n\n return decorator"},"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_user_and_login(self) -> Response:\n pass","def check_auth_none(self, username):\n return AUTH_FAILED","def check_user_logged():\n global user\n if 'user' not in session:\n return False\n else:\n user = session.get('user')\n return user['username'] != ''","def validUser(self):\n if self.state == SessionStates.LOGGED_OUT:\n return False\n\n # if self.user == None:\n # return False\n return True","def test_user_login_attempt_when_user_already_logged_in(self):\n\t\tpass","def test_non_existing_user_login(self):\n user = {\n 'email': 'test@gmail.com',\n 'password': 'password123'}\n res = self.app.post('/login', data=user)\n self.assertEqual(res.status_code, 200)\n self.assertIn(\"You have no account\", str(res.data))","def require_login(self):\n\tif users.get_current_user():\n\t return True\n\telse:\n\t self.redirect(users.create_login_url(self.request.uri))\n\t return False","def check_login(request, username=None):\r\n if request.user is None:\r\n return False\r\n\r\n # if we have a username we're told to check against, make sure the\r\n # username matches\r\n if username is not None and username != request.user.username:\r\n return False\r\n\r\n return True","def logged_in(self):\n return self.auth.get_user_by_session() is not None","def test_username_not_exist(self):\n\n url_extend = 'user_auth/login/'\n # get the first input button under the first form in login page.\n username = 'usersomerandomeuser'\n password = 'user'\n login_button = login(self.browser, self.url + url_extend, username, password)\n try:\n login_button.click()\n except:\n raise Exception(\"Login Error!\")\n\n ## check the current url\n assert self.browser.current_url == self.url + url_extend","def test_not_authenticated(self):\n self.client.logout()\n response = self._get(get_kwargs=self._data())\n self._check_response(response, 101)\n self.assertEqual(UserFitbit.objects.count(), 1)","def __check_user_exist(self):\n\n login_form = self.login_form()\n\n user = User.query.filter_by(username=login_form.username.data).first()\n if user is None or not user.get_password(login_form.password.data):\n flash('Invalid username or password') # TODO: flash in Template hinzufuegen\n return redirect(url_for('login'))\n\n login_user(user, remember=login_form.remember_me.data)\n\n next_page = request.args.get('next')\n\n # if 'next' is found and the host is specified\n # it will redirect\n if not next_page or url_parse(next_page).netloc != '':\n next_page = url_for('index')\n\n return redirect(next_page)","def is_correct_user(self, login, password):\n pass","def check_user(self):\n try:\n if self.get_customer()[0][0] == self.dni:\n return True\n else:\n return False\n except:\n return False","def has_user(self):\n\t\treturn len( self.a_token ) > 0 and len( self.a_secret ) > 0","def check_user(self):\n try:\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\n return True\n else:\n return False\n except:\n return False","def can_log_in_without_cas(self):\n return self.password is not None and self.password != \"\"","def test_non_user_login(self):\n self.user.list_of_accounts = [{'username': 'Parseen',\n 'pwd': 'mypassword',\n 'email': 'david.parseen@yahoo.com'}]\n msg = self.user.login(\"nonuser@yahoo.com\", \"idontevenhaveone\")\n self.assertEqual(msg, \"Account not registered, sign up\")","def test_login_route_no_user(self):\n result = self.client.post(\"/login\",\n data={\"username\":\"test_user2\", \"password\":\"test_pass1\"}, follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"Looks like you have not made an account yet!\", result.data)","def check_if_should_always_be_logged_in(connection,username_log):\r\n with connection:\r\n c = connection.execute(SELECT_USER_BY_LOGIN_PREVILAGES, (username_log,))\r\n return c.fetchone()","def test_nonexistent_user(self):\n self.client.login(username=self.global_staff.username, password=self.password)\n resp = self.client.get(self.get_url('IDoNotExist'))\n assert resp.status_code == status.HTTP_404_NOT_FOUND","def is_logged_in():\n return 'user' in session","def isLoggedIn(self):\n session = self.getSession()\n if session is not None:\n return True\n return False","def test__user_passed_as_none(self):\r\n access.has_access(None, 'staff', 'global', None)","def test_not_logged_user_cannot_access(self):\n\n utils.test_not_logged_cannot_access(self, self.url)","def test_not_logged_user_cannot_access(self):\n\n utils.test_not_logged_cannot_access(self, self.url)","def test_not_logged_user_cannot_access(self):\n\n utils.test_not_logged_cannot_access(self, self.url)","def test_not_logged_user_cannot_access(self):\n\n utils.test_not_logged_cannot_access(self, self.url)","def test_login_no_user(self):\n post_data = client.post(LOGIN_URL, json=self.post_data1)\n self.assertEqual(post_data.status_code, 401)\n self.assertEqual(post_data.get_json()[\"msg\"], \"Incorrect username.\")","def check_auth():","def check_user(user):\n result_user = search_column_with_constraint(choose_database(\"auth\"), \"users\", \"id\", \"id\", user)\n # result_user = search_single_entry(choose_database(\"auth\"), \"users\", \"id\", user)\n\n if len(result_user) == 0:\n return 0\n else:\n return 1","def test_login_for_user_not_registered(self):\n response = self.client.post(LOGIN_URL,\n data=json.dumps(\n {'username': 'otieno', 'password': 'otieno254'}),\n content_type='application/json')\n self.assertEqual(response.status_code, 404)\n result = json.loads(response.data.decode())\n self.assertEqual(result['message'], 'User unavailable')","def test_no_user(self):\n self.request.user = None\n result = user_id_get_view(self.request)['d']\n self.assertEqual(result, error_dict('api_errors', 'not authenticated for this request'))","def is_regular_user(user):\n return user.is_authenticated()","def invalid_user(self, username):\n con = dbcon()\n cur = con.cursor()\n cur.execute(\"SELECT * FROM my_users WHERE username=%(username)s\",\\\n {'username':username})\n rows = cur.rowcount\n if rows > 0:\n return True\n return False","def is_logged_in(self) -> bool:\n return self.id is not None and self.username is not None","def check_user(self, username):\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\n row = self.dbcursor.fetchone()\n if row:\n return True \n return False","def check_user(self, username):\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\n row = self.dbcursor.fetchone()\n if row:\n return True \n return False","def verifyLogin():\n global HUB\n\n loginInfo = FloatingTools.userData()['Login']\n if loginInfo['username'] is None or loginInfo['password'] is None:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False\n try:\n HUB = Github(loginInfo['username'], loginInfo['password'])\n for repo in HUB.get_user().get_repos():\n break\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\n return True\n except BadCredentialsException:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False","def test_func(self):\n if not self.request.user.is_authenticated:\n return False\n if self.request.user.is_staff:\n return True\n return self.get_user() == self.request.user","def logged_in(self):\n return self.user is not None","def logged():\n if session.login==1:\n return True\n else:\n return False","def is_user(self, user='') -> int:\n try:\n if user in self.users:\n return(1)\n else:\n return(0)\n except Exception as error:\n print(f\"Error: self.is_user({user}) -> {error}\")","def test_not_authenticated(self):\n pass # lint-amnesty, pylint: disable=unnecessary-pass","def test_not_authenticated(self):\n pass # lint-amnesty, pylint: disable=unnecessary-pass","def has_user(self, user): # pylint: disable=unused-argument\r\n return False","def user_exists(self, login):\n\t\tif login in self.users_by_name and isinstance(self.users_by_name[login], VDOM_user):\n\t\t\treturn True\n\t\treturn False","def _check_auth(self):\n if self.authToken:\n return True\n else:\n msg = \"you need to login\"\n self.raise_error(msg)","def has_username(self):\n return self.username is not None","def test_returns_none_if_no_user(self):\r\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))","def check_authentication():\r\n\r\n #TODO: Reservation based authentication\r\n try:\r\n authenticated_user()\r\n except Exception as e:\r\n return e\r\n\r\n return True","def user_auth(request):\n if request.user.is_authenticated:\n user = User.objects.get(email=request.user.email)\n if UserInformation.objects.filter(user=user).exists():\n return True\n return False","def user_in_session():\n return 'user_id' in login_session","def check_my_users(user):\n user_data = my_users.get(user['username'])\n if not user_data:\n return False # <--- invalid credentials\n elif user_data.get('password') == user['password']:\n return True # <--- user is logged in!\n\n return False # <--- invalid credentials","def test_unauthenticated(self):\n self.browser.open(\"http://nohost/plone/full_review_list\")\n self.assertTrue(\"Login Name\" in self.browser.contents)","def check_user(self,username, password):\n safe_input = (username, password)\n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\",safe_input).fetchone()\n if vals:\n logging.info('%s was authenticated', username)\n return True\n else:\n logging.info('Failed login for %s', username)\n return False","def validate_login(self, request):\n\n if 'id' not in request.session or 'steam_id' not in request.session:\n raise PermissionDenied('You need to login')\n\n # if self.mode9:\n # if 'team' not in PlayerList[request.session['id']]:\n # raise PermissionDenied('Player is not in a team!')","def login_user():\n pass","def check():\n # Sets variable username to username inputed by user\n username = request.args.get(\"username\")\n # Selects userid from username inputed by user (if there is one)\n userinfo = db.execute(\"SELECT * FROM users WHERE username = :username\", username=username)\n # If there is no info on the username inputed, that means username is not taken, and user can take the username\n if not userinfo:\n # Return true for the username is not taken\n return jsonify(True)\n # Return false if there is info on the username (meaning it was taken)\n return jsonify(False)","def test_login_login_inexisting_user_false(self):\n logins = {\n \"Email\": \"user@example.com\",\n \"Password\": \"pass1234\"\n }\n resp = self.client().post('/api/v1/auth/login', data=logins)\n self.assertEqual(resp.status_code, 400)\n resp = resp.get_json()\n self.assertEqual(resp['error'],\n 'User not found in our database')","def is_logged_in():\n logged_in = \"uid\" in session\n if logged_in:\n user = api.user.get_user(uid=session[\"uid\"])\n if not user or (user.get(\"disabled\", False) is True):\n logout()\n return False\n return logged_in","def is_logged(html):\n soup = BeautifulSoup(html, \"html.parser\")\n\n if soup.find('div', {'id': 'user_information'}) is None:\n return False\n return True","def test_no_user_exists(self):\n actual = get_user_if_exists(None, self.details)\n self.assertDictEqual(actual, {})","def test_non_registered_user_login(self):\n self.request.user.is_active = True\n self.request.user.is_registered = False\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_registered_user_login(self):\n self.request.user.is_active = True\n self.request.user.is_registered = False\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_registered_user_login(self):\n self.request.user.is_active = True\n self.request.user.is_registered = False\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_registered_user_login(self):\n self.request.user.is_active = True\n self.request.user.is_registered = False\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def is_new_user_service(uid):\n user = user_dao.get_user_by_uid_dao(uid)\n return user is None","def logged_in(request):\n return request.current_user is not None","def checkLogin():\n if 'access_token' in login_session:\n return True\n else:\n return False","def is_logged_in(self):\n return self.router.token is not None","def check_user(used_name, used_password):\n user_exists = UserData.user_login(used_name, used_password)\n\n return user_exists","def default_login_works(self):\n return True if self.default_login_auth_header else False","def test_get_user_non_exist_id(self):\n print('(' + self.test_get_user_non_exist_id.__name__+')',\n self.test_get_user_non_exist_id.__doc__)\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))","def test_nonexistent_user_login(self):\n\n fake_user = {\"email\": \"eat@me.com\",\n \"password\": \"lolzIKid\"}\n\n res = self.client.post(\n \"/api/v2/auth/login\", data=json.dumps(fake_user), content_type=\"application/json\")\n result = json.loads(res.data)\n self.assertEqual(result[\"Error\"], \"User does not exist\")\n self.assertEqual(res.status_code, 404)","def _has_data(cls):\n return User.objects.count() > 0","def checkLogin(self):\n if self._thread:\n return False\n\n try:\n return self._checkLogin()\n except Exception:\n self.expired = True\n self.finished = True\n\n return False","def check_login(self, u, p):\r\n\t\tlogger.debug(\"Entering\")\r\n\t\t\r\n\t\ttry:\r\n\t\t\tval = login.validate_user(u, p)\r\n\t\texcept ValueError as e:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, e.message\r\n\t\t\r\n\t\tif val:\r\n\t\t\tlogger.debug(\"Exiting - success\")\r\n\t\t\treturn True, \"Login successful!\"\r\n\t\telse:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, \"Login failed.\"","def is_logged_in():\n _has_cookie = util.web.has_cookie('pass')\n if _has_cookie:\n _is_expired = util.web.is_cookie_expired('pass')\n if _is_expired:\n return False\n return True\n return False","def is_user(username: str) -> bool:\n db = get_db()\n if username is None:\n return False\n return not db.get_user_by_name(username) is None","def test_non_active_user_login(self):\n self.request.user.is_active = False\n self.request.user.is_registered = True\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_active_user_login(self):\n self.request.user.is_active = False\n self.request.user.is_registered = True\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_active_user_login(self):\n self.request.user.is_active = False\n self.request.user.is_registered = True\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def test_non_active_user_login(self):\n self.request.user.is_active = False\n self.request.user.is_registered = True\n self.request.user.is_superuser = True\n self.request.user.is_staff = True\n nt.assert_equal(self.view.test_func(), False)","def is_logged_in(self):\n return self.cookie is not None","def test_login_missing_username(self):\n resp = self.client.post(\n reverse('login'),\n json.dumps({\n \"password\": \"pass\",\n }),\n content_type=\"application/json\"\n )\n assert resp.status_code == 400, resp.content.decode('utf-8')\n assert not self.is_authenticated(self.user)","def is_anonymous():\n return False","def check_for_user_not_in_system(player_name: str) -> bool:\n\n for uid, user in self.connected_users.items():\n if user['authorized'] and user['main']['player_name'] == player_name:\n return False\n return True","def test_non_registered_user_trying_to_login(self): \n # try logging in the user without registering the user \n res = self.client().post(AuthTestCase.login, data=self.user)\n # bad request \n self.assertEqual(res.status_code, 401)","def no_network_access_check(user):\n return not user.has_property(\"network_access\")","def test_returns_401_if_user_not_logged_in(self):\n # Act\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 401)","def test_returns_401_if_user_not_logged_in(self):\n # Act\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 401)","def test_returns_401_if_user_not_logged_in(self):\n # Act\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 401)","def loginState(self, user_data):\n\t\tif self.db.request(\"getOne\", user_data):\n\t\t\treturn True;\n\t\telse:\n\t\t\treturn False;","def _checkUserExists(username,self):\r\n \r\n exists = False\r\n \r\n if _findUser(username) is not None:\r\n exists = True\r\n \r\n return exists","def check(self):\n\n us = ServiceLocator.resolve(ServiceLocator.USERS)\n\n user_session = self.get()\n user = self.get_user()\n\n return user is not None and us.verify_auth_token(user_session.token, config.SESSION_EXPIRES)","def testGetUserWithoutData(self):\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n deferred = self.facade.getUser(session, u'unknown')\n error = yield self.assertFailure(deferred, TNoSuchUser)\n self.assertEqual(u'unknown', error.name)","def is_user_present(self, username): # WORKS\n done = self.cur.execute(\"SELECT username FROM users WHERE username = \\\"{}\\\"\".format(username))\n if done == 1:\n return True\n else:\n return False","def check_auth(username, password):\n return get_ct_object(username, password) is not None","def testNoPermission(self):\n self.login_user(self.user)\n response = self.client.get(self.url, self.args)\n self.assertEqual(response.status_code, 302)","def user_logged_in():\n if not session.get('user_id'):\n return \"nope\", 401\n else:\n return \"yep\", 200"],"string":"[\n \"def check_user_and_login(self) -> Response:\\n pass\",\n \"def check_auth_none(self, username):\\n return AUTH_FAILED\",\n \"def check_user_logged():\\n global user\\n if 'user' not in session:\\n return False\\n else:\\n user = session.get('user')\\n return user['username'] != ''\",\n \"def validUser(self):\\n if self.state == SessionStates.LOGGED_OUT:\\n return False\\n\\n # if self.user == None:\\n # return False\\n return True\",\n \"def test_user_login_attempt_when_user_already_logged_in(self):\\n\\t\\tpass\",\n \"def test_non_existing_user_login(self):\\n user = {\\n 'email': 'test@gmail.com',\\n 'password': 'password123'}\\n res = self.app.post('/login', data=user)\\n self.assertEqual(res.status_code, 200)\\n self.assertIn(\\\"You have no account\\\", str(res.data))\",\n \"def require_login(self):\\n\\tif users.get_current_user():\\n\\t return True\\n\\telse:\\n\\t self.redirect(users.create_login_url(self.request.uri))\\n\\t return False\",\n \"def check_login(request, username=None):\\r\\n if request.user is None:\\r\\n return False\\r\\n\\r\\n # if we have a username we're told to check against, make sure the\\r\\n # username matches\\r\\n if username is not None and username != request.user.username:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def logged_in(self):\\n return self.auth.get_user_by_session() is not None\",\n \"def test_username_not_exist(self):\\n\\n url_extend = 'user_auth/login/'\\n # get the first input button under the first form in login page.\\n username = 'usersomerandomeuser'\\n password = 'user'\\n login_button = login(self.browser, self.url + url_extend, username, password)\\n try:\\n login_button.click()\\n except:\\n raise Exception(\\\"Login Error!\\\")\\n\\n ## check the current url\\n assert self.browser.current_url == self.url + url_extend\",\n \"def test_not_authenticated(self):\\n self.client.logout()\\n response = self._get(get_kwargs=self._data())\\n self._check_response(response, 101)\\n self.assertEqual(UserFitbit.objects.count(), 1)\",\n \"def __check_user_exist(self):\\n\\n login_form = self.login_form()\\n\\n user = User.query.filter_by(username=login_form.username.data).first()\\n if user is None or not user.get_password(login_form.password.data):\\n flash('Invalid username or password') # TODO: flash in Template hinzufuegen\\n return redirect(url_for('login'))\\n\\n login_user(user, remember=login_form.remember_me.data)\\n\\n next_page = request.args.get('next')\\n\\n # if 'next' is found and the host is specified\\n # it will redirect\\n if not next_page or url_parse(next_page).netloc != '':\\n next_page = url_for('index')\\n\\n return redirect(next_page)\",\n \"def is_correct_user(self, login, password):\\n pass\",\n \"def check_user(self):\\n try:\\n if self.get_customer()[0][0] == self.dni:\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def has_user(self):\\n\\t\\treturn len( self.a_token ) > 0 and len( self.a_secret ) > 0\",\n \"def check_user(self):\\n try:\\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def can_log_in_without_cas(self):\\n return self.password is not None and self.password != \\\"\\\"\",\n \"def test_non_user_login(self):\\n self.user.list_of_accounts = [{'username': 'Parseen',\\n 'pwd': 'mypassword',\\n 'email': 'david.parseen@yahoo.com'}]\\n msg = self.user.login(\\\"nonuser@yahoo.com\\\", \\\"idontevenhaveone\\\")\\n self.assertEqual(msg, \\\"Account not registered, sign up\\\")\",\n \"def test_login_route_no_user(self):\\n result = self.client.post(\\\"/login\\\",\\n data={\\\"username\\\":\\\"test_user2\\\", \\\"password\\\":\\\"test_pass1\\\"}, follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"Looks like you have not made an account yet!\\\", result.data)\",\n \"def check_if_should_always_be_logged_in(connection,username_log):\\r\\n with connection:\\r\\n c = connection.execute(SELECT_USER_BY_LOGIN_PREVILAGES, (username_log,))\\r\\n return c.fetchone()\",\n \"def test_nonexistent_user(self):\\n self.client.login(username=self.global_staff.username, password=self.password)\\n resp = self.client.get(self.get_url('IDoNotExist'))\\n assert resp.status_code == status.HTTP_404_NOT_FOUND\",\n \"def is_logged_in():\\n return 'user' in session\",\n \"def isLoggedIn(self):\\n session = self.getSession()\\n if session is not None:\\n return True\\n return False\",\n \"def test__user_passed_as_none(self):\\r\\n access.has_access(None, 'staff', 'global', None)\",\n \"def test_not_logged_user_cannot_access(self):\\n\\n utils.test_not_logged_cannot_access(self, self.url)\",\n \"def test_not_logged_user_cannot_access(self):\\n\\n utils.test_not_logged_cannot_access(self, self.url)\",\n \"def test_not_logged_user_cannot_access(self):\\n\\n utils.test_not_logged_cannot_access(self, self.url)\",\n \"def test_not_logged_user_cannot_access(self):\\n\\n utils.test_not_logged_cannot_access(self, self.url)\",\n \"def test_login_no_user(self):\\n post_data = client.post(LOGIN_URL, json=self.post_data1)\\n self.assertEqual(post_data.status_code, 401)\\n self.assertEqual(post_data.get_json()[\\\"msg\\\"], \\\"Incorrect username.\\\")\",\n \"def check_auth():\",\n \"def check_user(user):\\n result_user = search_column_with_constraint(choose_database(\\\"auth\\\"), \\\"users\\\", \\\"id\\\", \\\"id\\\", user)\\n # result_user = search_single_entry(choose_database(\\\"auth\\\"), \\\"users\\\", \\\"id\\\", user)\\n\\n if len(result_user) == 0:\\n return 0\\n else:\\n return 1\",\n \"def test_login_for_user_not_registered(self):\\n response = self.client.post(LOGIN_URL,\\n data=json.dumps(\\n {'username': 'otieno', 'password': 'otieno254'}),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 404)\\n result = json.loads(response.data.decode())\\n self.assertEqual(result['message'], 'User unavailable')\",\n \"def test_no_user(self):\\n self.request.user = None\\n result = user_id_get_view(self.request)['d']\\n self.assertEqual(result, error_dict('api_errors', 'not authenticated for this request'))\",\n \"def is_regular_user(user):\\n return user.is_authenticated()\",\n \"def invalid_user(self, username):\\n con = dbcon()\\n cur = con.cursor()\\n cur.execute(\\\"SELECT * FROM my_users WHERE username=%(username)s\\\",\\\\\\n {'username':username})\\n rows = cur.rowcount\\n if rows > 0:\\n return True\\n return False\",\n \"def is_logged_in(self) -> bool:\\n return self.id is not None and self.username is not None\",\n \"def check_user(self, username):\\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\\n row = self.dbcursor.fetchone()\\n if row:\\n return True \\n return False\",\n \"def check_user(self, username):\\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\\n row = self.dbcursor.fetchone()\\n if row:\\n return True \\n return False\",\n \"def verifyLogin():\\n global HUB\\n\\n loginInfo = FloatingTools.userData()['Login']\\n if loginInfo['username'] is None or loginInfo['password'] is None:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\\n try:\\n HUB = Github(loginInfo['username'], loginInfo['password'])\\n for repo in HUB.get_user().get_repos():\\n break\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\\n return True\\n except BadCredentialsException:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\",\n \"def test_func(self):\\n if not self.request.user.is_authenticated:\\n return False\\n if self.request.user.is_staff:\\n return True\\n return self.get_user() == self.request.user\",\n \"def logged_in(self):\\n return self.user is not None\",\n \"def logged():\\n if session.login==1:\\n return True\\n else:\\n return False\",\n \"def is_user(self, user='') -> int:\\n try:\\n if user in self.users:\\n return(1)\\n else:\\n return(0)\\n except Exception as error:\\n print(f\\\"Error: self.is_user({user}) -> {error}\\\")\",\n \"def test_not_authenticated(self):\\n pass # lint-amnesty, pylint: disable=unnecessary-pass\",\n \"def test_not_authenticated(self):\\n pass # lint-amnesty, pylint: disable=unnecessary-pass\",\n \"def has_user(self, user): # pylint: disable=unused-argument\\r\\n return False\",\n \"def user_exists(self, login):\\n\\t\\tif login in self.users_by_name and isinstance(self.users_by_name[login], VDOM_user):\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def _check_auth(self):\\n if self.authToken:\\n return True\\n else:\\n msg = \\\"you need to login\\\"\\n self.raise_error(msg)\",\n \"def has_username(self):\\n return self.username is not None\",\n \"def test_returns_none_if_no_user(self):\\r\\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))\",\n \"def check_authentication():\\r\\n\\r\\n #TODO: Reservation based authentication\\r\\n try:\\r\\n authenticated_user()\\r\\n except Exception as e:\\r\\n return e\\r\\n\\r\\n return True\",\n \"def user_auth(request):\\n if request.user.is_authenticated:\\n user = User.objects.get(email=request.user.email)\\n if UserInformation.objects.filter(user=user).exists():\\n return True\\n return False\",\n \"def user_in_session():\\n return 'user_id' in login_session\",\n \"def check_my_users(user):\\n user_data = my_users.get(user['username'])\\n if not user_data:\\n return False # <--- invalid credentials\\n elif user_data.get('password') == user['password']:\\n return True # <--- user is logged in!\\n\\n return False # <--- invalid credentials\",\n \"def test_unauthenticated(self):\\n self.browser.open(\\\"http://nohost/plone/full_review_list\\\")\\n self.assertTrue(\\\"Login Name\\\" in self.browser.contents)\",\n \"def check_user(self,username, password):\\n safe_input = (username, password)\\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\\\",safe_input).fetchone()\\n if vals:\\n logging.info('%s was authenticated', username)\\n return True\\n else:\\n logging.info('Failed login for %s', username)\\n return False\",\n \"def validate_login(self, request):\\n\\n if 'id' not in request.session or 'steam_id' not in request.session:\\n raise PermissionDenied('You need to login')\\n\\n # if self.mode9:\\n # if 'team' not in PlayerList[request.session['id']]:\\n # raise PermissionDenied('Player is not in a team!')\",\n \"def login_user():\\n pass\",\n \"def check():\\n # Sets variable username to username inputed by user\\n username = request.args.get(\\\"username\\\")\\n # Selects userid from username inputed by user (if there is one)\\n userinfo = db.execute(\\\"SELECT * FROM users WHERE username = :username\\\", username=username)\\n # If there is no info on the username inputed, that means username is not taken, and user can take the username\\n if not userinfo:\\n # Return true for the username is not taken\\n return jsonify(True)\\n # Return false if there is info on the username (meaning it was taken)\\n return jsonify(False)\",\n \"def test_login_login_inexisting_user_false(self):\\n logins = {\\n \\\"Email\\\": \\\"user@example.com\\\",\\n \\\"Password\\\": \\\"pass1234\\\"\\n }\\n resp = self.client().post('/api/v1/auth/login', data=logins)\\n self.assertEqual(resp.status_code, 400)\\n resp = resp.get_json()\\n self.assertEqual(resp['error'],\\n 'User not found in our database')\",\n \"def is_logged_in():\\n logged_in = \\\"uid\\\" in session\\n if logged_in:\\n user = api.user.get_user(uid=session[\\\"uid\\\"])\\n if not user or (user.get(\\\"disabled\\\", False) is True):\\n logout()\\n return False\\n return logged_in\",\n \"def is_logged(html):\\n soup = BeautifulSoup(html, \\\"html.parser\\\")\\n\\n if soup.find('div', {'id': 'user_information'}) is None:\\n return False\\n return True\",\n \"def test_no_user_exists(self):\\n actual = get_user_if_exists(None, self.details)\\n self.assertDictEqual(actual, {})\",\n \"def test_non_registered_user_login(self):\\n self.request.user.is_active = True\\n self.request.user.is_registered = False\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_registered_user_login(self):\\n self.request.user.is_active = True\\n self.request.user.is_registered = False\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_registered_user_login(self):\\n self.request.user.is_active = True\\n self.request.user.is_registered = False\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_registered_user_login(self):\\n self.request.user.is_active = True\\n self.request.user.is_registered = False\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def is_new_user_service(uid):\\n user = user_dao.get_user_by_uid_dao(uid)\\n return user is None\",\n \"def logged_in(request):\\n return request.current_user is not None\",\n \"def checkLogin():\\n if 'access_token' in login_session:\\n return True\\n else:\\n return False\",\n \"def is_logged_in(self):\\n return self.router.token is not None\",\n \"def check_user(used_name, used_password):\\n user_exists = UserData.user_login(used_name, used_password)\\n\\n return user_exists\",\n \"def default_login_works(self):\\n return True if self.default_login_auth_header else False\",\n \"def test_get_user_non_exist_id(self):\\n print('(' + self.test_get_user_non_exist_id.__name__+')',\\n self.test_get_user_non_exist_id.__doc__)\\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))\",\n \"def test_nonexistent_user_login(self):\\n\\n fake_user = {\\\"email\\\": \\\"eat@me.com\\\",\\n \\\"password\\\": \\\"lolzIKid\\\"}\\n\\n res = self.client.post(\\n \\\"/api/v2/auth/login\\\", data=json.dumps(fake_user), content_type=\\\"application/json\\\")\\n result = json.loads(res.data)\\n self.assertEqual(result[\\\"Error\\\"], \\\"User does not exist\\\")\\n self.assertEqual(res.status_code, 404)\",\n \"def _has_data(cls):\\n return User.objects.count() > 0\",\n \"def checkLogin(self):\\n if self._thread:\\n return False\\n\\n try:\\n return self._checkLogin()\\n except Exception:\\n self.expired = True\\n self.finished = True\\n\\n return False\",\n \"def check_login(self, u, p):\\r\\n\\t\\tlogger.debug(\\\"Entering\\\")\\r\\n\\t\\t\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tval = login.validate_user(u, p)\\r\\n\\t\\texcept ValueError as e:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, e.message\\r\\n\\t\\t\\r\\n\\t\\tif val:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - success\\\")\\r\\n\\t\\t\\treturn True, \\\"Login successful!\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, \\\"Login failed.\\\"\",\n \"def is_logged_in():\\n _has_cookie = util.web.has_cookie('pass')\\n if _has_cookie:\\n _is_expired = util.web.is_cookie_expired('pass')\\n if _is_expired:\\n return False\\n return True\\n return False\",\n \"def is_user(username: str) -> bool:\\n db = get_db()\\n if username is None:\\n return False\\n return not db.get_user_by_name(username) is None\",\n \"def test_non_active_user_login(self):\\n self.request.user.is_active = False\\n self.request.user.is_registered = True\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_active_user_login(self):\\n self.request.user.is_active = False\\n self.request.user.is_registered = True\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_active_user_login(self):\\n self.request.user.is_active = False\\n self.request.user.is_registered = True\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def test_non_active_user_login(self):\\n self.request.user.is_active = False\\n self.request.user.is_registered = True\\n self.request.user.is_superuser = True\\n self.request.user.is_staff = True\\n nt.assert_equal(self.view.test_func(), False)\",\n \"def is_logged_in(self):\\n return self.cookie is not None\",\n \"def test_login_missing_username(self):\\n resp = self.client.post(\\n reverse('login'),\\n json.dumps({\\n \\\"password\\\": \\\"pass\\\",\\n }),\\n content_type=\\\"application/json\\\"\\n )\\n assert resp.status_code == 400, resp.content.decode('utf-8')\\n assert not self.is_authenticated(self.user)\",\n \"def is_anonymous():\\n return False\",\n \"def check_for_user_not_in_system(player_name: str) -> bool:\\n\\n for uid, user in self.connected_users.items():\\n if user['authorized'] and user['main']['player_name'] == player_name:\\n return False\\n return True\",\n \"def test_non_registered_user_trying_to_login(self): \\n # try logging in the user without registering the user \\n res = self.client().post(AuthTestCase.login, data=self.user)\\n # bad request \\n self.assertEqual(res.status_code, 401)\",\n \"def no_network_access_check(user):\\n return not user.has_property(\\\"network_access\\\")\",\n \"def test_returns_401_if_user_not_logged_in(self):\\n # Act\\n response = self.client.get(self.url)\\n self.assertEqual(response.status_code, 401)\",\n \"def test_returns_401_if_user_not_logged_in(self):\\n # Act\\n response = self.client.get(self.url)\\n self.assertEqual(response.status_code, 401)\",\n \"def test_returns_401_if_user_not_logged_in(self):\\n # Act\\n response = self.client.get(self.url)\\n self.assertEqual(response.status_code, 401)\",\n \"def loginState(self, user_data):\\n\\t\\tif self.db.request(\\\"getOne\\\", user_data):\\n\\t\\t\\treturn True;\\n\\t\\telse:\\n\\t\\t\\treturn False;\",\n \"def _checkUserExists(username,self):\\r\\n \\r\\n exists = False\\r\\n \\r\\n if _findUser(username) is not None:\\r\\n exists = True\\r\\n \\r\\n return exists\",\n \"def check(self):\\n\\n us = ServiceLocator.resolve(ServiceLocator.USERS)\\n\\n user_session = self.get()\\n user = self.get_user()\\n\\n return user is not None and us.verify_auth_token(user_session.token, config.SESSION_EXPIRES)\",\n \"def testGetUserWithoutData(self):\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n deferred = self.facade.getUser(session, u'unknown')\\n error = yield self.assertFailure(deferred, TNoSuchUser)\\n self.assertEqual(u'unknown', error.name)\",\n \"def is_user_present(self, username): # WORKS\\n done = self.cur.execute(\\\"SELECT username FROM users WHERE username = \\\\\\\"{}\\\\\\\"\\\".format(username))\\n if done == 1:\\n return True\\n else:\\n return False\",\n \"def check_auth(username, password):\\n return get_ct_object(username, password) is not None\",\n \"def testNoPermission(self):\\n self.login_user(self.user)\\n response = self.client.get(self.url, self.args)\\n self.assertEqual(response.status_code, 302)\",\n \"def user_logged_in():\\n if not session.get('user_id'):\\n return \\\"nope\\\", 401\\n else:\\n return \\\"yep\\\", 200\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7631167","0.7377581","0.7348826","0.7320364","0.72438157","0.7098895","0.70730084","0.70391387","0.6981259","0.6977111","0.6969315","0.6933913","0.69154346","0.6907214","0.6865833","0.6815512","0.6799823","0.67882526","0.67734057","0.67627156","0.670679","0.66872627","0.6678289","0.6670774","0.66642874","0.66642874","0.66642874","0.66642874","0.6658266","0.6647678","0.66453034","0.6643202","0.6614826","0.66104454","0.6610254","0.6607496","0.6599286","0.6599286","0.6596498","0.65961397","0.65958214","0.6589427","0.6584934","0.65828604","0.65828604","0.6580714","0.6571355","0.6569671","0.6567775","0.65668136","0.6552768","0.6536445","0.65211916","0.6520104","0.6495194","0.64897794","0.6488937","0.6485867","0.64820725","0.6480279","0.64787126","0.64693314","0.64597744","0.64550805","0.64550805","0.64550805","0.64550805","0.6442284","0.64394444","0.643134","0.6420422","0.6419667","0.63987947","0.63966054","0.6391801","0.6389647","0.6385969","0.6379187","0.6373667","0.6351344","0.634396","0.634396","0.634396","0.634396","0.63412654","0.63407344","0.63357306","0.6333855","0.6332498","0.6325428","0.632134","0.632134","0.632134","0.6314297","0.6311178","0.63093805","0.63085514","0.63066286","0.62943804","0.6292416","0.6289367"],"string":"[\n \"0.7631167\",\n \"0.7377581\",\n \"0.7348826\",\n \"0.7320364\",\n \"0.72438157\",\n \"0.7098895\",\n \"0.70730084\",\n \"0.70391387\",\n \"0.6981259\",\n \"0.6977111\",\n \"0.6969315\",\n \"0.6933913\",\n \"0.69154346\",\n \"0.6907214\",\n \"0.6865833\",\n \"0.6815512\",\n \"0.6799823\",\n \"0.67882526\",\n \"0.67734057\",\n \"0.67627156\",\n \"0.670679\",\n \"0.66872627\",\n \"0.6678289\",\n \"0.6670774\",\n \"0.66642874\",\n \"0.66642874\",\n \"0.66642874\",\n \"0.66642874\",\n \"0.6658266\",\n \"0.6647678\",\n \"0.66453034\",\n \"0.6643202\",\n \"0.6614826\",\n \"0.66104454\",\n \"0.6610254\",\n \"0.6607496\",\n \"0.6599286\",\n \"0.6599286\",\n \"0.6596498\",\n \"0.65961397\",\n \"0.65958214\",\n \"0.6589427\",\n \"0.6584934\",\n \"0.65828604\",\n \"0.65828604\",\n \"0.6580714\",\n \"0.6571355\",\n \"0.6569671\",\n \"0.6567775\",\n \"0.65668136\",\n \"0.6552768\",\n \"0.6536445\",\n \"0.65211916\",\n \"0.6520104\",\n \"0.6495194\",\n \"0.64897794\",\n \"0.6488937\",\n \"0.6485867\",\n \"0.64820725\",\n \"0.6480279\",\n \"0.64787126\",\n \"0.64693314\",\n \"0.64597744\",\n \"0.64550805\",\n \"0.64550805\",\n \"0.64550805\",\n \"0.64550805\",\n \"0.6442284\",\n \"0.64394444\",\n \"0.643134\",\n \"0.6420422\",\n \"0.6419667\",\n \"0.63987947\",\n \"0.63966054\",\n \"0.6391801\",\n \"0.6389647\",\n \"0.6385969\",\n \"0.6379187\",\n \"0.6373667\",\n \"0.6351344\",\n \"0.634396\",\n \"0.634396\",\n \"0.634396\",\n \"0.634396\",\n \"0.63412654\",\n \"0.63407344\",\n \"0.63357306\",\n \"0.6333855\",\n \"0.6332498\",\n \"0.6325428\",\n \"0.632134\",\n \"0.632134\",\n \"0.632134\",\n \"0.6314297\",\n \"0.6311178\",\n \"0.63093805\",\n \"0.63085514\",\n \"0.63066286\",\n \"0.62943804\",\n \"0.6292416\",\n \"0.6289367\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6884,"cells":{"query":{"kind":"string","value":"Check if user login"},"document":{"kind":"string","value":"def require_user(func):\n\n @wraps(func)\n def decorator(*args, **kwargs):\n if not g.user:\n # flash('此操作需要登录账户')\n return render_template('account/error.html', error='抱歉，您无权进行该操作！')\n # return redirect(url_for('site.login'))\n return func(*args, **kwargs)\n\n return decorator"},"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_user_and_login(self) -> Response:\n pass","def is_correct_user(self, login, password):\n pass","def check_user_logged():\n global user\n if 'user' not in session:\n return False\n else:\n user = session.get('user')\n return user['username'] != ''","def logged():\n if session.login==1:\n return True\n else:\n return False","def check_login(request, username=None):\r\n if request.user is None:\r\n return False\r\n\r\n # if we have a username we're told to check against, make sure the\r\n # username matches\r\n if username is not None and username != request.user.username:\r\n return False\r\n\r\n return True","def is_logged_in():\n return 'user' in session","def check_user(self,username, password):\n safe_input = (username, password)\n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\",safe_input).fetchone()\n if vals:\n logging.info('%s was authenticated', username)\n return True\n else:\n logging.info('Failed login for %s', username)\n return False","def login_user():\n pass","def check_user(self):\n try:\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\n return True\n else:\n return False\n except:\n return False","def check_login(self, u, p):\r\n\t\tlogger.debug(\"Entering\")\r\n\t\t\r\n\t\ttry:\r\n\t\t\tval = login.validate_user(u, p)\r\n\t\texcept ValueError as e:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, e.message\r\n\t\t\r\n\t\tif val:\r\n\t\t\tlogger.debug(\"Exiting - success\")\r\n\t\t\treturn True, \"Login successful!\"\r\n\t\telse:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, \"Login failed.\"","def logged_in(self):\n return self.auth.get_user_by_session() is not None","def login():","def login():","def checkLogin():\n if 'access_token' in login_session:\n return True\n else:\n return False","def verifyLogin():\n global HUB\n\n loginInfo = FloatingTools.userData()['Login']\n if loginInfo['username'] is None or loginInfo['password'] is None:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False\n try:\n HUB = Github(loginInfo['username'], loginInfo['password'])\n for repo in HUB.get_user().get_repos():\n break\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\n return True\n except BadCredentialsException:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False","def require_login(self):\n\tif users.get_current_user():\n\t return True\n\telse:\n\t self.redirect(users.create_login_url(self.request.uri))\n\t return False","def validate_login(self, username, password):\n user = User(self).get(username)\n return user and user['Password'] == password","def check_auth():","def check_login(self):\n # read token first\n user_data = self.storage.get_user_data(self.user_id)\n if not \"token\" in user_data:\n sys.exit(\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\")\n\n # check token\n token = user_data[\"token\"]\n url = self.host_address + \"/assist/authentication\"\n payload = {\n 'action' : \"check\",\n 'client' : self.client_info,\n 'KEY' : (self.user_id + \";\" + token)\n }\n headers = {\n 'Content-Type': \"application/json\"\n }\n response = requests.request(\"POST\", url, json=payload, headers=headers)\n try:\n res = json.loads(response.text)\n except NameError:\n res = None\n\n if res[\"result\"] and res[\"result\"] == \"success\":\n name = res[\"user_name\"][\"nick\"] or res[\"user_name\"][\"first\"]\n print(\"SEPIA account: Success - Wb \" + name + \", your login token is still valid.\")\n else:\n print(\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\")","def isLoggedIn(self):\n session = self.getSession()\n if session is not None:\n return True\n return False","def test_user_login_attempt_when_user_already_logged_in(self):\n\t\tpass","def logged_in(browser: RoboBrowser):\n login_div = browser.find('div', content=\"Login\")\n return True if not login_div else False","def user_in_session():\n return 'user_id' in login_session","def login_check(self, username, password):\n can_login, msg = self.db.check_login(username, password)\n self.send_message(str(can_login) + DOLLAR + msg)","def check_my_users(user):\n user_data = my_users.get(user['username'])\n if not user_data:\n return False # <--- invalid credentials\n elif user_data.get('password') == user['password']:\n return True # <--- user is logged in!\n\n return False # <--- invalid credentials","def is_logged_in(session):\n return 'user' in session","def __check_user_exist(self):\n\n login_form = self.login_form()\n\n user = User.query.filter_by(username=login_form.username.data).first()\n if user is None or not user.get_password(login_form.password.data):\n flash('Invalid username or password') # TODO: flash in Template hinzufuegen\n return redirect(url_for('login'))\n\n login_user(user, remember=login_form.remember_me.data)\n\n next_page = request.args.get('next')\n\n # if 'next' is found and the host is specified\n # it will redirect\n if not next_page or url_parse(next_page).netloc != '':\n next_page = url_for('index')\n\n return redirect(next_page)","def loginState(self, user_data):\n\t\tif self.db.request(\"getOne\", user_data):\n\t\t\treturn True;\n\t\telse:\n\t\t\treturn False;","def check_user(used_name, used_password):\n user_exists = UserData.user_login(used_name, used_password)\n\n return user_exists","def log_in(user_name,password):\n log_in == User.log_in(user_name,password)\n if log_in != False:\n return User.log_in(user_name,password)","def is_logged_in(self, params):\n email = self.credentials.get('email', '')\n password = self.credentials.get('password', '')\n if email != '' and password != '':\n return False\n return self.netflix_session.is_logged_in(account=self.credentials)","def logged_in():\n\n if current_user.is_authenticated:\n return True\n\n return False","def check_user(self, login, password):\n user = self.cursor.execute(\n '''SELECT * FROM users WHERE login = ?''', login).fetchone()\n if user is not None:\n if user[3] == password:\n return Message('response', 'User exists')\n else:\n return Message('response',\n 'Users exists. Check password')\n else:\n return Message('response', 'User does not exists')","def login(uname, password, db, session):\n\tquery = db((db.User.username == uname) & (db.User.password == password))\n\tif query.count() == 1:\n\t\tsession.auth = query.select().first().id\n\t\treturn True\n\telse:\n\t\treturn False","def is_logged_in(self, login_url: str) -> bool:\n self.d('Check login - %s', login_url)\n if not login_url:\n return False\n res = self.get(login_url, allow_redirects=False)\n if res.status_code == 302:\n self.i('Is logged in')\n return True\n self.i('Is not logged in')\n return False","def _login(self):\n if User.login(self.session.teller_id, self.session.teller_pin, 'teller'):\n return True\n else:\n self.session.output({'authentication_failure': 'wrong ID or PIN\\n'}, '[ Login failed ]')\n return False","def login_user(username,password):\n \n check_user = Records.verify_user(username,password)\n return check_user","def validUser(self):\n if self.state == SessionStates.LOGGED_OUT:\n return False\n\n # if self.user == None:\n # return False\n return True","def CheckLogin(self) :\n url = Judge.UrlStatus + 'contestId=1&search=true&firstId=-1&lastId=-1&handle=' + self.username\n logging.info(\"open_url %s\" % url)\n req = urllib2.Request(url, headers=Judge.Headers)\n rsp = self.opener.open(req)\n res = None\n if rsp :\n res = rsp.read()\n #wf(\"CheckLogin_\", res)\n result = self.__parse_result(None, res, need_extra_info=False)\n if result and result.has_key('origin_runid') :\n #print \"CheckLogin last_submit_time{%s}END\" % result['_submit_time']\n self.last_runid = result['origin_runid']\n return res and res.find(r'<a href=\"/onlinejudge/login.do\">Login</a>') == -1","def is_logged_in():\n _has_cookie = util.web.has_cookie('pass')\n if _has_cookie:\n _is_expired = util.web.is_cookie_expired('pass')\n if _is_expired:\n return False\n return True\n return False","def valid_login(username: str, password: str):\n\n try:\n LoginHandler.login(username, password)\n global validLogin\n validLogin = True\n except:\n validLogin = False","def check_if_should_always_be_logged_in(connection,username_log):\r\n with connection:\r\n c = connection.execute(SELECT_USER_BY_LOGIN_PREVILAGES, (username_log,))\r\n return c.fetchone()","def login():\n pass","def user_auth(request):\n if request.user.is_authenticated:\n user = User.objects.get(email=request.user.email)\n if UserInformation.objects.filter(user=user).exists():\n return True\n return False","def is_logged_in(self) -> bool:\n return self.id is not None and self.username is not None","def check_authentication():\r\n\r\n #TODO: Reservation based authentication\r\n try:\r\n authenticated_user()\r\n except Exception as e:\r\n return e\r\n\r\n return True","def is_logged_in() -> bool:\n is_dev_login_disabled = SETTINGS.DEV_LOGIN_DISABLED and is_localhost()\n return bool(is_dev_login_disabled or is_logged_in_user())","def check_user(self):\n try:\n if self.get_customer()[0][0] == self.dni:\n return True\n else:\n return False\n except:\n return False","def check(self):\n\n us = ServiceLocator.resolve(ServiceLocator.USERS)\n\n user_session = self.get()\n user = self.get_user()\n\n return user is not None and us.verify_auth_token(user_session.token, config.SESSION_EXPIRES)","def check_auth(username, password):\n # return username == app.config['USER'] and password == app.config['PASS']\n\n return username == app.config['USER'] and password == app.config['PASS']","def is_logged_in(self):\n return self.router.token is not None","def test_user_can_login(self):\n user = authenticate(username='Marry', password='secret')\n self.assertFalse(user is None)\n self.assertTrue(user.is_authenticated)","def _check_auth(self):\n if self.authToken:\n return True\n else:\n msg = \"you need to login\"\n self.raise_error(msg)","def is_logged_in():\n logged_in = \"uid\" in session\n if logged_in:\n user = api.user.get_user(uid=session[\"uid\"])\n if not user or (user.get(\"disabled\", False) is True):\n logout()\n return False\n return logged_in","def user_exists(self, login):\n\t\tif login in self.users_by_name and isinstance(self.users_by_name[login], VDOM_user):\n\t\t\treturn True\n\t\treturn False","def check_auth(username, password):\r\n return username == current_app.config['ADMIN_USERNAME'] \\\r\n and password == current_app.config['ADMIN_PASSWORD']","def CheckLogin(self):\n \n username = self.username.get().lstrip().rstrip()\n if not username:\n messagebox.showerror('Error', 'No username entered.')\n return False, None, None\n \n password = self.password.get().lstrip().rstrip()\n if not password:\n messagebox.showerror('Error', 'No password entered.')\n return False, None, None\n \n for user in self.user_db:\n if user['User'] == username:\n if user['Password'] == password:\n # Retrive the last log-in date, then update value to now\n prev_login = user['LastLogIn']\n user['LastLogIn'] = date.today().strftime('%B %d, %Y')\n return True, username, prev_login\n else:\n messagebox.showerror('Error',\n 'The provided password is incorrect.')\n return False, None, None\n \n messagebox.showerror('Error', f'User {username} does not exist.')\n return False, None, None","def test_func(self):\n if not self.request.user.is_authenticated:\n return False\n if self.request.user.is_staff:\n return True\n return self.get_user() == self.request.user","def is_logged_in(self, email):\n wait_for_element(self.browser, self.expand_left_panel)\n expand_panel = self.browser.find_element(*self.expand_left_panel)\n custom_click(self.browser, expand_panel)\n wait_for(lambda: len(self.browser.find_element(*self.logged_user).text) > 0, delay=1, num_sec=5)\n user_logged_in = self.browser.find_element(*self.logged_user).text\n if user_logged_in == email:\n return True\n else:\n raise Exception('Failed to login by user => {}'.format(email))","def login(self, returnToURL):\r\n\t\tif not self.request().hasValue('userId') or \\\r\n\t\t\tnot self.request().hasValue('password'):\r\n\t\t\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\r\n\t\t\treturn 0\r\n\t\treturn 1","def logged_in(request):\n return request.current_user is not None","def check_login_response(self, response):\n\t\tprint(response.body)\n\t\tif login_error[0] not in response.body.decode('utf-8'):\n\t\t self.log(\"Successfully logged in. Let's start crawling!\")\n\t\t # Now the crawling can begin..\n\t\t return self.initialized()\n\t\t print(\"logged in\")\n\t\telse:\n\t\t self.log(\"Bad times :(\")\n\t\t # Something went wrong, we couldn't log in, so nothing happens.","def login_check():\n\n user_email = request.form['email']\n user_password = request.form['password']\n\n # Check user info against database\n email_query = User.query.filter_by(email=user_email).first()\n if email_query == None:\n flash('Invalid email or password')\n return redirect('/')\n\n # Get user's id using email\n user_id = email_query.user_id\n\n # Valid user password\n if user_password == email_query.password:\n #create user session\n session['user'] = email_query.user_id\n return redirect('/user-%s' % user_id)\n else:\n flash('Invalid email or password')\n return redirect('/')","def login_to_system(credentials):\n return True if credentials else False","def validate_login(self, request):\n\n if 'id' not in request.session or 'steam_id' not in request.session:\n raise PermissionDenied('You need to login')\n\n # if self.mode9:\n # if 'team' not in PlayerList[request.session['id']]:\n # raise PermissionDenied('Player is not in a team!')","def validarLogin(self, usuario, senha):\r\n try:\r\n if usuario is not None and senha is not None:\r\n self.cursor.execute(\"SELECT SENHA FROM LOGIN WHERE USUARIO = '%s';\" %(usuario))\r\n self.__temp = self.cursor.fetchone()\r\n if self.__temp[0] == senha:\r\n return True\r\n return False\r\n except:\r\n return False","def login_form_valid(self, form):\n self.request.session.update({\n 'user_is_none': None,\n 'user_is_active': None\n })\n\n email = form.cleaned_data['email']\n password = form.cleaned_data['password']\n user = authenticate(email=email, password=password)\n\n if user is None:\n self.request.session['user_is_none'] = True\n return HttpResponseRedirect('/user_account/')\n elif user.active is False:\n self.request.session['user_is_active'] = False\n return HttpResponseRedirect('/user_account/')\n else:\n self.request.session.update({\n 'user_is_none': False,\n 'user_is_active': True\n })\n login(self.request, user)\n return HttpResponseRedirect('/schedule/')","def default_login_works(self):\n return True if self.default_login_auth_header else False","def check_auth(username, password):\n return get_ct_object(username, password) is not None","def test_can_login(self):\n user = authenticate(username='jack', password='secret')\n self.assertTrue(user is not None)\n self.assertTrue(user.is_authenticated)","def is_valid_login(self, username, password):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)","def check_auth(username, password):\n return username == 'asimov' and password == 'tagada72'","def login(self):\n\t\treturn","def is_registered(self):\n if self.user == getpass.getuser():\n return True\n else:\n return False","def is_logged_in_user_valid(user_name, password):\n if user_name.upper() == \"HELLO\" and password == \"World\":\n return True # User input matches user name and password.\n else:\n return False # User input does not match user name and password.s","def check_login_status(self):\n\n if (hasattr(self, 'username') and hasattr(self, 'password')\n and hasattr(self, 'session')):\n authenticated = self._request('POST', CosmoSim.QUERY_URL,\n auth=(self.username, self.password),\n cache=False)\n if authenticated.status_code == 200:\n warnings.warn(\"Status: You are logged in as {0}.\"\n .format(self.username))\n soup = BeautifulSoup(authenticated.content, \"lxml\")\n self.delete_job(jobid=str(soup.find(\"uws:jobref\")[\"id\"]),\n squash=True)\n else:\n warnings.warn(\"Status: The username/password combination \"\n \"for {0} appears to be incorrect.\"\n .format(self.username))\n warnings.warn(\"Please re-attempt to login with your cosmosim \"\n \"credentials.\")\n else:\n warnings.warn(\"Status: You are not logged in.\")","def is_logged_in(self, username):\n if username in self.users:\n return self.users[username].is_logged\n return False","def logged_in(self):\n return self.user is not None","def is_authenticated(self):\n result = self.lpass(\"lpass status\")\n\n if \"Logged in as\" in result.output:\n return True\n\n return False","def check_user(self, username):\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\n row = self.dbcursor.fetchone()\n if row:\n return True \n return False","def check_user(self, username):\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\n row = self.dbcursor.fetchone()\n if row:\n return True \n return False","def _logged_in_successful(data):\r\n if re.match(r'^:(testserver\\.local|tmi\\.twitch\\.tv)'\r\n r' NOTICE \\* :'\r\n r'(Login unsuccessful|Error logging in)*$',\r\n data.strip()):\r\n return False\r\n else:\r\n return True","def is_logged_in(session):\n if 'tid' in session:\n return {'success': 1, 'message': '你处于登录状态.', \n 'teamname': session['teamname'], 'is_zju_user': session['is_zju_user']}\n else:\n return {\"success\": 0, \"message\": \"你并未处于登录状态.\"}","def is_regular_user(user):\n return user.is_authenticated()","def login(self):","def check_auth(username, password):\n return username == 'admin' and password == 'worcester'","def check_auth(username, password):\n return username == app.config['USERNAME'] and (\n password == app.config['PASSWORD'])","def login(UserID, Password):\n\tif UserID in USERS and USERS[UserID] == Password:\n\t\treturn True\n\telse:\n\t\treturn False","def is_logged_in(self):\n return self.cookie is not None","def check_auth(username, password):\n return username == 'admin' and password == 'admin'","def check_auth(username, password):\n return (username == app.config['USERNAME'] and\n password == app.config['PASSWORD'])","def check_auth(username, password):\n return username == USERNAME and password == PASSWORD","def check_auth(username, password):\n return username == 'jeffkoons' and password == 'likesweirdbaloons'","def checkLogin(self):\n if self._thread:\n return False\n\n try:\n return self._checkLogin()\n except Exception:\n self.expired = True\n self.finished = True\n\n return False","def check_login(db, useremail, password):\n import hashlib\n\n cursor = db.cursor().execute('SELECT password FROM users WHERE email IS ?', [useremail])\n result = cursor.fetchone()\n if result:\n return result[0] == hashlib.sha1(password.encode()).hexdigest()\n return False","def check_auth(username, password):\n return username == 'admin' and password == 'password'","def _can_login(self):\n return all([self.user.is_active, self.status, self.status_detail == \"active\"])","def do_login():\n\n isTeacher = False\n\n # check if this_user is admin or normal user\n this_user = User.query.filter_by(username=request.form['username']).first()\n \n # is this_user is not student or admin then check teacher table\n if this_user is None:\n this_user = Teacher.query.filter_by(username=request.form['username']).first()\n isTeacher = True\n\n # if this_user is still none -> invalid user\n if this_user is not None:\n if this_user.password == request.form[\"password\"]:\n session['authenticated'] = True\n session['username'] = this_user.username\n session['name'] = this_user.name\n session['isTeacher'] = isTeacher\n if session['username'] == \"admin\":\n session['wasAt'] = \"manageusers\"\n try:\n session['cpi'] = this_user.cpi\n session['grp_size'] = this_user.group_size\n except:\n pass\n else:\n flash(\"Incorrect Password, Please Try Again\") \n else:\n flash(\"Invalid Username, Please Try Again\")\n return home()","def check_auth(username, password):\n return username == 'admin' and password == 'Passw0rd'","def check_auth(username, password):\n return username == 'admin' and password == 'root'","def acctLogin(self):\n loggedIn = False\n if self.acctObj.login():\n loggedIn = True\n else:\n logger.warning(\"{} Authentication failed\".format(self))\n self.acctObj = None\n\n if loggedIn:\n return True\n return False"],"string":"[\n \"def check_user_and_login(self) -> Response:\\n pass\",\n \"def is_correct_user(self, login, password):\\n pass\",\n \"def check_user_logged():\\n global user\\n if 'user' not in session:\\n return False\\n else:\\n user = session.get('user')\\n return user['username'] != ''\",\n \"def logged():\\n if session.login==1:\\n return True\\n else:\\n return False\",\n \"def check_login(request, username=None):\\r\\n if request.user is None:\\r\\n return False\\r\\n\\r\\n # if we have a username we're told to check against, make sure the\\r\\n # username matches\\r\\n if username is not None and username != request.user.username:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def is_logged_in():\\n return 'user' in session\",\n \"def check_user(self,username, password):\\n safe_input = (username, password)\\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\\\",safe_input).fetchone()\\n if vals:\\n logging.info('%s was authenticated', username)\\n return True\\n else:\\n logging.info('Failed login for %s', username)\\n return False\",\n \"def login_user():\\n pass\",\n \"def check_user(self):\\n try:\\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check_login(self, u, p):\\r\\n\\t\\tlogger.debug(\\\"Entering\\\")\\r\\n\\t\\t\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tval = login.validate_user(u, p)\\r\\n\\t\\texcept ValueError as e:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, e.message\\r\\n\\t\\t\\r\\n\\t\\tif val:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - success\\\")\\r\\n\\t\\t\\treturn True, \\\"Login successful!\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, \\\"Login failed.\\\"\",\n \"def logged_in(self):\\n return self.auth.get_user_by_session() is not None\",\n \"def login():\",\n \"def login():\",\n \"def checkLogin():\\n if 'access_token' in login_session:\\n return True\\n else:\\n return False\",\n \"def verifyLogin():\\n global HUB\\n\\n loginInfo = FloatingTools.userData()['Login']\\n if loginInfo['username'] is None or loginInfo['password'] is None:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\\n try:\\n HUB = Github(loginInfo['username'], loginInfo['password'])\\n for repo in HUB.get_user().get_repos():\\n break\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\\n return True\\n except BadCredentialsException:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\",\n \"def require_login(self):\\n\\tif users.get_current_user():\\n\\t return True\\n\\telse:\\n\\t self.redirect(users.create_login_url(self.request.uri))\\n\\t return False\",\n \"def validate_login(self, username, password):\\n user = User(self).get(username)\\n return user and user['Password'] == password\",\n \"def check_auth():\",\n \"def check_login(self):\\n # read token first\\n user_data = self.storage.get_user_data(self.user_id)\\n if not \\\"token\\\" in user_data:\\n sys.exit(\\\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\\\")\\n\\n # check token\\n token = user_data[\\\"token\\\"]\\n url = self.host_address + \\\"/assist/authentication\\\"\\n payload = {\\n 'action' : \\\"check\\\",\\n 'client' : self.client_info,\\n 'KEY' : (self.user_id + \\\";\\\" + token)\\n }\\n headers = {\\n 'Content-Type': \\\"application/json\\\"\\n }\\n response = requests.request(\\\"POST\\\", url, json=payload, headers=headers)\\n try:\\n res = json.loads(response.text)\\n except NameError:\\n res = None\\n\\n if res[\\\"result\\\"] and res[\\\"result\\\"] == \\\"success\\\":\\n name = res[\\\"user_name\\\"][\\\"nick\\\"] or res[\\\"user_name\\\"][\\\"first\\\"]\\n print(\\\"SEPIA account: Success - Wb \\\" + name + \\\", your login token is still valid.\\\")\\n else:\\n print(\\\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\\\")\",\n \"def isLoggedIn(self):\\n session = self.getSession()\\n if session is not None:\\n return True\\n return False\",\n \"def test_user_login_attempt_when_user_already_logged_in(self):\\n\\t\\tpass\",\n \"def logged_in(browser: RoboBrowser):\\n login_div = browser.find('div', content=\\\"Login\\\")\\n return True if not login_div else False\",\n \"def user_in_session():\\n return 'user_id' in login_session\",\n \"def login_check(self, username, password):\\n can_login, msg = self.db.check_login(username, password)\\n self.send_message(str(can_login) + DOLLAR + msg)\",\n \"def check_my_users(user):\\n user_data = my_users.get(user['username'])\\n if not user_data:\\n return False # <--- invalid credentials\\n elif user_data.get('password') == user['password']:\\n return True # <--- user is logged in!\\n\\n return False # <--- invalid credentials\",\n \"def is_logged_in(session):\\n return 'user' in session\",\n \"def __check_user_exist(self):\\n\\n login_form = self.login_form()\\n\\n user = User.query.filter_by(username=login_form.username.data).first()\\n if user is None or not user.get_password(login_form.password.data):\\n flash('Invalid username or password') # TODO: flash in Template hinzufuegen\\n return redirect(url_for('login'))\\n\\n login_user(user, remember=login_form.remember_me.data)\\n\\n next_page = request.args.get('next')\\n\\n # if 'next' is found and the host is specified\\n # it will redirect\\n if not next_page or url_parse(next_page).netloc != '':\\n next_page = url_for('index')\\n\\n return redirect(next_page)\",\n \"def loginState(self, user_data):\\n\\t\\tif self.db.request(\\\"getOne\\\", user_data):\\n\\t\\t\\treturn True;\\n\\t\\telse:\\n\\t\\t\\treturn False;\",\n \"def check_user(used_name, used_password):\\n user_exists = UserData.user_login(used_name, used_password)\\n\\n return user_exists\",\n \"def log_in(user_name,password):\\n log_in == User.log_in(user_name,password)\\n if log_in != False:\\n return User.log_in(user_name,password)\",\n \"def is_logged_in(self, params):\\n email = self.credentials.get('email', '')\\n password = self.credentials.get('password', '')\\n if email != '' and password != '':\\n return False\\n return self.netflix_session.is_logged_in(account=self.credentials)\",\n \"def logged_in():\\n\\n if current_user.is_authenticated:\\n return True\\n\\n return False\",\n \"def check_user(self, login, password):\\n user = self.cursor.execute(\\n '''SELECT * FROM users WHERE login = ?''', login).fetchone()\\n if user is not None:\\n if user[3] == password:\\n return Message('response', 'User exists')\\n else:\\n return Message('response',\\n 'Users exists. Check password')\\n else:\\n return Message('response', 'User does not exists')\",\n \"def login(uname, password, db, session):\\n\\tquery = db((db.User.username == uname) & (db.User.password == password))\\n\\tif query.count() == 1:\\n\\t\\tsession.auth = query.select().first().id\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def is_logged_in(self, login_url: str) -> bool:\\n self.d('Check login - %s', login_url)\\n if not login_url:\\n return False\\n res = self.get(login_url, allow_redirects=False)\\n if res.status_code == 302:\\n self.i('Is logged in')\\n return True\\n self.i('Is not logged in')\\n return False\",\n \"def _login(self):\\n if User.login(self.session.teller_id, self.session.teller_pin, 'teller'):\\n return True\\n else:\\n self.session.output({'authentication_failure': 'wrong ID or PIN\\\\n'}, '[ Login failed ]')\\n return False\",\n \"def login_user(username,password):\\n \\n check_user = Records.verify_user(username,password)\\n return check_user\",\n \"def validUser(self):\\n if self.state == SessionStates.LOGGED_OUT:\\n return False\\n\\n # if self.user == None:\\n # return False\\n return True\",\n \"def CheckLogin(self) :\\n url = Judge.UrlStatus + 'contestId=1&search=true&firstId=-1&lastId=-1&handle=' + self.username\\n logging.info(\\\"open_url %s\\\" % url)\\n req = urllib2.Request(url, headers=Judge.Headers)\\n rsp = self.opener.open(req)\\n res = None\\n if rsp :\\n res = rsp.read()\\n #wf(\\\"CheckLogin_\\\", res)\\n result = self.__parse_result(None, res, need_extra_info=False)\\n if result and result.has_key('origin_runid') :\\n #print \\\"CheckLogin last_submit_time{%s}END\\\" % result['_submit_time']\\n self.last_runid = result['origin_runid']\\n return res and res.find(r'<a href=\\\"/onlinejudge/login.do\\\">Login</a>') == -1\",\n \"def is_logged_in():\\n _has_cookie = util.web.has_cookie('pass')\\n if _has_cookie:\\n _is_expired = util.web.is_cookie_expired('pass')\\n if _is_expired:\\n return False\\n return True\\n return False\",\n \"def valid_login(username: str, password: str):\\n\\n try:\\n LoginHandler.login(username, password)\\n global validLogin\\n validLogin = True\\n except:\\n validLogin = False\",\n \"def check_if_should_always_be_logged_in(connection,username_log):\\r\\n with connection:\\r\\n c = connection.execute(SELECT_USER_BY_LOGIN_PREVILAGES, (username_log,))\\r\\n return c.fetchone()\",\n \"def login():\\n pass\",\n \"def user_auth(request):\\n if request.user.is_authenticated:\\n user = User.objects.get(email=request.user.email)\\n if UserInformation.objects.filter(user=user).exists():\\n return True\\n return False\",\n \"def is_logged_in(self) -> bool:\\n return self.id is not None and self.username is not None\",\n \"def check_authentication():\\r\\n\\r\\n #TODO: Reservation based authentication\\r\\n try:\\r\\n authenticated_user()\\r\\n except Exception as e:\\r\\n return e\\r\\n\\r\\n return True\",\n \"def is_logged_in() -> bool:\\n is_dev_login_disabled = SETTINGS.DEV_LOGIN_DISABLED and is_localhost()\\n return bool(is_dev_login_disabled or is_logged_in_user())\",\n \"def check_user(self):\\n try:\\n if self.get_customer()[0][0] == self.dni:\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check(self):\\n\\n us = ServiceLocator.resolve(ServiceLocator.USERS)\\n\\n user_session = self.get()\\n user = self.get_user()\\n\\n return user is not None and us.verify_auth_token(user_session.token, config.SESSION_EXPIRES)\",\n \"def check_auth(username, password):\\n # return username == app.config['USER'] and password == app.config['PASS']\\n\\n return username == app.config['USER'] and password == app.config['PASS']\",\n \"def is_logged_in(self):\\n return self.router.token is not None\",\n \"def test_user_can_login(self):\\n user = authenticate(username='Marry', password='secret')\\n self.assertFalse(user is None)\\n self.assertTrue(user.is_authenticated)\",\n \"def _check_auth(self):\\n if self.authToken:\\n return True\\n else:\\n msg = \\\"you need to login\\\"\\n self.raise_error(msg)\",\n \"def is_logged_in():\\n logged_in = \\\"uid\\\" in session\\n if logged_in:\\n user = api.user.get_user(uid=session[\\\"uid\\\"])\\n if not user or (user.get(\\\"disabled\\\", False) is True):\\n logout()\\n return False\\n return logged_in\",\n \"def user_exists(self, login):\\n\\t\\tif login in self.users_by_name and isinstance(self.users_by_name[login], VDOM_user):\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def check_auth(username, password):\\r\\n return username == current_app.config['ADMIN_USERNAME'] \\\\\\r\\n and password == current_app.config['ADMIN_PASSWORD']\",\n \"def CheckLogin(self):\\n \\n username = self.username.get().lstrip().rstrip()\\n if not username:\\n messagebox.showerror('Error', 'No username entered.')\\n return False, None, None\\n \\n password = self.password.get().lstrip().rstrip()\\n if not password:\\n messagebox.showerror('Error', 'No password entered.')\\n return False, None, None\\n \\n for user in self.user_db:\\n if user['User'] == username:\\n if user['Password'] == password:\\n # Retrive the last log-in date, then update value to now\\n prev_login = user['LastLogIn']\\n user['LastLogIn'] = date.today().strftime('%B %d, %Y')\\n return True, username, prev_login\\n else:\\n messagebox.showerror('Error',\\n 'The provided password is incorrect.')\\n return False, None, None\\n \\n messagebox.showerror('Error', f'User {username} does not exist.')\\n return False, None, None\",\n \"def test_func(self):\\n if not self.request.user.is_authenticated:\\n return False\\n if self.request.user.is_staff:\\n return True\\n return self.get_user() == self.request.user\",\n \"def is_logged_in(self, email):\\n wait_for_element(self.browser, self.expand_left_panel)\\n expand_panel = self.browser.find_element(*self.expand_left_panel)\\n custom_click(self.browser, expand_panel)\\n wait_for(lambda: len(self.browser.find_element(*self.logged_user).text) > 0, delay=1, num_sec=5)\\n user_logged_in = self.browser.find_element(*self.logged_user).text\\n if user_logged_in == email:\\n return True\\n else:\\n raise Exception('Failed to login by user => {}'.format(email))\",\n \"def login(self, returnToURL):\\r\\n\\t\\tif not self.request().hasValue('userId') or \\\\\\r\\n\\t\\t\\tnot self.request().hasValue('password'):\\r\\n\\t\\t\\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\\r\\n\\t\\t\\treturn 0\\r\\n\\t\\treturn 1\",\n \"def logged_in(request):\\n return request.current_user is not None\",\n \"def check_login_response(self, response):\\n\\t\\tprint(response.body)\\n\\t\\tif login_error[0] not in response.body.decode('utf-8'):\\n\\t\\t self.log(\\\"Successfully logged in. Let's start crawling!\\\")\\n\\t\\t # Now the crawling can begin..\\n\\t\\t return self.initialized()\\n\\t\\t print(\\\"logged in\\\")\\n\\t\\telse:\\n\\t\\t self.log(\\\"Bad times :(\\\")\\n\\t\\t # Something went wrong, we couldn't log in, so nothing happens.\",\n \"def login_check():\\n\\n user_email = request.form['email']\\n user_password = request.form['password']\\n\\n # Check user info against database\\n email_query = User.query.filter_by(email=user_email).first()\\n if email_query == None:\\n flash('Invalid email or password')\\n return redirect('/')\\n\\n # Get user's id using email\\n user_id = email_query.user_id\\n\\n # Valid user password\\n if user_password == email_query.password:\\n #create user session\\n session['user'] = email_query.user_id\\n return redirect('/user-%s' % user_id)\\n else:\\n flash('Invalid email or password')\\n return redirect('/')\",\n \"def login_to_system(credentials):\\n return True if credentials else False\",\n \"def validate_login(self, request):\\n\\n if 'id' not in request.session or 'steam_id' not in request.session:\\n raise PermissionDenied('You need to login')\\n\\n # if self.mode9:\\n # if 'team' not in PlayerList[request.session['id']]:\\n # raise PermissionDenied('Player is not in a team!')\",\n \"def validarLogin(self, usuario, senha):\\r\\n try:\\r\\n if usuario is not None and senha is not None:\\r\\n self.cursor.execute(\\\"SELECT SENHA FROM LOGIN WHERE USUARIO = '%s';\\\" %(usuario))\\r\\n self.__temp = self.cursor.fetchone()\\r\\n if self.__temp[0] == senha:\\r\\n return True\\r\\n return False\\r\\n except:\\r\\n return False\",\n \"def login_form_valid(self, form):\\n self.request.session.update({\\n 'user_is_none': None,\\n 'user_is_active': None\\n })\\n\\n email = form.cleaned_data['email']\\n password = form.cleaned_data['password']\\n user = authenticate(email=email, password=password)\\n\\n if user is None:\\n self.request.session['user_is_none'] = True\\n return HttpResponseRedirect('/user_account/')\\n elif user.active is False:\\n self.request.session['user_is_active'] = False\\n return HttpResponseRedirect('/user_account/')\\n else:\\n self.request.session.update({\\n 'user_is_none': False,\\n 'user_is_active': True\\n })\\n login(self.request, user)\\n return HttpResponseRedirect('/schedule/')\",\n \"def default_login_works(self):\\n return True if self.default_login_auth_header else False\",\n \"def check_auth(username, password):\\n return get_ct_object(username, password) is not None\",\n \"def test_can_login(self):\\n user = authenticate(username='jack', password='secret')\\n self.assertTrue(user is not None)\\n self.assertTrue(user.is_authenticated)\",\n \"def is_valid_login(self, username, password):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)\",\n \"def check_auth(username, password):\\n return username == 'asimov' and password == 'tagada72'\",\n \"def login(self):\\n\\t\\treturn\",\n \"def is_registered(self):\\n if self.user == getpass.getuser():\\n return True\\n else:\\n return False\",\n \"def is_logged_in_user_valid(user_name, password):\\n if user_name.upper() == \\\"HELLO\\\" and password == \\\"World\\\":\\n return True # User input matches user name and password.\\n else:\\n return False # User input does not match user name and password.s\",\n \"def check_login_status(self):\\n\\n if (hasattr(self, 'username') and hasattr(self, 'password')\\n and hasattr(self, 'session')):\\n authenticated = self._request('POST', CosmoSim.QUERY_URL,\\n auth=(self.username, self.password),\\n cache=False)\\n if authenticated.status_code == 200:\\n warnings.warn(\\\"Status: You are logged in as {0}.\\\"\\n .format(self.username))\\n soup = BeautifulSoup(authenticated.content, \\\"lxml\\\")\\n self.delete_job(jobid=str(soup.find(\\\"uws:jobref\\\")[\\\"id\\\"]),\\n squash=True)\\n else:\\n warnings.warn(\\\"Status: The username/password combination \\\"\\n \\\"for {0} appears to be incorrect.\\\"\\n .format(self.username))\\n warnings.warn(\\\"Please re-attempt to login with your cosmosim \\\"\\n \\\"credentials.\\\")\\n else:\\n warnings.warn(\\\"Status: You are not logged in.\\\")\",\n \"def is_logged_in(self, username):\\n if username in self.users:\\n return self.users[username].is_logged\\n return False\",\n \"def logged_in(self):\\n return self.user is not None\",\n \"def is_authenticated(self):\\n result = self.lpass(\\\"lpass status\\\")\\n\\n if \\\"Logged in as\\\" in result.output:\\n return True\\n\\n return False\",\n \"def check_user(self, username):\\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\\n row = self.dbcursor.fetchone()\\n if row:\\n return True \\n return False\",\n \"def check_user(self, username):\\n self.dbcursor.execute(self.SQL_CHECK_USER, [username])\\n row = self.dbcursor.fetchone()\\n if row:\\n return True \\n return False\",\n \"def _logged_in_successful(data):\\r\\n if re.match(r'^:(testserver\\\\.local|tmi\\\\.twitch\\\\.tv)'\\r\\n r' NOTICE \\\\* :'\\r\\n r'(Login unsuccessful|Error logging in)*$',\\r\\n data.strip()):\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def is_logged_in(session):\\n if 'tid' in session:\\n return {'success': 1, 'message': '你处于登录状态.', \\n 'teamname': session['teamname'], 'is_zju_user': session['is_zju_user']}\\n else:\\n return {\\\"success\\\": 0, \\\"message\\\": \\\"你并未处于登录状态.\\\"}\",\n \"def is_regular_user(user):\\n return user.is_authenticated()\",\n \"def login(self):\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'worcester'\",\n \"def check_auth(username, password):\\n return username == app.config['USERNAME'] and (\\n password == app.config['PASSWORD'])\",\n \"def login(UserID, Password):\\n\\tif UserID in USERS and USERS[UserID] == Password:\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def is_logged_in(self):\\n return self.cookie is not None\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'admin'\",\n \"def check_auth(username, password):\\n return (username == app.config['USERNAME'] and\\n password == app.config['PASSWORD'])\",\n \"def check_auth(username, password):\\n return username == USERNAME and password == PASSWORD\",\n \"def check_auth(username, password):\\n return username == 'jeffkoons' and password == 'likesweirdbaloons'\",\n \"def checkLogin(self):\\n if self._thread:\\n return False\\n\\n try:\\n return self._checkLogin()\\n except Exception:\\n self.expired = True\\n self.finished = True\\n\\n return False\",\n \"def check_login(db, useremail, password):\\n import hashlib\\n\\n cursor = db.cursor().execute('SELECT password FROM users WHERE email IS ?', [useremail])\\n result = cursor.fetchone()\\n if result:\\n return result[0] == hashlib.sha1(password.encode()).hexdigest()\\n return False\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'password'\",\n \"def _can_login(self):\\n return all([self.user.is_active, self.status, self.status_detail == \\\"active\\\"])\",\n \"def do_login():\\n\\n isTeacher = False\\n\\n # check if this_user is admin or normal user\\n this_user = User.query.filter_by(username=request.form['username']).first()\\n \\n # is this_user is not student or admin then check teacher table\\n if this_user is None:\\n this_user = Teacher.query.filter_by(username=request.form['username']).first()\\n isTeacher = True\\n\\n # if this_user is still none -> invalid user\\n if this_user is not None:\\n if this_user.password == request.form[\\\"password\\\"]:\\n session['authenticated'] = True\\n session['username'] = this_user.username\\n session['name'] = this_user.name\\n session['isTeacher'] = isTeacher\\n if session['username'] == \\\"admin\\\":\\n session['wasAt'] = \\\"manageusers\\\"\\n try:\\n session['cpi'] = this_user.cpi\\n session['grp_size'] = this_user.group_size\\n except:\\n pass\\n else:\\n flash(\\\"Incorrect Password, Please Try Again\\\") \\n else:\\n flash(\\\"Invalid Username, Please Try Again\\\")\\n return home()\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'Passw0rd'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'root'\",\n \"def acctLogin(self):\\n loggedIn = False\\n if self.acctObj.login():\\n loggedIn = True\\n else:\\n logger.warning(\\\"{} Authentication failed\\\".format(self))\\n self.acctObj = None\\n\\n if loggedIn:\\n return True\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8381395","0.8055585","0.7813263","0.7678583","0.7649151","0.7576734","0.7567418","0.7521423","0.75094885","0.7488563","0.74643886","0.7460811","0.7460811","0.7443086","0.7417814","0.74102914","0.7391327","0.73445153","0.73423046","0.72956836","0.7277331","0.72458184","0.7244352","0.724247","0.723785","0.7231149","0.72120786","0.7196707","0.71806514","0.71768206","0.7166374","0.7160414","0.7157582","0.71544594","0.7114222","0.7111135","0.71090746","0.70937395","0.70930314","0.7076667","0.7073319","0.7061583","0.70432377","0.7025321","0.70132774","0.7009884","0.6997237","0.6990148","0.69825286","0.6976101","0.69747275","0.695906","0.6944757","0.69443876","0.6941434","0.69339997","0.69278216","0.6924908","0.6917136","0.691316","0.6908974","0.6903402","0.6894987","0.68923765","0.6886722","0.6878631","0.6870336","0.68470937","0.68447274","0.6842939","0.68408334","0.6840231","0.68296224","0.68287593","0.68269473","0.6823845","0.68073136","0.6806805","0.68049407","0.6797839","0.6797839","0.6796853","0.67956036","0.67931885","0.679113","0.6784908","0.6784704","0.67844296","0.6783589","0.67728573","0.6772496","0.67714155","0.6767632","0.675321","0.675311","0.6749905","0.67493784","0.6744074","0.6741154","0.6737048","0.6733501"],"string":"[\n \"0.8381395\",\n \"0.8055585\",\n \"0.7813263\",\n \"0.7678583\",\n \"0.7649151\",\n \"0.7576734\",\n \"0.7567418\",\n \"0.7521423\",\n \"0.75094885\",\n \"0.7488563\",\n \"0.74643886\",\n \"0.7460811\",\n \"0.7460811\",\n \"0.7443086\",\n \"0.7417814\",\n \"0.74102914\",\n \"0.7391327\",\n \"0.73445153\",\n \"0.73423046\",\n \"0.72956836\",\n \"0.7277331\",\n \"0.72458184\",\n \"0.7244352\",\n \"0.724247\",\n \"0.723785\",\n \"0.7231149\",\n \"0.72120786\",\n \"0.7196707\",\n \"0.71806514\",\n \"0.71768206\",\n \"0.7166374\",\n \"0.7160414\",\n \"0.7157582\",\n \"0.71544594\",\n \"0.7114222\",\n \"0.7111135\",\n \"0.71090746\",\n \"0.70937395\",\n \"0.70930314\",\n \"0.7076667\",\n \"0.7073319\",\n \"0.7061583\",\n \"0.70432377\",\n \"0.7025321\",\n \"0.70132774\",\n \"0.7009884\",\n \"0.6997237\",\n \"0.6990148\",\n \"0.69825286\",\n \"0.6976101\",\n \"0.69747275\",\n \"0.695906\",\n \"0.6944757\",\n \"0.69443876\",\n \"0.6941434\",\n \"0.69339997\",\n \"0.69278216\",\n \"0.6924908\",\n \"0.6917136\",\n \"0.691316\",\n \"0.6908974\",\n \"0.6903402\",\n \"0.6894987\",\n \"0.68923765\",\n \"0.6886722\",\n \"0.6878631\",\n \"0.6870336\",\n \"0.68470937\",\n \"0.68447274\",\n \"0.6842939\",\n \"0.68408334\",\n \"0.6840231\",\n \"0.68296224\",\n \"0.68287593\",\n \"0.68269473\",\n \"0.6823845\",\n \"0.68073136\",\n \"0.6806805\",\n \"0.68049407\",\n \"0.6797839\",\n \"0.6797839\",\n \"0.6796853\",\n \"0.67956036\",\n \"0.67931885\",\n \"0.679113\",\n \"0.6784908\",\n \"0.6784704\",\n \"0.67844296\",\n \"0.6783589\",\n \"0.67728573\",\n \"0.6772496\",\n \"0.67714155\",\n \"0.6767632\",\n \"0.675321\",\n \"0.675311\",\n \"0.6749905\",\n \"0.67493784\",\n \"0.6744074\",\n \"0.6741154\",\n \"0.6737048\",\n \"0.6733501\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6885,"cells":{"query":{"kind":"string","value":"Check if mobile user login"},"document":{"kind":"string","value":"def require_mobile_user(func):\n\n @wraps(func)\n def decorator(*args, **kwargs):\n if not g.user:\n return redirect(url_for('wechat.signin'))\n return func(*args, **kwargs)\n\n return decorator"},"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_mobile(request):\n MOBILE_AGENT_RE=re.compile(r\".*(iphone|mobile|androidtouch)\",re.IGNORECASE)\n\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\n return True\n else:\n return False","def mobile(request):\n MOBILE_AGENT_RE = re.compile(\n r\".*(iphone|mobile|androidtouch)\", re.IGNORECASE)\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\n return True\n else:\n return False","def _login(self):\n if User.login(self.session.teller_id, self.session.teller_pin, 'teller'):\n return True\n else:\n self.session.output({'authentication_failure': 'wrong ID or PIN\\n'}, '[ Login failed ]')\n return False","def is_mobile(request_object):\n \n return utilities.is_mobile(request_object)","def checkLogin():\n if 'access_token' in login_session:\n return True\n else:\n return False","def omm_login():\r\n msg, status = \"\", True\r\n try:\r\n if g.platform == 'android':\r\n sleep(5)\r\n 'Enters value in password text box based on the user inputs'\r\n flag1 = ui_controls.text_box(get_obj_identifier('login_enterPassword_txt'), value=g.password)\r\n sleep(3)\r\n 'Clicks on the login button'\r\n flag2 = ui_controls.button(get_obj_identifier('login_createPasswordLogin_btn'))\r\n \r\n status = False if not (flag1 and flag2) else True\r\n else: \r\n 'Enters value in password text box based on the user inputs'\r\n flag1 = ui_controls.setValue(get_obj_identifier('login_enterPassword_txt'), value=g.password)\r\n\r\n 'Clicks on the login button'\r\n flag2 = ui_controls.button(get_obj_identifier('login_btn'))\r\n \r\n status = False if not (flag1 and flag2) else True\r\n \r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def check_user_and_login(self) -> Response:\n pass","def set_mobile_session(id_token):\n try:\n user = google.oauth2.id_token.verify_oauth2_token(id_token, requests.Request())\n return True, user['name'].replace(' ', '_')\n except ValueError:\n raise exceptions.TokenExpired()","def logged_in(browser: RoboBrowser):\n login_div = browser.find('div', content=\"Login\")\n return True if not login_div else False","def is_correct_user(self, login, password):\n pass","def login():\r\n if not request.is_json or 'phone_number' not in request.get_json() or 'password' not in request.get_json():\r\n return bad_request('Missing required data.')\r\n return login_user(request)","def phone_mobile(self, instance):\r\n return instance.user.profile.phone_mobile","def is_integrated(user):\n if user.is_authenticated() and user.is_active:\n return NokiaUser.objects.filter(user=user).exists()\n return False","def login_mobile(request):\n\n email = request.POST['email'].lower()\n pin = hashlib.sha224(request.POST['pin']).hexdigest()\n user = authenticate(username=email, pin=pin)\n if user is not None:\n login(request, user)\n logger.debug( \"User %s authenticated and logged in\"%email )\n exp_group = user.experiment.id\n # log latitude and longitude\n if 'lat' in request.POST:\n event = Event(user=user, action=Event.LOGIN, latitude=float(request.POST['lat']), longitude=float(request.POST['lon']))\n event.save()\n return JSONHttpResponse({'result': '1', 'experiment': str(exp_group), 'first_name': str(user.first_name)}) \n else:\n return JSONHttpResponse({'result': '-1'})\n\n\n # TODO: if basic login, send to Home\n # if group purchase alert, send to that specific group purchase info\n # if price down alert, send to the item \n return JSONHttpResponse()","def check_auth():","def otp_is_verified(request):\n auth = JSONWebTokenAuthentication()\n jwt_value = auth.get_jwt_value(request)\n if jwt_value is None:\n return False\n\n payload = jwt_decode_handler(jwt_value)\n persistent_id = payload.get('otp_device_id')\n\n if persistent_id:\n device = Device.from_persistent_id(persistent_id)\n if device is not None and device.user_id != request.user.id:\n return False\n # Valid device in JWT\n return True\n return False","def detect_login(soup):\n \n main = soup.find(id='main')\n notice = main.find(class_='notice')\n for c in notice.children:\n if c.name == 'div':\n if c.has_attr('class') and 'formulaire_login' in c['class']:\n return True\n \n return False","def log_in(self):\n print('-=' * 12 + \" Log in \" + '-=' * 12)\n mob_num, password = self._input_mob_num('Mobile Number :'), input(\"Password: \")\n self._user = self.auth.log_in(mob_num, password)\n if self._user:\n print(\"you are logged in, Welcome '{}'\".format(self._user.username))\n self.homepage()\n else:\n print(\"Mobile number or/and password is/are Invaild \\n\" + '-=' * 30)\n options = {1: self.log_in, 2: self.logging_page, 3: self.exit}\n print_out = \"(1) Try Again \\n (2) Back to Logging Page \\n (3) Exit\"\n self._take_option(options, print_out)","def login(request):\n data = {}\n if request.method == \"POST\":\n form = LoginForm(request.POST)\n if form.is_valid():\n mob_no = form.cleaned_data.get('mob_no')\n password = form.cleaned_data.get('password')\n u_obj = Login.objects.filter(mobile_number=mob_no,\n password=password)\n if u_obj:\n data['success']=1\n data['message']='login successful'\n return JsonResponse(data)\n else:\n data['success']=0\n data['message']='login error'\n return JsonResponse(data)\n else:\n form = LoginForm()\n return render(request, 'login/login.html',\n {'form':form,})","def check_mobile(data):\n\n firebase_uid = data['session'].split('/')[-1]\n db = firebase.database()\n follow_up_event = \"continue_house\"\n mobile = db.child(\"user_data\").child(firebase_uid).child(\"Mobile Number\").get().val()\n try:\n origin = data[\"queryResult\"][\"fulfillmentMessages\"][1][\"payload\"][\"origin\"]\n if origin == \"confirmedCall\":\n follow_up_event = \"continue_call\"\n except:\n pass\n if mobile == \"0\" or mobile is None:\n print(\"Mobile number not found.\")\n response = {\n \"followupEventInput\": {\n \"name\": \"request_mobile\",\n \"languageCode\": \"en-US\"\n }}\n else:\n print(\"Mobile number found: \" + mobile)\n response = {\n \"followupEventInput\": {\n \"name\": follow_up_event,\n \"languageCode\": \"en-US\"\n }\n }\n return response","def login_to_system(credentials):\n return True if credentials else False","def loginState(self, user_data):\n\t\tif self.db.request(\"getOne\", user_data):\n\t\t\treturn True;\n\t\telse:\n\t\t\treturn False;","def user_in_session():\n return 'user_id' in login_session","def verifyLogin():\n global HUB\n\n loginInfo = FloatingTools.userData()['Login']\n if loginInfo['username'] is None or loginInfo['password'] is None:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False\n try:\n HUB = Github(loginInfo['username'], loginInfo['password'])\n for repo in HUB.get_user().get_repos():\n break\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\n return True\n except BadCredentialsException:\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\n return False","def _logged_in_successful(data):\r\n if re.match(r'^:(testserver\\.local|tmi\\.twitch\\.tv)'\r\n r' NOTICE \\* :'\r\n r'(Login unsuccessful|Error logging in)*$',\r\n data.strip()):\r\n return False\r\n else:\r\n return True","def login_user():\n pass","def check_user(self):\n try:\n if self.get_customer()[0][0] == self.dni:\n return True\n else:\n return False\n except:\n return False","def check_login(self):\n # read token first\n user_data = self.storage.get_user_data(self.user_id)\n if not \"token\" in user_data:\n sys.exit(\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\")\n\n # check token\n token = user_data[\"token\"]\n url = self.host_address + \"/assist/authentication\"\n payload = {\n 'action' : \"check\",\n 'client' : self.client_info,\n 'KEY' : (self.user_id + \";\" + token)\n }\n headers = {\n 'Content-Type': \"application/json\"\n }\n response = requests.request(\"POST\", url, json=payload, headers=headers)\n try:\n res = json.loads(response.text)\n except NameError:\n res = None\n\n if res[\"result\"] and res[\"result\"] == \"success\":\n name = res[\"user_name\"][\"nick\"] or res[\"user_name\"][\"first\"]\n print(\"SEPIA account: Success - Wb \" + name + \", your login token is still valid.\")\n else:\n print(\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\")","def _check_user_pass(self):\n if not self.username:\n self.username = input(' 请输入手机号：')\n if self.username.isdigit() and '+86' not in self.username:\n self.username = '+86' + self.username\n\n if not self.password:\n self.password = input(' 请输入密码：')","def user_login():\n \n data = user_obj.user_login()\n return data","async def check_authenticated(self):\n\n def function():\n return self._api.request(\"user\", \"getdevice\", version=\"v2\")\n\n return await self.call(function)","def is_logged_in(self, email):\n wait_for_element(self.browser, self.expand_left_panel)\n expand_panel = self.browser.find_element(*self.expand_left_panel)\n custom_click(self.browser, expand_panel)\n wait_for(lambda: len(self.browser.find_element(*self.logged_user).text) > 0, delay=1, num_sec=5)\n user_logged_in = self.browser.find_element(*self.logged_user).text\n if user_logged_in == email:\n return True\n else:\n raise Exception('Failed to login by user => {}'.format(email))","def user_auth(request):\n if request.user.is_authenticated:\n user = User.objects.get(email=request.user.email)\n if UserInformation.objects.filter(user=user).exists():\n return True\n return False","def i_am_in_the_login_page(browser):","def logged_in(self):\n return self.auth.get_user_by_session() is not None","def logged():\n if session.login==1:\n return True\n else:\n return False","def is_logged_in(self, params):\n email = self.credentials.get('email', '')\n password = self.credentials.get('password', '')\n if email != '' and password != '':\n return False\n return self.netflix_session.is_logged_in(account=self.credentials)","def username(provider, username):\n\n if provider == 'alditalk':\n if username.isdigit(): # only mobile number\n return True\n else:\n return False\n elif provider == 'netzclub': # mobile number and email\n if ((username.isdigit()) or (\"@\" in username)):\n return True\n else:\n return False\n elif provider == 'congstar':\n return True","def is_logged_in() -> bool:\n is_dev_login_disabled = SETTINGS.DEV_LOGIN_DISABLED and is_localhost()\n return bool(is_dev_login_disabled or is_logged_in_user())","def login():","def login():","def login_check(self, username, password):\n can_login, msg = self.db.check_login(username, password)\n self.send_message(str(can_login) + DOLLAR + msg)","def save_login(mobile):\n mobile = Mobile(mobile)\n ktt = KTT(mobile)\n ktt.gen_device_code()\n ktt.get_api_start()\n time.sleep(4)\n ktt.post_login()\n time.sleep(4)\n ktt.get_user_info()\n user_info = (\n ktt.user_info[\"uid\"], ktt.user_info[\"name\"], ktt.user_info[\"mobile\"],\n ktt.user_info[\"father\"], ktt.user_info[\"balance\"], ktt.user_info[\"coin\"],\n ktt.device_code, ktt.token, ktt.mobile.os, ktt.mobile.brand, ktt.mobile.mac,\n ktt.mobile.android_id\n )\n print(user_info)\n\n # save one user info record and one user flag\n uis.save([user_info])\n read_flag = [(user_info[0],)]\n uis.save_flag(read_flag)","def is_logged_in():\n return 'user' in session","def login_web_required(view_func):\r\n @wraps(view_func, assigned=available_attrs(view_func))\r\n def _wrapped_view_func(request, *args, **kwargs):\r\n if hasattr(request, \"session\") and request.session.get('is_logon', False) and request.user.is_active:\r\n return view_func(request, *args, **kwargs)\r\n else:\r\n return HttpResponse(FailResponse(u'请先登录'))\r\n return _wrapped_view_func","def is_logged_in(self):\n return self.router.token is not None","def login_auto(token: Token, mac_address: str) -> bool:\n device = Device.get_by_mac(mac_address)\n fail_msg = \"\"\n if device is None:\n fail_msg = \"No device with mac address exist\"\n elif Token.is_token_expired(device.token_expires):\n fail_msg = \"Token is expired\"\n elif token != device.token:\n fail_msg = \"Wrong token\"\n if fail_msg:\n client_logger_security().info(f\"Failed to login automatically: {fail_msg}\")\n return False\n else:\n _set_user_authenticated(device.user_id, device.device_id)\n client_logger_security().info(f\"Successfully logged in automatically: device_id={device.device_id}, \"\n f\"user_id={device.user_id}\")\n return True","def check_user(cls, user):\n if user.mobile_phone and cls.contains_number(user.mobile_phone):\n return True\n\n if user.add_mobile_phone and cls.contains_number(user.add_mobile_phone):\n return True\n\n if user.landline_phone and cls.contains_number(user.landline_phone):\n return True\n\n if user.add_landline_phone and cls.contains_number(user.add_landline_phone):\n return True\n\n return False","def if_user_isback_update_login_session(connection,user):\r\n with connection:\r\n return connection.execute(UPDATE_USER_LOGIN_STATUS_TO_TRUE, (user,))","def check_user_logged():\n global user\n if 'user' not in session:\n return False\n else:\n user = session.get('user')\n return user['username'] != ''","def login(self):\n url = self._root + self._routes[\"login\"]\n self.r = self.reqsession.get(url) \n if self.r.url == 'https://console.zerodha.com/dashboard':\n cookies = self.reqsession.cookies.get_dict('console.zerodha.com')\n self.console_session = cookies['session']\n self.public_token = self.reqsession.cookies['public_token']\n return True\n else:\n raise Exception(\"Login failed or Kite session expired\")","def _can_login(self):\n return all([self.user.is_active, self.status, self.status_detail == \"active\"])","def test_user_login_attempt_when_user_already_logged_in(self):\n\t\tpass","def validate(self, data):\n user_type = 3\n return validate_login_user(self, data, user_type)","def is_logged_in(session):\n if 'tid' in session:\n return {'success': 1, 'message': '你处于登录状态.', \n 'teamname': session['teamname'], 'is_zju_user': session['is_zju_user']}\n else:\n return {\"success\": 0, \"message\": \"你并未处于登录状态.\"}","def mobile(self) -> Optional[str]:\n return pulumi.get(self, \"mobile\")","def login():\n data = request.get_json()\n email = data.get('email')\n password = data.get('pwrd')\n user = SQLModel.get_by_attrs(('email', 'pwrd'), 'users', 'email', email)\n try:\n user_pw = user[0][1]\n user_nick = user[0][0]\n if password == user_pw:\n stuff = SQLModel.get_by_attrs(('login', 'pwrdHash', 'type', 'name'), 'users', 'login', login)\n return jsonify(stuff)\n else:\n return 'fail'\n except:\n return 'fail'","def login(uname, password, db, session):\n\tquery = db((db.User.username == uname) & (db.User.password == password))\n\tif query.count() == 1:\n\t\tsession.auth = query.select().first().id\n\t\treturn True\n\telse:\n\t\treturn False","def validate_mobile(self, mobile):\n self.mobile = mobile.strip()\n example = \"mobile number (ex. +2346787646)\"\n if re.match(r'(^[+0-9]{1,3})*([0-9]{10,11}$)',\n self.mobile) is None:\n raise GraphQLError(\n ERROR_RESPONSES[\"invalid_field_error\"].format(example))\n return self.mobile","def login(self, returnToURL):\r\n\t\tif not self.request().hasValue('userId') or \\\r\n\t\t\tnot self.request().hasValue('password'):\r\n\t\t\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\r\n\t\t\treturn 0\r\n\t\treturn 1","def login(self, email, password):\n url = \"https://mbasic.facebook.com\"\n self.get(url)\n email_element = self.find_element_by_name(\"email\")\n email_element.send_keys(email)\n pass_element = self.find_element_by_name(\"pass\")\n pass_element.send_keys(password)\n pass_element.send_keys(Keys.ENTER)\n if self.find_element_by_class_name(\"bi\"):\n self.find_element_by_class_name(\"bp\").click();\n try:\n self.find_element_by_name(\"xc_message\")\n log.debug(\"Logged in\")\n return True\n except NoSuchElementException as e:\n log.error(\"Failed to login\")\n return False","def check_login(self, resp: ResponseContextManager) -> None:\n is_login_page = '__appianCsrfToken' in resp.cookies\n if resp.ok and is_login_page:\n self.login()\n elif not resp.ok:\n # Check login page actually returns a csrf token\n login_page_resp = self.get_page('/suite/', label=\"Login.LoadUi\", check_login=False)\n if login_page_resp.ok and '__appianCsrfToken' in login_page_resp.cookies:\n self.login()","def login_core(self, usuario_model) -> bool:\n usuario_json = eval(json.dumps(usuario_model.__dict__))\n result = self.database.select_db(name_object=\"Usuario\", filter_data=usuario_json)\n if isinstance(result, object) and result is not None:\n Constant.USUARIO = self.encrypt.decrypt(eval(result[\"usuario\"]))\n return True\n return False","def _check(self):\n if self.browser is None:\n self._init_browser()\n\n print(\"Checking if the browser can make login\")\n\n # Test 1: Should sign in using the form, signed should be True\n signed = self._sign_in()\n print(\"Finished, [signed = {}]\".format(signed))\n\n return signed","def is_logged(html):\n soup = BeautifulSoup(html, \"html.parser\")\n\n if soup.find('div', {'id': 'user_information'}) is None:\n return False\n return True","def check():\n req = requests.post('https://net.tsinghua.edu.cn/do_login.php',\n {'action': 'check_online'})\n print(req.text)\n if req.text != 'not_online':\n req = requests.post('https://net.tsinghua.edu.cn/rad_user_info.php')\n info = req.text.split(',')\n traffic = int(info[6]) / 1000000000\n timelen = int(info[2]) - int(info[1])\n timelen_str = '{}:{}:{}'.format(\n timelen // 3600,\n timelen // 60 % 60,\n timelen % 60)\n info_s = 'ip={0[8]},user={0[0]},traffic={1:.2f}GB,timelen={2}'\n info_s = info_s.format(info, traffic, timelen_str)\n print(info_s)","def check_sc_login(text, exit_on_fail=True):\n if re.search(r'Login Required', text, re.I):\n print(\"!! Authentication Failed. Please login to System Center via your browser (%s), then try again.\" % (get_active_browser()))\n if exit_on_fail:\n sys.exit(220)\n else:\n return False\n else:\n return True","def login(self, user_data):\n\n\t\tuser_data[\"password\"] = makeHash(user_data[\"password\"]);\n\n\t\tif self.db.request(\"getOne\", user_data):\n\t\t\treturn True;\n\t\telse:\n\t\t\treturn False;","def login_check():\n\n user_email = request.form['email']\n user_password = request.form['password']\n\n # Check user info against database\n email_query = User.query.filter_by(email=user_email).first()\n if email_query == None:\n flash('Invalid email or password')\n return redirect('/')\n\n # Get user's id using email\n user_id = email_query.user_id\n\n # Valid user password\n if user_password == email_query.password:\n #create user session\n session['user'] = email_query.user_id\n return redirect('/user-%s' % user_id)\n else:\n flash('Invalid email or password')\n return redirect('/')","def logged_in(self, use_page=None):\n # allow page soup to be passed as argument to make get_soup calling this function faster\n if use_page is None: soup = self.get_soup(\"overview\")\n else: soup = use_page\n\n found = soup.find(\"meta\", {\"name\": \"ogame-player-name\"})\n if found is None: return False\n if str(found[\"content\"]) == self.username: return True","def authenticate_user(data):\n \n try:\n auth_token = data[\"auth_token\"]\n user_token = Token.objects.get(username=data[\"username\"])\n if user_token.token == auth_token:\n return True\n except:\n return False\n return False","def default_login_works(self):\n return True if self.default_login_auth_header else False","def login_user(username,password):\n \n check_user = Records.verify_user(username,password)\n return check_user","def validate_login(self, username, password):\n user = User(self).get(username)\n return user and user['Password'] == password","def check_login(db, useremail, password):\n import hashlib\n\n cursor = db.cursor().execute('SELECT password FROM users WHERE email IS ?', [useremail])\n result = cursor.fetchone()\n if result:\n return result[0] == hashlib.sha1(password.encode()).hexdigest()\n return False","def usercheck(userip):\n if userip in session:\n return userstate.check(session[userip])\n else:\n return False","def earthdata_login(uid=None, pwd=None, email=None, s3token=False) -> bool:\n\n try:\n url = \"urs.earthdata.nasa.gov\"\n mock_uid, _, mock_pwd = netrc.netrc(netrc).authenticators(url)\n except:\n\n mock_uid = os.environ.get(\"EARTHDATA_USERNAME\")\n mock_pwd = os.environ.get(\"EARTHDATA_PASSWORD\")\n\n if (uid == mock_uid) & (pwd == mock_pwd):\n return True\n else:\n return False","def check_login(self, u, p):\r\n\t\tlogger.debug(\"Entering\")\r\n\t\t\r\n\t\ttry:\r\n\t\t\tval = login.validate_user(u, p)\r\n\t\texcept ValueError as e:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, e.message\r\n\t\t\r\n\t\tif val:\r\n\t\t\tlogger.debug(\"Exiting - success\")\r\n\t\t\treturn True, \"Login successful!\"\r\n\t\telse:\r\n\t\t\tlogger.debug(\"Exiting - failure\")\r\n\t\t\treturn False, \"Login failed.\"","def details_not_matching():\n print(\"login details don't match.\")","def login_user(self, input_email, input_password):\n logging_user_details = self.check_email_for_login(input_email)\n if BCRYPT.check_password_hash(logging_user_details['password'],\n input_password):\n # compare password input to saved password\n return logging_user_details\n return False","def connectPhone(self):\n value = os.popen(self.checkPhone)\n\n for data in value.readline():\n sDate = str(data)\n if sDate.find(\"device\"):\n return True\n return False","def valid_login(username: str, password: str):\n\n try:\n LoginHandler.login(username, password)\n global validLogin\n validLogin = True\n except:\n validLogin = False","def login(self) -> int:\n r = self.session.post(\n self.api_endpoint,\n data={\n \"action\": \"login\",\n \"lgname\": self.user,\n \"lgpassword\": self.password,\n \"format\": \"json\",\n },\n )\n token = json.loads(r.text)[\"login\"][\"token\"]\n r = self.session.post(\n self.api_endpoint,\n data={\n \"action\": \"login\",\n \"lgname\": self.user,\n \"lgpassword\": self.password,\n \"lgtoken\": token,\n \"format\": \"json\",\n },\n )\n if json.loads(r.text)[\"login\"][\"result\"] != \"Success\":\n return -1\n return 0","def CheckLogin(self) :\n url = Judge.UrlStatus + 'contestId=1&search=true&firstId=-1&lastId=-1&handle=' + self.username\n logging.info(\"open_url %s\" % url)\n req = urllib2.Request(url, headers=Judge.Headers)\n rsp = self.opener.open(req)\n res = None\n if rsp :\n res = rsp.read()\n #wf(\"CheckLogin_\", res)\n result = self.__parse_result(None, res, need_extra_info=False)\n if result and result.has_key('origin_runid') :\n #print \"CheckLogin last_submit_time{%s}END\" % result['_submit_time']\n self.last_runid = result['origin_runid']\n return res and res.find(r'<a href=\"/onlinejudge/login.do\">Login</a>') == -1","def checkSession(self):\r\n\r\n app_settings = QSettings(conf_parser.get(\"APP\", \"name\"))\r\n end_date_time = app_settings.value(\"EndDateTime\", type=QDateTime)\r\n cur_date_time = QDateTime.currentDateTime()\r\n if(cur_date_time.secsTo(end_date_time) > 0):\r\n # get values from app_settings\r\n gl_content.auth_email = app_settings.value(\"Email\")\r\n gl_content.auth_user_company = app_settings.value(\"UserCompany\")\r\n gl_content.auth_first_name = app_settings.value(\"FirstName\")\r\n gl_content.auth_last_name = app_settings.value(\"LastName\")\r\n gl_content.auth_user_sys_id = app_settings.value(\"UserSysId\")\r\n gl_content.auth_password = app_settings.value(\"Password\")\r\n \r\n # decrypt password\r\n bytes_password = bytes(gl_content.auth_password)\r\n gl_content.auth_password = crypt.decrypt(bytes_password)\r\n\r\n # make login request\r\n # get mac address\r\n mac_addr = uuid.getnode()\r\n if(not mac_addr):\r\n self.accept()\r\n return\r\n \r\n # configure data\r\n data = QtCore.QByteArray()\r\n data.append(\"username={}&\".format(gl_content.auth_email))\r\n data.append(\"appVersion={}&\".format(conf_parser.get(\"APP\", \"version\")))\r\n data.append(\"appID={}&\".format(conf_parser.get(\"APP\", \"id\")))\r\n data.append(\"machineID={}&\".format(mac_addr))\r\n data.append(\"password={}\".format(gl_content.auth_password))\r\n \r\n # send request\r\n request = QtNetwork.QNetworkRequest(QtCore.QUrl(conf_parser.get(\"URLs\", \"auth\")))\r\n request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,'application/x-www-form-urlencoded')\r\n self.networkAccessManager.post(request, data)\r\n \r\n # start timer\r\n self.lb_msg.setText(\"Logging in to the server ...\")\r\n self.login_timer.start(200)\r\n self.pros = 0\r\n else:\r\n self.accept()","def check_login_result(self, result):\n success_flag = \"成功登陆\"\n m = re.search(success_flag, result)\n if m is not None:\n print \"Login successfully!\"\n # Store the auth cooie into file\n self.mycookie.store_cookie()\n \n # Get the column\n option_flag = '<option\\svalue=\"(.*)\">(.*)</option>'\n return self.get_post_data(self.article_add_url, self.login_send_header, option_flag)\n else:\n print \"Login failed!\"\n return False","def on_login(self, username):","def on_login(self, username):","def verify_password_student(mobile_or_token, password):\n\n # try with token\n student = Student.verify_auth_token(mobile_or_token)\n\n # if auth failed\n if not student:\n\n # try with mobile/password\n student = Student.query.filter_by(MOBILE=mobile_or_token).first()\n\n # if mobile not in db or in db but password doesn't match\n if not student or not student.verify_password(password):\n return False\n\n # set current user if succeeded and return success\n g.user = student\n return True","def is_registered(self):\n if self.user == getpass.getuser():\n return True\n else:\n return False","def logged_in():\n\n if current_user.is_authenticated:\n return True\n\n return False","def login(self, device_name):\n try:\n device = next((item for item in self.host_dict if item.get('hostname') == device_name))\n except StopIteration:\n self.err_str = f\"Exception occurred. Please check hostname \\\"{device_name}\\\". Skipping back up\"\n backup_logger.exception(self.err_str)\n return\n backup_logger.info(f\"Logging into {device['host']}\")\n hostname = device.pop(\"hostname\")\n logged_in = False\n try:\n self.session = ConnectHandler(**device)\n if 'secret' in device:\n self.session.enable()\n self.current_device = device_name\n self.connected_devices.append(device)\n logged_in = True\n except (AuthenticationException, SSHException) as e:\n self.err_str = f\"Exception '{e}' occurred. \" \\\n f\"SSH is unsuccessful for device {hostname}. Skipping back up\"\n backup_logger.exception(self.err_str)\n # sys.exit()\n\n return logged_in\n # self.session = ConnectHandler(**device)","def ismobile(number):\n if number[0] in ['7', '8', '9']:\n return True\n return False","def do_login_login():\n print(inspect.stack()[1][3])\n print(request.form)\n query = select([User]).where(and_(User.columns.email == request.form['email'],User.columns.password==request.form['password'] ))\n ResultProxy = connection.execute(query)\n ResultSet = ResultProxy.fetchone()\n if ResultSet:\n session['logged_in'] = True\n else:\n flash('wrong password!')\n # return str(get_flashed_messages())\n return home(result)","def check_user(used_name, used_password):\n user_exists = UserData.user_login(used_name, used_password)\n\n return user_exists","def isLoggedIn(self):\n session = self.getSession()\n if session is not None:\n return True\n return False","def the_browser_is_open_the_freenas_url_and_logged_in(driver, nas_ip, root_password):\n if nas_ip not in driver.current_url:\n driver.get(f\"http://{nas_ip}\")\n assert wait_on_element(driver, 10, '//input[@data-placeholder=\"Username\"]')\n if not is_element_present(driver, '//mat-list-item[@ix-auto=\"option__Dashboard\"]'):\n assert wait_on_element(driver, 10, '//input[@data-placeholder=\"Username\"]')\n driver.find_element_by_xpath('//input[@data-placeholder=\"Username\"]').clear()\n driver.find_element_by_xpath('//input[@data-placeholder=\"Username\"]').send_keys('root')\n driver.find_element_by_xpath('//input[@data-placeholder=\"Password\"]').clear()\n driver.find_element_by_xpath('//input[@data-placeholder=\"Password\"]').send_keys(root_password)\n assert wait_on_element(driver, 5, '//button[@name=\"signin_button\"]')\n driver.find_element_by_xpath('//button[@name=\"signin_button\"]').click()\n else:\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Dashboard\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Dashboard\"]').click()","def is_valid_login(self, username, password):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)","def login(self,username,password):\n try:\n userNameField = self.driver.findElement(element = self.locators.lblUsernameField, elementType = \"id\", timeout = \"4\")\n if not userNameField:\n return False\n\n userNameField.click()\n userNameField.send_keys(username)\n time.sleep(self.waitShort)\n passwordField = self.driver.findElement(element = self.locators.lblPasswordField, elementType = \"id\", timeout = \"4\")\n if not passwordField:\n return False\n\n passwordField.click()\n passwordField.send_keys(password)\n time.sleep(self.waitShort)\n\n signIn = self.driver.findElement(element = self.locators.signIn, elementType = \"id\", timeout = \"4\")\n if not signIn:\n return False\n\n signIn.click()\n time.sleep(self.waitLong)\n #handler for No Thanks pop-up\n noThanks = self.driver.findElement(element = self.locators.btnNoThanks, elementType = \"id\", timeout = \"4\")\n if noThanks:\n noThanks.click()\n return True\n except Exception as exp:\n print \"Error in login(): {}\".format(exp)\n return False\n return True","def is_logged_in(session):\n return 'user' in session"],"string":"[\n \"def check_mobile(request):\\n MOBILE_AGENT_RE=re.compile(r\\\".*(iphone|mobile|androidtouch)\\\",re.IGNORECASE)\\n\\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\\n return True\\n else:\\n return False\",\n \"def mobile(request):\\n MOBILE_AGENT_RE = re.compile(\\n r\\\".*(iphone|mobile|androidtouch)\\\", re.IGNORECASE)\\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\\n return True\\n else:\\n return False\",\n \"def _login(self):\\n if User.login(self.session.teller_id, self.session.teller_pin, 'teller'):\\n return True\\n else:\\n self.session.output({'authentication_failure': 'wrong ID or PIN\\\\n'}, '[ Login failed ]')\\n return False\",\n \"def is_mobile(request_object):\\n \\n return utilities.is_mobile(request_object)\",\n \"def checkLogin():\\n if 'access_token' in login_session:\\n return True\\n else:\\n return False\",\n \"def omm_login():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n if g.platform == 'android':\\r\\n sleep(5)\\r\\n 'Enters value in password text box based on the user inputs'\\r\\n flag1 = ui_controls.text_box(get_obj_identifier('login_enterPassword_txt'), value=g.password)\\r\\n sleep(3)\\r\\n 'Clicks on the login button'\\r\\n flag2 = ui_controls.button(get_obj_identifier('login_createPasswordLogin_btn'))\\r\\n \\r\\n status = False if not (flag1 and flag2) else True\\r\\n else: \\r\\n 'Enters value in password text box based on the user inputs'\\r\\n flag1 = ui_controls.setValue(get_obj_identifier('login_enterPassword_txt'), value=g.password)\\r\\n\\r\\n 'Clicks on the login button'\\r\\n flag2 = ui_controls.button(get_obj_identifier('login_btn'))\\r\\n \\r\\n status = False if not (flag1 and flag2) else True\\r\\n \\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def check_user_and_login(self) -> Response:\\n pass\",\n \"def set_mobile_session(id_token):\\n try:\\n user = google.oauth2.id_token.verify_oauth2_token(id_token, requests.Request())\\n return True, user['name'].replace(' ', '_')\\n except ValueError:\\n raise exceptions.TokenExpired()\",\n \"def logged_in(browser: RoboBrowser):\\n login_div = browser.find('div', content=\\\"Login\\\")\\n return True if not login_div else False\",\n \"def is_correct_user(self, login, password):\\n pass\",\n \"def login():\\r\\n if not request.is_json or 'phone_number' not in request.get_json() or 'password' not in request.get_json():\\r\\n return bad_request('Missing required data.')\\r\\n return login_user(request)\",\n \"def phone_mobile(self, instance):\\r\\n return instance.user.profile.phone_mobile\",\n \"def is_integrated(user):\\n if user.is_authenticated() and user.is_active:\\n return NokiaUser.objects.filter(user=user).exists()\\n return False\",\n \"def login_mobile(request):\\n\\n email = request.POST['email'].lower()\\n pin = hashlib.sha224(request.POST['pin']).hexdigest()\\n user = authenticate(username=email, pin=pin)\\n if user is not None:\\n login(request, user)\\n logger.debug( \\\"User %s authenticated and logged in\\\"%email )\\n exp_group = user.experiment.id\\n # log latitude and longitude\\n if 'lat' in request.POST:\\n event = Event(user=user, action=Event.LOGIN, latitude=float(request.POST['lat']), longitude=float(request.POST['lon']))\\n event.save()\\n return JSONHttpResponse({'result': '1', 'experiment': str(exp_group), 'first_name': str(user.first_name)}) \\n else:\\n return JSONHttpResponse({'result': '-1'})\\n\\n\\n # TODO: if basic login, send to Home\\n # if group purchase alert, send to that specific group purchase info\\n # if price down alert, send to the item \\n return JSONHttpResponse()\",\n \"def check_auth():\",\n \"def otp_is_verified(request):\\n auth = JSONWebTokenAuthentication()\\n jwt_value = auth.get_jwt_value(request)\\n if jwt_value is None:\\n return False\\n\\n payload = jwt_decode_handler(jwt_value)\\n persistent_id = payload.get('otp_device_id')\\n\\n if persistent_id:\\n device = Device.from_persistent_id(persistent_id)\\n if device is not None and device.user_id != request.user.id:\\n return False\\n # Valid device in JWT\\n return True\\n return False\",\n \"def detect_login(soup):\\n \\n main = soup.find(id='main')\\n notice = main.find(class_='notice')\\n for c in notice.children:\\n if c.name == 'div':\\n if c.has_attr('class') and 'formulaire_login' in c['class']:\\n return True\\n \\n return False\",\n \"def log_in(self):\\n print('-=' * 12 + \\\" Log in \\\" + '-=' * 12)\\n mob_num, password = self._input_mob_num('Mobile Number :'), input(\\\"Password: \\\")\\n self._user = self.auth.log_in(mob_num, password)\\n if self._user:\\n print(\\\"you are logged in, Welcome '{}'\\\".format(self._user.username))\\n self.homepage()\\n else:\\n print(\\\"Mobile number or/and password is/are Invaild \\\\n\\\" + '-=' * 30)\\n options = {1: self.log_in, 2: self.logging_page, 3: self.exit}\\n print_out = \\\"(1) Try Again \\\\n (2) Back to Logging Page \\\\n (3) Exit\\\"\\n self._take_option(options, print_out)\",\n \"def login(request):\\n data = {}\\n if request.method == \\\"POST\\\":\\n form = LoginForm(request.POST)\\n if form.is_valid():\\n mob_no = form.cleaned_data.get('mob_no')\\n password = form.cleaned_data.get('password')\\n u_obj = Login.objects.filter(mobile_number=mob_no,\\n password=password)\\n if u_obj:\\n data['success']=1\\n data['message']='login successful'\\n return JsonResponse(data)\\n else:\\n data['success']=0\\n data['message']='login error'\\n return JsonResponse(data)\\n else:\\n form = LoginForm()\\n return render(request, 'login/login.html',\\n {'form':form,})\",\n \"def check_mobile(data):\\n\\n firebase_uid = data['session'].split('/')[-1]\\n db = firebase.database()\\n follow_up_event = \\\"continue_house\\\"\\n mobile = db.child(\\\"user_data\\\").child(firebase_uid).child(\\\"Mobile Number\\\").get().val()\\n try:\\n origin = data[\\\"queryResult\\\"][\\\"fulfillmentMessages\\\"][1][\\\"payload\\\"][\\\"origin\\\"]\\n if origin == \\\"confirmedCall\\\":\\n follow_up_event = \\\"continue_call\\\"\\n except:\\n pass\\n if mobile == \\\"0\\\" or mobile is None:\\n print(\\\"Mobile number not found.\\\")\\n response = {\\n \\\"followupEventInput\\\": {\\n \\\"name\\\": \\\"request_mobile\\\",\\n \\\"languageCode\\\": \\\"en-US\\\"\\n }}\\n else:\\n print(\\\"Mobile number found: \\\" + mobile)\\n response = {\\n \\\"followupEventInput\\\": {\\n \\\"name\\\": follow_up_event,\\n \\\"languageCode\\\": \\\"en-US\\\"\\n }\\n }\\n return response\",\n \"def login_to_system(credentials):\\n return True if credentials else False\",\n \"def loginState(self, user_data):\\n\\t\\tif self.db.request(\\\"getOne\\\", user_data):\\n\\t\\t\\treturn True;\\n\\t\\telse:\\n\\t\\t\\treturn False;\",\n \"def user_in_session():\\n return 'user_id' in login_session\",\n \"def verifyLogin():\\n global HUB\\n\\n loginInfo = FloatingTools.userData()['Login']\\n if loginInfo['username'] is None or loginInfo['password'] is None:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\\n try:\\n HUB = Github(loginInfo['username'], loginInfo['password'])\\n for repo in HUB.get_user().get_repos():\\n break\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', True)\\n return True\\n except BadCredentialsException:\\n FloatingTools.Dashboard.setDashboardVariable('logged_in', False)\\n return False\",\n \"def _logged_in_successful(data):\\r\\n if re.match(r'^:(testserver\\\\.local|tmi\\\\.twitch\\\\.tv)'\\r\\n r' NOTICE \\\\* :'\\r\\n r'(Login unsuccessful|Error logging in)*$',\\r\\n data.strip()):\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def login_user():\\n pass\",\n \"def check_user(self):\\n try:\\n if self.get_customer()[0][0] == self.dni:\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check_login(self):\\n # read token first\\n user_data = self.storage.get_user_data(self.user_id)\\n if not \\\"token\\\" in user_data:\\n sys.exit(\\\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\\\")\\n\\n # check token\\n token = user_data[\\\"token\\\"]\\n url = self.host_address + \\\"/assist/authentication\\\"\\n payload = {\\n 'action' : \\\"check\\\",\\n 'client' : self.client_info,\\n 'KEY' : (self.user_id + \\\";\\\" + token)\\n }\\n headers = {\\n 'Content-Type': \\\"application/json\\\"\\n }\\n response = requests.request(\\\"POST\\\", url, json=payload, headers=headers)\\n try:\\n res = json.loads(response.text)\\n except NameError:\\n res = None\\n\\n if res[\\\"result\\\"] and res[\\\"result\\\"] == \\\"success\\\":\\n name = res[\\\"user_name\\\"][\\\"nick\\\"] or res[\\\"user_name\\\"][\\\"first\\\"]\\n print(\\\"SEPIA account: Success - Wb \\\" + name + \\\", your login token is still valid.\\\")\\n else:\\n print(\\\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\\\")\",\n \"def _check_user_pass(self):\\n if not self.username:\\n self.username = input(' 请输入手机号：')\\n if self.username.isdigit() and '+86' not in self.username:\\n self.username = '+86' + self.username\\n\\n if not self.password:\\n self.password = input(' 请输入密码：')\",\n \"def user_login():\\n \\n data = user_obj.user_login()\\n return data\",\n \"async def check_authenticated(self):\\n\\n def function():\\n return self._api.request(\\\"user\\\", \\\"getdevice\\\", version=\\\"v2\\\")\\n\\n return await self.call(function)\",\n \"def is_logged_in(self, email):\\n wait_for_element(self.browser, self.expand_left_panel)\\n expand_panel = self.browser.find_element(*self.expand_left_panel)\\n custom_click(self.browser, expand_panel)\\n wait_for(lambda: len(self.browser.find_element(*self.logged_user).text) > 0, delay=1, num_sec=5)\\n user_logged_in = self.browser.find_element(*self.logged_user).text\\n if user_logged_in == email:\\n return True\\n else:\\n raise Exception('Failed to login by user => {}'.format(email))\",\n \"def user_auth(request):\\n if request.user.is_authenticated:\\n user = User.objects.get(email=request.user.email)\\n if UserInformation.objects.filter(user=user).exists():\\n return True\\n return False\",\n \"def i_am_in_the_login_page(browser):\",\n \"def logged_in(self):\\n return self.auth.get_user_by_session() is not None\",\n \"def logged():\\n if session.login==1:\\n return True\\n else:\\n return False\",\n \"def is_logged_in(self, params):\\n email = self.credentials.get('email', '')\\n password = self.credentials.get('password', '')\\n if email != '' and password != '':\\n return False\\n return self.netflix_session.is_logged_in(account=self.credentials)\",\n \"def username(provider, username):\\n\\n if provider == 'alditalk':\\n if username.isdigit(): # only mobile number\\n return True\\n else:\\n return False\\n elif provider == 'netzclub': # mobile number and email\\n if ((username.isdigit()) or (\\\"@\\\" in username)):\\n return True\\n else:\\n return False\\n elif provider == 'congstar':\\n return True\",\n \"def is_logged_in() -> bool:\\n is_dev_login_disabled = SETTINGS.DEV_LOGIN_DISABLED and is_localhost()\\n return bool(is_dev_login_disabled or is_logged_in_user())\",\n \"def login():\",\n \"def login():\",\n \"def login_check(self, username, password):\\n can_login, msg = self.db.check_login(username, password)\\n self.send_message(str(can_login) + DOLLAR + msg)\",\n \"def save_login(mobile):\\n mobile = Mobile(mobile)\\n ktt = KTT(mobile)\\n ktt.gen_device_code()\\n ktt.get_api_start()\\n time.sleep(4)\\n ktt.post_login()\\n time.sleep(4)\\n ktt.get_user_info()\\n user_info = (\\n ktt.user_info[\\\"uid\\\"], ktt.user_info[\\\"name\\\"], ktt.user_info[\\\"mobile\\\"],\\n ktt.user_info[\\\"father\\\"], ktt.user_info[\\\"balance\\\"], ktt.user_info[\\\"coin\\\"],\\n ktt.device_code, ktt.token, ktt.mobile.os, ktt.mobile.brand, ktt.mobile.mac,\\n ktt.mobile.android_id\\n )\\n print(user_info)\\n\\n # save one user info record and one user flag\\n uis.save([user_info])\\n read_flag = [(user_info[0],)]\\n uis.save_flag(read_flag)\",\n \"def is_logged_in():\\n return 'user' in session\",\n \"def login_web_required(view_func):\\r\\n @wraps(view_func, assigned=available_attrs(view_func))\\r\\n def _wrapped_view_func(request, *args, **kwargs):\\r\\n if hasattr(request, \\\"session\\\") and request.session.get('is_logon', False) and request.user.is_active:\\r\\n return view_func(request, *args, **kwargs)\\r\\n else:\\r\\n return HttpResponse(FailResponse(u'请先登录'))\\r\\n return _wrapped_view_func\",\n \"def is_logged_in(self):\\n return self.router.token is not None\",\n \"def login_auto(token: Token, mac_address: str) -> bool:\\n device = Device.get_by_mac(mac_address)\\n fail_msg = \\\"\\\"\\n if device is None:\\n fail_msg = \\\"No device with mac address exist\\\"\\n elif Token.is_token_expired(device.token_expires):\\n fail_msg = \\\"Token is expired\\\"\\n elif token != device.token:\\n fail_msg = \\\"Wrong token\\\"\\n if fail_msg:\\n client_logger_security().info(f\\\"Failed to login automatically: {fail_msg}\\\")\\n return False\\n else:\\n _set_user_authenticated(device.user_id, device.device_id)\\n client_logger_security().info(f\\\"Successfully logged in automatically: device_id={device.device_id}, \\\"\\n f\\\"user_id={device.user_id}\\\")\\n return True\",\n \"def check_user(cls, user):\\n if user.mobile_phone and cls.contains_number(user.mobile_phone):\\n return True\\n\\n if user.add_mobile_phone and cls.contains_number(user.add_mobile_phone):\\n return True\\n\\n if user.landline_phone and cls.contains_number(user.landline_phone):\\n return True\\n\\n if user.add_landline_phone and cls.contains_number(user.add_landline_phone):\\n return True\\n\\n return False\",\n \"def if_user_isback_update_login_session(connection,user):\\r\\n with connection:\\r\\n return connection.execute(UPDATE_USER_LOGIN_STATUS_TO_TRUE, (user,))\",\n \"def check_user_logged():\\n global user\\n if 'user' not in session:\\n return False\\n else:\\n user = session.get('user')\\n return user['username'] != ''\",\n \"def login(self):\\n url = self._root + self._routes[\\\"login\\\"]\\n self.r = self.reqsession.get(url) \\n if self.r.url == 'https://console.zerodha.com/dashboard':\\n cookies = self.reqsession.cookies.get_dict('console.zerodha.com')\\n self.console_session = cookies['session']\\n self.public_token = self.reqsession.cookies['public_token']\\n return True\\n else:\\n raise Exception(\\\"Login failed or Kite session expired\\\")\",\n \"def _can_login(self):\\n return all([self.user.is_active, self.status, self.status_detail == \\\"active\\\"])\",\n \"def test_user_login_attempt_when_user_already_logged_in(self):\\n\\t\\tpass\",\n \"def validate(self, data):\\n user_type = 3\\n return validate_login_user(self, data, user_type)\",\n \"def is_logged_in(session):\\n if 'tid' in session:\\n return {'success': 1, 'message': '你处于登录状态.', \\n 'teamname': session['teamname'], 'is_zju_user': session['is_zju_user']}\\n else:\\n return {\\\"success\\\": 0, \\\"message\\\": \\\"你并未处于登录状态.\\\"}\",\n \"def mobile(self) -> Optional[str]:\\n return pulumi.get(self, \\\"mobile\\\")\",\n \"def login():\\n data = request.get_json()\\n email = data.get('email')\\n password = data.get('pwrd')\\n user = SQLModel.get_by_attrs(('email', 'pwrd'), 'users', 'email', email)\\n try:\\n user_pw = user[0][1]\\n user_nick = user[0][0]\\n if password == user_pw:\\n stuff = SQLModel.get_by_attrs(('login', 'pwrdHash', 'type', 'name'), 'users', 'login', login)\\n return jsonify(stuff)\\n else:\\n return 'fail'\\n except:\\n return 'fail'\",\n \"def login(uname, password, db, session):\\n\\tquery = db((db.User.username == uname) & (db.User.password == password))\\n\\tif query.count() == 1:\\n\\t\\tsession.auth = query.select().first().id\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def validate_mobile(self, mobile):\\n self.mobile = mobile.strip()\\n example = \\\"mobile number (ex. +2346787646)\\\"\\n if re.match(r'(^[+0-9]{1,3})*([0-9]{10,11}$)',\\n self.mobile) is None:\\n raise GraphQLError(\\n ERROR_RESPONSES[\\\"invalid_field_error\\\"].format(example))\\n return self.mobile\",\n \"def login(self, returnToURL):\\r\\n\\t\\tif not self.request().hasValue('userId') or \\\\\\r\\n\\t\\t\\tnot self.request().hasValue('password'):\\r\\n\\t\\t\\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\\r\\n\\t\\t\\treturn 0\\r\\n\\t\\treturn 1\",\n \"def login(self, email, password):\\n url = \\\"https://mbasic.facebook.com\\\"\\n self.get(url)\\n email_element = self.find_element_by_name(\\\"email\\\")\\n email_element.send_keys(email)\\n pass_element = self.find_element_by_name(\\\"pass\\\")\\n pass_element.send_keys(password)\\n pass_element.send_keys(Keys.ENTER)\\n if self.find_element_by_class_name(\\\"bi\\\"):\\n self.find_element_by_class_name(\\\"bp\\\").click();\\n try:\\n self.find_element_by_name(\\\"xc_message\\\")\\n log.debug(\\\"Logged in\\\")\\n return True\\n except NoSuchElementException as e:\\n log.error(\\\"Failed to login\\\")\\n return False\",\n \"def check_login(self, resp: ResponseContextManager) -> None:\\n is_login_page = '__appianCsrfToken' in resp.cookies\\n if resp.ok and is_login_page:\\n self.login()\\n elif not resp.ok:\\n # Check login page actually returns a csrf token\\n login_page_resp = self.get_page('/suite/', label=\\\"Login.LoadUi\\\", check_login=False)\\n if login_page_resp.ok and '__appianCsrfToken' in login_page_resp.cookies:\\n self.login()\",\n \"def login_core(self, usuario_model) -> bool:\\n usuario_json = eval(json.dumps(usuario_model.__dict__))\\n result = self.database.select_db(name_object=\\\"Usuario\\\", filter_data=usuario_json)\\n if isinstance(result, object) and result is not None:\\n Constant.USUARIO = self.encrypt.decrypt(eval(result[\\\"usuario\\\"]))\\n return True\\n return False\",\n \"def _check(self):\\n if self.browser is None:\\n self._init_browser()\\n\\n print(\\\"Checking if the browser can make login\\\")\\n\\n # Test 1: Should sign in using the form, signed should be True\\n signed = self._sign_in()\\n print(\\\"Finished, [signed = {}]\\\".format(signed))\\n\\n return signed\",\n \"def is_logged(html):\\n soup = BeautifulSoup(html, \\\"html.parser\\\")\\n\\n if soup.find('div', {'id': 'user_information'}) is None:\\n return False\\n return True\",\n \"def check():\\n req = requests.post('https://net.tsinghua.edu.cn/do_login.php',\\n {'action': 'check_online'})\\n print(req.text)\\n if req.text != 'not_online':\\n req = requests.post('https://net.tsinghua.edu.cn/rad_user_info.php')\\n info = req.text.split(',')\\n traffic = int(info[6]) / 1000000000\\n timelen = int(info[2]) - int(info[1])\\n timelen_str = '{}:{}:{}'.format(\\n timelen // 3600,\\n timelen // 60 % 60,\\n timelen % 60)\\n info_s = 'ip={0[8]},user={0[0]},traffic={1:.2f}GB,timelen={2}'\\n info_s = info_s.format(info, traffic, timelen_str)\\n print(info_s)\",\n \"def check_sc_login(text, exit_on_fail=True):\\n if re.search(r'Login Required', text, re.I):\\n print(\\\"!! Authentication Failed. Please login to System Center via your browser (%s), then try again.\\\" % (get_active_browser()))\\n if exit_on_fail:\\n sys.exit(220)\\n else:\\n return False\\n else:\\n return True\",\n \"def login(self, user_data):\\n\\n\\t\\tuser_data[\\\"password\\\"] = makeHash(user_data[\\\"password\\\"]);\\n\\n\\t\\tif self.db.request(\\\"getOne\\\", user_data):\\n\\t\\t\\treturn True;\\n\\t\\telse:\\n\\t\\t\\treturn False;\",\n \"def login_check():\\n\\n user_email = request.form['email']\\n user_password = request.form['password']\\n\\n # Check user info against database\\n email_query = User.query.filter_by(email=user_email).first()\\n if email_query == None:\\n flash('Invalid email or password')\\n return redirect('/')\\n\\n # Get user's id using email\\n user_id = email_query.user_id\\n\\n # Valid user password\\n if user_password == email_query.password:\\n #create user session\\n session['user'] = email_query.user_id\\n return redirect('/user-%s' % user_id)\\n else:\\n flash('Invalid email or password')\\n return redirect('/')\",\n \"def logged_in(self, use_page=None):\\n # allow page soup to be passed as argument to make get_soup calling this function faster\\n if use_page is None: soup = self.get_soup(\\\"overview\\\")\\n else: soup = use_page\\n\\n found = soup.find(\\\"meta\\\", {\\\"name\\\": \\\"ogame-player-name\\\"})\\n if found is None: return False\\n if str(found[\\\"content\\\"]) == self.username: return True\",\n \"def authenticate_user(data):\\n \\n try:\\n auth_token = data[\\\"auth_token\\\"]\\n user_token = Token.objects.get(username=data[\\\"username\\\"])\\n if user_token.token == auth_token:\\n return True\\n except:\\n return False\\n return False\",\n \"def default_login_works(self):\\n return True if self.default_login_auth_header else False\",\n \"def login_user(username,password):\\n \\n check_user = Records.verify_user(username,password)\\n return check_user\",\n \"def validate_login(self, username, password):\\n user = User(self).get(username)\\n return user and user['Password'] == password\",\n \"def check_login(db, useremail, password):\\n import hashlib\\n\\n cursor = db.cursor().execute('SELECT password FROM users WHERE email IS ?', [useremail])\\n result = cursor.fetchone()\\n if result:\\n return result[0] == hashlib.sha1(password.encode()).hexdigest()\\n return False\",\n \"def usercheck(userip):\\n if userip in session:\\n return userstate.check(session[userip])\\n else:\\n return False\",\n \"def earthdata_login(uid=None, pwd=None, email=None, s3token=False) -> bool:\\n\\n try:\\n url = \\\"urs.earthdata.nasa.gov\\\"\\n mock_uid, _, mock_pwd = netrc.netrc(netrc).authenticators(url)\\n except:\\n\\n mock_uid = os.environ.get(\\\"EARTHDATA_USERNAME\\\")\\n mock_pwd = os.environ.get(\\\"EARTHDATA_PASSWORD\\\")\\n\\n if (uid == mock_uid) & (pwd == mock_pwd):\\n return True\\n else:\\n return False\",\n \"def check_login(self, u, p):\\r\\n\\t\\tlogger.debug(\\\"Entering\\\")\\r\\n\\t\\t\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tval = login.validate_user(u, p)\\r\\n\\t\\texcept ValueError as e:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, e.message\\r\\n\\t\\t\\r\\n\\t\\tif val:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - success\\\")\\r\\n\\t\\t\\treturn True, \\\"Login successful!\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlogger.debug(\\\"Exiting - failure\\\")\\r\\n\\t\\t\\treturn False, \\\"Login failed.\\\"\",\n \"def details_not_matching():\\n print(\\\"login details don't match.\\\")\",\n \"def login_user(self, input_email, input_password):\\n logging_user_details = self.check_email_for_login(input_email)\\n if BCRYPT.check_password_hash(logging_user_details['password'],\\n input_password):\\n # compare password input to saved password\\n return logging_user_details\\n return False\",\n \"def connectPhone(self):\\n value = os.popen(self.checkPhone)\\n\\n for data in value.readline():\\n sDate = str(data)\\n if sDate.find(\\\"device\\\"):\\n return True\\n return False\",\n \"def valid_login(username: str, password: str):\\n\\n try:\\n LoginHandler.login(username, password)\\n global validLogin\\n validLogin = True\\n except:\\n validLogin = False\",\n \"def login(self) -> int:\\n r = self.session.post(\\n self.api_endpoint,\\n data={\\n \\\"action\\\": \\\"login\\\",\\n \\\"lgname\\\": self.user,\\n \\\"lgpassword\\\": self.password,\\n \\\"format\\\": \\\"json\\\",\\n },\\n )\\n token = json.loads(r.text)[\\\"login\\\"][\\\"token\\\"]\\n r = self.session.post(\\n self.api_endpoint,\\n data={\\n \\\"action\\\": \\\"login\\\",\\n \\\"lgname\\\": self.user,\\n \\\"lgpassword\\\": self.password,\\n \\\"lgtoken\\\": token,\\n \\\"format\\\": \\\"json\\\",\\n },\\n )\\n if json.loads(r.text)[\\\"login\\\"][\\\"result\\\"] != \\\"Success\\\":\\n return -1\\n return 0\",\n \"def CheckLogin(self) :\\n url = Judge.UrlStatus + 'contestId=1&search=true&firstId=-1&lastId=-1&handle=' + self.username\\n logging.info(\\\"open_url %s\\\" % url)\\n req = urllib2.Request(url, headers=Judge.Headers)\\n rsp = self.opener.open(req)\\n res = None\\n if rsp :\\n res = rsp.read()\\n #wf(\\\"CheckLogin_\\\", res)\\n result = self.__parse_result(None, res, need_extra_info=False)\\n if result and result.has_key('origin_runid') :\\n #print \\\"CheckLogin last_submit_time{%s}END\\\" % result['_submit_time']\\n self.last_runid = result['origin_runid']\\n return res and res.find(r'<a href=\\\"/onlinejudge/login.do\\\">Login</a>') == -1\",\n \"def checkSession(self):\\r\\n\\r\\n app_settings = QSettings(conf_parser.get(\\\"APP\\\", \\\"name\\\"))\\r\\n end_date_time = app_settings.value(\\\"EndDateTime\\\", type=QDateTime)\\r\\n cur_date_time = QDateTime.currentDateTime()\\r\\n if(cur_date_time.secsTo(end_date_time) > 0):\\r\\n # get values from app_settings\\r\\n gl_content.auth_email = app_settings.value(\\\"Email\\\")\\r\\n gl_content.auth_user_company = app_settings.value(\\\"UserCompany\\\")\\r\\n gl_content.auth_first_name = app_settings.value(\\\"FirstName\\\")\\r\\n gl_content.auth_last_name = app_settings.value(\\\"LastName\\\")\\r\\n gl_content.auth_user_sys_id = app_settings.value(\\\"UserSysId\\\")\\r\\n gl_content.auth_password = app_settings.value(\\\"Password\\\")\\r\\n \\r\\n # decrypt password\\r\\n bytes_password = bytes(gl_content.auth_password)\\r\\n gl_content.auth_password = crypt.decrypt(bytes_password)\\r\\n\\r\\n # make login request\\r\\n # get mac address\\r\\n mac_addr = uuid.getnode()\\r\\n if(not mac_addr):\\r\\n self.accept()\\r\\n return\\r\\n \\r\\n # configure data\\r\\n data = QtCore.QByteArray()\\r\\n data.append(\\\"username={}&\\\".format(gl_content.auth_email))\\r\\n data.append(\\\"appVersion={}&\\\".format(conf_parser.get(\\\"APP\\\", \\\"version\\\")))\\r\\n data.append(\\\"appID={}&\\\".format(conf_parser.get(\\\"APP\\\", \\\"id\\\")))\\r\\n data.append(\\\"machineID={}&\\\".format(mac_addr))\\r\\n data.append(\\\"password={}\\\".format(gl_content.auth_password))\\r\\n \\r\\n # send request\\r\\n request = QtNetwork.QNetworkRequest(QtCore.QUrl(conf_parser.get(\\\"URLs\\\", \\\"auth\\\")))\\r\\n request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,'application/x-www-form-urlencoded')\\r\\n self.networkAccessManager.post(request, data)\\r\\n \\r\\n # start timer\\r\\n self.lb_msg.setText(\\\"Logging in to the server ...\\\")\\r\\n self.login_timer.start(200)\\r\\n self.pros = 0\\r\\n else:\\r\\n self.accept()\",\n \"def check_login_result(self, result):\\n success_flag = \\\"成功登陆\\\"\\n m = re.search(success_flag, result)\\n if m is not None:\\n print \\\"Login successfully!\\\"\\n # Store the auth cooie into file\\n self.mycookie.store_cookie()\\n \\n # Get the column\\n option_flag = '<option\\\\svalue=\\\"(.*)\\\">(.*)</option>'\\n return self.get_post_data(self.article_add_url, self.login_send_header, option_flag)\\n else:\\n print \\\"Login failed!\\\"\\n return False\",\n \"def on_login(self, username):\",\n \"def on_login(self, username):\",\n \"def verify_password_student(mobile_or_token, password):\\n\\n # try with token\\n student = Student.verify_auth_token(mobile_or_token)\\n\\n # if auth failed\\n if not student:\\n\\n # try with mobile/password\\n student = Student.query.filter_by(MOBILE=mobile_or_token).first()\\n\\n # if mobile not in db or in db but password doesn't match\\n if not student or not student.verify_password(password):\\n return False\\n\\n # set current user if succeeded and return success\\n g.user = student\\n return True\",\n \"def is_registered(self):\\n if self.user == getpass.getuser():\\n return True\\n else:\\n return False\",\n \"def logged_in():\\n\\n if current_user.is_authenticated:\\n return True\\n\\n return False\",\n \"def login(self, device_name):\\n try:\\n device = next((item for item in self.host_dict if item.get('hostname') == device_name))\\n except StopIteration:\\n self.err_str = f\\\"Exception occurred. Please check hostname \\\\\\\"{device_name}\\\\\\\". Skipping back up\\\"\\n backup_logger.exception(self.err_str)\\n return\\n backup_logger.info(f\\\"Logging into {device['host']}\\\")\\n hostname = device.pop(\\\"hostname\\\")\\n logged_in = False\\n try:\\n self.session = ConnectHandler(**device)\\n if 'secret' in device:\\n self.session.enable()\\n self.current_device = device_name\\n self.connected_devices.append(device)\\n logged_in = True\\n except (AuthenticationException, SSHException) as e:\\n self.err_str = f\\\"Exception '{e}' occurred. \\\" \\\\\\n f\\\"SSH is unsuccessful for device {hostname}. Skipping back up\\\"\\n backup_logger.exception(self.err_str)\\n # sys.exit()\\n\\n return logged_in\\n # self.session = ConnectHandler(**device)\",\n \"def ismobile(number):\\n if number[0] in ['7', '8', '9']:\\n return True\\n return False\",\n \"def do_login_login():\\n print(inspect.stack()[1][3])\\n print(request.form)\\n query = select([User]).where(and_(User.columns.email == request.form['email'],User.columns.password==request.form['password'] ))\\n ResultProxy = connection.execute(query)\\n ResultSet = ResultProxy.fetchone()\\n if ResultSet:\\n session['logged_in'] = True\\n else:\\n flash('wrong password!')\\n # return str(get_flashed_messages())\\n return home(result)\",\n \"def check_user(used_name, used_password):\\n user_exists = UserData.user_login(used_name, used_password)\\n\\n return user_exists\",\n \"def isLoggedIn(self):\\n session = self.getSession()\\n if session is not None:\\n return True\\n return False\",\n \"def the_browser_is_open_the_freenas_url_and_logged_in(driver, nas_ip, root_password):\\n if nas_ip not in driver.current_url:\\n driver.get(f\\\"http://{nas_ip}\\\")\\n assert wait_on_element(driver, 10, '//input[@data-placeholder=\\\"Username\\\"]')\\n if not is_element_present(driver, '//mat-list-item[@ix-auto=\\\"option__Dashboard\\\"]'):\\n assert wait_on_element(driver, 10, '//input[@data-placeholder=\\\"Username\\\"]')\\n driver.find_element_by_xpath('//input[@data-placeholder=\\\"Username\\\"]').clear()\\n driver.find_element_by_xpath('//input[@data-placeholder=\\\"Username\\\"]').send_keys('root')\\n driver.find_element_by_xpath('//input[@data-placeholder=\\\"Password\\\"]').clear()\\n driver.find_element_by_xpath('//input[@data-placeholder=\\\"Password\\\"]').send_keys(root_password)\\n assert wait_on_element(driver, 5, '//button[@name=\\\"signin_button\\\"]')\\n driver.find_element_by_xpath('//button[@name=\\\"signin_button\\\"]').click()\\n else:\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Dashboard\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Dashboard\\\"]').click()\",\n \"def is_valid_login(self, username, password):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)\",\n \"def login(self,username,password):\\n try:\\n userNameField = self.driver.findElement(element = self.locators.lblUsernameField, elementType = \\\"id\\\", timeout = \\\"4\\\")\\n if not userNameField:\\n return False\\n\\n userNameField.click()\\n userNameField.send_keys(username)\\n time.sleep(self.waitShort)\\n passwordField = self.driver.findElement(element = self.locators.lblPasswordField, elementType = \\\"id\\\", timeout = \\\"4\\\")\\n if not passwordField:\\n return False\\n\\n passwordField.click()\\n passwordField.send_keys(password)\\n time.sleep(self.waitShort)\\n\\n signIn = self.driver.findElement(element = self.locators.signIn, elementType = \\\"id\\\", timeout = \\\"4\\\")\\n if not signIn:\\n return False\\n\\n signIn.click()\\n time.sleep(self.waitLong)\\n #handler for No Thanks pop-up\\n noThanks = self.driver.findElement(element = self.locators.btnNoThanks, elementType = \\\"id\\\", timeout = \\\"4\\\")\\n if noThanks:\\n noThanks.click()\\n return True\\n except Exception as exp:\\n print \\\"Error in login(): {}\\\".format(exp)\\n return False\\n return True\",\n \"def is_logged_in(session):\\n return 'user' in session\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6898011","0.689399","0.6369667","0.635195","0.63429105","0.63109106","0.62703073","0.6228723","0.62186426","0.6195903","0.6157435","0.61390567","0.6046515","0.60213834","0.5956583","0.59477335","0.5935797","0.5915573","0.58781195","0.58594924","0.58545065","0.5844821","0.58345634","0.5815404","0.5740041","0.57194996","0.5712774","0.56821424","0.56702864","0.56501263","0.5641082","0.5639972","0.56349766","0.56207985","0.56196487","0.56122655","0.559915","0.5572023","0.5565744","0.5559303","0.5559303","0.5553387","0.55425876","0.5535613","0.5530373","0.5527646","0.5524359","0.5519153","0.5518919","0.5516539","0.5512466","0.55121666","0.5505517","0.5484138","0.5477298","0.5476916","0.5476521","0.547006","0.5469212","0.5465067","0.54592633","0.54486054","0.54400724","0.5438683","0.54356325","0.5421263","0.54169667","0.5415251","0.5395401","0.53892857","0.538205","0.53776604","0.53732276","0.53697246","0.53634596","0.53615355","0.5360588","0.5354252","0.5354074","0.5352828","0.5338414","0.53364915","0.53337073","0.5325875","0.53232384","0.5321441","0.53195566","0.53195566","0.5317524","0.531629","0.5313517","0.5313131","0.5308204","0.53064245","0.5303523","0.5299893","0.52995163","0.5292093","0.52898794","0.5284045"],"string":"[\n \"0.6898011\",\n \"0.689399\",\n \"0.6369667\",\n \"0.635195\",\n \"0.63429105\",\n \"0.63109106\",\n \"0.62703073\",\n \"0.6228723\",\n \"0.62186426\",\n \"0.6195903\",\n \"0.6157435\",\n \"0.61390567\",\n \"0.6046515\",\n \"0.60213834\",\n \"0.5956583\",\n \"0.59477335\",\n \"0.5935797\",\n \"0.5915573\",\n \"0.58781195\",\n \"0.58594924\",\n \"0.58545065\",\n \"0.5844821\",\n \"0.58345634\",\n \"0.5815404\",\n \"0.5740041\",\n \"0.57194996\",\n \"0.5712774\",\n \"0.56821424\",\n \"0.56702864\",\n \"0.56501263\",\n \"0.5641082\",\n \"0.5639972\",\n \"0.56349766\",\n \"0.56207985\",\n \"0.56196487\",\n \"0.56122655\",\n \"0.559915\",\n \"0.5572023\",\n \"0.5565744\",\n \"0.5559303\",\n \"0.5559303\",\n \"0.5553387\",\n \"0.55425876\",\n \"0.5535613\",\n \"0.5530373\",\n \"0.5527646\",\n \"0.5524359\",\n \"0.5519153\",\n \"0.5518919\",\n \"0.5516539\",\n \"0.5512466\",\n \"0.55121666\",\n \"0.5505517\",\n \"0.5484138\",\n \"0.5477298\",\n \"0.5476916\",\n \"0.5476521\",\n \"0.547006\",\n \"0.5469212\",\n \"0.5465067\",\n \"0.54592633\",\n \"0.54486054\",\n \"0.54400724\",\n \"0.5438683\",\n \"0.54356325\",\n \"0.5421263\",\n \"0.54169667\",\n \"0.5415251\",\n \"0.5395401\",\n \"0.53892857\",\n \"0.538205\",\n \"0.53776604\",\n \"0.53732276\",\n \"0.53697246\",\n \"0.53634596\",\n \"0.53615355\",\n \"0.5360588\",\n \"0.5354252\",\n \"0.5354074\",\n \"0.5352828\",\n \"0.5338414\",\n \"0.53364915\",\n \"0.53337073\",\n \"0.5325875\",\n \"0.53232384\",\n \"0.5321441\",\n \"0.53195566\",\n \"0.53195566\",\n \"0.5317524\",\n \"0.531629\",\n \"0.5313517\",\n \"0.5313131\",\n \"0.5308204\",\n \"0.53064245\",\n \"0.5303523\",\n \"0.5299893\",\n \"0.52995163\",\n \"0.5292093\",\n \"0.52898794\",\n \"0.5284045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6534018"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6886,"cells":{"query":{"kind":"string","value":"Check if user is admin"},"document":{"kind":"string","value":"def require_admin(func):\n\n @wraps(func)\n def decorator(*args, **kwargs):\n if not g.user:\n # flash('此操作需要登录账户')\n return redirect(url_for('admin.login'))\n if g.user.name != 'admin':\n abort(403)\n return func(*args, **kwargs)\n\n return decorator"},"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 user_is_admin(user):\n return user in admins","def is_admin(user):\n return user.is_authenticated and user.id == app.config.get('ADMIN')","def is_admin(self, user):\n return user.name in self.admins","def is_admin_user(self):\n if \"is_admin\" in self._properties and self.is_admin == 'YES':\n return True\n return False","def isAdmin(user):\n return isUserType(user, Admin)","def isAdmin():\n\tif 'username' in session and session['username'] == 'admin':\n\t\treturn True\n\telse:\n\t\treturn False","def isAdmin(self, user):\r\n if user.id in self.admins:\r\n return True\r\n return False","def check_admin() -> bool:\n return ctypes.windll.shell32.IsUserAnAdmin() == 1","def is_admin(self):\n if not self.current_user:\n return False\n else:\n return self.current_user in [\"1\"]","def admin_flag(user_id):\n user = User.query.filter_by(id=user_id).first()\n if user.is_admin:\n return True\n return False","def check_is_admin(current_user):\n return current_user['isAdmin'] == True","def is_user_admin(request):\n return request.user.is_superuser","def is_admin(self,user):\n if user.is_superuser:\n return True\n\n if user.groups.filter(name=self.admin_group_name).count() > 0:\n return True\n else:\n return False","def is_admin(ctx) -> bool:\n return db.user(ctx.author).is_admin","def check_admin():\r\n if not current_user.is_admin:\r\n abort(403)","def check_admin():\n if not current_user.is_admin:\n abort(403)","def check_admin():\n if not current_user.is_admin:\n abort(403)","def is_admin():\n user = users.get_current_user()\n if user:\n if users.is_current_user_admin() or is_local_admin():\n return 'Yes, you are admin'\n else:\n return \"No, you don't admin\"\n else:\n return \"You not logged in\"","def check_admin():\n\tif not current_user.is_admin:\n\t\tabort(403)","def is_admin(self):\r\n return self.admin","def get_is_admin(self, obj):\n try:\n user = self.context.get('request').user\n except Exception:\n # raise serializers.ValidationError('Could not access request.user')\n return False\n if user == obj.admin:\n return True\n else:\n return False","def is_admin(self):\n if self.user is None:\n return False\n if unicode(self.user._id) in self.barcamp.admins:\n return True\n if self.user.is_admin:\n return True\n return False","def is_admin(self):\n return self.admin","def is_user_admin(self, user):\n return user == self.created_by","def is_current_user_admin():\n return (os.environ.get('USER_IS_ADMIN', '0')) == \"1\"","def check_admin(self, user: TelegramController.User = None, id: str = None):\n\n if id == None:\n id = user.id\n\n return md5((str(id) + \"admin\").encode()).hexdigest() in self.__admins","def is_admin(user):\n return user.groups.filter(name='Profesores').exists()","def is_admin(username: str) -> bool:\n db = get_db()\n return int(db.get_user_by_name(username)[\"is_admin\"]) == 1","def user_is_admin(userobj):\n from .node import Node\n from .subject import Subject\n from .period import Period\n from .assignment import Assignment\n return user_is_basenodeadmin(userobj, Node, Subject, Period, Assignment)","def is_not_admin(user):\n return not user.is_superuser","def is_admin(self) -> bool:\n return self._is_admin","def is_admin(self, user) -> bool:\n return (\n user.is_superuser\n or user.groups.filter(pk=self.admins_group.pk).exists()\n )","def is_admin():\n # TODO(felipemonteiro): Make this more robust via a context is admin\n # lookup.\n return CONF.patrole.rbac_test_role == CONF.identity.admin_role","def is_admin(self):\n return self._is_admin","def is_admin(self):\n return self._is_admin","def is_admin(self, username):\n con = dbcon()\n cur = con.cursor()\n cur.execute(\"SELECT * FROM my_users WHERE username=%(username)s\",\\\n {\"username\":username})\n res = cur.fetchone()\n if res[5].lower() == 'admin':\n return True\n return False","def is_main_admin(self):\n if self.user is None:\n return False\n return self.user.has_permission(\"admin\")","def admin(self):\n if self.is_admin:\n return True\n return False","def _check_admin_only(self, request):\r\n api_key = request.params.get(self.api_field, None)\r\n\r\n if request.user is None:\r\n user = self.user_fetcher(api_key=api_key)\r\n else:\r\n user = request.user\r\n\r\n if user is not None and user.is_admin:\r\n request.user = user\r\n return True","def admin_user_exists(self):\n try:\n User.objects.get(username='admin')\n except User.DoesNotExist:\n return False\n\n return True","def is_admin(self):\n return False","def is_admin(user):\n return get_organisations_as_admin(user).count() > 0","def is_admin(self, username): #WORKS\n done = self.cur.execute(\"SELECT username FROM admins WHERE username=\\\"{}\\\"\".format(username))\n if done == 0: # If query is unsuccessful, username is not an administrator.\n return False\n else:\n return True","def is_admin():\n if platform_is(WINDOWS):\n return windll.shell32.IsUserAnAdmin()\n return os.getuid() == 0","def is_admin(context):\n request = context[\"request\"]\n url = resolve(request.path)\n context['is_admin'] = False\n return url.app_name == 'admin'","def is_admin(self):\n if self.type == 1:\n return True\n else:\n return False","def is_admin(self, user):\n return (acl.action_allowed(self.request, 'OperatorDashboard', '*') or\n acl.action_allowed(self.request, 'Feed', 'Curate'))","def check_admin(self, *args, **kwargs):\n if not users.is_current_user_admin():\n self.response.write(\n '<div style=\"padding-top: 200px; height:178px; width: 500px; color: white; margin: 0 auto; font-size: 52px; text-align: center; background: url(\\'http://3.bp.blogspot.com/_d_q1e2dFExM/TNWbWrJJ7xI/AAAAAAAAAjU/JnjBiTSA1xg/s1600/Bank+Vault.jpg\\')\">Forbidden Access <a style=\\'color: white;\\' href=\\'%s\\'>Login</a></div>' %\n users.create_login_url(self.request.path_url + self.request.query_string))\n return\n else:\n return handler(self, *args, **kwargs)","def is_admin(self):\n if self.is_main_admin:\n return True\n if self.user is not None and self.barcamp is not None:\n if unicode(self.user._id) in self.barcamp.admins:\n return True\n return False","def check_is_admin(context):\n init()\n\n #the target is user-self\n credentials = context.to_dict()\n target = credentials\n\n return policy.check('context_is_admin', target, credentials)","def check_is_admin(self, wormhole: str, user: int):\n query = \"SELECT 1 FROM wormhole_admin WHERE name = ? AND admin = ?\"\n query_res = self.bot.db_query(query, (wormhole, user))\n return len(query_res) > 0","async def is_admin(ctx):\n member = ctx.message.author\n aRole = discord.utils.get(member.guild.roles, name=ROLE_AD)\n if aRole in member.roles or member.id == 715048392408956950: return True","def validate_admin(self, request):\n\n self.validate_login(request)\n\n if request.session['id'] not in self.admins:\n handler.logHelper.log_it_visit(request, __name__ + '.validate_admin', authorized=False)\n raise PermissionDenied('You need to be an admin to access this page.')","def be_admin(username):\n user_data = my_users.get(username)\n if not user_data or 'admin' not in user_data.get('roles', []):\n return \"User does not have admin role\"","def check_is_admin(context):\n\n init()\n # the target is user-self\n target = default_target(context)\n return _ENFORCER.authorize('context_is_admin', target, context)","def test_is_admin_user(self):\n admin = User.objects.get(email='testadminuser@test.com')\n self.assertEqual(admin.is_staff, True)","def is_admin(self) -> bool:\n\n return current_app.config[\"AUTH_ROLE_ADMIN\"] in [\n role.name for role in self.get_user_roles()\n ]","def check_admin_session(self):\n for session in vms.get_vm_sessions(vm_name=self.vm_name):\n if (\n session.get_console_user()\n and\n session.get_user().get_user_name().startswith(\"admin\")\n ):\n return True\n return False","def is_admin(self):\n return Role.query.get(2) in self.roles","def is_admin(author):\n if str(author).lower() in config[\"admins\"]:\n return True\n return False","def check_is_admin(context):\n init()\n credentials = context.to_policy_values()\n target = credentials\n return _ENFORCER.authorize('admin_required', target, credentials)","def check_is_admin(cookie):\n return ';admin=true;' in cookie","def is_administrator(self):\n return False","async def assert_user_is_admin(auth: Auth, requester: Requester) -> None:\n is_admin = await auth.is_server_admin(requester)\n if not is_admin:\n raise AuthError(HTTPStatus.FORBIDDEN, \"You are not a server admin\")","def isAdmin(self, nick):\n\t\tif nick in self.config[\"admins\"]:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False","def test_func(self, user):\n return self.get_object().admin == user","def is_user_cloud_admin(self):\n user = users.get_current_user()\n if not user:\n return False\n try:\n user_info = self.get_by_id(UserInfo, user.email())\n if user_info:\n return user_info.is_user_cloud_admin\n else:\n return False\n except Exception as err:\n logging.exception(err)\n return False","def is_superuser(self):\n sesh = self.get_session()\n return sesh.curr_role == 'admin'","def user_is_nodeadmin(userobj):\n from .node import Node\n return user_is_basenodeadmin(userobj, Node)","def is_admin():\n # type: () -> bool\n current_os_name = os.name\n\n # Works with XP SP2 +\n if current_os_name == \"nt\":\n try:\n return IsUserAnAdmin()\n except Exception:\n raise EnvironmentError(\"Cannot check admin privileges\")\n elif current_os_name == \"posix\":\n # Check for root on Posix\n # os.getuid only exists on postix OSes\n # pylint: disable=E1101 (no-member)\n return os.getuid() == 0\n else:\n raise EnvironmentError(\n \"OS does not seem to be supported for admin check. OS: {}\".format(\n current_os_name\n )\n )","def user_is_admin_or_superadmin(userobj):\n if userobj.is_superuser:\n return True\n else:\n return user_is_admin(userobj)","def validateUser(self,admin):\n \n res=admin.helper.getOneUser(self.name)\n if res == False:\n return True\n else:\n return False","def is_superuser(self):\n return self.is_admin","def test_admin(self):\r\n \r\n self.assertEqual(False, self.user.isAdmin)","def admin(ctx):\n return ctx.message.author.permissions_in(ctx.channel).administrator","def admin(request):\n if not request.user.is_staff:\n return render_to_response('error.htm', {\n 'error': \"Sorry, you are not staff... (user permissions 'is_staff')\",\n })\n return render_to_response('admin.htm', {\n 'username': request.user,\n })","def is_administrator(self):\n return self.can(Permission.ADMIN)","def is_administrator(self):\n return self.can(Permission.ADMIN)","def GET_adminon(self):\r\n #check like this because c.user_is_admin is still false\r\n if not c.user.name in g.admins:\r\n return self.abort404()\r\n self.login(c.user, admin = True)\r\n\r\n dest = request.referer or '/'\r\n return self.redirect(dest)","def is_accessible(self):\n return current_user.is_authenticated and current_user.role == 'admin'","def is_accessible(self):\n return current_user.is_authenticated and current_user.role == 'admin'","def is_staff(self):\r\n return self.is_admin","def admin_required(handler):\n def admin_login(self, *args, **kwargs):\n auth = self.auth\n if not auth.get_user_by_session():\n self.redirect('/auth/login', abort=True)\n \n user = auth.get_user_by_session()\n queried_entity = User.get_by_id(user['user_id'])\n \n if queried_entity and queried_entity.phb_user_admin_status == 'admin-1':\n return handler(self, *args, **kwargs)\n else:\n self.redirect('/', abort = True)\n \n return admin_login","def is_admin(func):\n\n @wraps(func)\n def decorated_function(*args, **kwargs):\n from .base_validator import ValidationError\n user = request.user\n if user.is_admin == IsAdmin.yes:\n return func(*args, **kwargs)\n raise ValidationError(\n {'message': 'You are not authorized to access this page'},\n 403\n )\n\n return decorated_function","def IsCorpUserOrAdmin(self):\n user_email = auth_util.GetUserEmail()\n return ((user_email and user_email.endswith('@google.com')) or\n auth_util.IsCurrentUserAdmin())","def login_as_admin():\n users.loginAsUser(\n config.VDC_ADMIN_USER, config.VDC_ADMIN_DOMAIN,\n config.VDC_PASSWORD, filter=False\n )\n return True","def is_administrator(self):\n return self.rol == ProfileRoles.ADMINISTRATOR or self.user.is_staff","def user_is_assignmentadmin(userobj):\n from .assignment import Assignment\n return user_is_basenodeadmin(userobj, Assignment)","def is_admin(self, is_admin):\n\n self._is_admin = is_admin","def get_editable(self, user):\n return user.get('role') == 'admin'","async def assert_requester_is_admin(auth: Auth, request: SynapseRequest) -> None:\n requester = await auth.get_user_by_req(request)\n await assert_user_is_admin(auth, requester)","def can_edit_user(user):\n\tu = current_user._get_current_object()\n\treturn u==user or u.is_admin()","def user_is_periodadmin(userobj):\n from .period import Period\n return user_is_basenodeadmin(userobj, Period)","def get_is_admin():\n try:\n return ctypes.windll.shell32.IsUserAnAdmin()\n except:\n return \"Could not get the UAC level.\"","def check_if_admin(bot, update, *args, **kwargs):\n user_id = update._effective_user\n # print(\"cerco user con id \" + str(user_id) + \", nel database\")\n user = DB.execute(TABELLE[\"id_users\"][\"select\"][\"from_id\"], (user_id['id'],))\n # print(\"ho trovato : \" + str(user))\n if not user:\n self.request_access(bot, user_id)\n return\n elif user[\"banned\"]:\n update.message.reply_text(\"Spiacente sei stato bannato dal bot\")\n return\n elif user[\"admin\"]:\n sig = signature(func)\n if len(sig.parameters) > 1:\n return func(bot, update, *args, **kwargs)\n else:\n return func(*args, **kwargs)\n else:\n update.message.reply_text(\"Non sei abilitato ad usare questo comando\")\n return","def admin(request):\n if not request.user.is_staff:\n return render(request, 'manager/denied.html')\n return render(request, 'manager/index.html')","def test_user_isnt_admin():\n app = create_ctfd()\n with app.app_context():\n register_user(app)\n client = login_as_user(app)\n for page in ['pages', 'teams', 'scoreboard', 'chals', 'statistics', 'config']:\n r = client.get('/admin/{}'.format(page))\n assert r.location.startswith(\"http://localhost/login?next=\")\n assert r.status_code == 302\n destroy_ctfd(app)","def test_func(self):\n return self.request.user.is_superuser","async def test_auth_admin_is_admin(app):\n # Admin user defined in MockPAMAuthenticator.\n name = 'admin'\n user = add_user(app.db, app, name=name, admin=False)\n assert user.admin is False\n cookies = await app.login_user(name)\n assert user.admin is True","def is_staff(self):\n return self.is_admin","def is_staff(self):\n return self.is_admin"],"string":"[\n \"def user_is_admin(user):\\n return user in admins\",\n \"def is_admin(user):\\n return user.is_authenticated and user.id == app.config.get('ADMIN')\",\n \"def is_admin(self, user):\\n return user.name in self.admins\",\n \"def is_admin_user(self):\\n if \\\"is_admin\\\" in self._properties and self.is_admin == 'YES':\\n return True\\n return False\",\n \"def isAdmin(user):\\n return isUserType(user, Admin)\",\n \"def isAdmin():\\n\\tif 'username' in session and session['username'] == 'admin':\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def isAdmin(self, user):\\r\\n if user.id in self.admins:\\r\\n return True\\r\\n return False\",\n \"def check_admin() -> bool:\\n return ctypes.windll.shell32.IsUserAnAdmin() == 1\",\n \"def is_admin(self):\\n if not self.current_user:\\n return False\\n else:\\n return self.current_user in [\\\"1\\\"]\",\n \"def admin_flag(user_id):\\n user = User.query.filter_by(id=user_id).first()\\n if user.is_admin:\\n return True\\n return False\",\n \"def check_is_admin(current_user):\\n return current_user['isAdmin'] == True\",\n \"def is_user_admin(request):\\n return request.user.is_superuser\",\n \"def is_admin(self,user):\\n if user.is_superuser:\\n return True\\n\\n if user.groups.filter(name=self.admin_group_name).count() > 0:\\n return True\\n else:\\n return False\",\n \"def is_admin(ctx) -> bool:\\n return db.user(ctx.author).is_admin\",\n \"def check_admin():\\r\\n if not current_user.is_admin:\\r\\n abort(403)\",\n \"def check_admin():\\n if not current_user.is_admin:\\n abort(403)\",\n \"def check_admin():\\n if not current_user.is_admin:\\n abort(403)\",\n \"def is_admin():\\n user = users.get_current_user()\\n if user:\\n if users.is_current_user_admin() or is_local_admin():\\n return 'Yes, you are admin'\\n else:\\n return \\\"No, you don't admin\\\"\\n else:\\n return \\\"You not logged in\\\"\",\n \"def check_admin():\\n\\tif not current_user.is_admin:\\n\\t\\tabort(403)\",\n \"def is_admin(self):\\r\\n return self.admin\",\n \"def get_is_admin(self, obj):\\n try:\\n user = self.context.get('request').user\\n except Exception:\\n # raise serializers.ValidationError('Could not access request.user')\\n return False\\n if user == obj.admin:\\n return True\\n else:\\n return False\",\n \"def is_admin(self):\\n if self.user is None:\\n return False\\n if unicode(self.user._id) in self.barcamp.admins:\\n return True\\n if self.user.is_admin:\\n return True\\n return False\",\n \"def is_admin(self):\\n return self.admin\",\n \"def is_user_admin(self, user):\\n return user == self.created_by\",\n \"def is_current_user_admin():\\n return (os.environ.get('USER_IS_ADMIN', '0')) == \\\"1\\\"\",\n \"def check_admin(self, user: TelegramController.User = None, id: str = None):\\n\\n if id == None:\\n id = user.id\\n\\n return md5((str(id) + \\\"admin\\\").encode()).hexdigest() in self.__admins\",\n \"def is_admin(user):\\n return user.groups.filter(name='Profesores').exists()\",\n \"def is_admin(username: str) -> bool:\\n db = get_db()\\n return int(db.get_user_by_name(username)[\\\"is_admin\\\"]) == 1\",\n \"def user_is_admin(userobj):\\n from .node import Node\\n from .subject import Subject\\n from .period import Period\\n from .assignment import Assignment\\n return user_is_basenodeadmin(userobj, Node, Subject, Period, Assignment)\",\n \"def is_not_admin(user):\\n return not user.is_superuser\",\n \"def is_admin(self) -> bool:\\n return self._is_admin\",\n \"def is_admin(self, user) -> bool:\\n return (\\n user.is_superuser\\n or user.groups.filter(pk=self.admins_group.pk).exists()\\n )\",\n \"def is_admin():\\n # TODO(felipemonteiro): Make this more robust via a context is admin\\n # lookup.\\n return CONF.patrole.rbac_test_role == CONF.identity.admin_role\",\n \"def is_admin(self):\\n return self._is_admin\",\n \"def is_admin(self):\\n return self._is_admin\",\n \"def is_admin(self, username):\\n con = dbcon()\\n cur = con.cursor()\\n cur.execute(\\\"SELECT * FROM my_users WHERE username=%(username)s\\\",\\\\\\n {\\\"username\\\":username})\\n res = cur.fetchone()\\n if res[5].lower() == 'admin':\\n return True\\n return False\",\n \"def is_main_admin(self):\\n if self.user is None:\\n return False\\n return self.user.has_permission(\\\"admin\\\")\",\n \"def admin(self):\\n if self.is_admin:\\n return True\\n return False\",\n \"def _check_admin_only(self, request):\\r\\n api_key = request.params.get(self.api_field, None)\\r\\n\\r\\n if request.user is None:\\r\\n user = self.user_fetcher(api_key=api_key)\\r\\n else:\\r\\n user = request.user\\r\\n\\r\\n if user is not None and user.is_admin:\\r\\n request.user = user\\r\\n return True\",\n \"def admin_user_exists(self):\\n try:\\n User.objects.get(username='admin')\\n except User.DoesNotExist:\\n return False\\n\\n return True\",\n \"def is_admin(self):\\n return False\",\n \"def is_admin(user):\\n return get_organisations_as_admin(user).count() > 0\",\n \"def is_admin(self, username): #WORKS\\n done = self.cur.execute(\\\"SELECT username FROM admins WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n if done == 0: # If query is unsuccessful, username is not an administrator.\\n return False\\n else:\\n return True\",\n \"def is_admin():\\n if platform_is(WINDOWS):\\n return windll.shell32.IsUserAnAdmin()\\n return os.getuid() == 0\",\n \"def is_admin(context):\\n request = context[\\\"request\\\"]\\n url = resolve(request.path)\\n context['is_admin'] = False\\n return url.app_name == 'admin'\",\n \"def is_admin(self):\\n if self.type == 1:\\n return True\\n else:\\n return False\",\n \"def is_admin(self, user):\\n return (acl.action_allowed(self.request, 'OperatorDashboard', '*') or\\n acl.action_allowed(self.request, 'Feed', 'Curate'))\",\n \"def check_admin(self, *args, **kwargs):\\n if not users.is_current_user_admin():\\n self.response.write(\\n '<div style=\\\"padding-top: 200px; height:178px; width: 500px; color: white; margin: 0 auto; font-size: 52px; text-align: center; background: url(\\\\'http://3.bp.blogspot.com/_d_q1e2dFExM/TNWbWrJJ7xI/AAAAAAAAAjU/JnjBiTSA1xg/s1600/Bank+Vault.jpg\\\\')\\\">Forbidden Access <a style=\\\\'color: white;\\\\' href=\\\\'%s\\\\'>Login</a></div>' %\\n users.create_login_url(self.request.path_url + self.request.query_string))\\n return\\n else:\\n return handler(self, *args, **kwargs)\",\n \"def is_admin(self):\\n if self.is_main_admin:\\n return True\\n if self.user is not None and self.barcamp is not None:\\n if unicode(self.user._id) in self.barcamp.admins:\\n return True\\n return False\",\n \"def check_is_admin(context):\\n init()\\n\\n #the target is user-self\\n credentials = context.to_dict()\\n target = credentials\\n\\n return policy.check('context_is_admin', target, credentials)\",\n \"def check_is_admin(self, wormhole: str, user: int):\\n query = \\\"SELECT 1 FROM wormhole_admin WHERE name = ? AND admin = ?\\\"\\n query_res = self.bot.db_query(query, (wormhole, user))\\n return len(query_res) > 0\",\n \"async def is_admin(ctx):\\n member = ctx.message.author\\n aRole = discord.utils.get(member.guild.roles, name=ROLE_AD)\\n if aRole in member.roles or member.id == 715048392408956950: return True\",\n \"def validate_admin(self, request):\\n\\n self.validate_login(request)\\n\\n if request.session['id'] not in self.admins:\\n handler.logHelper.log_it_visit(request, __name__ + '.validate_admin', authorized=False)\\n raise PermissionDenied('You need to be an admin to access this page.')\",\n \"def be_admin(username):\\n user_data = my_users.get(username)\\n if not user_data or 'admin' not in user_data.get('roles', []):\\n return \\\"User does not have admin role\\\"\",\n \"def check_is_admin(context):\\n\\n init()\\n # the target is user-self\\n target = default_target(context)\\n return _ENFORCER.authorize('context_is_admin', target, context)\",\n \"def test_is_admin_user(self):\\n admin = User.objects.get(email='testadminuser@test.com')\\n self.assertEqual(admin.is_staff, True)\",\n \"def is_admin(self) -> bool:\\n\\n return current_app.config[\\\"AUTH_ROLE_ADMIN\\\"] in [\\n role.name for role in self.get_user_roles()\\n ]\",\n \"def check_admin_session(self):\\n for session in vms.get_vm_sessions(vm_name=self.vm_name):\\n if (\\n session.get_console_user()\\n and\\n session.get_user().get_user_name().startswith(\\\"admin\\\")\\n ):\\n return True\\n return False\",\n \"def is_admin(self):\\n return Role.query.get(2) in self.roles\",\n \"def is_admin(author):\\n if str(author).lower() in config[\\\"admins\\\"]:\\n return True\\n return False\",\n \"def check_is_admin(context):\\n init()\\n credentials = context.to_policy_values()\\n target = credentials\\n return _ENFORCER.authorize('admin_required', target, credentials)\",\n \"def check_is_admin(cookie):\\n return ';admin=true;' in cookie\",\n \"def is_administrator(self):\\n return False\",\n \"async def assert_user_is_admin(auth: Auth, requester: Requester) -> None:\\n is_admin = await auth.is_server_admin(requester)\\n if not is_admin:\\n raise AuthError(HTTPStatus.FORBIDDEN, \\\"You are not a server admin\\\")\",\n \"def isAdmin(self, nick):\\n\\t\\tif nick in self.config[\\\"admins\\\"]:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def test_func(self, user):\\n return self.get_object().admin == user\",\n \"def is_user_cloud_admin(self):\\n user = users.get_current_user()\\n if not user:\\n return False\\n try:\\n user_info = self.get_by_id(UserInfo, user.email())\\n if user_info:\\n return user_info.is_user_cloud_admin\\n else:\\n return False\\n except Exception as err:\\n logging.exception(err)\\n return False\",\n \"def is_superuser(self):\\n sesh = self.get_session()\\n return sesh.curr_role == 'admin'\",\n \"def user_is_nodeadmin(userobj):\\n from .node import Node\\n return user_is_basenodeadmin(userobj, Node)\",\n \"def is_admin():\\n # type: () -> bool\\n current_os_name = os.name\\n\\n # Works with XP SP2 +\\n if current_os_name == \\\"nt\\\":\\n try:\\n return IsUserAnAdmin()\\n except Exception:\\n raise EnvironmentError(\\\"Cannot check admin privileges\\\")\\n elif current_os_name == \\\"posix\\\":\\n # Check for root on Posix\\n # os.getuid only exists on postix OSes\\n # pylint: disable=E1101 (no-member)\\n return os.getuid() == 0\\n else:\\n raise EnvironmentError(\\n \\\"OS does not seem to be supported for admin check. OS: {}\\\".format(\\n current_os_name\\n )\\n )\",\n \"def user_is_admin_or_superadmin(userobj):\\n if userobj.is_superuser:\\n return True\\n else:\\n return user_is_admin(userobj)\",\n \"def validateUser(self,admin):\\n \\n res=admin.helper.getOneUser(self.name)\\n if res == False:\\n return True\\n else:\\n return False\",\n \"def is_superuser(self):\\n return self.is_admin\",\n \"def test_admin(self):\\r\\n \\r\\n self.assertEqual(False, self.user.isAdmin)\",\n \"def admin(ctx):\\n return ctx.message.author.permissions_in(ctx.channel).administrator\",\n \"def admin(request):\\n if not request.user.is_staff:\\n return render_to_response('error.htm', {\\n 'error': \\\"Sorry, you are not staff... (user permissions 'is_staff')\\\",\\n })\\n return render_to_response('admin.htm', {\\n 'username': request.user,\\n })\",\n \"def is_administrator(self):\\n return self.can(Permission.ADMIN)\",\n \"def is_administrator(self):\\n return self.can(Permission.ADMIN)\",\n \"def GET_adminon(self):\\r\\n #check like this because c.user_is_admin is still false\\r\\n if not c.user.name in g.admins:\\r\\n return self.abort404()\\r\\n self.login(c.user, admin = True)\\r\\n\\r\\n dest = request.referer or '/'\\r\\n return self.redirect(dest)\",\n \"def is_accessible(self):\\n return current_user.is_authenticated and current_user.role == 'admin'\",\n \"def is_accessible(self):\\n return current_user.is_authenticated and current_user.role == 'admin'\",\n \"def is_staff(self):\\r\\n return self.is_admin\",\n \"def admin_required(handler):\\n def admin_login(self, *args, **kwargs):\\n auth = self.auth\\n if not auth.get_user_by_session():\\n self.redirect('/auth/login', abort=True)\\n \\n user = auth.get_user_by_session()\\n queried_entity = User.get_by_id(user['user_id'])\\n \\n if queried_entity and queried_entity.phb_user_admin_status == 'admin-1':\\n return handler(self, *args, **kwargs)\\n else:\\n self.redirect('/', abort = True)\\n \\n return admin_login\",\n \"def is_admin(func):\\n\\n @wraps(func)\\n def decorated_function(*args, **kwargs):\\n from .base_validator import ValidationError\\n user = request.user\\n if user.is_admin == IsAdmin.yes:\\n return func(*args, **kwargs)\\n raise ValidationError(\\n {'message': 'You are not authorized to access this page'},\\n 403\\n )\\n\\n return decorated_function\",\n \"def IsCorpUserOrAdmin(self):\\n user_email = auth_util.GetUserEmail()\\n return ((user_email and user_email.endswith('@google.com')) or\\n auth_util.IsCurrentUserAdmin())\",\n \"def login_as_admin():\\n users.loginAsUser(\\n config.VDC_ADMIN_USER, config.VDC_ADMIN_DOMAIN,\\n config.VDC_PASSWORD, filter=False\\n )\\n return True\",\n \"def is_administrator(self):\\n return self.rol == ProfileRoles.ADMINISTRATOR or self.user.is_staff\",\n \"def user_is_assignmentadmin(userobj):\\n from .assignment import Assignment\\n return user_is_basenodeadmin(userobj, Assignment)\",\n \"def is_admin(self, is_admin):\\n\\n self._is_admin = is_admin\",\n \"def get_editable(self, user):\\n return user.get('role') == 'admin'\",\n \"async def assert_requester_is_admin(auth: Auth, request: SynapseRequest) -> None:\\n requester = await auth.get_user_by_req(request)\\n await assert_user_is_admin(auth, requester)\",\n \"def can_edit_user(user):\\n\\tu = current_user._get_current_object()\\n\\treturn u==user or u.is_admin()\",\n \"def user_is_periodadmin(userobj):\\n from .period import Period\\n return user_is_basenodeadmin(userobj, Period)\",\n \"def get_is_admin():\\n try:\\n return ctypes.windll.shell32.IsUserAnAdmin()\\n except:\\n return \\\"Could not get the UAC level.\\\"\",\n \"def check_if_admin(bot, update, *args, **kwargs):\\n user_id = update._effective_user\\n # print(\\\"cerco user con id \\\" + str(user_id) + \\\", nel database\\\")\\n user = DB.execute(TABELLE[\\\"id_users\\\"][\\\"select\\\"][\\\"from_id\\\"], (user_id['id'],))\\n # print(\\\"ho trovato : \\\" + str(user))\\n if not user:\\n self.request_access(bot, user_id)\\n return\\n elif user[\\\"banned\\\"]:\\n update.message.reply_text(\\\"Spiacente sei stato bannato dal bot\\\")\\n return\\n elif user[\\\"admin\\\"]:\\n sig = signature(func)\\n if len(sig.parameters) > 1:\\n return func(bot, update, *args, **kwargs)\\n else:\\n return func(*args, **kwargs)\\n else:\\n update.message.reply_text(\\\"Non sei abilitato ad usare questo comando\\\")\\n return\",\n \"def admin(request):\\n if not request.user.is_staff:\\n return render(request, 'manager/denied.html')\\n return render(request, 'manager/index.html')\",\n \"def test_user_isnt_admin():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app)\\n client = login_as_user(app)\\n for page in ['pages', 'teams', 'scoreboard', 'chals', 'statistics', 'config']:\\n r = client.get('/admin/{}'.format(page))\\n assert r.location.startswith(\\\"http://localhost/login?next=\\\")\\n assert r.status_code == 302\\n destroy_ctfd(app)\",\n \"def test_func(self):\\n return self.request.user.is_superuser\",\n \"async def test_auth_admin_is_admin(app):\\n # Admin user defined in MockPAMAuthenticator.\\n name = 'admin'\\n user = add_user(app.db, app, name=name, admin=False)\\n assert user.admin is False\\n cookies = await app.login_user(name)\\n assert user.admin is True\",\n \"def is_staff(self):\\n return self.is_admin\",\n \"def is_staff(self):\\n return self.is_admin\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8688236","0.8687356","0.8556875","0.8554287","0.85044616","0.84716874","0.8450938","0.841185","0.84050906","0.8394017","0.8363089","0.83423585","0.83161926","0.8280715","0.82797027","0.82743096","0.82743096","0.8248748","0.82192075","0.8196186","0.8167282","0.81253445","0.81230384","0.81167454","0.8113847","0.8090466","0.80842537","0.8070545","0.80473363","0.80244833","0.80222696","0.80142","0.7963673","0.7962265","0.7962265","0.79258263","0.7924748","0.7910106","0.7880401","0.7865896","0.7852999","0.78060323","0.7799159","0.7760705","0.7748111","0.7722419","0.7708694","0.77079415","0.7675929","0.7661388","0.76584923","0.7632804","0.7627969","0.762729","0.76091015","0.7595937","0.75892967","0.75881845","0.75832874","0.7583276","0.755741","0.75534755","0.7529439","0.75187206","0.7501087","0.7493089","0.74736077","0.746824","0.745469","0.7451439","0.7437464","0.7410849","0.74057436","0.73977953","0.7370247","0.73670954","0.7356686","0.7356686","0.73216","0.7273192","0.7273192","0.7266639","0.725893","0.7247856","0.7245229","0.7223091","0.7207827","0.7207159","0.7194789","0.7191841","0.71648115","0.7158346","0.71554595","0.71331006","0.710514","0.7103049","0.70620286","0.70268095","0.7017761","0.7008628","0.7008628"],"string":"[\n \"0.8688236\",\n \"0.8687356\",\n \"0.8556875\",\n \"0.8554287\",\n \"0.85044616\",\n \"0.84716874\",\n \"0.8450938\",\n \"0.841185\",\n \"0.84050906\",\n \"0.8394017\",\n \"0.8363089\",\n \"0.83423585\",\n \"0.83161926\",\n \"0.8280715\",\n \"0.82797027\",\n \"0.82743096\",\n \"0.82743096\",\n \"0.8248748\",\n \"0.82192075\",\n \"0.8196186\",\n \"0.8167282\",\n \"0.81253445\",\n \"0.81230384\",\n \"0.81167454\",\n \"0.8113847\",\n \"0.8090466\",\n \"0.80842537\",\n \"0.8070545\",\n \"0.80473363\",\n \"0.80244833\",\n \"0.80222696\",\n \"0.80142\",\n \"0.7963673\",\n \"0.7962265\",\n \"0.7962265\",\n \"0.79258263\",\n \"0.7924748\",\n \"0.7910106\",\n \"0.7880401\",\n \"0.7865896\",\n \"0.7852999\",\n \"0.78060323\",\n \"0.7799159\",\n \"0.7760705\",\n \"0.7748111\",\n \"0.7722419\",\n \"0.7708694\",\n \"0.77079415\",\n \"0.7675929\",\n \"0.7661388\",\n \"0.76584923\",\n \"0.7632804\",\n \"0.7627969\",\n \"0.762729\",\n \"0.76091015\",\n \"0.7595937\",\n \"0.75892967\",\n \"0.75881845\",\n \"0.75832874\",\n \"0.7583276\",\n \"0.755741\",\n \"0.75534755\",\n \"0.7529439\",\n \"0.75187206\",\n \"0.7501087\",\n \"0.7493089\",\n \"0.74736077\",\n \"0.746824\",\n \"0.745469\",\n \"0.7451439\",\n \"0.7437464\",\n \"0.7410849\",\n \"0.74057436\",\n \"0.73977953\",\n \"0.7370247\",\n \"0.73670954\",\n \"0.7356686\",\n \"0.7356686\",\n \"0.73216\",\n \"0.7273192\",\n \"0.7273192\",\n \"0.7266639\",\n \"0.725893\",\n \"0.7247856\",\n \"0.7245229\",\n \"0.7223091\",\n \"0.7207827\",\n \"0.7207159\",\n \"0.7194789\",\n \"0.7191841\",\n \"0.71648115\",\n \"0.7158346\",\n \"0.71554595\",\n \"0.71331006\",\n \"0.710514\",\n \"0.7103049\",\n \"0.70620286\",\n \"0.70268095\",\n \"0.7017761\",\n \"0.7008628\",\n \"0.7008628\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6887,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the ``d x d`` identity matrices on ``nvar`` variables."},"document":{"kind":"string","value":"def symbolic_max_plus_identity(d, nvar, ch=None):\n d = int(d)\n nvar = int(nvar)\n V = FreeModule(ZZ, nvar)\n e = ()\n zero = (V([0]*nvar),)\n\n data = [[zero if i == j else e for j in range(d)] for i in range(d)]\n return SymbolicMaxPlusMatrix(d, nvar, data, ch)"},"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 identity_matrix(self, n):\r\n IdM = self.zeros_matrix(n, n)\r\n for i in range(n):\r\n IdM[i][i] = 1.0\r\n \r\n return IdM","def identity(n):\r\n I = np.zeros((n, n))\r\n diag = np.ones(n)\r\n np.fill_diagonal(I, diag)\r\n return matrix(I)","def identity_matrix(n):\n data = [[1 if c == r else 0 for c in range(n)] for r in range(n)]\n return Matrix(data)","def matIxs( n ):\n rows, cols = np.indices( (n,n) )\n row = rows.flatten()\n col = cols.flatten()\n \n return map( lambda x: Vector( x[0], x[1] ), zip( col, row ) )","def I(n):\n identity = Matrix(n,n)\n print identity.matrix\n index = 0 \n for i in range(identity.nrows):\n for j in range(identity.ncols):\n identity.matrix[i][index] = 1\n index += 1\n\n\n flat = []\n for i in range(identity.nrows):\n for j in range(identity.ncols):\n flat.append(identity.matrix[i][j])\n\n\n return identity","def identity_matrix(n):\n I = zeros_matrix(n, n)\n for i in range(n):\n I[i][i] = 1.0\n\n return I","def identity_matrix(n):\n I = zeros_matrix(n, n)\n for i in range(n):\n I[i][i] = 1.0\n\n return I","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def identity_matrix():\n return numpy.identity(4)","def identity_matrix():\r\n return numpy.identity(4)","def make_numpy_matrix(df,variables):\n observations = []\n for col in variables:\n observations.append(np.array(df[col]))\n observations = np.mat(observations).transpose().A #annoying numpy magic, and Tim loves it\n print observations.shape\n return observations","def _identity_dense(d, dtype=complex):\n return np.eye(d, dtype=dtype)","def generate_random_matrix(n):\n return [[random.randint(1, 50) for i in range(n)] for j in range(n)]","def matEye(n):\n ret=matZeros((n,n))\n for i in range(n):\n matSet(ret,i,i,1)\n return ret","def eye(cls, n, domain):\n # XXX: flint matrices do not have anything like eye\n return DDM.eye(n, domain).to_dfm()","def identity(n):\n I = zeroes(n, n)\n for i in range(n):\n I.g[i][i] = 1.0\n return I","def define_iid_random_variable(rv, num_vars):\n unique_variables = [rv]\n unique_var_indices = [np.arange(num_vars)]\n return IndependentMarginalsVariable(\n unique_variables, unique_var_indices)","def get_dct_matrix(N):\r\n dct_m = np.eye(N)\r\n for k in np.arange(N):\r\n for i in np.arange(N):\r\n w = np.sqrt(2 / N)\r\n if k == 0:\r\n w = np.sqrt(1 / N)\r\n dct_m[k, i] = w * np.cos(np.pi * (i + 1 / 2) * k / N)\r\n idct_m = np.linalg.inv(dct_m)\r\n return dct_m, idct_m","def _compute_ind_mat(n, m, nb_coeff):\r\n\r\n ind_mat = np.zeros((nb_coeff, n))\r\n curr_idx = 0\r\n for indexes in itr.combinations_with_replacement(range(m), n):\r\n ind_mat[curr_idx] = np.array(indexes)\r\n curr_idx += 1\r\n\r\n return ind_mat","def identity(n,dtype=None):\n a = array([1]+n*[0],dtype=dtype)\n b = empty((n,n),dtype=dtype)\n b.flat = a\n return b","def coordinate_matrix(n):\n xcoordinates = np.zeros((n,n))\n xcoordinates = xcoordinates + np.arange(0,worksize) #broadcasting trick\n ycoordinates = xcoordinates.T\n return np.array([ycoordinates,xcoordinates])","def create_x_image(n):\n alist = create_diagonal_image(n)\n for i in range(0, n):\n alist[i][i]=1\n alist[i][n-1-i]=1\n return alist","def idiosyncratic_var_vector(returns, idiosyncratic_var_matrix):\r\n\r\n return pd.DataFrame(np.diag(idiosyncratic_var_matrix), returns.columns)","def identMatrix(size):\n returnvalue = Matrix()\n for i in range(size):\n newrow = [0] * size\n newrow[i] = 1\n returnvalue.addRow(*newrow)\n return returnvalue","def direct_obs_matrix(Nx,obs_inds):\n Ny = len(obs_inds)\n H = zeros((Ny,Nx))\n H[range(Ny),obs_inds] = 1\n return H","def identity(cls,N:int)-> 'Matrix': #note single quotes because this is the class, itself and has not been completely defined yet.\n\n # -------------------------------------------------------\n # TODO: You write this one.\n # I'd suggest that you start by using another method to get a matrix of the right size, and then modify it.\n\n\n I = cls.zeros((N,N))\n for i in range(N):\n I.mat[i][i] = 1\n return I\n\n return Matrix([[\"Not yet written\"]]) # remove this when you add your code.\n # -------------------------------------------------------","def eye(n,M=None, k=0, dtype=float):\n return asmatrix(np.eye(n,M,k,dtype))","def build_difs_matrix(xs):\n n = len(xs)\n difs = np.zeros((n, n, 2))\n for row_id in range(n):\n ident = -np.eye(n)\n ident[:, row_id] += 1\n difs[row_id, :, 0] = ident @ xs[:, 0]\n difs[row_id, :, 1] = ident @ xs[:, 1]\n return difs","def get_matrixS(n):\n\n mat_nxn = np.zeros([n, n], dtype=int)\n for row_num in range(1, n + 1):\n i = row_num - 1\n if row_num == 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i + 2] = 1\n elif row_num == 2:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i + 2] = 1\n elif row_num == n - 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num == n:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num % 2 == 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i + 2] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num % 2 == 0:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i + 2] = 1\n mat_nxn[i][i - 2] = 1\n mat_nxn = mat_nxn + np.eye(n, dtype=int)\n mat_2nx2n = np.repeat(np.repeat(mat_nxn, 2, 0), 2, 1)\n return torch.as_tensor(mat_2nx2n)","def generate_positive_semi_definite_matrix(n_dim):\n cov = np.random.randn(n_dim, n_dim)\n return np.dot(cov, cov.T)","def create_dims(self, n_vec, m_vec):\n dims_mat = np.array([], dtype=np.int64).reshape(2, 0)\n for n in n_vec:\n for m in m_vec[m_vec > n]:\n dims_mat = np.hstack((dims_mat,\n np.array([[n], [m]])))\n return dims_mat","def to_array(X, n=2):\n return np.array([np.eye(n)[x] for x in X])","def vars(self):\n return [Var(i,self.dims[i]) for i in range(self.nvar)] # TODO: use stored state info (=1 sometimes)","def _make_random_matrix(self, n_components, n_features):","def generate_random_sparse_array(nrows, ncols, numdense):\n i = np.random.randint(0, nrows, numdense)\n j = np.random.randint(0, ncols, numdense)\n data = np.random.randint(1,6, numdense)\n ij = np.vstack((i,j))\n return coo_matrix((data, ij), shape=(nrows, ncols))","def unfold_grid(var):\n if (len(var.shape)==2): # 2-D variable\n work = N.concatenate((N.zeros((var.shape[0],24),float),var),1)\n work[39:68,0:24] = work[39:68,var.shape[1]:]\n work[39:68,var.shape[1]:] = 0.0\n elif (len(var.shape)==3): # 3-D variable\n work = (N.concatenate((N.zeros((var.shape[0],var.shape[1],24),float),\n var),2))\n work[:,39:68,0:24] = work[:,39:68,var.shape[2]:]\n work[:,39:68,var.shape[2]:] = 0.0\n\n return work","def create_matrix(n, m):\n matrix = [[None]*m for i in range(n)]\n return matrix","def createarray(m,n):\n return( np.ones((m,2,n)) )","def diag_indices(n, ndim=2):\r\n idx = np.arange(n)\r\n return (idx,) * ndim","def build_toy_dataset(N):\n pi = np.array([0.4, 0.6])\n mus = [[1, 1], [-1, -1]]\n stds = [[0.1, 0.1], [0.1, 0.1]]\n x = np.zeros((N, 2), dtype=np.float32)\n\n for n in range(N):\n k = np.argmax(np.random.multinomial(1, pi))\n x[n, :] = np.random.multivariate_normal(mus[k], np.diag(stds[k]))\n\n return x","def makeHadamard(n, d):\n return [[1 if d[\"r%dc%d\" % (i, j)] else 0 for j in range(n)] for i in range(n)]","def irandmatrix(n, range = 10):\n A = mp.matrix(n, n)\n for i in xrange(n):\n for j in xrange(n):\n A[i,j]=int( (2 * mp.rand() - 1) * range)\n return A","def reshape_var(var):\n dims = np.shape(var)\n nx = dims[0]\n ny = dims[1]\n nz = dims[2]\n\n var_2d = var.reshape(nx * ny, nz)\n return var_2d","def Dinvmatrix(N):\r\n import numpy as np\r\n D = np.zeros((N,N,2))\r\n D[:,:,0] = np.diag((np.append(np.ones((1,int(N/2))),np.zeros((1,int(N/2))))))\r\n D[:,:,1] = np.diag((np.append(np.zeros((1,int(N/2))),np.ones((1,int(N/2))))))\r\n return D","def normal(n):\n m=np.zeros((n,n))\n for i,j in itertools.product(range(n), range(n)):\n m[i][j]=normalvariate(0,1)\n return m","def init(nvars, shape, dtype=float, masked=True):\n fun = ma.zeros if masked else np.zeros\n for _ in range(nvars):\n yield fun(shape, dtype=dtype)","def makeIncidenceMatrix(self, variable, token, mechanism, network):\n model = self.model\n size = self.size_of_variable( variable )\n mat = np.zeros(size)\n for i, (label, node) in enumerate(model.nodes.items()):\n if node.named_network in self.nw_nnw_dict[network]:\n for j, (arc_label, arc) in enumerate(model.arcs.items()):\n if str(node.label) == str(arc.source) and mechanism == arc.mechanism:\n mat[i, j] = -1.\n elif str(node.label) == str(arc.sink) and mechanism == arc.mechanism:\n mat[i, j] = 1.\n return mat","def idiosyncratic_var_matrix(returns, factor_returns, factor_betas, ann_factor):\r\n residuals_ = returns - pd.DataFrame(np.dot(factor_returns, factor_betas.T), index=returns.index, columns=returns.columns)\r\n return pd.DataFrame(np.diag(residuals_.var(axis=0, ddof=1) * ann_factor),returns.columns,returns.columns)","def make_matrix(n):\n #number that makes up the matrix depending on value of n\n num = 1/n**2\n #creates a blur box as a dictionary\n blur_box = {'height': n, 'width': n, 'pixels': [num]*n**2 }\n return blur_box","def gen_mats(seed, shape, n=4, fmt=\"csr\", density=0.1):\n\n np.random.seed(seed)\n dens = density * np.random.random()\n mats = [sp.random(*shape, density=dens, format=fmt) for i in range(n)]\n return mats","def get_extremist_network(Nx, Dx):\n N = np.zeros([Nx, Nx], dtype=int)\n\n for i in range(0, Nx): # Iterate over the upper diagonal only\n for j in range(i+1, Nx):\n r = rg.random() # r is in [0.0, 1.0)\n if r <= Dx:\n N[i][j] = 1\n N[j][i] = 1\n return N","def generate_matrix(size) -> np.ndarray:\n np.random.seed(1)\n return np.random.rand(size, size) - 0.5","def get_identity(l):\n identity = np.zeros((l, l))\n for i in range(l):\n identity[i][i] = 1\n return identity","def idensity(n):\n I = zeroes(n, n)\n for i in range(n):\n I.g[i][i] = 1.0\n return I","def var(self,i): # TODO: change to property to access (read only?) X?\n return Var(i,self.dims[i])","def xn_xn_prod(self,x_n):\n \n x_n_tiled =T.tile(x_n,(self.num_vars,1))\n \n return T.transpose(x_n_tiled)*x_n_tiled","def init_matrix(x_dim = 10, y_dim = 10):\n ret = np.zeros((x_dim, y_dim))\n x_rand = np.random.randint(0, x_dim - 1)\n y_rand = np.random.randint(0, y_dim - 1)\n ret[x_rand, y_rand] = 1\n\n return(ret)","def get_multivariate_matrix(x_data, D):\n rows = []\n terms = get_polynomial(['x1', 'x2', 'x3', 'x4', 'x5'], D)\n for row in range(len(x_data)):\n row_data = {}\n row_data['x1'] = x_data[row, 0]\n row_data['x2'] = x_data[row, 1]\n row_data['x3'] = x_data[row, 2]\n row_data['x4'] = x_data[row, 3]\n row_data['x5'] = x_data[row, 4]\n \n row_entry = []\n for t in terms:\n prod = 1\n for var in t:\n prod *= row_data[var]\n row_entry.append(prod)\n \n row_entry = np.array(row_entry) \n rows.append(row_entry)\n return np.vstack(rows)","def nvar(self):\n return self.h.shape[0]","def make_synthetic_matrix(n_features, n_samples, sparsity=.98, random_state=0):\n prng = check_random_state(random_state)\n prec = make_sparse_spd_matrix(n_features, alpha=sparsity,\n smallest_coef=.4, largest_coef=.7,\n random_state=prng)\n cov = linalg.inv(prec)\n d = np.sqrt(np.diag(cov))\n cov /= d\n cov /= d[:, np.newaxis]\n prec *= d\n prec *= d[:, np.newaxis]\n X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples)\n X -= X.mean(axis=0)\n X /= X.std(axis=0)\n # Estimate the covariance\n emp_cov = np.dot(X.T, X) / n_samples\n return emp_cov, prec","def makeIdentity(m):\n Matrix.validate_dimensions(m, m)\n data = [[1 if i == j else 0 for j in range(m)] for i in range(m)]\n return IntegerMatrix(m, m, data)","def _instantiate_vars(labels: np.ndarray):\n n = len(labels)\n if len(set(labels)) == n:\n index_seed = np.arange(n)\n index_remain = np.arange(n)\n else:\n index_seed = np.argwhere(labels >= 0).ravel()\n index_remain = np.argwhere(labels < 0).ravel()\n labels = labels[index_seed]\n return index_seed.astype(np.int32), index_remain.astype(np.int32), labels.astype(np.int32)","def crear_matrix(nxn):\n matrix =[]\n for i in range(nxn):\n matrix.append([])\n for e in range(nxn):\n matrix[i].append(\"\")\n return matrix","def simulator(n, mu, covmat):\n a = np.random.multivariate_normal(mu, covmat, n)\n return [tuple(a[i, :]) for i in range(n)]","def generate_sparse_randn(n, s):\n x = np.zeros(n)\n I = np.random.randint(0, n, s)\n x[I] = np.random.randn(s)\n return x","def _defineNAVars(self, vars):\n self.na_dict[\"NV\"] = len(vars)\n self.na_dict[\"VNAME\"] = []\n self.na_dict[\"VMISS\"] = []\n self.na_dict[\"VSCAL\"] = []\n self.na_dict[\"V\"] = []\n\n for var in vars:\n name = xarray_utils.getBestName(var)\n self.na_dict[\"VNAME\"].append(name)\n miss = xarray_utils.getMissingValue(var)\n miss = self._resolve_float(miss)\n\n self.na_dict[\"VMISS\"].append(miss)\n self.na_dict[\"VSCAL\"].append(1)\n\n # Populate the variable list with the array\n # Make sure missing values are converted to real values using the required missing value\n self.na_dict[\"V\"].append(xarray_utils.getArrayAsList(var, missing_value=miss, handle_datetimes=True))\n\n # Create independent variable info\n if not \"X\" in self.na_dict:\n\n # Set up lists ready to populate with values\n self.na_dict[\"NXDEF\"] = []\n self.na_dict[\"NX\"] = []\n\n self.ax0 = xarray_utils.get_coord_by_index(var, 0)\n\n self.na_dict[\"X\"] = [xarray_utils.getArrayAsList(self.ax0)]\n self.na_dict[\"XNAME\"] = [xarray_utils.getBestName(self.ax0)]\n\n if len(self.ax0) == 1:\n self.na_dict[\"DX\"] = [0]\n else:\n # Set default increment as gap between first two\n incr = xarray_utils.get_interval(self.ax0, 0, 1)\n\n self.na_dict[\"DX\"] = [incr]\n # Now overwrite it as zero if non-uniform interval in axis\n\n for i in range(1, len(self.ax0)):\n if xarray_utils.get_interval(self.ax0, i-1, i) != incr:\n self.na_dict[\"DX\"] = [0]\n break\n\n # If 1D only then \"X\" should only be a list and not list of lists\n if self.na_dict[\"FFI\"] in (1001, 1010, 1020):\n self.na_dict[\"X\"] = self.na_dict[\"X\"][0]\n\n # If FFI is 1020 need to reduce axis down to reduced values as most are implied\n if self.na_dict[\"FFI\"] == 1020: \n vals = self.na_dict[\"X\"]\n self.na_dict[\"X\"] = vals[0:len(vals):self.na_dict[\"NVPM\"]] \n\n # Now add the rest of the axes to the self.na_dict objects \n for axis in xarray_utils.getAxisList(var)[1:]:\n self._appendAxisDefinition(axis)\n\n # If FFI is 2110 then need to modify the \"NX\" and \"X\" lists to cope with odd shape\n # Also need to add NX to auxiliary variables\n if self.na_dict[\"FFI\"] == 2110:\n new_x = []\n new_nx = []\n ax2_values = xarray_utils.get_coord_by_index(var, 1).data.tolist()\n\n for i in self.ax0[:]:\n new_x.append([i, ax2_values])\n new_nx.append(len(ax2_values))\n\n # Re-assign to new lists\n self.na_dict[\"NX\"] = new_nx\n self.na_dict[\"X\"] = new_x \n\n # Now auxiliary variable info here with independent var info\n # First aux var is NX\n self.na_dict[\"A\"] = [self.na_dict[\"NX\"][:]]\n ind_var_name = self.na_dict[\"XNAME\"][0]\n self.na_dict[\"ANAME\"] = [\"Number of '%s' values recorded in subsequent data records\" % ind_var_name]\n self.na_dict[\"AMISS\"] = [-9999.999]\n self.na_dict[\"ASCAL\"] = [1.0]\n\n # If FFI is 2310 then need to modify na_dict items for that\n elif self.na_dict[\"FFI\"] == 2310:\n new_x = []\n new_nx = []\n new_dx = []\n ax2_values = xarray_utils.get_coord_by_index(var, 1).data.tolist()\n incr = xarray_utils.get_interval(ax2_values, 0, 1)\n\n for i in self.ax0[:]:\n new_x.append([i, ax2_values])\n new_nx.append(len(ax2_values))\n new_dx.append(incr)\n\n # Re-assign to new lists\n self.na_dict[\"NX\"] = new_nx\n self.na_dict[\"X\"] = new_x\n self.na_dict[\"DX\"] = new_dx\n\n # Now auxiliary variable info here with independent var info\n # First three aux vars are NX, X0 and DX\n self.na_dict[\"A\"] = []\n self.na_dict[\"A\"].append(self.na_dict[\"NX\"][:])\n self.na_dict[\"A\"].append([i[1][0] for i in self.na_dict[\"X\"]])\n self.na_dict[\"A\"].append(self.na_dict[\"DX\"][:])\n\n ind_var_name = self.na_dict[\"XNAME\"][0]\n self.na_dict[\"ANAME\"] = [\"Number of '%s' values recorded in subsequent data records\" % ind_var_name,\n \"'%s' value for first data point\" % ind_var_name,\n \"'%s' increment\" % ind_var_name]\n self.na_dict[\"AMISS\"] = [-9999.999, -9999.999, -9999.999]\n self.na_dict[\"ASCAL\"] = [1.0, 1.0, 1.0]","def matrix_generate(n):\n a = np.eye(n)\n max = 0\n for i in range(n):\n for j in range(n):\n a[i][j] = random.randint(0,50)\n a[j][i] = a[i][j]\n if a[i][j] > max:\n max = a[i][j]\n for i in range(n):\n a[i][i] = max * n + random.randint(20,40)\n return np.array(a)","def build_Xij_inv_matrix(self,Nmesh=64):\n H0, F = self.cosmo.H0, self.cosmo.F\n Lbox = self.attrs['Lbox']\n kgrid = initialize_kgrid(Nmesh,Lbox)\n kmag_grid = np.linalg.norm(kgrid,axis=3)\n w_grid = self.cosmo.Pk_lin(kmag_grid)*(1/Lbox**3)*np.exp(-kmag_grid*kmag_grid*self.RG*self.RG)\n k2 = kmag_grid**2\n k2[0,0,0] = 1 \n #----------------------------------------------------\n cspace = np.arange(0,18)\n \n xij_tensor = [[np.sum(np.conj(Hhats[i](kgrid,k2,H0,F))*Hhats[j](kgrid,k2,H0,F)*w_grid)\n for j in cspace[self.cmask]] for i in cspace[self.cmask]]\n \n xij_tensor = np.array(xij_tensor)\n self.xij_tensor_inv = np.linalg.inv(xij_tensor.real)","def make_matrix():\n row, col = [int(x) for x in input().split()]\n island = [[int(x) for x in input().split()] for _ in range(row)]\n return row, col, island","def generate_onehot_matrix(n: int = 1024, ndim: int = 8, random_seed: int = None) -> TYPE_ARRAY:\n to_vec = lambda x: [1 if i == x else 0 for i in range(ndim)]\n return numpy.array([to_vec(x) for x in _RNG.randint(0, ndim, n)]).astype(int)","def __init__(self, n):\n\t\tself._matr = []\n\t\tfor i in range(n):\n\t\t\tself._matr.append([])\n\t\t\tfor j in range(n):\n\t\t\t\tself._matr[i].append(False)","def _make_random_matrix(self, n_components, n_features):\n #random_state = check_random_state(self.random_state)\n return _gaussian_random_matrix(\n n_components, n_features, random_state=self.random_state\n )","def make_matrix(sizex, sizey):\n return [[0]*sizey for i in xrange(sizex)]","def construct_M_N(n):\n n2 = n**2\n D0 = 2*np.ones(n2) # 0th diagonal\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\n DN = - np.ones(n2 - n) # -nth, nth diagonals\n return (scipy.sparse.diags((D1, D0, D1), (-1, 0, 1), shape=(n2, n2), format=\"csr\"),\n scipy.sparse.diags((DN, D0, DN), (-n, 0, n), shape=(n2, n2), format=\"csr\"))","def new_game(n):\n matrix = []\n\n for i in range(n):\n matrix.append([0] * n)\n return matrix","def get_stain_matrix(I):","def create_array( n ):","def FE_create_interaction_vars(df, intxn_vars):\r\n df = df.copy(deep=True)\r\n for (each_intxn1,each_intxn2) in intxn_vars:\r\n new_col = each_intxn1 + '_x_' + each_intxn2\r\n try:\r\n df[new_col] = df[each_intxn1] * df[each_intxn2]\r\n except:\r\n continue\r\n return df","def make_xyz(df: pd.DataFrame,\n response_var: list,\n fixed_var: list = ['Sex']) -> np.ndarray:\n x = pd.get_dummies(df[fixed_var]).to_numpy()\n x = np.fliplr(x)\n n_animals = df.shape[0] # to fix z the the same shape\n z = np.identity(n_animals)[1]\n y = df[[response_var]].to_numpy()\n\n return x, z, y","def matrix_initialization(variable):\n # Range of value for 11 and 22\n min_11 = 2.0\n max_11 = 4.5\n # Range of random values for 33\n min_33 = 8.0\n max_33 = 13.0\n # range of values for off-diagonal\n min_offdiag = -0.8\n max_offdiag = 0.8\n\n if variable[-2:] == \"33\":\n return np.round(min_33 + (max_33 - min_33) * np.random.rand(), 1)\n if variable[-1] == variable[-2]:\n return np.round(min_11 + (max_11 - min_11) * np.random.rand(), 1)\n return np.round(min_offdiag + (max_offdiag - min_offdiag) * np.random.rand(), 1)","def random_transition_matrix(n: int) -> np.ndarray:\n\n x = np.abs(np.random.normal(size=(n, n)))\n rsum = x.sum(axis=1)\n return x / rsum[:, np.newaxis]","def generate(n):\n \n m1 = np.zeros((n, n), dtype = int)\n m2 = np.zeros((n, n), dtype = int)\n \n for i in range(n):\n for j in range(n):\n m1[i][j] = (j % 32)\n m2[i][j] = (j % 64)\n \n return m1,m2","def __init__(self, n):\r\n self.matr = []\r\n self.n = n\r\n for i in range(n):\r\n self.matr.append([])\r\n for j in range(n):\r\n self.matr[i].append(False)","def make_data(n,m):\n I = range(1,n+1)\n J = range(1,m+1)\n x,y,w = {},{},{}\n for i in I:\n x[i] = random.randint(0,100)\n y[i] = random.randint(0,100)\n w[i] = random.randint(1,5)\n return I,J,x,y,w","def __init__(self, n):\r\n self.size = n\r\n self.mat = []\r\n for i in range(n):\r\n self.mat.append([0] * n)","def make_matrix(sizex, sizey):\n return [[0] * sizey for i in range(sizex)]","def create_variable_array(times):\n R=np.empty(np.sum(times))\n return R","def initial_x():\n\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\n\n return np.array(temp, dtype=np.float_)","def generate_pos_def(n):\n A = np.random.normal(size=(n,n)) + 1j * np.random.normal(size=(n,n))\n A += np.conjugate(A).T\n # Add just enough of an identity matrix to make all eigenvalues positive\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\n return A","def generate_grid(nrows, ncols, ndots):\n\n # Validation\n if nrows * ncols < ndots:\n raise Exception(\"ndots must be <= than grid size\")\n\n rows = np.arange(1, nrows + 1)\n cols = np.arange(1, ncols + 1)\n\n # Create empty matrix\n grid = np.empty((len(rows), len(cols), 2), dtype=np.intp)\n grid[..., 0] = rows[:, None]\n grid[..., 1] = cols \n\n return grid.reshape(nrows * ncols, -1)[:ndots]","def marginals(self):\n all_variables = [None for ii in range(self.nvars)]\n for ii in range(self.nunique_vars):\n for jj in self.unique_variable_indices[ii]:\n all_variables[jj] = self.unique_variables[ii]\n return all_variables","def create_matrix(list_of_edges, n):\n matrix = [[0 for i in range(n)] for j in range(n)]\n ind = 0\n for i in range(n):\n for j in range(i):\n matrix[i][j] = list_of_edges[ind]\n matrix[j][i] = list_of_edges[ind]\n ind += 1\n return matrix","def zeros(m, n):\n data = dict.fromkeys(itertools.product(range(m), range(n)), mpfr(0))\n return MPMatrix((m, n), data)","def get5x5matrix(self): #modified from nxvasc get3x3matrix()\n try:\n i = na.identity(3)\n \n self.d124 = i.copy()\n self.ds124 = na.zeros(124,na.float64)\n \n for k in range(1,124):\n self.d124 = na.concatenate((self.d124,i))\n# print len(self.d124)\n count = 0\n a = []\n for k in range(-2,3):\n for j in range(-2,3):\n for i in range(-2,3):\n if( i != 0 or j != 0 or k != 0 ):\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\n count += 1\n a.append(i)\n a.append(j)\n a.append(k)\n# print len(a)\n a = na.reshape(na.array(a),(372,1))\n# print len(self.d124)\n self.d124 = na.concatenate((self.d124,a),axis=1)\n except Exception as error:\n print(\"failed in get5x5matrix(): \", error)","def random_density_matrix(nqubits: int, dtype=np.complex128) -> np.ndarray:\n rho = random_numpy_hermitian(nqubits, dtype=dtype)\n # Normalize\n ids = np.arange(2 ** nqubits)\n rho[ids, ids] = rho[ids, ids] / np.trace(rho)\n return rho.astype(dtype)","def generate_pos_def_all_pos(n):\n A = np.random.uniform(size=(n,n))\n A += A.T\n # Add just enough of an identity matrix to make all eigenvalues positive\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\n return A","def EmptyStateMat(nX,nU,nY):\n Xx = np.zeros((nX,nX)) # Ac \n Yx = np.zeros((nY,nX)) # Gc \n Xu = np.zeros((nX,nU)) # Xu \n Yu = np.zeros((nY,nU)) # Jc \n return Xx,Xu,Yx,Yu","def synthesize_data_X(n_x, m, mu_x = sp.random.random(1) * 25, sigma_x = sp.random.random(1) * 25):\n # Create a (1*m) array that represents m examples of a feature x_i.\n x_i = sp.random.normal(mu_x, sigma_x, m).reshape(1, m)\n # Compile all n_x x_i's into a matrix X, dim (n_x * m).\n X = np.matrix(np.array([sp.random.normal(mu_x, sigma_x, m).reshape(1, m)\n for i in range(n_x)])).reshape(n_x, m)\n return X, n_x, m, mu_x, sigma_x","def create_diagonal_image(n):\n alist = []\n for i in range(0, n):\n alist.append([])\n for j in range(0,n):\n if i ==j:\n alist[i].append(1)\n else:\n alist[i].append(0)\n\n ##########\n # img = create_zeroed_image(n)\n # for i in range(n):\n# for j in range(n):\n# if i == j:\n# img[i][j] = 1\n #######\n \n return alist"],"string":"[\n \"def identity_matrix(self, n):\\r\\n IdM = self.zeros_matrix(n, n)\\r\\n for i in range(n):\\r\\n IdM[i][i] = 1.0\\r\\n \\r\\n return IdM\",\n \"def identity(n):\\r\\n I = np.zeros((n, n))\\r\\n diag = np.ones(n)\\r\\n np.fill_diagonal(I, diag)\\r\\n return matrix(I)\",\n \"def identity_matrix(n):\\n data = [[1 if c == r else 0 for c in range(n)] for r in range(n)]\\n return Matrix(data)\",\n \"def matIxs( n ):\\n rows, cols = np.indices( (n,n) )\\n row = rows.flatten()\\n col = cols.flatten()\\n \\n return map( lambda x: Vector( x[0], x[1] ), zip( col, row ) )\",\n \"def I(n):\\n identity = Matrix(n,n)\\n print identity.matrix\\n index = 0 \\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n identity.matrix[i][index] = 1\\n index += 1\\n\\n\\n flat = []\\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n flat.append(identity.matrix[i][j])\\n\\n\\n return identity\",\n \"def identity_matrix(n):\\n I = zeros_matrix(n, n)\\n for i in range(n):\\n I[i][i] = 1.0\\n\\n return I\",\n \"def identity_matrix(n):\\n I = zeros_matrix(n, n)\\n for i in range(n):\\n I[i][i] = 1.0\\n\\n return I\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def identity_matrix():\\n return numpy.identity(4)\",\n \"def identity_matrix():\\r\\n return numpy.identity(4)\",\n \"def make_numpy_matrix(df,variables):\\n observations = []\\n for col in variables:\\n observations.append(np.array(df[col]))\\n observations = np.mat(observations).transpose().A #annoying numpy magic, and Tim loves it\\n print observations.shape\\n return observations\",\n \"def _identity_dense(d, dtype=complex):\\n return np.eye(d, dtype=dtype)\",\n \"def generate_random_matrix(n):\\n return [[random.randint(1, 50) for i in range(n)] for j in range(n)]\",\n \"def matEye(n):\\n ret=matZeros((n,n))\\n for i in range(n):\\n matSet(ret,i,i,1)\\n return ret\",\n \"def eye(cls, n, domain):\\n # XXX: flint matrices do not have anything like eye\\n return DDM.eye(n, domain).to_dfm()\",\n \"def identity(n):\\n I = zeroes(n, n)\\n for i in range(n):\\n I.g[i][i] = 1.0\\n return I\",\n \"def define_iid_random_variable(rv, num_vars):\\n unique_variables = [rv]\\n unique_var_indices = [np.arange(num_vars)]\\n return IndependentMarginalsVariable(\\n unique_variables, unique_var_indices)\",\n \"def get_dct_matrix(N):\\r\\n dct_m = np.eye(N)\\r\\n for k in np.arange(N):\\r\\n for i in np.arange(N):\\r\\n w = np.sqrt(2 / N)\\r\\n if k == 0:\\r\\n w = np.sqrt(1 / N)\\r\\n dct_m[k, i] = w * np.cos(np.pi * (i + 1 / 2) * k / N)\\r\\n idct_m = np.linalg.inv(dct_m)\\r\\n return dct_m, idct_m\",\n \"def _compute_ind_mat(n, m, nb_coeff):\\r\\n\\r\\n ind_mat = np.zeros((nb_coeff, n))\\r\\n curr_idx = 0\\r\\n for indexes in itr.combinations_with_replacement(range(m), n):\\r\\n ind_mat[curr_idx] = np.array(indexes)\\r\\n curr_idx += 1\\r\\n\\r\\n return ind_mat\",\n \"def identity(n,dtype=None):\\n a = array([1]+n*[0],dtype=dtype)\\n b = empty((n,n),dtype=dtype)\\n b.flat = a\\n return b\",\n \"def coordinate_matrix(n):\\n xcoordinates = np.zeros((n,n))\\n xcoordinates = xcoordinates + np.arange(0,worksize) #broadcasting trick\\n ycoordinates = xcoordinates.T\\n return np.array([ycoordinates,xcoordinates])\",\n \"def create_x_image(n):\\n alist = create_diagonal_image(n)\\n for i in range(0, n):\\n alist[i][i]=1\\n alist[i][n-1-i]=1\\n return alist\",\n \"def idiosyncratic_var_vector(returns, idiosyncratic_var_matrix):\\r\\n\\r\\n return pd.DataFrame(np.diag(idiosyncratic_var_matrix), returns.columns)\",\n \"def identMatrix(size):\\n returnvalue = Matrix()\\n for i in range(size):\\n newrow = [0] * size\\n newrow[i] = 1\\n returnvalue.addRow(*newrow)\\n return returnvalue\",\n \"def direct_obs_matrix(Nx,obs_inds):\\n Ny = len(obs_inds)\\n H = zeros((Ny,Nx))\\n H[range(Ny),obs_inds] = 1\\n return H\",\n \"def identity(cls,N:int)-> 'Matrix': #note single quotes because this is the class, itself and has not been completely defined yet.\\n\\n # -------------------------------------------------------\\n # TODO: You write this one.\\n # I'd suggest that you start by using another method to get a matrix of the right size, and then modify it.\\n\\n\\n I = cls.zeros((N,N))\\n for i in range(N):\\n I.mat[i][i] = 1\\n return I\\n\\n return Matrix([[\\\"Not yet written\\\"]]) # remove this when you add your code.\\n # -------------------------------------------------------\",\n \"def eye(n,M=None, k=0, dtype=float):\\n return asmatrix(np.eye(n,M,k,dtype))\",\n \"def build_difs_matrix(xs):\\n n = len(xs)\\n difs = np.zeros((n, n, 2))\\n for row_id in range(n):\\n ident = -np.eye(n)\\n ident[:, row_id] += 1\\n difs[row_id, :, 0] = ident @ xs[:, 0]\\n difs[row_id, :, 1] = ident @ xs[:, 1]\\n return difs\",\n \"def get_matrixS(n):\\n\\n mat_nxn = np.zeros([n, n], dtype=int)\\n for row_num in range(1, n + 1):\\n i = row_num - 1\\n if row_num == 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i + 2] = 1\\n elif row_num == 2:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i + 2] = 1\\n elif row_num == n - 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num == n:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num % 2 == 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i + 2] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num % 2 == 0:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i + 2] = 1\\n mat_nxn[i][i - 2] = 1\\n mat_nxn = mat_nxn + np.eye(n, dtype=int)\\n mat_2nx2n = np.repeat(np.repeat(mat_nxn, 2, 0), 2, 1)\\n return torch.as_tensor(mat_2nx2n)\",\n \"def generate_positive_semi_definite_matrix(n_dim):\\n cov = np.random.randn(n_dim, n_dim)\\n return np.dot(cov, cov.T)\",\n \"def create_dims(self, n_vec, m_vec):\\n dims_mat = np.array([], dtype=np.int64).reshape(2, 0)\\n for n in n_vec:\\n for m in m_vec[m_vec > n]:\\n dims_mat = np.hstack((dims_mat,\\n np.array([[n], [m]])))\\n return dims_mat\",\n \"def to_array(X, n=2):\\n return np.array([np.eye(n)[x] for x in X])\",\n \"def vars(self):\\n return [Var(i,self.dims[i]) for i in range(self.nvar)] # TODO: use stored state info (=1 sometimes)\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def generate_random_sparse_array(nrows, ncols, numdense):\\n i = np.random.randint(0, nrows, numdense)\\n j = np.random.randint(0, ncols, numdense)\\n data = np.random.randint(1,6, numdense)\\n ij = np.vstack((i,j))\\n return coo_matrix((data, ij), shape=(nrows, ncols))\",\n \"def unfold_grid(var):\\n if (len(var.shape)==2): # 2-D variable\\n work = N.concatenate((N.zeros((var.shape[0],24),float),var),1)\\n work[39:68,0:24] = work[39:68,var.shape[1]:]\\n work[39:68,var.shape[1]:] = 0.0\\n elif (len(var.shape)==3): # 3-D variable\\n work = (N.concatenate((N.zeros((var.shape[0],var.shape[1],24),float),\\n var),2))\\n work[:,39:68,0:24] = work[:,39:68,var.shape[2]:]\\n work[:,39:68,var.shape[2]:] = 0.0\\n\\n return work\",\n \"def create_matrix(n, m):\\n matrix = [[None]*m for i in range(n)]\\n return matrix\",\n \"def createarray(m,n):\\n return( np.ones((m,2,n)) )\",\n \"def diag_indices(n, ndim=2):\\r\\n idx = np.arange(n)\\r\\n return (idx,) * ndim\",\n \"def build_toy_dataset(N):\\n pi = np.array([0.4, 0.6])\\n mus = [[1, 1], [-1, -1]]\\n stds = [[0.1, 0.1], [0.1, 0.1]]\\n x = np.zeros((N, 2), dtype=np.float32)\\n\\n for n in range(N):\\n k = np.argmax(np.random.multinomial(1, pi))\\n x[n, :] = np.random.multivariate_normal(mus[k], np.diag(stds[k]))\\n\\n return x\",\n \"def makeHadamard(n, d):\\n return [[1 if d[\\\"r%dc%d\\\" % (i, j)] else 0 for j in range(n)] for i in range(n)]\",\n \"def irandmatrix(n, range = 10):\\n A = mp.matrix(n, n)\\n for i in xrange(n):\\n for j in xrange(n):\\n A[i,j]=int( (2 * mp.rand() - 1) * range)\\n return A\",\n \"def reshape_var(var):\\n dims = np.shape(var)\\n nx = dims[0]\\n ny = dims[1]\\n nz = dims[2]\\n\\n var_2d = var.reshape(nx * ny, nz)\\n return var_2d\",\n \"def Dinvmatrix(N):\\r\\n import numpy as np\\r\\n D = np.zeros((N,N,2))\\r\\n D[:,:,0] = np.diag((np.append(np.ones((1,int(N/2))),np.zeros((1,int(N/2))))))\\r\\n D[:,:,1] = np.diag((np.append(np.zeros((1,int(N/2))),np.ones((1,int(N/2))))))\\r\\n return D\",\n \"def normal(n):\\n m=np.zeros((n,n))\\n for i,j in itertools.product(range(n), range(n)):\\n m[i][j]=normalvariate(0,1)\\n return m\",\n \"def init(nvars, shape, dtype=float, masked=True):\\n fun = ma.zeros if masked else np.zeros\\n for _ in range(nvars):\\n yield fun(shape, dtype=dtype)\",\n \"def makeIncidenceMatrix(self, variable, token, mechanism, network):\\n model = self.model\\n size = self.size_of_variable( variable )\\n mat = np.zeros(size)\\n for i, (label, node) in enumerate(model.nodes.items()):\\n if node.named_network in self.nw_nnw_dict[network]:\\n for j, (arc_label, arc) in enumerate(model.arcs.items()):\\n if str(node.label) == str(arc.source) and mechanism == arc.mechanism:\\n mat[i, j] = -1.\\n elif str(node.label) == str(arc.sink) and mechanism == arc.mechanism:\\n mat[i, j] = 1.\\n return mat\",\n \"def idiosyncratic_var_matrix(returns, factor_returns, factor_betas, ann_factor):\\r\\n residuals_ = returns - pd.DataFrame(np.dot(factor_returns, factor_betas.T), index=returns.index, columns=returns.columns)\\r\\n return pd.DataFrame(np.diag(residuals_.var(axis=0, ddof=1) * ann_factor),returns.columns,returns.columns)\",\n \"def make_matrix(n):\\n #number that makes up the matrix depending on value of n\\n num = 1/n**2\\n #creates a blur box as a dictionary\\n blur_box = {'height': n, 'width': n, 'pixels': [num]*n**2 }\\n return blur_box\",\n \"def gen_mats(seed, shape, n=4, fmt=\\\"csr\\\", density=0.1):\\n\\n np.random.seed(seed)\\n dens = density * np.random.random()\\n mats = [sp.random(*shape, density=dens, format=fmt) for i in range(n)]\\n return mats\",\n \"def get_extremist_network(Nx, Dx):\\n N = np.zeros([Nx, Nx], dtype=int)\\n\\n for i in range(0, Nx): # Iterate over the upper diagonal only\\n for j in range(i+1, Nx):\\n r = rg.random() # r is in [0.0, 1.0)\\n if r <= Dx:\\n N[i][j] = 1\\n N[j][i] = 1\\n return N\",\n \"def generate_matrix(size) -> np.ndarray:\\n np.random.seed(1)\\n return np.random.rand(size, size) - 0.5\",\n \"def get_identity(l):\\n identity = np.zeros((l, l))\\n for i in range(l):\\n identity[i][i] = 1\\n return identity\",\n \"def idensity(n):\\n I = zeroes(n, n)\\n for i in range(n):\\n I.g[i][i] = 1.0\\n return I\",\n \"def var(self,i): # TODO: change to property to access (read only?) X?\\n return Var(i,self.dims[i])\",\n \"def xn_xn_prod(self,x_n):\\n \\n x_n_tiled =T.tile(x_n,(self.num_vars,1))\\n \\n return T.transpose(x_n_tiled)*x_n_tiled\",\n \"def init_matrix(x_dim = 10, y_dim = 10):\\n ret = np.zeros((x_dim, y_dim))\\n x_rand = np.random.randint(0, x_dim - 1)\\n y_rand = np.random.randint(0, y_dim - 1)\\n ret[x_rand, y_rand] = 1\\n\\n return(ret)\",\n \"def get_multivariate_matrix(x_data, D):\\n rows = []\\n terms = get_polynomial(['x1', 'x2', 'x3', 'x4', 'x5'], D)\\n for row in range(len(x_data)):\\n row_data = {}\\n row_data['x1'] = x_data[row, 0]\\n row_data['x2'] = x_data[row, 1]\\n row_data['x3'] = x_data[row, 2]\\n row_data['x4'] = x_data[row, 3]\\n row_data['x5'] = x_data[row, 4]\\n \\n row_entry = []\\n for t in terms:\\n prod = 1\\n for var in t:\\n prod *= row_data[var]\\n row_entry.append(prod)\\n \\n row_entry = np.array(row_entry) \\n rows.append(row_entry)\\n return np.vstack(rows)\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def make_synthetic_matrix(n_features, n_samples, sparsity=.98, random_state=0):\\n prng = check_random_state(random_state)\\n prec = make_sparse_spd_matrix(n_features, alpha=sparsity,\\n smallest_coef=.4, largest_coef=.7,\\n random_state=prng)\\n cov = linalg.inv(prec)\\n d = np.sqrt(np.diag(cov))\\n cov /= d\\n cov /= d[:, np.newaxis]\\n prec *= d\\n prec *= d[:, np.newaxis]\\n X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples)\\n X -= X.mean(axis=0)\\n X /= X.std(axis=0)\\n # Estimate the covariance\\n emp_cov = np.dot(X.T, X) / n_samples\\n return emp_cov, prec\",\n \"def makeIdentity(m):\\n Matrix.validate_dimensions(m, m)\\n data = [[1 if i == j else 0 for j in range(m)] for i in range(m)]\\n return IntegerMatrix(m, m, data)\",\n \"def _instantiate_vars(labels: np.ndarray):\\n n = len(labels)\\n if len(set(labels)) == n:\\n index_seed = np.arange(n)\\n index_remain = np.arange(n)\\n else:\\n index_seed = np.argwhere(labels >= 0).ravel()\\n index_remain = np.argwhere(labels < 0).ravel()\\n labels = labels[index_seed]\\n return index_seed.astype(np.int32), index_remain.astype(np.int32), labels.astype(np.int32)\",\n \"def crear_matrix(nxn):\\n matrix =[]\\n for i in range(nxn):\\n matrix.append([])\\n for e in range(nxn):\\n matrix[i].append(\\\"\\\")\\n return matrix\",\n \"def simulator(n, mu, covmat):\\n a = np.random.multivariate_normal(mu, covmat, n)\\n return [tuple(a[i, :]) for i in range(n)]\",\n \"def generate_sparse_randn(n, s):\\n x = np.zeros(n)\\n I = np.random.randint(0, n, s)\\n x[I] = np.random.randn(s)\\n return x\",\n \"def _defineNAVars(self, vars):\\n self.na_dict[\\\"NV\\\"] = len(vars)\\n self.na_dict[\\\"VNAME\\\"] = []\\n self.na_dict[\\\"VMISS\\\"] = []\\n self.na_dict[\\\"VSCAL\\\"] = []\\n self.na_dict[\\\"V\\\"] = []\\n\\n for var in vars:\\n name = xarray_utils.getBestName(var)\\n self.na_dict[\\\"VNAME\\\"].append(name)\\n miss = xarray_utils.getMissingValue(var)\\n miss = self._resolve_float(miss)\\n\\n self.na_dict[\\\"VMISS\\\"].append(miss)\\n self.na_dict[\\\"VSCAL\\\"].append(1)\\n\\n # Populate the variable list with the array\\n # Make sure missing values are converted to real values using the required missing value\\n self.na_dict[\\\"V\\\"].append(xarray_utils.getArrayAsList(var, missing_value=miss, handle_datetimes=True))\\n\\n # Create independent variable info\\n if not \\\"X\\\" in self.na_dict:\\n\\n # Set up lists ready to populate with values\\n self.na_dict[\\\"NXDEF\\\"] = []\\n self.na_dict[\\\"NX\\\"] = []\\n\\n self.ax0 = xarray_utils.get_coord_by_index(var, 0)\\n\\n self.na_dict[\\\"X\\\"] = [xarray_utils.getArrayAsList(self.ax0)]\\n self.na_dict[\\\"XNAME\\\"] = [xarray_utils.getBestName(self.ax0)]\\n\\n if len(self.ax0) == 1:\\n self.na_dict[\\\"DX\\\"] = [0]\\n else:\\n # Set default increment as gap between first two\\n incr = xarray_utils.get_interval(self.ax0, 0, 1)\\n\\n self.na_dict[\\\"DX\\\"] = [incr]\\n # Now overwrite it as zero if non-uniform interval in axis\\n\\n for i in range(1, len(self.ax0)):\\n if xarray_utils.get_interval(self.ax0, i-1, i) != incr:\\n self.na_dict[\\\"DX\\\"] = [0]\\n break\\n\\n # If 1D only then \\\"X\\\" should only be a list and not list of lists\\n if self.na_dict[\\\"FFI\\\"] in (1001, 1010, 1020):\\n self.na_dict[\\\"X\\\"] = self.na_dict[\\\"X\\\"][0]\\n\\n # If FFI is 1020 need to reduce axis down to reduced values as most are implied\\n if self.na_dict[\\\"FFI\\\"] == 1020: \\n vals = self.na_dict[\\\"X\\\"]\\n self.na_dict[\\\"X\\\"] = vals[0:len(vals):self.na_dict[\\\"NVPM\\\"]] \\n\\n # Now add the rest of the axes to the self.na_dict objects \\n for axis in xarray_utils.getAxisList(var)[1:]:\\n self._appendAxisDefinition(axis)\\n\\n # If FFI is 2110 then need to modify the \\\"NX\\\" and \\\"X\\\" lists to cope with odd shape\\n # Also need to add NX to auxiliary variables\\n if self.na_dict[\\\"FFI\\\"] == 2110:\\n new_x = []\\n new_nx = []\\n ax2_values = xarray_utils.get_coord_by_index(var, 1).data.tolist()\\n\\n for i in self.ax0[:]:\\n new_x.append([i, ax2_values])\\n new_nx.append(len(ax2_values))\\n\\n # Re-assign to new lists\\n self.na_dict[\\\"NX\\\"] = new_nx\\n self.na_dict[\\\"X\\\"] = new_x \\n\\n # Now auxiliary variable info here with independent var info\\n # First aux var is NX\\n self.na_dict[\\\"A\\\"] = [self.na_dict[\\\"NX\\\"][:]]\\n ind_var_name = self.na_dict[\\\"XNAME\\\"][0]\\n self.na_dict[\\\"ANAME\\\"] = [\\\"Number of '%s' values recorded in subsequent data records\\\" % ind_var_name]\\n self.na_dict[\\\"AMISS\\\"] = [-9999.999]\\n self.na_dict[\\\"ASCAL\\\"] = [1.0]\\n\\n # If FFI is 2310 then need to modify na_dict items for that\\n elif self.na_dict[\\\"FFI\\\"] == 2310:\\n new_x = []\\n new_nx = []\\n new_dx = []\\n ax2_values = xarray_utils.get_coord_by_index(var, 1).data.tolist()\\n incr = xarray_utils.get_interval(ax2_values, 0, 1)\\n\\n for i in self.ax0[:]:\\n new_x.append([i, ax2_values])\\n new_nx.append(len(ax2_values))\\n new_dx.append(incr)\\n\\n # Re-assign to new lists\\n self.na_dict[\\\"NX\\\"] = new_nx\\n self.na_dict[\\\"X\\\"] = new_x\\n self.na_dict[\\\"DX\\\"] = new_dx\\n\\n # Now auxiliary variable info here with independent var info\\n # First three aux vars are NX, X0 and DX\\n self.na_dict[\\\"A\\\"] = []\\n self.na_dict[\\\"A\\\"].append(self.na_dict[\\\"NX\\\"][:])\\n self.na_dict[\\\"A\\\"].append([i[1][0] for i in self.na_dict[\\\"X\\\"]])\\n self.na_dict[\\\"A\\\"].append(self.na_dict[\\\"DX\\\"][:])\\n\\n ind_var_name = self.na_dict[\\\"XNAME\\\"][0]\\n self.na_dict[\\\"ANAME\\\"] = [\\\"Number of '%s' values recorded in subsequent data records\\\" % ind_var_name,\\n \\\"'%s' value for first data point\\\" % ind_var_name,\\n \\\"'%s' increment\\\" % ind_var_name]\\n self.na_dict[\\\"AMISS\\\"] = [-9999.999, -9999.999, -9999.999]\\n self.na_dict[\\\"ASCAL\\\"] = [1.0, 1.0, 1.0]\",\n \"def matrix_generate(n):\\n a = np.eye(n)\\n max = 0\\n for i in range(n):\\n for j in range(n):\\n a[i][j] = random.randint(0,50)\\n a[j][i] = a[i][j]\\n if a[i][j] > max:\\n max = a[i][j]\\n for i in range(n):\\n a[i][i] = max * n + random.randint(20,40)\\n return np.array(a)\",\n \"def build_Xij_inv_matrix(self,Nmesh=64):\\n H0, F = self.cosmo.H0, self.cosmo.F\\n Lbox = self.attrs['Lbox']\\n kgrid = initialize_kgrid(Nmesh,Lbox)\\n kmag_grid = np.linalg.norm(kgrid,axis=3)\\n w_grid = self.cosmo.Pk_lin(kmag_grid)*(1/Lbox**3)*np.exp(-kmag_grid*kmag_grid*self.RG*self.RG)\\n k2 = kmag_grid**2\\n k2[0,0,0] = 1 \\n #----------------------------------------------------\\n cspace = np.arange(0,18)\\n \\n xij_tensor = [[np.sum(np.conj(Hhats[i](kgrid,k2,H0,F))*Hhats[j](kgrid,k2,H0,F)*w_grid)\\n for j in cspace[self.cmask]] for i in cspace[self.cmask]]\\n \\n xij_tensor = np.array(xij_tensor)\\n self.xij_tensor_inv = np.linalg.inv(xij_tensor.real)\",\n \"def make_matrix():\\n row, col = [int(x) for x in input().split()]\\n island = [[int(x) for x in input().split()] for _ in range(row)]\\n return row, col, island\",\n \"def generate_onehot_matrix(n: int = 1024, ndim: int = 8, random_seed: int = None) -> TYPE_ARRAY:\\n to_vec = lambda x: [1 if i == x else 0 for i in range(ndim)]\\n return numpy.array([to_vec(x) for x in _RNG.randint(0, ndim, n)]).astype(int)\",\n \"def __init__(self, n):\\n\\t\\tself._matr = []\\n\\t\\tfor i in range(n):\\n\\t\\t\\tself._matr.append([])\\n\\t\\t\\tfor j in range(n):\\n\\t\\t\\t\\tself._matr[i].append(False)\",\n \"def _make_random_matrix(self, n_components, n_features):\\n #random_state = check_random_state(self.random_state)\\n return _gaussian_random_matrix(\\n n_components, n_features, random_state=self.random_state\\n )\",\n \"def make_matrix(sizex, sizey):\\n return [[0]*sizey for i in xrange(sizex)]\",\n \"def construct_M_N(n):\\n n2 = n**2\\n D0 = 2*np.ones(n2) # 0th diagonal\\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\\n DN = - np.ones(n2 - n) # -nth, nth diagonals\\n return (scipy.sparse.diags((D1, D0, D1), (-1, 0, 1), shape=(n2, n2), format=\\\"csr\\\"),\\n scipy.sparse.diags((DN, D0, DN), (-n, 0, n), shape=(n2, n2), format=\\\"csr\\\"))\",\n \"def new_game(n):\\n matrix = []\\n\\n for i in range(n):\\n matrix.append([0] * n)\\n return matrix\",\n \"def get_stain_matrix(I):\",\n \"def create_array( n ):\",\n \"def FE_create_interaction_vars(df, intxn_vars):\\r\\n df = df.copy(deep=True)\\r\\n for (each_intxn1,each_intxn2) in intxn_vars:\\r\\n new_col = each_intxn1 + '_x_' + each_intxn2\\r\\n try:\\r\\n df[new_col] = df[each_intxn1] * df[each_intxn2]\\r\\n except:\\r\\n continue\\r\\n return df\",\n \"def make_xyz(df: pd.DataFrame,\\n response_var: list,\\n fixed_var: list = ['Sex']) -> np.ndarray:\\n x = pd.get_dummies(df[fixed_var]).to_numpy()\\n x = np.fliplr(x)\\n n_animals = df.shape[0] # to fix z the the same shape\\n z = np.identity(n_animals)[1]\\n y = df[[response_var]].to_numpy()\\n\\n return x, z, y\",\n \"def matrix_initialization(variable):\\n # Range of value for 11 and 22\\n min_11 = 2.0\\n max_11 = 4.5\\n # Range of random values for 33\\n min_33 = 8.0\\n max_33 = 13.0\\n # range of values for off-diagonal\\n min_offdiag = -0.8\\n max_offdiag = 0.8\\n\\n if variable[-2:] == \\\"33\\\":\\n return np.round(min_33 + (max_33 - min_33) * np.random.rand(), 1)\\n if variable[-1] == variable[-2]:\\n return np.round(min_11 + (max_11 - min_11) * np.random.rand(), 1)\\n return np.round(min_offdiag + (max_offdiag - min_offdiag) * np.random.rand(), 1)\",\n \"def random_transition_matrix(n: int) -> np.ndarray:\\n\\n x = np.abs(np.random.normal(size=(n, n)))\\n rsum = x.sum(axis=1)\\n return x / rsum[:, np.newaxis]\",\n \"def generate(n):\\n \\n m1 = np.zeros((n, n), dtype = int)\\n m2 = np.zeros((n, n), dtype = int)\\n \\n for i in range(n):\\n for j in range(n):\\n m1[i][j] = (j % 32)\\n m2[i][j] = (j % 64)\\n \\n return m1,m2\",\n \"def __init__(self, n):\\r\\n self.matr = []\\r\\n self.n = n\\r\\n for i in range(n):\\r\\n self.matr.append([])\\r\\n for j in range(n):\\r\\n self.matr[i].append(False)\",\n \"def make_data(n,m):\\n I = range(1,n+1)\\n J = range(1,m+1)\\n x,y,w = {},{},{}\\n for i in I:\\n x[i] = random.randint(0,100)\\n y[i] = random.randint(0,100)\\n w[i] = random.randint(1,5)\\n return I,J,x,y,w\",\n \"def __init__(self, n):\\r\\n self.size = n\\r\\n self.mat = []\\r\\n for i in range(n):\\r\\n self.mat.append([0] * n)\",\n \"def make_matrix(sizex, sizey):\\n return [[0] * sizey for i in range(sizex)]\",\n \"def create_variable_array(times):\\n R=np.empty(np.sum(times))\\n return R\",\n \"def initial_x():\\n\\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\\n\\n return np.array(temp, dtype=np.float_)\",\n \"def generate_pos_def(n):\\n A = np.random.normal(size=(n,n)) + 1j * np.random.normal(size=(n,n))\\n A += np.conjugate(A).T\\n # Add just enough of an identity matrix to make all eigenvalues positive\\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\\n return A\",\n \"def generate_grid(nrows, ncols, ndots):\\n\\n # Validation\\n if nrows * ncols < ndots:\\n raise Exception(\\\"ndots must be <= than grid size\\\")\\n\\n rows = np.arange(1, nrows + 1)\\n cols = np.arange(1, ncols + 1)\\n\\n # Create empty matrix\\n grid = np.empty((len(rows), len(cols), 2), dtype=np.intp)\\n grid[..., 0] = rows[:, None]\\n grid[..., 1] = cols \\n\\n return grid.reshape(nrows * ncols, -1)[:ndots]\",\n \"def marginals(self):\\n all_variables = [None for ii in range(self.nvars)]\\n for ii in range(self.nunique_vars):\\n for jj in self.unique_variable_indices[ii]:\\n all_variables[jj] = self.unique_variables[ii]\\n return all_variables\",\n \"def create_matrix(list_of_edges, n):\\n matrix = [[0 for i in range(n)] for j in range(n)]\\n ind = 0\\n for i in range(n):\\n for j in range(i):\\n matrix[i][j] = list_of_edges[ind]\\n matrix[j][i] = list_of_edges[ind]\\n ind += 1\\n return matrix\",\n \"def zeros(m, n):\\n data = dict.fromkeys(itertools.product(range(m), range(n)), mpfr(0))\\n return MPMatrix((m, n), data)\",\n \"def get5x5matrix(self): #modified from nxvasc get3x3matrix()\\n try:\\n i = na.identity(3)\\n \\n self.d124 = i.copy()\\n self.ds124 = na.zeros(124,na.float64)\\n \\n for k in range(1,124):\\n self.d124 = na.concatenate((self.d124,i))\\n# print len(self.d124)\\n count = 0\\n a = []\\n for k in range(-2,3):\\n for j in range(-2,3):\\n for i in range(-2,3):\\n if( i != 0 or j != 0 or k != 0 ):\\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\\n count += 1\\n a.append(i)\\n a.append(j)\\n a.append(k)\\n# print len(a)\\n a = na.reshape(na.array(a),(372,1))\\n# print len(self.d124)\\n self.d124 = na.concatenate((self.d124,a),axis=1)\\n except Exception as error:\\n print(\\\"failed in get5x5matrix(): \\\", error)\",\n \"def random_density_matrix(nqubits: int, dtype=np.complex128) -> np.ndarray:\\n rho = random_numpy_hermitian(nqubits, dtype=dtype)\\n # Normalize\\n ids = np.arange(2 ** nqubits)\\n rho[ids, ids] = rho[ids, ids] / np.trace(rho)\\n return rho.astype(dtype)\",\n \"def generate_pos_def_all_pos(n):\\n A = np.random.uniform(size=(n,n))\\n A += A.T\\n # Add just enough of an identity matrix to make all eigenvalues positive\\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\\n return A\",\n \"def EmptyStateMat(nX,nU,nY):\\n Xx = np.zeros((nX,nX)) # Ac \\n Yx = np.zeros((nY,nX)) # Gc \\n Xu = np.zeros((nX,nU)) # Xu \\n Yu = np.zeros((nY,nU)) # Jc \\n return Xx,Xu,Yx,Yu\",\n \"def synthesize_data_X(n_x, m, mu_x = sp.random.random(1) * 25, sigma_x = sp.random.random(1) * 25):\\n # Create a (1*m) array that represents m examples of a feature x_i.\\n x_i = sp.random.normal(mu_x, sigma_x, m).reshape(1, m)\\n # Compile all n_x x_i's into a matrix X, dim (n_x * m).\\n X = np.matrix(np.array([sp.random.normal(mu_x, sigma_x, m).reshape(1, m)\\n for i in range(n_x)])).reshape(n_x, m)\\n return X, n_x, m, mu_x, sigma_x\",\n \"def create_diagonal_image(n):\\n alist = []\\n for i in range(0, n):\\n alist.append([])\\n for j in range(0,n):\\n if i ==j:\\n alist[i].append(1)\\n else:\\n alist[i].append(0)\\n\\n ##########\\n # img = create_zeroed_image(n)\\n # for i in range(n):\\n# for j in range(n):\\n# if i == j:\\n# img[i][j] = 1\\n #######\\n \\n return alist\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6807005","0.63776374","0.63734645","0.63494134","0.6294045","0.6278014","0.6278014","0.61580557","0.61580557","0.61580557","0.615476","0.6121155","0.6051036","0.601457","0.58180785","0.5777933","0.57341456","0.5717382","0.5687784","0.5684385","0.5680099","0.5672847","0.5670253","0.5622504","0.5604844","0.5603232","0.55817324","0.55645996","0.55474067","0.554359","0.5521029","0.5509594","0.54692394","0.545146","0.5449567","0.5428243","0.5426758","0.5412075","0.54081684","0.53864765","0.53850555","0.53832114","0.5354908","0.5350996","0.5340386","0.533802","0.53275317","0.53251094","0.5316921","0.5314654","0.5308686","0.5300276","0.52708554","0.52675295","0.52621925","0.52620864","0.5251341","0.52472085","0.52387774","0.5229686","0.522429","0.5224283","0.52172196","0.5205456","0.5182113","0.51784873","0.51711595","0.51607215","0.51528317","0.51524043","0.5149917","0.5142965","0.51321614","0.51278394","0.51167244","0.51126456","0.5103993","0.510277","0.50977796","0.50955623","0.5077434","0.50731003","0.5068964","0.5067611","0.5064672","0.5056716","0.505666","0.505613","0.50490165","0.5041239","0.5032271","0.5032065","0.5026967","0.5021533","0.50180745","0.5011186","0.501036","0.5004049","0.49969843","0.49966446","0.49963754"],"string":"[\n \"0.6807005\",\n \"0.63776374\",\n \"0.63734645\",\n \"0.63494134\",\n \"0.6294045\",\n \"0.6278014\",\n \"0.6278014\",\n \"0.61580557\",\n \"0.61580557\",\n \"0.61580557\",\n \"0.615476\",\n \"0.6121155\",\n \"0.6051036\",\n \"0.601457\",\n \"0.58180785\",\n \"0.5777933\",\n \"0.57341456\",\n \"0.5717382\",\n \"0.5687784\",\n \"0.5684385\",\n \"0.5680099\",\n \"0.5672847\",\n \"0.5670253\",\n \"0.5622504\",\n \"0.5604844\",\n \"0.5603232\",\n \"0.55817324\",\n \"0.55645996\",\n \"0.55474067\",\n \"0.554359\",\n \"0.5521029\",\n \"0.5509594\",\n \"0.54692394\",\n \"0.545146\",\n \"0.5449567\",\n \"0.5428243\",\n \"0.5426758\",\n \"0.5412075\",\n \"0.54081684\",\n \"0.53864765\",\n \"0.53850555\",\n \"0.53832114\",\n \"0.5354908\",\n \"0.5350996\",\n \"0.5340386\",\n \"0.533802\",\n \"0.53275317\",\n \"0.53251094\",\n \"0.5316921\",\n \"0.5314654\",\n \"0.5308686\",\n \"0.5300276\",\n \"0.52708554\",\n \"0.52675295\",\n \"0.52621925\",\n \"0.52620864\",\n \"0.5251341\",\n \"0.52472085\",\n \"0.52387774\",\n \"0.5229686\",\n \"0.522429\",\n \"0.5224283\",\n \"0.52172196\",\n \"0.5205456\",\n \"0.5182113\",\n \"0.51784873\",\n \"0.51711595\",\n \"0.51607215\",\n \"0.51528317\",\n \"0.51524043\",\n \"0.5149917\",\n \"0.5142965\",\n \"0.51321614\",\n \"0.51278394\",\n \"0.51167244\",\n \"0.51126456\",\n \"0.5103993\",\n \"0.510277\",\n \"0.50977796\",\n \"0.50955623\",\n \"0.5077434\",\n \"0.50731003\",\n \"0.5068964\",\n \"0.5067611\",\n \"0.5064672\",\n \"0.5056716\",\n \"0.505666\",\n \"0.505613\",\n \"0.50490165\",\n \"0.5041239\",\n \"0.5032271\",\n \"0.5032065\",\n \"0.5026967\",\n \"0.5021533\",\n \"0.50180745\",\n \"0.5011186\",\n \"0.501036\",\n \"0.5004049\",\n \"0.49969843\",\n \"0.49966446\",\n \"0.49963754\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6888,"cells":{"query":{"kind":"string","value":"r\"\"\" Return ``n`` independent symbolic matrices in dimension ``d``."},"document":{"kind":"string","value":"def symbolic_max_plus_matrices(d, n, ch=None, typ='sym'):\n d = int(d)\n n = int(n)\n if d <= 0:\n raise ValueError(\"d (= {}) must be postive\".format(d))\n\n nvar = n * d * d\n\n V = FreeModule(ZZ, nvar)\n B = ((b,) for b in V.basis())\n\n matrices = []\n\n if d == 1:\n typ = 'full'\n\n if typ == 'sym' or typ == 'quick':\n z = [0]*nvar\n for i in range(n):\n z[i*d*d] = 1\n diag = (V(z),)\n z[i*d*d] = 0\n\n z[i*d*d+1] = 1\n nondiag = (V(z),)\n z[i*d*d+1] = 0\n\n if typ == 'sym':\n matrices.append(SymbolicSymmetricMaxPlusMatrix(d, n, diag, nondiag, ch))\n else:\n matrices.append(QuickSymbolicSymmetricMaxPlusMatrix(d, n, diag, nondiag, ch))\n elif typ == 'full':\n for i in range(n):\n mat = []\n for j in range(d):\n mat.append([next(B) for k in range(d)])\n matrices.append(SymbolicMaxPlusMatrix(d, nvar, mat, ch))\n else:\n raise ValueError\n\n return matrices"},"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 basis(d, symbolic=True):\n X = sym.symbols('X')\n if d == 0:\n phi_sym = [1]\n else:\n if symbolic:\n h = sym.Rational(1, d) # node spacing\n nodes = [2*i*h - 1 for i in range(d+1)]\n else:\n nodes = np.linspace(-1, 1, d+1)\n \n phi_sym = [Lagrange_polynomials(X, r, nodes) for r in range(d+1)]\n \n # Transform to Python functions\n phi_num = [sym.lambdify([X], phi_sym[r], modules='numpy') for r in range(d+1)]\n return phi_sym if symbolic else phi_num","def makeHadamard(n, d):\n return [[1 if d[\"r%dc%d\" % (i, j)] else 0 for j in range(n)] for i in range(n)]","def matIxs( n ):\n rows, cols = np.indices( (n,n) )\n row = rows.flatten()\n col = cols.flatten()\n \n return map( lambda x: Vector( x[0], x[1] ), zip( col, row ) )","def matrix_chain_dynamic(dimensions, n):\n\n m = [[-1 for _ in range(n)] for _ in range(n)]\n s = [[0 for _ in range(n)] for _ in range(n)]\n\n # multiplying matrix by itself\n for i in range(1, n):\n m[i][i] = 0\n\n for length in range(2, n):\n for i in range(1, n - length + 1):\n j = i + length - 1\n for k in range(i, j):\n cost = m[i][k] + m[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j]\n if cost > m[i][j]:\n m[i][j] = cost\n # index if splitting\n s[i][j] = k\n return m, s","def find_linear_recurrence(self,n,d=None,gfvar=None):\n from sympy.simplify import simplify\n x = [simplify(expand(t)) for t in self[:n]]\n lx = len(x)\n if d is None:\n r = lx//2\n else:\n r = min(d,lx//2)\n coeffs = []\n for l in range(1, r+1):\n l2 = 2*l\n mlist = []\n for k in range(l):\n mlist.append(x[k:k+l])\n m = Matrix(mlist)\n if m.det() != 0:\n y = simplify(m.LUsolve(Matrix(x[l:l2])))\n if lx == l2:\n coeffs = flatten(y[::-1])\n break\n mlist = []\n for k in range(l,lx-l):\n mlist.append(x[k:k+l])\n m = Matrix(mlist)\n if m*y == Matrix(x[l2:]):\n coeffs = flatten(y[::-1])\n break\n if gfvar is None:\n return coeffs\n else:\n l = len(coeffs)\n if l == 0:\n return [], None\n else:\n n, d = x[l-1]*gfvar**(l-1), 1 - coeffs[l-1]*gfvar**l\n for i in range(l-1):\n n += x[i]*gfvar**i\n for j in range(l-i-1):\n n -= coeffs[i]*x[j]*gfvar**(i+j+1)\n d -= coeffs[i]*gfvar**(i+1)\n return coeffs, simplify(factor(n)/factor(d))","def symbolic_max_plus_identity(d, nvar, ch=None):\n d = int(d)\n nvar = int(nvar)\n V = FreeModule(ZZ, nvar)\n e = ()\n zero = (V([0]*nvar),)\n\n data = [[zero if i == j else e for j in range(d)] for i in range(d)]\n return SymbolicMaxPlusMatrix(d, nvar, data, ch)","def _identity_dense(d, dtype=complex):\n return np.eye(d, dtype=dtype)","def solve(n=10):\n return sum(M_N_S(n, d)[2] for d in range(10))","def _relax_matrix(self, n=1):\n\n for i in range(n):\n self.level.mid.reshape(-1)[:] = self.R_w.dot(self.level.mid.reshape(-1)) \\\n + self.omega * self.level.rhs / self.D","def diag_indices(n, ndim=2):\n\n if not use_origin_backend():\n return dpnp_diag_indices(n, ndim)\n\n return call_origin(numpy.diag_indices, n, ndim)","def expansion_matrix_d(self):\n row = self._base_nlp._d_map\n nnz = len(self._base_nlp._d_map)\n col = np.arange(nnz, dtype=np.int)\n data = np.ones(nnz)\n return csr_matrix((data, (row, col)), shape=(self.ng, nnz))","def random_planted_matrix(d, n, replace='True'):\n all_idx = np.asarray(list(zip(*np.tril_indices(d,-1))))\n chosen_idx_positions = np.random.choice(len(all_idx), size=n, replace=replace)\n subspaces = all_idx[chosen_idx_positions]\n angles = 2*np.pi * (np.random.rand(len(subspaces)) - 0.5)\n U = np.eye(d)\n for s, alpha in zip(subspaces, angles):\n U = right_givens(math.cos(alpha), math.sin(alpha), U, s[0], s[1])\n return U","def construct_M_N(n):\n n2 = n**2\n D0 = 2*np.ones(n2) # 0th diagonal\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\n DN = - np.ones(n2 - n) # -nth, nth diagonals\n return (scipy.sparse.diags((D1, D0, D1), (-1, 0, 1), shape=(n2, n2), format=\"csr\"),\n scipy.sparse.diags((DN, D0, DN), (-n, 0, n), shape=(n2, n2), format=\"csr\"))","def diag_indices(n, ndim=2):\r\n idx = np.arange(n)\r\n return (idx,) * ndim","def dens_matrix(state):\n size = len(state)\n state_conj = np.conj(state)\n dm = np.zeros((size,) * 4, dtype=complex)\n\n for p1 in range(size):\n for p2 in range(size):\n for p1_ in range(size):\n for p2_ in range(size):\n dm[p1, p2, p1_, p2_] = state[p1, p2] * state_conj[p1_, p2_]\n\n return dm","def Dinvmatrix(N):\r\n import numpy as np\r\n D = np.zeros((N,N,2))\r\n D[:,:,0] = np.diag((np.append(np.ones((1,int(N/2))),np.zeros((1,int(N/2))))))\r\n D[:,:,1] = np.diag((np.append(np.zeros((1,int(N/2))),np.ones((1,int(N/2))))))\r\n return D","def symmetrize(n):\n times = lambda x: jnp.concatenate((jnp.flipud(x), x))\n trans = lambda x: x[n:] + x[n-1::-1]\n return Operator(times=times, trans=trans, shape=(2*n,n))","def get_matrixS(n):\n\n mat_nxn = np.zeros([n, n], dtype=int)\n for row_num in range(1, n + 1):\n i = row_num - 1\n if row_num == 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i + 2] = 1\n elif row_num == 2:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i + 2] = 1\n elif row_num == n - 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num == n:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num % 2 == 1:\n mat_nxn[i][i + 1] = 1\n mat_nxn[i][i + 2] = 1\n mat_nxn[i][i - 2] = 1\n elif row_num % 2 == 0:\n mat_nxn[i][i - 1] = 1\n mat_nxn[i][i + 2] = 1\n mat_nxn[i][i - 2] = 1\n mat_nxn = mat_nxn + np.eye(n, dtype=int)\n mat_2nx2n = np.repeat(np.repeat(mat_nxn, 2, 0), 2, 1)\n return torch.as_tensor(mat_2nx2n)","def dirac(self,n):\r\n y = np.zeros(len(n),dtype = complex)\r\n y[n==0] = 1\r\n return y","def all_basis_vectors(n: int) -> list:\n assert n >= 0, \"n must be > 0\"\n basis_1dim = ['0', '1']\n\n if n == 0:\n return []\n if n == 1:\n return basis_1dim\n else:\n current_basis = basis_1dim\n for i in range(1, n):\n # can be made more efficient (e.g. by current_basis, current basis until we reach sqrt(n))\n current_basis = outer_subspace_product(basis_1dim, current_basis)\n\n return current_basis","def _compute_ind_mat(n, m, nb_coeff):\r\n\r\n ind_mat = np.zeros((nb_coeff, n))\r\n curr_idx = 0\r\n for indexes in itr.combinations_with_replacement(range(m), n):\r\n ind_mat[curr_idx] = np.array(indexes)\r\n curr_idx += 1\r\n\r\n return ind_mat","def matrix_N1(l, omega, S, cn):\n sqrt = np.sqrt(l * (l + 1))\n zl = omega * S / cn['l']\n zt = omega * S / cn['t']\n col1 = - np.array((dN1(l, zt), dN2(l, zt), dN3(l, zt), dN4(l, zt))) / zt\n col2 = (sqrt * np.array((dL1(l, zt), dL2(l, zl),\n dL3(l, zl), dL4(l, zt, zl))) / zl\n )\n N = np.array((col1, col2))\n return N.T","def novelty(self, d, x):\n # measure the data and check if the dimmension agree\n N = len(x)\n if not len(d) == N:\n raise ValueError('The length of vector d and matrix x must agree.')\n self.n = len(x[0])\n # prepare data\n try:\n x = np.array(x)\n d = np.array(d)\n except:\n raise ValueError('Impossible to convert x or d to a numpy array')\n # create empty arrays\n y = np.zeros(N)\n e = np.zeros(N)\n nd = np.zeros((N,self.n))\n self.w_history = np.zeros((N,self.n))\n # adaptation loop\n for k in range(N):\n self.update_memory_x(x[k])\n m_d, m_x = self.read_memory()\n # estimate\n y[k] = np.dot(self.w, x[k]-m_x) + m_d\n e[k] = d[k] - y[k]\n nu = self.mu / (self.eps + np.dot(x[k]-m_x, x[k]-m_x))\n dw = nu * e[k] * (x[k]-m_x)\n self.w += dw\n self.w_history[k,:] = self.w\n nd[k,:] = dw * e[k]\n self.update_memory_d(d[k])\n return y, e, self.w_history, nd","def all_matrices(n):\n complete = int(n * (n-1) / 2)\n least = (n-1)*2 - 1 # the number of edges is at least 2(n-1)-1\n all_possible_list = [i for i in itertools.product([0, 1], repeat=complete)\n if sum(i) >= least]\n all_mats = [create_matrix(i, n) for i in all_possible_list]\n return all_mats","def get_dct_matrix(N):\r\n dct_m = np.eye(N)\r\n for k in np.arange(N):\r\n for i in np.arange(N):\r\n w = np.sqrt(2 / N)\r\n if k == 0:\r\n w = np.sqrt(1 / N)\r\n dct_m[k, i] = w * np.cos(np.pi * (i + 1 / 2) * k / N)\r\n idct_m = np.linalg.inv(dct_m)\r\n return dct_m, idct_m","def identity_matrix(n):\n data = [[1 if c == r else 0 for c in range(n)] for r in range(n)]\n return Matrix(data)","def _dmatrix(kn_u, kn_d):\n d = np.zeros((kn_u.size, 4, 4), np.complex128)\n d_inv = np.zeros_like(d)\n\n d[:, 0, 0] = 1\n d[:, 0, 1] = 1\n d[:, 1, 0] = kn_u\n d[:, 1, 1] = -kn_u\n\n d[:, 2, 2] = 1\n d[:, 2, 3] = 1\n d[:, 3, 2] = kn_d\n d[:, 3, 3] = -kn_d\n\n # an analytic matrix inverse saves time\n inv_kn_u = 0.5 / kn_u\n inv_kn_d = 0.5 / kn_d\n\n d_inv[:, 0, 0] = 0.5\n d_inv[:, 0, 1] = inv_kn_u\n d_inv[:, 1, 0] = 0.5\n d_inv[:, 1, 1] = -inv_kn_u\n\n d_inv[:, 2, 2] = 0.5\n d_inv[:, 2, 3] = inv_kn_d\n d_inv[:, 3, 2] = 0.5\n d_inv[:, 3, 3] = -inv_kn_d\n\n return d, d_inv","def decomposition_into_s_n_irreducibles(self, n):\r\n w5 = partitions_list(n)\r\n M5 = form_matrix_yt(w5)\r\n card = math.factorial(n)\r\n vec_dic = {}\r\n for k in range(self.dimension()+1):\r\n D = {}\r\n uu = []\r\n vv = []\r\n p = k \r\n A = self.matrix_simmetric_representate(p)\r\n if (p >0 and (p <= self.dimension())):\r\n null = nullspace(A)\r\n w3 = []\r\n for i in range(len(null[0])):\r\n w = []\r\n for j in range(len(null)):\r\n w.append(null[j][i])\r\n w3.append(w) \r\n null = w3\r\n M = np.matrix(w3, dtype= np.float64).transpose()\r\n Mi = np.linalg.pinv(M)\r\n else:\r\n if (p == 0):\r\n M = A\r\n null = []\r\n for i in range(A.shape[0]):\r\n aux = []\r\n for j in range(A.shape[1]):\r\n aux.append(M[i,j])\r\n null.append(aux)\r\n M = np.matrix(null, dtype=np.float64)\r\n Mi = M\r\n p = k + 1\r\n if (p>0 and (p <= self.dimension())):\r\n A1=self.matrix_simmetric_representate(p)\r\n col = columnspace(A1)\r\n w4 = []\r\n for i in range(len(col[0])):\r\n w = []\r\n for j in range(len(col)):\r\n w.append(col[j][i])\r\n w4.append(w)\r\n col = w4\r\n M1 = np.matrix(w4, dtype=np.float64).transpose()\r\n Mii = np.linalg.pinv(M1)\r\n for h in w5:\r\n p = k \r\n if (p >0 and (p <= self.dimension())):\r\n if (all(elem == 0 for elem in null[0])):\r\n l1 = 0\r\n else:\r\n he = self.basis_group_oriented_p_chains(p) \r\n on1 = np.ones(len(list(he.dic.keys())), dtype=np.float64) \r\n v = P_chains([],[])\r\n v = P_chains(list(he.dic.keys()),on1)\r\n v1 = permutation_in_simplex_test(v, make_permutation(h))\r\n D1={}\r\n c1 = 0\r\n for i in list(v1.dic.keys()):\r\n c2 = 1\r\n for j in list(he.dic.keys()):\r\n if (i == j):\r\n if (v1.dic[i] == he.dic[j]):\r\n D1[c1] = c2\r\n else:\r\n D1[c1] = -c2\r\n c2 = c2 + 1\r\n c1 = c1 + 1\r\n rr = M.shape[0]\r\n cc = M.shape[1]\r\n Ma = np.zeros([rr,cc],dtype=np.float64)\r\n for i in range(rr):\r\n Ma[i,:] = (M[(abs(D1[i])-1),:]*(np.sign(D1[i])))\r\n l1 = 0\r\n for j in range(cc):\r\n l1 = np.dot(Mi[j,:],Ma[:,j])[0,0] + l1\r\n else:\r\n if (p == 0):\r\n he = self.basis_group_oriented_p_chains(p) \r\n on1 = np.ones(len(list(he.dic.keys())), dtype=np.float64) \r\n v = P_chains([],[])\r\n v = P_chains(list(he.dic.keys()),on1)\r\n v1 = permutation_in_simplex_test(v, make_permutation(h))\r\n D1={}\r\n c1 = 0\r\n for i in list(v1.dic.keys()):\r\n c2 = 1\r\n for j in list(he.dic.keys()):\r\n if (i == j):\r\n if (v1.dic[i] == he.dic[j]):\r\n D1[c1] = c2\r\n else:\r\n D1[c1] = -c2\r\n c2 = c2 + 1\r\n c1 = c1 + 1\r\n rr = M.shape[0]\r\n cc = M.shape[1]\r\n Ma = np.zeros([rr,cc],dtype=np.float64)\r\n for i in range(rr):\r\n Ma[i,:] = (M[(abs(D1[i])-1),:]*(np.sign(D1[i])))\r\n l1 = 0\r\n for j in range(cc):\r\n l1 = np.dot(Mi[j,:],Ma[:,j])[0,0] + l1\r\n else:\r\n l1 = 0\r\n p = k + 1\r\n if (p>0 and (p <= self.dimension())):\r\n hi = self.basis_group_oriented_p_chains(p-1) \r\n on1i = np.ones(len(list(hi.dic.keys())), dtype=np.float64) \r\n vi = P_chains([],[])\r\n vi = P_chains(list(hi.dic.keys()),on1i)\r\n v1i = permutation_in_simplex_test(vi, make_permutation(h))\r\n D1i={}\r\n c1 = 0\r\n for i in list(v1i.dic.keys()):\r\n c2 = 1\r\n for j in list(hi.dic.keys()):\r\n if (i == j):\r\n if (v1i.dic[i] == hi.dic[j]):\r\n D1i[c1] = c2\r\n else:\r\n D1i[c1] = -c2\r\n c2 = c2 + 1\r\n c1 = c1 + 1\r\n rr = M1.shape[0]\r\n cc = M1.shape[1]\r\n Mai = np.zeros([rr,cc],dtype=np.float64)\r\n for i in range(rr):\r\n Mai[i,:] = (M1[(abs(D1i[i])-1),:]*(np.sign(D1i[i])))\r\n l2 = 0\r\n for j in range(cc):\r\n l2 = np.dot(Mii[j,:],Mai[:,j])[0,0] + l2\r\n else:\r\n l2 = 0\r\n uu.append(l1-l2) \r\n vv.append(size_conjugacy_class(h,n))\r\n for i in range(M5.shape[0]):\r\n Ip = 0\r\n for j in range(M5.shape[1]):\r\n Ip = Ip + M5[i,j]*uu[j]*vv[j]\r\n Ip = Ip/card\r\n D[tuple(w5[i])] = abs(round(Ip))\r\n '''Note that I am using round, only because the results obtained are \r\n not esthetics'''\r\n vec_dic[k] = D\r\n return vec_dic","def I(n):\n identity = Matrix(n,n)\n print identity.matrix\n index = 0 \n for i in range(identity.nrows):\n for j in range(identity.ncols):\n identity.matrix[i][index] = 1\n index += 1\n\n\n flat = []\n for i in range(identity.nrows):\n for j in range(identity.ncols):\n flat.append(identity.matrix[i][j])\n\n\n return identity","def expansion_matrix_dl(self):\n\n row = self._base_nlp._lower_d_map\n nnz = len(self._base_nlp._lower_d_map)\n col = np.arange(nnz, dtype=np.int)\n data = np.ones(nnz)\n return csr_matrix((data, (row, col)), shape=(self.nd, nnz))","def modalDiffMatrix(n):\n k = np.arange(n)\n a = (-1)**k\n A = sp.triu(1-np.outer(a,a))\n D = np.dot(A,np.diag(k))\n D[0,:] = D[0,:]/2\n return D","def D2mat(numpts, delta=1, periodic=True, q=0):\n\n a = 1. / delta ** 2 * ones(numpts)\n b = -2. / delta ** 2 * ones(numpts)\n c = 1. / delta ** 2 * ones(numpts)\n #print \"delta = %f\" % (delta)\n if periodic:\n if q == 0:\n return sparse.spdiags([c, a, b, c, c], [-numpts + 1, -1, 0, 1, numpts - 1], numpts, numpts)\n else:\n return sparse.spdiags([exp(-(0. + 1.j) * q) * c, a, b, c, exp((0. + 1.j) * q) * c],\n [-numpts + 1, -1, 0, 1, numpts - 1], numpts, numpts)\n else:\n return sparse.spdiags([a, b, c], [-1, 0, 1], numpts, numpts)","def Problem2(n):\n diag_entries = np.empty((3,n))\n diag_entries[0] = np.ones(n)*(-1)\n diag_entries[1] = np.ones(n)*2\n diag_entries[2] = np.ones(n)*(-1)\n A = sparse.spdiags(diag_entries, [-1,0,1],n,n,format=\"csr\")\n return A","def create_matrix(n, m):\n matrix = [[None]*m for i in range(n)]\n return matrix","def generate_basis(n, dim):\n planes = [np.random.randn(dim) for i in range(n)]\n return [p / np.linalg.norm(p) for p in planes]","def gen_M_1d(k=None, n=None, sparse=True):\n if n is None:\n print(\"specify `n` in gen_M_1d\")\n sys.exit(0)\n\n if k is None:\n print(\"specify `k` in gen_M_1d\")\n sys.exit(0)\n\n ## find split1 and split 2 indices\n s1 = (n-k)/2\n s2 = n-(s1+k)\n\n ## build diagonal\n if sparse:\n data = np.ones(n)\n offsets = s1\n M = sps.dia_matrix((data,offsets), shape=(k,n))\n else:\n d = np.concatenate([np.zeros(s1), np.ones(k), np.zeros(s2)])\n M = np.diag(d)\n M = M[s1:(s1+k),:]\n return M","def decomposition_into_s_n_irreducibles_chain_sp(self, n):\r\n w5 = partitions_list(n)\r\n M5 = form_matrix_yt(w5)\r\n card = math.factorial(n)\r\n vec_dic = {}\r\n for k in range(self.dimension()+1):\r\n D = {}\r\n uu = []\r\n vv = []\r\n he = self.basis_group_oriented_p_chains(k) \r\n for h in w5:\r\n v1 = P_chains([],[])\r\n v1 = permutation_in_simplex_test(he, make_permutation(h))\r\n rr = len(list(he.dic.keys()))\r\n Ma = np.zeros([rr,rr],dtype=np.float64)\r\n c1 = 0\r\n for i in list(he.dic.keys()):\r\n c2 = 0\r\n for j in list(v1.dic.keys()):\r\n if (i == j):\r\n Ma[c1,c2] = v1.dic[i]\r\n c2 = c2 + 1\r\n c1 = c1 + 1\r\n Ma = np.matrix(Ma, dtype='float64')\r\n uu.append(np.trace(Ma)) \r\n vv.append(size_conjugacy_class(h,n))\r\n for i in range(M5.shape[0]):\r\n Ip = 0\r\n for j in range(M5.shape[1]):\r\n Ip = Ip + M5[i,j]*uu[j]*vv[j]\r\n Ip = Ip/card\r\n D[tuple(w5[i])]=Ip\r\n vec_dic[k] = D\r\n return vec_dic","def construct_matrix_A(n):\n n2 = n**2\n D0 = 4*np.ones(n2) # 0th diagonal\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\n DN = - np.ones(n2 - n) # -nth, nth diagonals\n return scipy.sparse.diags((DN, D1, D0, D1, DN), (-n, -1, 0, 1, n),\n shape=(n2, n2), format=\"csr\")","def get_feature_matrix(N, Xtrain, D):\n for i in range(D+1):\n if i == 0:\n X = [1] * N\n else:\n X = np.vstack([np.power(Xtrain, i), X])\n X = X.transpose()\n return X","def magma_dnrm2(n, dx, incx, queue):\n\n return _libmagma.magma_dnrm2(n, int(dx), incx, queue)","def __init__(self, n):\r\n self.size = n\r\n self.mat = []\r\n for i in range(n):\r\n self.mat.append([0] * n)","def calc_einsum_idx(bits, n):\n assert len(bits) + n <= len(SYMBOLS)\n\n tens_in = SYMBOLS[:n]\n tens_out = list(tens_in)\n mat_left = ''\n mat_right = ''\n\n for pos, idx in enumerate(reversed(bits)):\n mat_left += SYMBOLS[-1 - pos]\n mat_right += tens_in[-1 - idx]\n tens_out[-1 - idx] = SYMBOLS[-1 - pos]\n tens_out = ''.join(tens_out)\n\n return mat_left + mat_right + ',' + tens_in + '->' + tens_out","def identity_matrix(self, n):\r\n IdM = self.zeros_matrix(n, n)\r\n for i in range(n):\r\n IdM[i][i] = 1.0\r\n \r\n return IdM","def coordinate_matrix(n):\n xcoordinates = np.zeros((n,n))\n xcoordinates = xcoordinates + np.arange(0,worksize) #broadcasting trick\n ycoordinates = xcoordinates.T\n return np.array([ycoordinates,xcoordinates])","def d(n,m):\r\n integrand = lambda r: r**3*R(n,0,r)*R(m,1,r)\r\n integral = integrate.quad(integrand, 0, np.inf)\r\n\r\n return e*a0*integral[0]/np.sqrt(3)","def get_nd_basis(n=5):\n assert n >= 0\n t = np.linspace(0, np.pi, n + 1)[:-1]\n xs = np.cos(t)\n ys = np.sin(t)\n return [(x, y) for x, y in zip(xs, ys)]","def n_simplex(self, dim_n=3, project = True):\n verts = permutations([0 for i in range(dim_n)] + [1])\n if project: verts = [Polytopes.project_1(x) for x in verts]\n return Polyhedron(vertices = verts)","def get_multivariate_matrix(x_data, D):\n rows = []\n terms = get_polynomial(['x1', 'x2', 'x3', 'x4', 'x5'], D)\n for row in range(len(x_data)):\n row_data = {}\n row_data['x1'] = x_data[row, 0]\n row_data['x2'] = x_data[row, 1]\n row_data['x3'] = x_data[row, 2]\n row_data['x4'] = x_data[row, 3]\n row_data['x5'] = x_data[row, 4]\n \n row_entry = []\n for t in terms:\n prod = 1\n for var in t:\n prod *= row_data[var]\n row_entry.append(prod)\n \n row_entry = np.array(row_entry) \n rows.append(row_entry)\n return np.vstack(rows)","def drum_like_env(N, sr):\n ## TODO: Fill this in\n return np.zeros(N)","def d_weights(n):\n i = np.arange(1, n)\n return np.sqrt(n / (i * (n - i)))","def eye(cls, n, domain):\n # XXX: flint matrices do not have anything like eye\n return DDM.eye(n, domain).to_dfm()","def basis_fns(n=0):\n return lambda x: np.sum(x ** (n+1), axis=1)","def dens_matrix_4ch(state):\n size = len(state)\n state_conj = np.conj(state)\n dens_matrix = np.zeros((size,) * 8, dtype=complex)\n\n for p1 in range(size):\n for p2 in range(size):\n for p3 in range(size):\n for p4 in range(size):\n for p1_ in range(size):\n for p2_ in range(size):\n for p3_ in range(size):\n for p4_ in range(size):\n dens_matrix[p1, p2, p3, p4, p1_, p2_, p3_, p4_] = state[p1, p2, p3, p4] * state_conj[p1_, p2_, p3_, p4_]\n\n return dens_matrix","def identity(n):\r\n I = np.zeros((n, n))\r\n diag = np.ones(n)\r\n np.fill_diagonal(I, diag)\r\n return matrix(I)","def identMatrix(size):\n returnvalue = Matrix()\n for i in range(size):\n newrow = [0] * size\n newrow[i] = 1\n returnvalue.addRow(*newrow)\n return returnvalue","def gen_density_matrix(states=None, dimensions=None):\n if states is None:\n tdim = np.prod(dimensions)\n dmtotal0 = np.eye(tdim) / tdim\n\n return dmtotal0\n\n dmtotal0 = np.eye(1, dtype=np.complex128)\n\n for i, s in enumerate(states):\n\n if not hasattr(s, \"__len__\"):\n # assume s is int or float showing the spin projection in the pure state\n d = dimensions[i]\n dm_nucleus = np.zeros((d, d), dtype=np.complex128)\n state_number = int(round((d - 1) / 2 - s))\n dm_nucleus[state_number, state_number] = 1\n\n else:\n if s.shape.__len__() == 1:\n d = dimensions[i]\n dm_nucleus = np.zeros((d, d), dtype=np.complex128)\n np.fill_diagonal(dm_nucleus, s)\n\n else:\n dm_nucleus = s\n\n dmtotal0 = np.kron(dmtotal0, dm_nucleus)\n\n return dmtotal0","def direct_obs_matrix(Nx,obs_inds):\n Ny = len(obs_inds)\n H = zeros((Ny,Nx))\n H[range(Ny),obs_inds] = 1\n return H","def generate(self, n, d):\n\n self.n = n\n self.d = d\n self.X = np.random.rand(n, d)\n self.Y = np.random.choice([0, 1], size=n)","def dctmtx(n):\n x,y = np.meshgrid(range(n), range(n))\n D = np.sqrt(2.0/n) * np.cos(np.pi * (2*x+1) * y / (2*n))\n D[0] /= np.sqrt(2)\n return D","def _fd_matrix(step_ratio, parity, nterms):\n _assert(0 <= parity <= 6,\n 'Parity must be 0, 1, 2, 3, 4, 5 or 6! ({0:d})'.format(parity))\n step = [1, 2, 2, 4, 4, 4, 4][parity]\n inv_sr = 1.0 / step_ratio\n offset = [1, 1, 2, 2, 4, 1, 3][parity]\n c0 = [1.0, 1.0, 1.0, 2.0, 24.0, 1.0, 6.0][parity]\n c = c0 / \\\n special.factorial(np.arange(offset, step * nterms + offset, step))\n [i, j] = np.ogrid[0:nterms, 0:nterms]\n return np.atleast_2d(c[j] * inv_sr ** (i * (step * j + offset)))","def reflect(d,n):\n\t# coefficent c, because easier\n\tc = 2 * dot(d,n)\n\treturn [di - c * ni for (di, ni) in zip(d,n)]","def exo4_q1(mu,n,x0,y0):\r\n #liste.append([x0,y0])\r\n absc = x0\r\n ordn = y0\r\n L = np.array([absc])\r\n M = np.array([ordn])\r\n for i in range(0,n):\r\n absc = exo2_1(absc,mu)\r\n ordn = exo2_1(ordn,mu)\r\n L = np.append(L,[absc])\r\n M = np.append(M,[ordn])\r\n return L,M","def from_list_sympy(cls, nrows, ncols, rows, **kwargs):\n assert len(rows) == nrows\n assert all(len(row) == ncols for row in rows)\n\n items_sympy = [_sympify(item) for row in rows for item in row]\n\n domain, items_domain = cls.get_domain(items_sympy, **kwargs)\n\n domain_rows = [[items_domain[ncols*r + c] for c in range(ncols)] for r in range(nrows)]\n\n return DomainMatrix(domain_rows, (nrows, ncols), domain)","def xyMatrixTransformMSD(d, m):\n functionSpace = np.zeros((d,d))\n for x in range(d):\n for y in range(d): \n xy = np.transpose([x, y])\n _xy = np.dot(m, xy)\n functionSpace[x, y] = int(str(_xy[0]*_xy[0]+_xy[1]*_xy[1])[0])\n \n return functionSpace","def laplacian_mat(n):\n data = [1, -2, 1]*n\n i = flatten([[k,k,k] for k in range(n)])\n j = flatten([[k-1, k, k+1] for k in range(n)])\n return scipy.sparse.coo_matrix((data[1:-1], (i[1:-1], j[1:-1])))","def generate_positive_semi_definite_matrix(n_dim):\n cov = np.random.randn(n_dim, n_dim)\n return np.dot(cov, cov.T)","def mesh_uniform(N_e, d, Omega):","def create_dims(self, n_vec, m_vec):\n dims_mat = np.array([], dtype=np.int64).reshape(2, 0)\n for n in n_vec:\n for m in m_vec[m_vec > n]:\n dims_mat = np.hstack((dims_mat,\n np.array([[n], [m]])))\n return dims_mat","def LDL(A, d):\n n = shape(A)[0]\n L = array(eye(n))\n dg = zeros(n)\n dg[0] = A[0, 0]\n for k in range(1, n):\n m = reshape(array(A[:k, k].copy()), k)\n rforwardsolve(L[:k, :k], m, d)\n L[k, :k] = m/dg[:k]\n dg[k] = A[k, k] - dot(L[k, :k], m)\n return L, dg","def get_omega_0(n_bits: int, as_numeric: bool = False) -> Matrix:\n q = qe.get_bit_map(len(DEPENDENTS), n_bits)\n mat = -q.T @ q + 4 * np.diag(np.sum(q, axis=0))\n return np.array(mat) if as_numeric else mat","def ddL(n):\n\n\tif (n==0):\n\t\treturn lambda x: 0.0\n\n\telif (n==1):\n\t\treturn lambda x: 0.0\n\n\telse:\n\n\t\t# approximate by fitting polynomial and taking derivatives\n\t\tc_om1 = coef_approximation(L(n), n)\n\t\tc_prime = polynomial_derivative(c_om1)\n\t\tc_double_prime = polynomial_derivative(c_prime)\n\n\t\t# [TODO]: fix own method from Hw 3\n\t\treturn lambda x: np.polyval(c_double_prime, x)","def matrix_L1(l, omega, S, cn):\n zt = omega * S / cn['t']\n L = np.array((dN2(l, zt), dN4(l, zt)))\n return L.T","def matrix_N2(l, omega, S, cn):\n sqrt = np.sqrt(l * (l + 1))\n zl = omega * S / cn['l']\n zt = omega * S / cn['t']\n col1 = - np.array((wN1(l, zt), wN2(l, zt), wN3(l, zt), wN4(l, zt))) / zt\n col2 = (sqrt * np.array((wL1(l, zt), wL2(l, zl),\n wL3(l, zl), wL4(l, zl, zt))) / zl\n )\n N = np.array((col1, col2))\n return N.T","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)","def _lambda(m, d, Q):\n\n d_2 = int(d / 2)\n def y_i_j(i, j):\n poly = list(np.zeros((d + 1, 1)))\n for k in range(d_2 + 1):\n for l in range(d_2 + 1):\n poly[k + l] += Q[i + k * m, j + l * m]\n return poly\n\n mat_y = [[y_i_j(i, j) for j in range(m)] for i in range(m)]\n mat_y = np.array(mat_y)\n return mat_y","def CreateDesignMatrix_X(z, x, y, n ):\n if len(x.shape) > 1:\n x = np.ravel(x)\n y = np.ravel(y)\n\n N = len(x)\n l = int((n+1)*(n+2)/2) \n X = np.ones((N,l))\n\n for i in range(1,n+1):\n q = int((i)*(i+1)/2)\n for k in range(i+1):\n X[:,q+k] = x**(i-k) * y**k\n \n X, z_, indicies = shuffle(X, z)\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\n\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies","def recomb_matrix(recomb_coefficients, atomic_number, ion_number):\n offdiag = np.zeros(atomic_number)\n index = recomb_coefficients.index\n for i in index:\n offdiag[i] = recomb_coefficients.loc[i]\n diag = np.hstack([np.zeros(1), -offdiag])\n return (np.diag(diag) + np.diag(offdiag, k=1))[ion_number, :]","def generate_random_matrix(n):\n return [[random.randint(1, 50) for i in range(n)] for j in range(n)]","def xn_xn_prod(self,x_n):\n \n x_n_tiled =T.tile(x_n,(self.num_vars,1))\n \n return T.transpose(x_n_tiled)*x_n_tiled","def eye(n,M=None, k=0, dtype=float):\n return asmatrix(np.eye(n,M,k,dtype))","def identity_matrix(n):\n I = zeros_matrix(n, n)\n for i in range(n):\n I[i][i] = 1.0\n\n return I","def identity_matrix(n):\n I = zeros_matrix(n, n)\n for i in range(n):\n I[i][i] = 1.0\n\n return I","def designMatrix(self,x,m):\n\n phi = []\n\n for i in x:\n matric = []\n for j in range(0, m + 1):\n matric.append(np.power(i,j))\n phi.append(matric)\n return np.asarray(phi)","def generate_model (d):\n return np.random.rand (d+1, 1)","def complex_matrix(n):\n\n matrix = np.zeros(shape=(n, n), dtype=complex)\n\n for row in np.arange(n):\n if row == 0:\n for col in np.arange(n):\n matrix[row, col] = 1\n else:\n for col in np.arange(n):\n if col == 0:\n matrix[row, col] = 1\n else:\n matrix[row, col] = roots(n, col*row)\n\n return matrix","def get_extremist_network(Nx, Dx):\n N = np.zeros([Nx, Nx], dtype=int)\n\n for i in range(0, Nx): # Iterate over the upper diagonal only\n for j in range(i+1, Nx):\n r = rg.random() # r is in [0.0, 1.0)\n if r <= Dx:\n N[i][j] = 1\n N[j][i] = 1\n return N","def bandcholesky(A, d):\n L, dg = LDL(A, d)\n return matrix(L)*diag(sqrt(dg))","def create_array( n ):","def build_difs_matrix(xs):\n n = len(xs)\n difs = np.zeros((n, n, 2))\n for row_id in range(n):\n ident = -np.eye(n)\n ident[:, row_id] += 1\n difs[row_id, :, 0] = ident @ xs[:, 0]\n difs[row_id, :, 1] = ident @ xs[:, 1]\n return difs","def discreteComplexComposeGraph(self,S,n):\n N=len(S)\n M=N//2\n g=[]\n d=0\n for k in range(M):\n d+=S[k+M]*cmath.exp(2j*cmath.pi*k*n/N)+S[-k+M]*cmath.exp(-2j*cmath.pi*k*n/N)\n g.append((d.real,d.imag))\n return g","def scale(self,n,d=1):\r\n\t\t\r\n\t\t# scale all terms\r\n\t\ts = [i.scale(n,d) for i in self]\r\n\t\t\r\n\t\treturn Li(s)","def r_vars(size, used=None):\n return r_symbols(size, VAR_SYMBOLS, ARGS.variable_length, used)","def syndSolveLazy(wdsize): # PENDING to debug\r\n # NameMat = wd2N[wdsize]\r\n r = int(math.ceil(math.log(wdsize, 2)) ) + 2 \r\n \r\n P = k2pmap[wdsize] # get the full parity matrix <kxr> \r\n assert P.shape[0]==wdsize and P.shape[1]==r \r\n finals = '' \r\n s1='assign noerr = '\r\n for i in xrange(r):\r\n ss = '~synd[{0}] & '.format(i) if i !=r-1 else '~synd[{0}];'.format(i) \r\n s1 += ss \r\n\r\n s1 += '\\n' \r\n\r\n finals += s1 \r\n\r\n # neg = lambda x: '~' if x==0 else '' \r\n\r\n s2 = ''\r\n\r\n for idx, name in enumerate(P):\r\n flip_s = 'assign flip[{0}] = '.format(idx)\r\n setbit_ind_array = np.nonzero(name)[0].astype('int') \r\n for i in setbit_ind_array: # set bit index\r\n subs = 'synd[{index}] & '.format(index = i) if i != setbit_ind_array[-1] else \\\r\n 'synd[{index}];'.format( index=i) \r\n flip_s += subs \r\n s2 = s2 + flip_s + '\\n' \r\n\r\n\r\n finals += s2 \r\n\r\n return finals","def diag_dom(n, num_entries=None):\n if num_entries is None:\n num_entries = int(n**1.5) - n\n A = np.zeros((n,n))\n rows = np.random.choice(np.arange(0,n), size=num_entries)\n cols = np.random.choice(np.arange(0,n), size=num_entries)\n data = np.random.randint(-4, 4, size=num_entries)\n for i in xrange(num_entries):\n A[rows[i], cols[i]] = data[i]\n for i in xrange(n):\n A[i,i] = np.sum(np.abs(A[i])) + 1\n return A","def expand_dofs(dofs, n_components):\n if dofs.ndim > 1:\n sh = dofs.shape\n dofs = dofs.ravel()\n\n else:\n sh = None\n\n edofs = nm.empty(n_components * dofs.shape[0], nm.int32)\n for idof in range(n_components):\n aux = n_components * dofs + idof\n edofs[idof::n_components] = aux\n\n if sh is not None:\n edofs.shape = sh[:-1] + (-1,)\n\n return edofs","def symbolize(X, m):\n \n X = np.array(X)\n\n if m >= len(X):\n raise ValueError(\"Length of the series must be greater than m\")\n \n dummy = []\n for i in range(m):\n l = np.roll(X,-i)\n dummy.append(l[:-(m-1)])\n \n dummy = np.array(dummy)\n \n symX = []\n \n for mset in dummy.T:\n rank = stats.rankdata(mset, method=\"min\")\n symbol = np.array2string(rank, separator=\"\")\n symbol = symbol[1:-1]\n symX.append(symbol)\n \n return symX","def get_X_lasso(n, m):\n\n jHa = np.arange(m * n)\n iHa = np.repeat(np.arange(n), m)\n jHb = np.arange(m * n)\n iHb = np.tile(np.arange(m), n) + n\n j = np.concatenate((jHa, jHb))\n i = np.concatenate((iHa, iHb))\n H = sp.csc_matrix((np.ones(n * m * 2), (i, j)), shape=(n+m, n*m))\n return H","def MM(x,N,n,l,t=0):\n Mat = np.zeros([2**l,2**l])\n for iii in range(N):\n Mat[iii,(x**n * iii)%N] = 1\n return Mat"],"string":"[\n \"def basis(d, symbolic=True):\\n X = sym.symbols('X')\\n if d == 0:\\n phi_sym = [1]\\n else:\\n if symbolic:\\n h = sym.Rational(1, d) # node spacing\\n nodes = [2*i*h - 1 for i in range(d+1)]\\n else:\\n nodes = np.linspace(-1, 1, d+1)\\n \\n phi_sym = [Lagrange_polynomials(X, r, nodes) for r in range(d+1)]\\n \\n # Transform to Python functions\\n phi_num = [sym.lambdify([X], phi_sym[r], modules='numpy') for r in range(d+1)]\\n return phi_sym if symbolic else phi_num\",\n \"def makeHadamard(n, d):\\n return [[1 if d[\\\"r%dc%d\\\" % (i, j)] else 0 for j in range(n)] for i in range(n)]\",\n \"def matIxs( n ):\\n rows, cols = np.indices( (n,n) )\\n row = rows.flatten()\\n col = cols.flatten()\\n \\n return map( lambda x: Vector( x[0], x[1] ), zip( col, row ) )\",\n \"def matrix_chain_dynamic(dimensions, n):\\n\\n m = [[-1 for _ in range(n)] for _ in range(n)]\\n s = [[0 for _ in range(n)] for _ in range(n)]\\n\\n # multiplying matrix by itself\\n for i in range(1, n):\\n m[i][i] = 0\\n\\n for length in range(2, n):\\n for i in range(1, n - length + 1):\\n j = i + length - 1\\n for k in range(i, j):\\n cost = m[i][k] + m[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j]\\n if cost > m[i][j]:\\n m[i][j] = cost\\n # index if splitting\\n s[i][j] = k\\n return m, s\",\n \"def find_linear_recurrence(self,n,d=None,gfvar=None):\\n from sympy.simplify import simplify\\n x = [simplify(expand(t)) for t in self[:n]]\\n lx = len(x)\\n if d is None:\\n r = lx//2\\n else:\\n r = min(d,lx//2)\\n coeffs = []\\n for l in range(1, r+1):\\n l2 = 2*l\\n mlist = []\\n for k in range(l):\\n mlist.append(x[k:k+l])\\n m = Matrix(mlist)\\n if m.det() != 0:\\n y = simplify(m.LUsolve(Matrix(x[l:l2])))\\n if lx == l2:\\n coeffs = flatten(y[::-1])\\n break\\n mlist = []\\n for k in range(l,lx-l):\\n mlist.append(x[k:k+l])\\n m = Matrix(mlist)\\n if m*y == Matrix(x[l2:]):\\n coeffs = flatten(y[::-1])\\n break\\n if gfvar is None:\\n return coeffs\\n else:\\n l = len(coeffs)\\n if l == 0:\\n return [], None\\n else:\\n n, d = x[l-1]*gfvar**(l-1), 1 - coeffs[l-1]*gfvar**l\\n for i in range(l-1):\\n n += x[i]*gfvar**i\\n for j in range(l-i-1):\\n n -= coeffs[i]*x[j]*gfvar**(i+j+1)\\n d -= coeffs[i]*gfvar**(i+1)\\n return coeffs, simplify(factor(n)/factor(d))\",\n \"def symbolic_max_plus_identity(d, nvar, ch=None):\\n d = int(d)\\n nvar = int(nvar)\\n V = FreeModule(ZZ, nvar)\\n e = ()\\n zero = (V([0]*nvar),)\\n\\n data = [[zero if i == j else e for j in range(d)] for i in range(d)]\\n return SymbolicMaxPlusMatrix(d, nvar, data, ch)\",\n \"def _identity_dense(d, dtype=complex):\\n return np.eye(d, dtype=dtype)\",\n \"def solve(n=10):\\n return sum(M_N_S(n, d)[2] for d in range(10))\",\n \"def _relax_matrix(self, n=1):\\n\\n for i in range(n):\\n self.level.mid.reshape(-1)[:] = self.R_w.dot(self.level.mid.reshape(-1)) \\\\\\n + self.omega * self.level.rhs / self.D\",\n \"def diag_indices(n, ndim=2):\\n\\n if not use_origin_backend():\\n return dpnp_diag_indices(n, ndim)\\n\\n return call_origin(numpy.diag_indices, n, ndim)\",\n \"def expansion_matrix_d(self):\\n row = self._base_nlp._d_map\\n nnz = len(self._base_nlp._d_map)\\n col = np.arange(nnz, dtype=np.int)\\n data = np.ones(nnz)\\n return csr_matrix((data, (row, col)), shape=(self.ng, nnz))\",\n \"def random_planted_matrix(d, n, replace='True'):\\n all_idx = np.asarray(list(zip(*np.tril_indices(d,-1))))\\n chosen_idx_positions = np.random.choice(len(all_idx), size=n, replace=replace)\\n subspaces = all_idx[chosen_idx_positions]\\n angles = 2*np.pi * (np.random.rand(len(subspaces)) - 0.5)\\n U = np.eye(d)\\n for s, alpha in zip(subspaces, angles):\\n U = right_givens(math.cos(alpha), math.sin(alpha), U, s[0], s[1])\\n return U\",\n \"def construct_M_N(n):\\n n2 = n**2\\n D0 = 2*np.ones(n2) # 0th diagonal\\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\\n DN = - np.ones(n2 - n) # -nth, nth diagonals\\n return (scipy.sparse.diags((D1, D0, D1), (-1, 0, 1), shape=(n2, n2), format=\\\"csr\\\"),\\n scipy.sparse.diags((DN, D0, DN), (-n, 0, n), shape=(n2, n2), format=\\\"csr\\\"))\",\n \"def diag_indices(n, ndim=2):\\r\\n idx = np.arange(n)\\r\\n return (idx,) * ndim\",\n \"def dens_matrix(state):\\n size = len(state)\\n state_conj = np.conj(state)\\n dm = np.zeros((size,) * 4, dtype=complex)\\n\\n for p1 in range(size):\\n for p2 in range(size):\\n for p1_ in range(size):\\n for p2_ in range(size):\\n dm[p1, p2, p1_, p2_] = state[p1, p2] * state_conj[p1_, p2_]\\n\\n return dm\",\n \"def Dinvmatrix(N):\\r\\n import numpy as np\\r\\n D = np.zeros((N,N,2))\\r\\n D[:,:,0] = np.diag((np.append(np.ones((1,int(N/2))),np.zeros((1,int(N/2))))))\\r\\n D[:,:,1] = np.diag((np.append(np.zeros((1,int(N/2))),np.ones((1,int(N/2))))))\\r\\n return D\",\n \"def symmetrize(n):\\n times = lambda x: jnp.concatenate((jnp.flipud(x), x))\\n trans = lambda x: x[n:] + x[n-1::-1]\\n return Operator(times=times, trans=trans, shape=(2*n,n))\",\n \"def get_matrixS(n):\\n\\n mat_nxn = np.zeros([n, n], dtype=int)\\n for row_num in range(1, n + 1):\\n i = row_num - 1\\n if row_num == 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i + 2] = 1\\n elif row_num == 2:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i + 2] = 1\\n elif row_num == n - 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num == n:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num % 2 == 1:\\n mat_nxn[i][i + 1] = 1\\n mat_nxn[i][i + 2] = 1\\n mat_nxn[i][i - 2] = 1\\n elif row_num % 2 == 0:\\n mat_nxn[i][i - 1] = 1\\n mat_nxn[i][i + 2] = 1\\n mat_nxn[i][i - 2] = 1\\n mat_nxn = mat_nxn + np.eye(n, dtype=int)\\n mat_2nx2n = np.repeat(np.repeat(mat_nxn, 2, 0), 2, 1)\\n return torch.as_tensor(mat_2nx2n)\",\n \"def dirac(self,n):\\r\\n y = np.zeros(len(n),dtype = complex)\\r\\n y[n==0] = 1\\r\\n return y\",\n \"def all_basis_vectors(n: int) -> list:\\n assert n >= 0, \\\"n must be > 0\\\"\\n basis_1dim = ['0', '1']\\n\\n if n == 0:\\n return []\\n if n == 1:\\n return basis_1dim\\n else:\\n current_basis = basis_1dim\\n for i in range(1, n):\\n # can be made more efficient (e.g. by current_basis, current basis until we reach sqrt(n))\\n current_basis = outer_subspace_product(basis_1dim, current_basis)\\n\\n return current_basis\",\n \"def _compute_ind_mat(n, m, nb_coeff):\\r\\n\\r\\n ind_mat = np.zeros((nb_coeff, n))\\r\\n curr_idx = 0\\r\\n for indexes in itr.combinations_with_replacement(range(m), n):\\r\\n ind_mat[curr_idx] = np.array(indexes)\\r\\n curr_idx += 1\\r\\n\\r\\n return ind_mat\",\n \"def matrix_N1(l, omega, S, cn):\\n sqrt = np.sqrt(l * (l + 1))\\n zl = omega * S / cn['l']\\n zt = omega * S / cn['t']\\n col1 = - np.array((dN1(l, zt), dN2(l, zt), dN3(l, zt), dN4(l, zt))) / zt\\n col2 = (sqrt * np.array((dL1(l, zt), dL2(l, zl),\\n dL3(l, zl), dL4(l, zt, zl))) / zl\\n )\\n N = np.array((col1, col2))\\n return N.T\",\n \"def novelty(self, d, x):\\n # measure the data and check if the dimmension agree\\n N = len(x)\\n if not len(d) == N:\\n raise ValueError('The length of vector d and matrix x must agree.')\\n self.n = len(x[0])\\n # prepare data\\n try:\\n x = np.array(x)\\n d = np.array(d)\\n except:\\n raise ValueError('Impossible to convert x or d to a numpy array')\\n # create empty arrays\\n y = np.zeros(N)\\n e = np.zeros(N)\\n nd = np.zeros((N,self.n))\\n self.w_history = np.zeros((N,self.n))\\n # adaptation loop\\n for k in range(N):\\n self.update_memory_x(x[k])\\n m_d, m_x = self.read_memory()\\n # estimate\\n y[k] = np.dot(self.w, x[k]-m_x) + m_d\\n e[k] = d[k] - y[k]\\n nu = self.mu / (self.eps + np.dot(x[k]-m_x, x[k]-m_x))\\n dw = nu * e[k] * (x[k]-m_x)\\n self.w += dw\\n self.w_history[k,:] = self.w\\n nd[k,:] = dw * e[k]\\n self.update_memory_d(d[k])\\n return y, e, self.w_history, nd\",\n \"def all_matrices(n):\\n complete = int(n * (n-1) / 2)\\n least = (n-1)*2 - 1 # the number of edges is at least 2(n-1)-1\\n all_possible_list = [i for i in itertools.product([0, 1], repeat=complete)\\n if sum(i) >= least]\\n all_mats = [create_matrix(i, n) for i in all_possible_list]\\n return all_mats\",\n \"def get_dct_matrix(N):\\r\\n dct_m = np.eye(N)\\r\\n for k in np.arange(N):\\r\\n for i in np.arange(N):\\r\\n w = np.sqrt(2 / N)\\r\\n if k == 0:\\r\\n w = np.sqrt(1 / N)\\r\\n dct_m[k, i] = w * np.cos(np.pi * (i + 1 / 2) * k / N)\\r\\n idct_m = np.linalg.inv(dct_m)\\r\\n return dct_m, idct_m\",\n \"def identity_matrix(n):\\n data = [[1 if c == r else 0 for c in range(n)] for r in range(n)]\\n return Matrix(data)\",\n \"def _dmatrix(kn_u, kn_d):\\n d = np.zeros((kn_u.size, 4, 4), np.complex128)\\n d_inv = np.zeros_like(d)\\n\\n d[:, 0, 0] = 1\\n d[:, 0, 1] = 1\\n d[:, 1, 0] = kn_u\\n d[:, 1, 1] = -kn_u\\n\\n d[:, 2, 2] = 1\\n d[:, 2, 3] = 1\\n d[:, 3, 2] = kn_d\\n d[:, 3, 3] = -kn_d\\n\\n # an analytic matrix inverse saves time\\n inv_kn_u = 0.5 / kn_u\\n inv_kn_d = 0.5 / kn_d\\n\\n d_inv[:, 0, 0] = 0.5\\n d_inv[:, 0, 1] = inv_kn_u\\n d_inv[:, 1, 0] = 0.5\\n d_inv[:, 1, 1] = -inv_kn_u\\n\\n d_inv[:, 2, 2] = 0.5\\n d_inv[:, 2, 3] = inv_kn_d\\n d_inv[:, 3, 2] = 0.5\\n d_inv[:, 3, 3] = -inv_kn_d\\n\\n return d, d_inv\",\n \"def decomposition_into_s_n_irreducibles(self, n):\\r\\n w5 = partitions_list(n)\\r\\n M5 = form_matrix_yt(w5)\\r\\n card = math.factorial(n)\\r\\n vec_dic = {}\\r\\n for k in range(self.dimension()+1):\\r\\n D = {}\\r\\n uu = []\\r\\n vv = []\\r\\n p = k \\r\\n A = self.matrix_simmetric_representate(p)\\r\\n if (p >0 and (p <= self.dimension())):\\r\\n null = nullspace(A)\\r\\n w3 = []\\r\\n for i in range(len(null[0])):\\r\\n w = []\\r\\n for j in range(len(null)):\\r\\n w.append(null[j][i])\\r\\n w3.append(w) \\r\\n null = w3\\r\\n M = np.matrix(w3, dtype= np.float64).transpose()\\r\\n Mi = np.linalg.pinv(M)\\r\\n else:\\r\\n if (p == 0):\\r\\n M = A\\r\\n null = []\\r\\n for i in range(A.shape[0]):\\r\\n aux = []\\r\\n for j in range(A.shape[1]):\\r\\n aux.append(M[i,j])\\r\\n null.append(aux)\\r\\n M = np.matrix(null, dtype=np.float64)\\r\\n Mi = M\\r\\n p = k + 1\\r\\n if (p>0 and (p <= self.dimension())):\\r\\n A1=self.matrix_simmetric_representate(p)\\r\\n col = columnspace(A1)\\r\\n w4 = []\\r\\n for i in range(len(col[0])):\\r\\n w = []\\r\\n for j in range(len(col)):\\r\\n w.append(col[j][i])\\r\\n w4.append(w)\\r\\n col = w4\\r\\n M1 = np.matrix(w4, dtype=np.float64).transpose()\\r\\n Mii = np.linalg.pinv(M1)\\r\\n for h in w5:\\r\\n p = k \\r\\n if (p >0 and (p <= self.dimension())):\\r\\n if (all(elem == 0 for elem in null[0])):\\r\\n l1 = 0\\r\\n else:\\r\\n he = self.basis_group_oriented_p_chains(p) \\r\\n on1 = np.ones(len(list(he.dic.keys())), dtype=np.float64) \\r\\n v = P_chains([],[])\\r\\n v = P_chains(list(he.dic.keys()),on1)\\r\\n v1 = permutation_in_simplex_test(v, make_permutation(h))\\r\\n D1={}\\r\\n c1 = 0\\r\\n for i in list(v1.dic.keys()):\\r\\n c2 = 1\\r\\n for j in list(he.dic.keys()):\\r\\n if (i == j):\\r\\n if (v1.dic[i] == he.dic[j]):\\r\\n D1[c1] = c2\\r\\n else:\\r\\n D1[c1] = -c2\\r\\n c2 = c2 + 1\\r\\n c1 = c1 + 1\\r\\n rr = M.shape[0]\\r\\n cc = M.shape[1]\\r\\n Ma = np.zeros([rr,cc],dtype=np.float64)\\r\\n for i in range(rr):\\r\\n Ma[i,:] = (M[(abs(D1[i])-1),:]*(np.sign(D1[i])))\\r\\n l1 = 0\\r\\n for j in range(cc):\\r\\n l1 = np.dot(Mi[j,:],Ma[:,j])[0,0] + l1\\r\\n else:\\r\\n if (p == 0):\\r\\n he = self.basis_group_oriented_p_chains(p) \\r\\n on1 = np.ones(len(list(he.dic.keys())), dtype=np.float64) \\r\\n v = P_chains([],[])\\r\\n v = P_chains(list(he.dic.keys()),on1)\\r\\n v1 = permutation_in_simplex_test(v, make_permutation(h))\\r\\n D1={}\\r\\n c1 = 0\\r\\n for i in list(v1.dic.keys()):\\r\\n c2 = 1\\r\\n for j in list(he.dic.keys()):\\r\\n if (i == j):\\r\\n if (v1.dic[i] == he.dic[j]):\\r\\n D1[c1] = c2\\r\\n else:\\r\\n D1[c1] = -c2\\r\\n c2 = c2 + 1\\r\\n c1 = c1 + 1\\r\\n rr = M.shape[0]\\r\\n cc = M.shape[1]\\r\\n Ma = np.zeros([rr,cc],dtype=np.float64)\\r\\n for i in range(rr):\\r\\n Ma[i,:] = (M[(abs(D1[i])-1),:]*(np.sign(D1[i])))\\r\\n l1 = 0\\r\\n for j in range(cc):\\r\\n l1 = np.dot(Mi[j,:],Ma[:,j])[0,0] + l1\\r\\n else:\\r\\n l1 = 0\\r\\n p = k + 1\\r\\n if (p>0 and (p <= self.dimension())):\\r\\n hi = self.basis_group_oriented_p_chains(p-1) \\r\\n on1i = np.ones(len(list(hi.dic.keys())), dtype=np.float64) \\r\\n vi = P_chains([],[])\\r\\n vi = P_chains(list(hi.dic.keys()),on1i)\\r\\n v1i = permutation_in_simplex_test(vi, make_permutation(h))\\r\\n D1i={}\\r\\n c1 = 0\\r\\n for i in list(v1i.dic.keys()):\\r\\n c2 = 1\\r\\n for j in list(hi.dic.keys()):\\r\\n if (i == j):\\r\\n if (v1i.dic[i] == hi.dic[j]):\\r\\n D1i[c1] = c2\\r\\n else:\\r\\n D1i[c1] = -c2\\r\\n c2 = c2 + 1\\r\\n c1 = c1 + 1\\r\\n rr = M1.shape[0]\\r\\n cc = M1.shape[1]\\r\\n Mai = np.zeros([rr,cc],dtype=np.float64)\\r\\n for i in range(rr):\\r\\n Mai[i,:] = (M1[(abs(D1i[i])-1),:]*(np.sign(D1i[i])))\\r\\n l2 = 0\\r\\n for j in range(cc):\\r\\n l2 = np.dot(Mii[j,:],Mai[:,j])[0,0] + l2\\r\\n else:\\r\\n l2 = 0\\r\\n uu.append(l1-l2) \\r\\n vv.append(size_conjugacy_class(h,n))\\r\\n for i in range(M5.shape[0]):\\r\\n Ip = 0\\r\\n for j in range(M5.shape[1]):\\r\\n Ip = Ip + M5[i,j]*uu[j]*vv[j]\\r\\n Ip = Ip/card\\r\\n D[tuple(w5[i])] = abs(round(Ip))\\r\\n '''Note that I am using round, only because the results obtained are \\r\\n not esthetics'''\\r\\n vec_dic[k] = D\\r\\n return vec_dic\",\n \"def I(n):\\n identity = Matrix(n,n)\\n print identity.matrix\\n index = 0 \\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n identity.matrix[i][index] = 1\\n index += 1\\n\\n\\n flat = []\\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n flat.append(identity.matrix[i][j])\\n\\n\\n return identity\",\n \"def expansion_matrix_dl(self):\\n\\n row = self._base_nlp._lower_d_map\\n nnz = len(self._base_nlp._lower_d_map)\\n col = np.arange(nnz, dtype=np.int)\\n data = np.ones(nnz)\\n return csr_matrix((data, (row, col)), shape=(self.nd, nnz))\",\n \"def modalDiffMatrix(n):\\n k = np.arange(n)\\n a = (-1)**k\\n A = sp.triu(1-np.outer(a,a))\\n D = np.dot(A,np.diag(k))\\n D[0,:] = D[0,:]/2\\n return D\",\n \"def D2mat(numpts, delta=1, periodic=True, q=0):\\n\\n a = 1. / delta ** 2 * ones(numpts)\\n b = -2. / delta ** 2 * ones(numpts)\\n c = 1. / delta ** 2 * ones(numpts)\\n #print \\\"delta = %f\\\" % (delta)\\n if periodic:\\n if q == 0:\\n return sparse.spdiags([c, a, b, c, c], [-numpts + 1, -1, 0, 1, numpts - 1], numpts, numpts)\\n else:\\n return sparse.spdiags([exp(-(0. + 1.j) * q) * c, a, b, c, exp((0. + 1.j) * q) * c],\\n [-numpts + 1, -1, 0, 1, numpts - 1], numpts, numpts)\\n else:\\n return sparse.spdiags([a, b, c], [-1, 0, 1], numpts, numpts)\",\n \"def Problem2(n):\\n diag_entries = np.empty((3,n))\\n diag_entries[0] = np.ones(n)*(-1)\\n diag_entries[1] = np.ones(n)*2\\n diag_entries[2] = np.ones(n)*(-1)\\n A = sparse.spdiags(diag_entries, [-1,0,1],n,n,format=\\\"csr\\\")\\n return A\",\n \"def create_matrix(n, m):\\n matrix = [[None]*m for i in range(n)]\\n return matrix\",\n \"def generate_basis(n, dim):\\n planes = [np.random.randn(dim) for i in range(n)]\\n return [p / np.linalg.norm(p) for p in planes]\",\n \"def gen_M_1d(k=None, n=None, sparse=True):\\n if n is None:\\n print(\\\"specify `n` in gen_M_1d\\\")\\n sys.exit(0)\\n\\n if k is None:\\n print(\\\"specify `k` in gen_M_1d\\\")\\n sys.exit(0)\\n\\n ## find split1 and split 2 indices\\n s1 = (n-k)/2\\n s2 = n-(s1+k)\\n\\n ## build diagonal\\n if sparse:\\n data = np.ones(n)\\n offsets = s1\\n M = sps.dia_matrix((data,offsets), shape=(k,n))\\n else:\\n d = np.concatenate([np.zeros(s1), np.ones(k), np.zeros(s2)])\\n M = np.diag(d)\\n M = M[s1:(s1+k),:]\\n return M\",\n \"def decomposition_into_s_n_irreducibles_chain_sp(self, n):\\r\\n w5 = partitions_list(n)\\r\\n M5 = form_matrix_yt(w5)\\r\\n card = math.factorial(n)\\r\\n vec_dic = {}\\r\\n for k in range(self.dimension()+1):\\r\\n D = {}\\r\\n uu = []\\r\\n vv = []\\r\\n he = self.basis_group_oriented_p_chains(k) \\r\\n for h in w5:\\r\\n v1 = P_chains([],[])\\r\\n v1 = permutation_in_simplex_test(he, make_permutation(h))\\r\\n rr = len(list(he.dic.keys()))\\r\\n Ma = np.zeros([rr,rr],dtype=np.float64)\\r\\n c1 = 0\\r\\n for i in list(he.dic.keys()):\\r\\n c2 = 0\\r\\n for j in list(v1.dic.keys()):\\r\\n if (i == j):\\r\\n Ma[c1,c2] = v1.dic[i]\\r\\n c2 = c2 + 1\\r\\n c1 = c1 + 1\\r\\n Ma = np.matrix(Ma, dtype='float64')\\r\\n uu.append(np.trace(Ma)) \\r\\n vv.append(size_conjugacy_class(h,n))\\r\\n for i in range(M5.shape[0]):\\r\\n Ip = 0\\r\\n for j in range(M5.shape[1]):\\r\\n Ip = Ip + M5[i,j]*uu[j]*vv[j]\\r\\n Ip = Ip/card\\r\\n D[tuple(w5[i])]=Ip\\r\\n vec_dic[k] = D\\r\\n return vec_dic\",\n \"def construct_matrix_A(n):\\n n2 = n**2\\n D0 = 4*np.ones(n2) # 0th diagonal\\n D1 = - np.ones(n2 - 1) # -1st, 1st diagonals\\n D1[n-1::n] = 0 # Setting every k*n-1 entries = 0 for k < n\\n DN = - np.ones(n2 - n) # -nth, nth diagonals\\n return scipy.sparse.diags((DN, D1, D0, D1, DN), (-n, -1, 0, 1, n),\\n shape=(n2, n2), format=\\\"csr\\\")\",\n \"def get_feature_matrix(N, Xtrain, D):\\n for i in range(D+1):\\n if i == 0:\\n X = [1] * N\\n else:\\n X = np.vstack([np.power(Xtrain, i), X])\\n X = X.transpose()\\n return X\",\n \"def magma_dnrm2(n, dx, incx, queue):\\n\\n return _libmagma.magma_dnrm2(n, int(dx), incx, queue)\",\n \"def __init__(self, n):\\r\\n self.size = n\\r\\n self.mat = []\\r\\n for i in range(n):\\r\\n self.mat.append([0] * n)\",\n \"def calc_einsum_idx(bits, n):\\n assert len(bits) + n <= len(SYMBOLS)\\n\\n tens_in = SYMBOLS[:n]\\n tens_out = list(tens_in)\\n mat_left = ''\\n mat_right = ''\\n\\n for pos, idx in enumerate(reversed(bits)):\\n mat_left += SYMBOLS[-1 - pos]\\n mat_right += tens_in[-1 - idx]\\n tens_out[-1 - idx] = SYMBOLS[-1 - pos]\\n tens_out = ''.join(tens_out)\\n\\n return mat_left + mat_right + ',' + tens_in + '->' + tens_out\",\n \"def identity_matrix(self, n):\\r\\n IdM = self.zeros_matrix(n, n)\\r\\n for i in range(n):\\r\\n IdM[i][i] = 1.0\\r\\n \\r\\n return IdM\",\n \"def coordinate_matrix(n):\\n xcoordinates = np.zeros((n,n))\\n xcoordinates = xcoordinates + np.arange(0,worksize) #broadcasting trick\\n ycoordinates = xcoordinates.T\\n return np.array([ycoordinates,xcoordinates])\",\n \"def d(n,m):\\r\\n integrand = lambda r: r**3*R(n,0,r)*R(m,1,r)\\r\\n integral = integrate.quad(integrand, 0, np.inf)\\r\\n\\r\\n return e*a0*integral[0]/np.sqrt(3)\",\n \"def get_nd_basis(n=5):\\n assert n >= 0\\n t = np.linspace(0, np.pi, n + 1)[:-1]\\n xs = np.cos(t)\\n ys = np.sin(t)\\n return [(x, y) for x, y in zip(xs, ys)]\",\n \"def n_simplex(self, dim_n=3, project = True):\\n verts = permutations([0 for i in range(dim_n)] + [1])\\n if project: verts = [Polytopes.project_1(x) for x in verts]\\n return Polyhedron(vertices = verts)\",\n \"def get_multivariate_matrix(x_data, D):\\n rows = []\\n terms = get_polynomial(['x1', 'x2', 'x3', 'x4', 'x5'], D)\\n for row in range(len(x_data)):\\n row_data = {}\\n row_data['x1'] = x_data[row, 0]\\n row_data['x2'] = x_data[row, 1]\\n row_data['x3'] = x_data[row, 2]\\n row_data['x4'] = x_data[row, 3]\\n row_data['x5'] = x_data[row, 4]\\n \\n row_entry = []\\n for t in terms:\\n prod = 1\\n for var in t:\\n prod *= row_data[var]\\n row_entry.append(prod)\\n \\n row_entry = np.array(row_entry) \\n rows.append(row_entry)\\n return np.vstack(rows)\",\n \"def drum_like_env(N, sr):\\n ## TODO: Fill this in\\n return np.zeros(N)\",\n \"def d_weights(n):\\n i = np.arange(1, n)\\n return np.sqrt(n / (i * (n - i)))\",\n \"def eye(cls, n, domain):\\n # XXX: flint matrices do not have anything like eye\\n return DDM.eye(n, domain).to_dfm()\",\n \"def basis_fns(n=0):\\n return lambda x: np.sum(x ** (n+1), axis=1)\",\n \"def dens_matrix_4ch(state):\\n size = len(state)\\n state_conj = np.conj(state)\\n dens_matrix = np.zeros((size,) * 8, dtype=complex)\\n\\n for p1 in range(size):\\n for p2 in range(size):\\n for p3 in range(size):\\n for p4 in range(size):\\n for p1_ in range(size):\\n for p2_ in range(size):\\n for p3_ in range(size):\\n for p4_ in range(size):\\n dens_matrix[p1, p2, p3, p4, p1_, p2_, p3_, p4_] = state[p1, p2, p3, p4] * state_conj[p1_, p2_, p3_, p4_]\\n\\n return dens_matrix\",\n \"def identity(n):\\r\\n I = np.zeros((n, n))\\r\\n diag = np.ones(n)\\r\\n np.fill_diagonal(I, diag)\\r\\n return matrix(I)\",\n \"def identMatrix(size):\\n returnvalue = Matrix()\\n for i in range(size):\\n newrow = [0] * size\\n newrow[i] = 1\\n returnvalue.addRow(*newrow)\\n return returnvalue\",\n \"def gen_density_matrix(states=None, dimensions=None):\\n if states is None:\\n tdim = np.prod(dimensions)\\n dmtotal0 = np.eye(tdim) / tdim\\n\\n return dmtotal0\\n\\n dmtotal0 = np.eye(1, dtype=np.complex128)\\n\\n for i, s in enumerate(states):\\n\\n if not hasattr(s, \\\"__len__\\\"):\\n # assume s is int or float showing the spin projection in the pure state\\n d = dimensions[i]\\n dm_nucleus = np.zeros((d, d), dtype=np.complex128)\\n state_number = int(round((d - 1) / 2 - s))\\n dm_nucleus[state_number, state_number] = 1\\n\\n else:\\n if s.shape.__len__() == 1:\\n d = dimensions[i]\\n dm_nucleus = np.zeros((d, d), dtype=np.complex128)\\n np.fill_diagonal(dm_nucleus, s)\\n\\n else:\\n dm_nucleus = s\\n\\n dmtotal0 = np.kron(dmtotal0, dm_nucleus)\\n\\n return dmtotal0\",\n \"def direct_obs_matrix(Nx,obs_inds):\\n Ny = len(obs_inds)\\n H = zeros((Ny,Nx))\\n H[range(Ny),obs_inds] = 1\\n return H\",\n \"def generate(self, n, d):\\n\\n self.n = n\\n self.d = d\\n self.X = np.random.rand(n, d)\\n self.Y = np.random.choice([0, 1], size=n)\",\n \"def dctmtx(n):\\n x,y = np.meshgrid(range(n), range(n))\\n D = np.sqrt(2.0/n) * np.cos(np.pi * (2*x+1) * y / (2*n))\\n D[0] /= np.sqrt(2)\\n return D\",\n \"def _fd_matrix(step_ratio, parity, nterms):\\n _assert(0 <= parity <= 6,\\n 'Parity must be 0, 1, 2, 3, 4, 5 or 6! ({0:d})'.format(parity))\\n step = [1, 2, 2, 4, 4, 4, 4][parity]\\n inv_sr = 1.0 / step_ratio\\n offset = [1, 1, 2, 2, 4, 1, 3][parity]\\n c0 = [1.0, 1.0, 1.0, 2.0, 24.0, 1.0, 6.0][parity]\\n c = c0 / \\\\\\n special.factorial(np.arange(offset, step * nterms + offset, step))\\n [i, j] = np.ogrid[0:nterms, 0:nterms]\\n return np.atleast_2d(c[j] * inv_sr ** (i * (step * j + offset)))\",\n \"def reflect(d,n):\\n\\t# coefficent c, because easier\\n\\tc = 2 * dot(d,n)\\n\\treturn [di - c * ni for (di, ni) in zip(d,n)]\",\n \"def exo4_q1(mu,n,x0,y0):\\r\\n #liste.append([x0,y0])\\r\\n absc = x0\\r\\n ordn = y0\\r\\n L = np.array([absc])\\r\\n M = np.array([ordn])\\r\\n for i in range(0,n):\\r\\n absc = exo2_1(absc,mu)\\r\\n ordn = exo2_1(ordn,mu)\\r\\n L = np.append(L,[absc])\\r\\n M = np.append(M,[ordn])\\r\\n return L,M\",\n \"def from_list_sympy(cls, nrows, ncols, rows, **kwargs):\\n assert len(rows) == nrows\\n assert all(len(row) == ncols for row in rows)\\n\\n items_sympy = [_sympify(item) for row in rows for item in row]\\n\\n domain, items_domain = cls.get_domain(items_sympy, **kwargs)\\n\\n domain_rows = [[items_domain[ncols*r + c] for c in range(ncols)] for r in range(nrows)]\\n\\n return DomainMatrix(domain_rows, (nrows, ncols), domain)\",\n \"def xyMatrixTransformMSD(d, m):\\n functionSpace = np.zeros((d,d))\\n for x in range(d):\\n for y in range(d): \\n xy = np.transpose([x, y])\\n _xy = np.dot(m, xy)\\n functionSpace[x, y] = int(str(_xy[0]*_xy[0]+_xy[1]*_xy[1])[0])\\n \\n return functionSpace\",\n \"def laplacian_mat(n):\\n data = [1, -2, 1]*n\\n i = flatten([[k,k,k] for k in range(n)])\\n j = flatten([[k-1, k, k+1] for k in range(n)])\\n return scipy.sparse.coo_matrix((data[1:-1], (i[1:-1], j[1:-1])))\",\n \"def generate_positive_semi_definite_matrix(n_dim):\\n cov = np.random.randn(n_dim, n_dim)\\n return np.dot(cov, cov.T)\",\n \"def mesh_uniform(N_e, d, Omega):\",\n \"def create_dims(self, n_vec, m_vec):\\n dims_mat = np.array([], dtype=np.int64).reshape(2, 0)\\n for n in n_vec:\\n for m in m_vec[m_vec > n]:\\n dims_mat = np.hstack((dims_mat,\\n np.array([[n], [m]])))\\n return dims_mat\",\n \"def LDL(A, d):\\n n = shape(A)[0]\\n L = array(eye(n))\\n dg = zeros(n)\\n dg[0] = A[0, 0]\\n for k in range(1, n):\\n m = reshape(array(A[:k, k].copy()), k)\\n rforwardsolve(L[:k, :k], m, d)\\n L[k, :k] = m/dg[:k]\\n dg[k] = A[k, k] - dot(L[k, :k], m)\\n return L, dg\",\n \"def get_omega_0(n_bits: int, as_numeric: bool = False) -> Matrix:\\n q = qe.get_bit_map(len(DEPENDENTS), n_bits)\\n mat = -q.T @ q + 4 * np.diag(np.sum(q, axis=0))\\n return np.array(mat) if as_numeric else mat\",\n \"def ddL(n):\\n\\n\\tif (n==0):\\n\\t\\treturn lambda x: 0.0\\n\\n\\telif (n==1):\\n\\t\\treturn lambda x: 0.0\\n\\n\\telse:\\n\\n\\t\\t# approximate by fitting polynomial and taking derivatives\\n\\t\\tc_om1 = coef_approximation(L(n), n)\\n\\t\\tc_prime = polynomial_derivative(c_om1)\\n\\t\\tc_double_prime = polynomial_derivative(c_prime)\\n\\n\\t\\t# [TODO]: fix own method from Hw 3\\n\\t\\treturn lambda x: np.polyval(c_double_prime, x)\",\n \"def matrix_L1(l, omega, S, cn):\\n zt = omega * S / cn['t']\\n L = np.array((dN2(l, zt), dN4(l, zt)))\\n return L.T\",\n \"def matrix_N2(l, omega, S, cn):\\n sqrt = np.sqrt(l * (l + 1))\\n zl = omega * S / cn['l']\\n zt = omega * S / cn['t']\\n col1 = - np.array((wN1(l, zt), wN2(l, zt), wN3(l, zt), wN4(l, zt))) / zt\\n col2 = (sqrt * np.array((wL1(l, zt), wL2(l, zl),\\n wL3(l, zl), wL4(l, zl, zt))) / zl\\n )\\n N = np.array((col1, col2))\\n return N.T\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def identity_matrix(n: int) -> Matrix:\\n return make_matrix(n, n, lambda i, j: 1 if i == j else 0)\",\n \"def _lambda(m, d, Q):\\n\\n d_2 = int(d / 2)\\n def y_i_j(i, j):\\n poly = list(np.zeros((d + 1, 1)))\\n for k in range(d_2 + 1):\\n for l in range(d_2 + 1):\\n poly[k + l] += Q[i + k * m, j + l * m]\\n return poly\\n\\n mat_y = [[y_i_j(i, j) for j in range(m)] for i in range(m)]\\n mat_y = np.array(mat_y)\\n return mat_y\",\n \"def CreateDesignMatrix_X(z, x, y, n ):\\n if len(x.shape) > 1:\\n x = np.ravel(x)\\n y = np.ravel(y)\\n\\n N = len(x)\\n l = int((n+1)*(n+2)/2) \\n X = np.ones((N,l))\\n\\n for i in range(1,n+1):\\n q = int((i)*(i+1)/2)\\n for k in range(i+1):\\n X[:,q+k] = x**(i-k) * y**k\\n \\n X, z_, indicies = shuffle(X, z)\\n X_train, X_test, z_train, z_test = train_test_split(X, z_, test_size=split_train_test, random_state=seed, shuffle=False)\\n X_test, X_val, z_test, z_val = train_test_split(X_test, z_test, test_size=split_test_val, random_state=seed, shuffle=False)\\n\\n return X, X_train, X_test, X_val, z_train, z_test, z_val, indicies\",\n \"def recomb_matrix(recomb_coefficients, atomic_number, ion_number):\\n offdiag = np.zeros(atomic_number)\\n index = recomb_coefficients.index\\n for i in index:\\n offdiag[i] = recomb_coefficients.loc[i]\\n diag = np.hstack([np.zeros(1), -offdiag])\\n return (np.diag(diag) + np.diag(offdiag, k=1))[ion_number, :]\",\n \"def generate_random_matrix(n):\\n return [[random.randint(1, 50) for i in range(n)] for j in range(n)]\",\n \"def xn_xn_prod(self,x_n):\\n \\n x_n_tiled =T.tile(x_n,(self.num_vars,1))\\n \\n return T.transpose(x_n_tiled)*x_n_tiled\",\n \"def eye(n,M=None, k=0, dtype=float):\\n return asmatrix(np.eye(n,M,k,dtype))\",\n \"def identity_matrix(n):\\n I = zeros_matrix(n, n)\\n for i in range(n):\\n I[i][i] = 1.0\\n\\n return I\",\n \"def identity_matrix(n):\\n I = zeros_matrix(n, n)\\n for i in range(n):\\n I[i][i] = 1.0\\n\\n return I\",\n \"def designMatrix(self,x,m):\\n\\n phi = []\\n\\n for i in x:\\n matric = []\\n for j in range(0, m + 1):\\n matric.append(np.power(i,j))\\n phi.append(matric)\\n return np.asarray(phi)\",\n \"def generate_model (d):\\n return np.random.rand (d+1, 1)\",\n \"def complex_matrix(n):\\n\\n matrix = np.zeros(shape=(n, n), dtype=complex)\\n\\n for row in np.arange(n):\\n if row == 0:\\n for col in np.arange(n):\\n matrix[row, col] = 1\\n else:\\n for col in np.arange(n):\\n if col == 0:\\n matrix[row, col] = 1\\n else:\\n matrix[row, col] = roots(n, col*row)\\n\\n return matrix\",\n \"def get_extremist_network(Nx, Dx):\\n N = np.zeros([Nx, Nx], dtype=int)\\n\\n for i in range(0, Nx): # Iterate over the upper diagonal only\\n for j in range(i+1, Nx):\\n r = rg.random() # r is in [0.0, 1.0)\\n if r <= Dx:\\n N[i][j] = 1\\n N[j][i] = 1\\n return N\",\n \"def bandcholesky(A, d):\\n L, dg = LDL(A, d)\\n return matrix(L)*diag(sqrt(dg))\",\n \"def create_array( n ):\",\n \"def build_difs_matrix(xs):\\n n = len(xs)\\n difs = np.zeros((n, n, 2))\\n for row_id in range(n):\\n ident = -np.eye(n)\\n ident[:, row_id] += 1\\n difs[row_id, :, 0] = ident @ xs[:, 0]\\n difs[row_id, :, 1] = ident @ xs[:, 1]\\n return difs\",\n \"def discreteComplexComposeGraph(self,S,n):\\n N=len(S)\\n M=N//2\\n g=[]\\n d=0\\n for k in range(M):\\n d+=S[k+M]*cmath.exp(2j*cmath.pi*k*n/N)+S[-k+M]*cmath.exp(-2j*cmath.pi*k*n/N)\\n g.append((d.real,d.imag))\\n return g\",\n \"def scale(self,n,d=1):\\r\\n\\t\\t\\r\\n\\t\\t# scale all terms\\r\\n\\t\\ts = [i.scale(n,d) for i in self]\\r\\n\\t\\t\\r\\n\\t\\treturn Li(s)\",\n \"def r_vars(size, used=None):\\n return r_symbols(size, VAR_SYMBOLS, ARGS.variable_length, used)\",\n \"def syndSolveLazy(wdsize): # PENDING to debug\\r\\n # NameMat = wd2N[wdsize]\\r\\n r = int(math.ceil(math.log(wdsize, 2)) ) + 2 \\r\\n \\r\\n P = k2pmap[wdsize] # get the full parity matrix <kxr> \\r\\n assert P.shape[0]==wdsize and P.shape[1]==r \\r\\n finals = '' \\r\\n s1='assign noerr = '\\r\\n for i in xrange(r):\\r\\n ss = '~synd[{0}] & '.format(i) if i !=r-1 else '~synd[{0}];'.format(i) \\r\\n s1 += ss \\r\\n\\r\\n s1 += '\\\\n' \\r\\n\\r\\n finals += s1 \\r\\n\\r\\n # neg = lambda x: '~' if x==0 else '' \\r\\n\\r\\n s2 = ''\\r\\n\\r\\n for idx, name in enumerate(P):\\r\\n flip_s = 'assign flip[{0}] = '.format(idx)\\r\\n setbit_ind_array = np.nonzero(name)[0].astype('int') \\r\\n for i in setbit_ind_array: # set bit index\\r\\n subs = 'synd[{index}] & '.format(index = i) if i != setbit_ind_array[-1] else \\\\\\r\\n 'synd[{index}];'.format( index=i) \\r\\n flip_s += subs \\r\\n s2 = s2 + flip_s + '\\\\n' \\r\\n\\r\\n\\r\\n finals += s2 \\r\\n\\r\\n return finals\",\n \"def diag_dom(n, num_entries=None):\\n if num_entries is None:\\n num_entries = int(n**1.5) - n\\n A = np.zeros((n,n))\\n rows = np.random.choice(np.arange(0,n), size=num_entries)\\n cols = np.random.choice(np.arange(0,n), size=num_entries)\\n data = np.random.randint(-4, 4, size=num_entries)\\n for i in xrange(num_entries):\\n A[rows[i], cols[i]] = data[i]\\n for i in xrange(n):\\n A[i,i] = np.sum(np.abs(A[i])) + 1\\n return A\",\n \"def expand_dofs(dofs, n_components):\\n if dofs.ndim > 1:\\n sh = dofs.shape\\n dofs = dofs.ravel()\\n\\n else:\\n sh = None\\n\\n edofs = nm.empty(n_components * dofs.shape[0], nm.int32)\\n for idof in range(n_components):\\n aux = n_components * dofs + idof\\n edofs[idof::n_components] = aux\\n\\n if sh is not None:\\n edofs.shape = sh[:-1] + (-1,)\\n\\n return edofs\",\n \"def symbolize(X, m):\\n \\n X = np.array(X)\\n\\n if m >= len(X):\\n raise ValueError(\\\"Length of the series must be greater than m\\\")\\n \\n dummy = []\\n for i in range(m):\\n l = np.roll(X,-i)\\n dummy.append(l[:-(m-1)])\\n \\n dummy = np.array(dummy)\\n \\n symX = []\\n \\n for mset in dummy.T:\\n rank = stats.rankdata(mset, method=\\\"min\\\")\\n symbol = np.array2string(rank, separator=\\\"\\\")\\n symbol = symbol[1:-1]\\n symX.append(symbol)\\n \\n return symX\",\n \"def get_X_lasso(n, m):\\n\\n jHa = np.arange(m * n)\\n iHa = np.repeat(np.arange(n), m)\\n jHb = np.arange(m * n)\\n iHb = np.tile(np.arange(m), n) + n\\n j = np.concatenate((jHa, jHb))\\n i = np.concatenate((iHa, iHb))\\n H = sp.csc_matrix((np.ones(n * m * 2), (i, j)), shape=(n+m, n*m))\\n return H\",\n \"def MM(x,N,n,l,t=0):\\n Mat = np.zeros([2**l,2**l])\\n for iii in range(N):\\n Mat[iii,(x**n * iii)%N] = 1\\n return Mat\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59795463","0.5888374","0.57391495","0.5711324","0.5686454","0.5563071","0.5492323","0.5435326","0.5423058","0.5419523","0.54059994","0.5392236","0.538575","0.5366352","0.5356909","0.53455615","0.5337914","0.5334625","0.5330213","0.53227186","0.53154725","0.53090394","0.5283747","0.5281429","0.526937","0.52573615","0.5251509","0.52102005","0.5202278","0.51470196","0.5135316","0.5134825","0.5132082","0.5124863","0.5110964","0.51070005","0.51016617","0.5088285","0.5072215","0.5069307","0.50554955","0.5036671","0.5034988","0.5034725","0.5011805","0.5010148","0.5008242","0.5007005","0.49876186","0.49870697","0.4985024","0.49813014","0.49687636","0.49648944","0.49542427","0.4951821","0.49510753","0.4947966","0.4934529","0.4932151","0.49213573","0.49023703","0.489465","0.4887559","0.48869953","0.48765406","0.487493","0.48700628","0.48667222","0.48587996","0.4850112","0.48480186","0.48474178","0.48402905","0.48402905","0.48402905","0.48332343","0.48322088","0.48312396","0.4821526","0.4819062","0.48096684","0.4808425","0.4808425","0.4808123","0.48002785","0.47954276","0.47933435","0.47853315","0.47746092","0.47739026","0.4773852","0.47694048","0.47665554","0.4763099","0.47616357","0.47612846","0.4755161","0.47484088","0.47371075"],"string":"[\n \"0.59795463\",\n \"0.5888374\",\n \"0.57391495\",\n \"0.5711324\",\n \"0.5686454\",\n \"0.5563071\",\n \"0.5492323\",\n \"0.5435326\",\n \"0.5423058\",\n \"0.5419523\",\n \"0.54059994\",\n \"0.5392236\",\n \"0.538575\",\n \"0.5366352\",\n \"0.5356909\",\n \"0.53455615\",\n \"0.5337914\",\n \"0.5334625\",\n \"0.5330213\",\n \"0.53227186\",\n \"0.53154725\",\n \"0.53090394\",\n \"0.5283747\",\n \"0.5281429\",\n \"0.526937\",\n \"0.52573615\",\n \"0.5251509\",\n \"0.52102005\",\n \"0.5202278\",\n \"0.51470196\",\n \"0.5135316\",\n \"0.5134825\",\n \"0.5132082\",\n \"0.5124863\",\n \"0.5110964\",\n \"0.51070005\",\n \"0.51016617\",\n \"0.5088285\",\n \"0.5072215\",\n \"0.5069307\",\n \"0.50554955\",\n \"0.5036671\",\n \"0.5034988\",\n \"0.5034725\",\n \"0.5011805\",\n \"0.5010148\",\n \"0.5008242\",\n \"0.5007005\",\n \"0.49876186\",\n \"0.49870697\",\n \"0.4985024\",\n \"0.49813014\",\n \"0.49687636\",\n \"0.49648944\",\n \"0.49542427\",\n \"0.4951821\",\n \"0.49510753\",\n \"0.4947966\",\n \"0.4934529\",\n \"0.4932151\",\n \"0.49213573\",\n \"0.49023703\",\n \"0.489465\",\n \"0.4887559\",\n \"0.48869953\",\n \"0.48765406\",\n \"0.487493\",\n \"0.48700628\",\n \"0.48667222\",\n \"0.48587996\",\n \"0.4850112\",\n \"0.48480186\",\n \"0.48474178\",\n \"0.48402905\",\n \"0.48402905\",\n \"0.48402905\",\n \"0.48332343\",\n \"0.48322088\",\n \"0.48312396\",\n \"0.4821526\",\n \"0.4819062\",\n \"0.48096684\",\n \"0.4808425\",\n \"0.4808425\",\n \"0.4808123\",\n \"0.48002785\",\n \"0.47954276\",\n \"0.47933435\",\n \"0.47853315\",\n \"0.47746092\",\n \"0.47739026\",\n \"0.4773852\",\n \"0.47694048\",\n \"0.47665554\",\n \"0.4763099\",\n \"0.47616357\",\n \"0.47612846\",\n \"0.4755161\",\n \"0.47484088\",\n \"0.47371075\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58973736"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":6889,"cells":{"query":{"kind":"string","value":"r\"\"\" Return a string that describes the convex hull engine."},"document":{"kind":"string","value":"def convex_hull_engine(self):\n return self.convex_hull._name"},"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 _repr_(self):\n desc = ''\n if self.n_vertices()==0:\n desc += 'The empty polyhedron'\n else:\n desc += 'A ' + repr(self.dim()) + '-dimensional polyhedron'\n desc += ' in '\n if self.field()==QQ: desc += 'QQ'\n else: desc += 'RDF'\n desc += '^' + repr(self.ambient_dim()) \n\n if self.n_vertices()>0:\n desc += ' defined as the convex hull of ' \n desc += repr(self.n_vertices())\n if self.n_vertices()==1: desc += ' vertex'\n else: desc += ' vertices'\n \n if self.n_rays()>0:\n if self.n_lines()>0: desc += \", \"\n else: desc += \" and \"\n desc += repr(self.n_rays())\n if self.n_rays()==1: desc += ' ray'\n else: desc += ' rays'\n \n if self.n_lines()>0:\n if self.n_rays()>0: desc += \", \"\n else: desc += \" and \"\n desc += repr(self.n_lines())\n if self.n_lines()==1: desc +=' line'\n else: desc +=' lines'\n\n return desc + \".\\n\";","def convex_hull(self):\n return self._geomgen(capi.geom_convex_hull)","def convex_hull(self):\n return _property_geo(arctern.ST_ConvexHull, self)","def _repr_(self):\n return \"Projective hypersurface defined by %s in %s\"%(\n self.defining_polynomial(), self.ambient_space())","def _repr_(self):\n return \"Affine hypersurface defined by %s in %s\"%(\n self.defining_polynomial(), self.ambient_space())","def convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len(points) <= 1:\n return points\n\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\n # Returns a positive value, if OAB makes a counter-clockwise turn,\n # negative for clockwise turn, and zero if the points are collinear.\n def cross(o, a, b):\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\n\n # Build lower hull\n lower = []\n for p in points:\n cont = 1\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\n print(\"antes \"), print(cont), print(lower)\n lower.pop()\n print(\"despues \"),print(lower)\n cont += 1\n lower.append(p)\n xlower ,ylower = getlists(lower)\n plt.plot(xlower,ylower,color=\"yellow\")\n # Build upper hull\n upper = []\n for p in reversed(points):\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\n upper.pop()\n upper.append(p)\n print(upper)\n print(\"hello2 \")\n print(cross((2,0),(2,4),(2.5,3)))\n\n xupper ,yupper = getlists(upper)\n plt.plot(xupper,yupper,color=\"blue\")\n\n\n return lower[:-1] + upper[:-1]","def _repr_(self):\n s = 'The projection of a polyhedron into ' + repr(self.dimension) \n s += ' dimensions.'\n return s + \"\\n\"","def hull(self):\n capacity = self._getAttribute(Attribute.hullCapacity)\n em = self._getAttribute(Attribute.hullEM)\n explosive = self._getAttribute(Attribute.hullExplosive)\n kinetic = self._getAttribute(Attribute.hullKinetic)\n thermal = self._getAttribute(Attribute.hullThermal)\n\n em = 1.0 - em\n explosive = 1.0 - explosive\n kinetic = 1.0 - kinetic\n thermal = 1.0 - thermal\n\n return {\n \"capacity\": capacity,\n \"resists\": {\n \"em\": em,\n \"explosive\": explosive,\n \"kinetic\": kinetic,\n \"thermal\": thermal\n }\n }","def convex_hull(self):\n nodes = self._datacontroller.get_data('nodes')\n scale = self._datacontroller.get_data('scale')\n hull = tsputil.convex_hull_helper(nodes)\n if hull:\n result = construct_step(hull, 'Most Top Left Node', 'Clockwise', nodes, scale)\n self._datacontroller.commit_change('path', result)","def getContourRep(self):\n\t\tvertex1 = [[self.startX, self.startY]]\n\t\tvertex2 = [[self.startX, self.endY]]\n\t\tvertex3 = [[self.endX, self.startY]]\n\t\tvertex4 = [[self.endX, self.endY]]\n\t\tvertices = [vertex1, vertex2, vertex3, vertex4]\n\t\treturn convexHull(np.asarray(vertices, dtype = np.int32))","def __str__(self):\n vertices = []\n for idx in range(3):\n v = self.vertices[idx]\n if v is not None:\n vertices.append(str(v))\n else:\n orig_idx, dest_idx = (idx - 1) % 3, (idx + 1) % 3\n orig, dest = self.vertices[orig_idx], self.vertices[dest_idx]\n halfway = (orig.x + dest.x) * .5, (orig.y + dest.y) * .5\n# print(halfway)\n d = orig.distance(dest)\n dx = dest.x - orig.x\n# print(d)\n# print(dx)\n dx /= d\n dy = dest.y - orig.y\n# print(dy)\n dy /= d\n dx *= d\n dy *= d\n pt_halfway = halfway[0] + dy, halfway[1] - dx\n# print(\"outside\", orig_idx, dest_idx, pt_halfway)\n vertices.append(\"{0[0]} {0[1]}\".format(pt_halfway))\n vertices.append(vertices[0])\n return \"POLYGON(({0}))\".format(\", \".join(vertices))","def _repr_(self):\n desc = ''\n if self.n_vertices()==0:\n desc += 'The empty lattice polytope'\n else:\n desc += 'A ' + repr(self.affine_dimension()) + '-dimensional lattice polytope'\n desc += ' in ZZ^' + repr(self.space_dimension())\n\n if self.n_vertices()>0:\n desc += ' with '\n desc += repr(self.n_vertices())\n if self.n_vertices()==1: desc += ' vertex'\n else: desc += ' vertices'\n return desc","def give_convex_hull(rand_points):\n return ConvexHull(rand_points)","def convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len(points) <= 1:\n return points\n\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\n # Returns a positive value, if OAB makes a counter-clockwise turn,\n # negative for clockwise turn, and zero if the points are collinear.\n def cross(o, a, b):\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\n\n # Build lower hull \n lower = []\n for p in points:\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\n lower.pop()\n lower.append(p)\n\n # Build upper hull\n upper = []\n for p in reversed(points):\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\n upper.pop()\n upper.append(p)\n\n # Concatenation of the lower and upper hulls gives the convex hull.\n # Last point of each list is omitted because it is repeated at the beginning of the other list. \n return lower[:-1] + upper[:-1]","def convex_hull(self):\n if self._faces is None:\n if self._vertices is None:\n return None\n self.triangulate()\n return self._convex_hull","def display_and_label_hulls(self, hulls, src):\n \n labels = []\n\n for hull in hulls:\n\n angle = 0\n MA = 1\n ma = 1\n try:\n _,(MA,ma),angle = cv.fitEllipse(hull)\n except:\n pass\n cosAngle = np.abs(np.cos(angle*np.pi/180))\n\n # Only human-classify hulls if it is reasonably a vertically oriented rectangle\n # This is a hueristic to not have to waste time clasifying hulls clearly not poles\n if (cosAngle < 1.75) and (cosAngle > 0.85) and (MA/ma < 0.28):\n cpy = src.copy()\n hull_img = cv.polylines(cpy, [hull], True, (0,0,255), 3)\n cv.imshow(\"Hull\", hull_img)\n keycode = cv.waitKey(0)\n if keycode == 49:\n labels.append((hull, 0))\n print(\"Not a Pole\")\n elif keycode == 50:\n labels.append((hull, 1))\n print(\"A Pole!\")\n else:\n raise Exception(\"Unexpected Key Pressed\")\n else:\n labels.append((hull, 0))\n cv.destroyAllWindows()\n return labels","def __str__(self):\n if self.getType() == FRAGMENT:\n t = \"FRAGMENT\"\n else:\n t = \"VERTEX\"\n if not self.isCompiled():\n s = \"not compiled\"\n else:\n s = \"compiled\"\n return \"file: {0}\\ntype: {1}\\nstatus: {2}\\n\".format(self.getPath(), t, s)","def __str__(self):\n return \"hl(\" + str(self.point) + \",\" + str(self.angle) + \")\"","def convex_hull(points):\n pointList = ExtendedTupleList(points)\n complete_ranges = pointList.range_within(0, 1)\n # Filters for four quadrants\n filters = [\n ((0, complete_ranges[1][\"max\"][2], \">=\"), (1, complete_ranges[0][\"max\"][2], \">=\")), #Q1\n ((0, complete_ranges[1][\"max\"][1], \"<=\"), (1, complete_ranges[0][\"min\"][2], \">=\")), #Q2\n ((0, complete_ranges[1][\"min\"][1], \"<=\"), (1, complete_ranges[0][\"min\"][1], \"<=\")), #Q3\n ((0, complete_ranges[1][\"min\"][2], \">=\"), (1, complete_ranges[0][\"max\"][1], \"<=\")) #Q4\n ]\n # Sorting reversals (True means Desc sort, False means Asc sort. Y sort given first)\n sorts = [\n (True, True),\n (True, False),\n (False, False),\n (False, True),\n ]\n hull = ExtendedTupleList([])\n # In CW order of quadrants...\n for index in [0, 3, 2, 1]:\n # Find all the relevant points\n quad_points = ExtendedTupleList([point for point in pointList.filter(filters[index])])\n # Sort them properly\n quad_points.double_sort(1, 0, reverse_outside=sorts[index][0], reverse_inside=sorts[index][1])\n # Build a convex line segment\n line_segment = convex_line_segment(quad_points, sorts[index][0], sorts[index][1])\n # Reverse it, if we need to\n if index % 2 == 1:\n line_segment.reverse()\n # Add all the points in, avoiding repeated points.\n hull.extend(line_segment, avoid_repeats=True)\n return hull","def convex_hull(l):\n\tpass","def show_convex_hull(points, input_choice, timing,percent_pts,size,hull_points = None):\n\texists = os.path.isdir('plots')\n\tif not exists: \n\t\tos.mkdir('plots')\n\n\n\tfor each in points:\n\t\tplt.plot(each[0],each[1],'o-')\n\n\tif hull_points is not None:\n\t\thull_pt_list = []\n\t\tfor each in hull_points:\n\t\t\thull_pt_list.append(list(each))\n\n\t\thull_pt_arr = np.asarray(hull_pt_list)\n\t\t# print(hull_pt_arr)\n\t\tplt.plot(hull_pt_arr[:,0],hull_pt_arr[:,1],'k-')\n\t\tfirst_coord = hull_pt_arr[0,:].reshape(1,2)\n\t\tlast_coord = hull_pt_arr[len(hull_pt_arr)-1,:].reshape(1,2)\n\n\t\tlast_coord_arr = np.append(first_coord, last_coord, axis = 0)\n\t\tplt.plot(last_coord_arr[:,0],last_coord_arr[:,1],'k-')\n\t\tplt.title(label = 'For input : '+input_choice+percent_pts+' time taken = '+str(timing)+' s\\n'+'N='+str(size))\n\t\n\tplt.savefig('plots/'+'Graham_Scan_'+str(input_choice)+str(percent_pts)+'_N='+str(size)+'.png')\n\tplt.show()","def to_str(self):\n return u\"Superellipse[{:.4g},{:.4g}]\".format(self.alpha0.l, self.alpha0.r)","def convex_hull(*args):\n from point import Point\n from line import Segment\n from polygon import Polygon\n\n def uniquify(a):\n # not order preserving\n return list(set(a))\n\n p = args[0]\n if isinstance(p, Point):\n p = uniquify(args)\n\n if len(p) == 1:\n return p[0]\n elif len(p) == 2:\n return Segment(p[0], p[1])\n\n def orientation(p, q, r):\n '''Return positive if p-q-r are clockwise, neg if ccw, zero if\n collinear.'''\n return (q[1] - p[1])*(r[0] - p[0]) - (q[0] - p[0])*(r[1] - p[1])\n\n # scan to find upper and lower convex hulls of a set of 2d points.\n U = []\n L = []\n p.sort()\n for p_i in p:\n while len(U) > 1 and orientation(U[-2], U[-1], p_i) <= 0:\n U.pop()\n while len(L) > 1 and orientation(L[-2], L[-1], p_i) >= 0:\n L.pop()\n U.append(p_i)\n L.append(p_i)\n U.reverse()\n convexHull = tuple(L + U[1:-1])\n\n if len(convexHull) == 2:\n return Segment(convexHull[0], convexHull[1])\n return Polygon(convexHull)","def visualHull(sils, length):\n result = sils.pop(0).cone(length)\n assert result.pnFacesInPoly()\n i = 0\n for s in sils:\n # print(i)\n assert result.pnFacesInPoly()\n result = result.intersection(s.cone(length), True)\n # result.plot()\n i += 1\n return result","def make_convex_hull(self):\n hull_points_d = []\n try:\n print \"self.V_bar_list_d******************\", self.V_bar_list_d\n hull = ConvexHull(self.V_bar_list_d)\n hull_vertices = hull.vertices\n\n for i in hull_vertices:\n hull_points_d.append(self.V_bar_list_d[i])\n\n except scipy.spatial.qhull.QhullError:\n hull_points_d = self.V_bar_list_d\n\n return hull_points_d","def formatted_str(self):\n # Verify correct vertex values\n self.verify_vertex_values()\n # Generate output string\n output_string = \"\"\n for line in range(9):\n for row in range(9):\n if self.grid[line][row] is None:\n output_string += \".\"\n else:\n output_string += str(self.grid[line][row])\n if row != 8:\n output_string += \" \"\n elif line != 8:\n output_string += \"\\n\"\n if row in [2, 5]:\n output_string += \"| \"\n if line in [2, 5]:\n output_string += \"------+-------+------\\n\"\n return output_string","def _convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len(points) <= 1:\n return points\n\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\n # Returns a positive value, if OAB makes a counter-clockwise turn,\n # negative for clockwise turn, and zero if the points are collinear.\n def cross(o, a, b):\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\n\n # Build lower hull\n lower = []\n for p in points:\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\n lower.pop()\n lower.append(p)\n\n # Build upper hull\n upper = []\n for p in reversed(points):\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\n upper.pop()\n upper.append(p)\n\n # Concatenation of the lower and upper hulls gives the convex hull.\n # Last point of each list is omitted because it is repeated at the beginning of the other list.\n return lower[:-1] + upper[:-1]","def __str__(self):\n puzzle_string = '—' * 13 + '\\n'\n for i in range(self.PUZZLE_NUM_ROWS):\n for j in range(self.PUZZLE_NUM_COLUMNS):\n puzzle_string += '│{0: >2}'.format(str(self.position[i][j]))\n if j == self.PUZZLE_NUM_COLUMNS - 1:\n puzzle_string += '│\\n'\n\n puzzle_string += '—' * 13 + '\\n'\n return puzzle_string","def draw(self):\n drawing = \"\"\n \n if self.get_gene().get_choice_at(1) is 'c':\n drawing += 'o'\n else:\n drawing += 'x'\n \n if self.is_tft():\n drawing += \"tft\"\n return drawing\n elif self.is_t2t():\n drawing += \"t2t\"\n return drawing\n elif self.is_ftf():\n drawing += \"ftf\"\n return drawing\n\n rule = self.get_gene().get_defect_fraction()\n fraction_display = 0.166\n\n if rule >= 1.0:\n drawing += \"ddd\"\n elif rule > (5*fraction_display):\n drawing += \"ddc\"\n elif rule > (4*fraction_display):\n drawing += \"dcd\"\n elif rule > (3*fraction_display):\n drawing += \"dcc\"\n elif rule > (2*fraction_display):\n drawing += \"cdd\"\n elif rule > (1*fraction_display):\n drawing += \"cdc\"\n elif rule > (0*fraction_display):\n drawing += \"ccd\"\n else:\n drawing += \"ccc\"\n\n return drawing","def construct_convex_hull(vertices: Sequence[Point]) -> Polyhedron:\n coords = np.zeros((len(vertices),3))\n for i,vertex in enumerate(vertices):\n coords[i,:] = vertex.coordinates\n hull = qconvex(\"i\", coords)\n n_facets = int(hull[0])\n facets = []\n for facet_vertices_str in hull[1:]:\n facet_vertices_idx = [int(x) for x in facet_vertices_str.split(' ')]\n facet_vertices = [vertices[i] for i in facet_vertices_idx]\n facet = Facet([Contour.from_vertices(facet_vertices)])\n facets.append(facet)\n polyhedron = Polyhedron(facets)\n return polyhedron","def __str__(self):\n output = 'Pathogens:\\n'\n for x in self.extant_p:\n output += ' n %s h %f d %f host %s extant\\n' % (x.name, x.height, x.dist, x.host.name)\n for x in self.not_extant_p:\n output += ' n %s h %f d %f host %s not extant\\n' % (x.name, x.height, x.dist, x.host.name)\n for x in self.not_yet_sampled_p:\n output += ' n %s h %f d %f host %s not yet sampled\\n' % (x.name, x.height, x.dist, x.host.name)\n\n output += 'Hosts:\\n'\n for x in self.extant_h:\n output += ' %s %f %f extant\\n' % (x.name, x.height, x.dist)\n for x in self.not_extant_h:\n output += ' %s %f %f not extant\\n' % (x.name, x.height, x.dist)\n for x in self.not_yet_sampled_h:\n output += ' %s %f %f not yet sampled\\n' % (x.name, x.height, x.dist)\n\n return output","def __str__(self) -> str:\n if self.decorator is None:\n decorator_str = \"\"\n elif self.decorator:\n decorator_str = \"+\"\n else:\n decorator_str = \"-\"\n return \" \".join([\"The nilpotent orbit corresponding\",\n f\"to partition {self.my_diagram}{decorator_str}\",\n f\"in type {self.my_type.letter()} {self.lie_rank}\"])","def __repr__(self):\n return 'Polygon({%s})' % \", \".join(str(line) for line in self.lines)","def __str__(self):\n s = \"\"\n for i in range(13,25):\n if (self.p1vec[i] > 0):\n s += \"|W{0:02}|\".format(self.p1vec[i])\n elif (self.p2vec[25 - i] > 0):\n s += \"|B{0:02}|\".format(self.p2vec[25 - i])\n else:\n s += \"| |\"\n s += '\\n'\n for i in range(12, 0,-1):\n if (self.p1vec[i] > 0):\n s += \"|W{0:02}|\".format(self.p1vec[i])\n elif (self.p2vec[25 - i] > 0):\n s += \"|B{0:02}|\".format(self.p2vec[25 - i])\n else:\n s += \"| |\"\n return s","def __str__(self) -> str:\n if self.scalar_vector:\n return f\"({self.w:-.4f} {self.x:+.4f}i {self.y:+.4f}j {self.z:+.4f}k)\"\n return f\"({self.x:-.4f}i {self.y:+.4f}j {self.z:+.4f}k {self.w:+.4f})\"","def convex_hull(self):\n if isinstance(self.crs, GeographicalCRS):\n raise CRSError(\"not implemented for geographical coordinate \"\n \"systems. Project to a projected coordinate system.\")\n\n points = [pt for pt in self]\n\n # Find the lowermost (left?) point\n pt0 = points[0]\n idx = 0\n for i, pt in enumerate(points[1:]):\n if (pt.y < pt0.y) or ((pt.y == pt0.y) and (pt.x < pt0.x)):\n pt0 = pt\n idx = i+1\n points.pop(idx)\n\n # Sort CCW relative to pt0, and drop all but farthest of any duplicates\n points.sort(key=lambda pt: pt0.distance(pt))\n points.sort(key=lambda pt: _cvectorgeo.polarangle(pt0.vertex, pt.vertex))\n alpha = -1\n drop = []\n for i,pt in enumerate(points):\n a = _cvectorgeo.polarangle(pt0.vertex, pt.vertex)\n if a == alpha:\n drop.append(i)\n else:\n alpha = a\n\n if len(drop) != 0:\n for i in drop[::-1]:\n points.pop(i)\n\n # initialize convex hull\n if len(points) == 2:\n return Polygon([pt0, points[0], points[1]])\n elif len(points) == 1:\n raise GeometryError(\"convex polygon not defined for two points\")\n else:\n\n S = [pt0, points[0], points[1]]\n for pt in points[2:]:\n while not _cvectorgeo.isleft(S[-2].vertex, S[-1].vertex, pt.vertex):\n S.pop()\n S.append(pt)\n\n return Polygon(S, crs=self.crs)","def convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len(points) <= 1:\n return points\n\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross\n # product. Returns a positive value, if OAB makes a counter-clockwise turn,\n # negative for clockwise turn, and zero if the points are collinear.\n def cross(o, a, b):\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\n\n # Build lower hull\n lower = []\n for p in points:\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\n lower.pop()\n lower.append(p)\n\n # Build upper hull\n upper = []\n for p in reversed(points):\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\n upper.pop()\n upper.append(p)\n\n return lower, upper","def name(self):\n return \"cnotdihedral\"","def solution_to_string(self):\n solution_vector_index_format = [index+1 if elem == 1 else -index-1 for index, elem in enumerate(self.solution_vector)]\n return \" \".join(map(str, solution_vector_index_format))","def __repr__(self) -> str:\n return_string = str()\n\n return_string += f\"Representation of dataset with {len(self.internal_types)} elements:\\n\"\n return_string += f\"List of categories:\\t{self.internal_types}\\n\"\n return_string += f\"First and last 5 features:\\n\"\n for i in range(5):\n return_string += f\"\\t{self.internal_data[i]}\\n\"\n return_string += f\"\\t...\\n\"\n for i in range(4, -1, -1):\n return_string += f\"\\t{self.internal_data[i]}\\n\"\n return_string += \"For more information, use debugger.\"\n\n return return_string","def hull_convex(ob, me, selected_only, precision = 0.1):\n # find convex hull\n vertices, triangles = pyffi.utils.quickhull.qhull3d(\n [tuple(v.co) for v in me.verts if v.sel or not selected_only],\n precision = precision)\n # create convex mesh\n box = Blender.Mesh.New('convexpoly')\n for vert in vertices:\n box.verts.extend(*vert)\n for triangle in triangles:\n box.faces.extend(triangle)\n # link mesh to scene and set transform\n scn = Blender.Scene.GetCurrent()\n boxob = scn.objects.new(box, 'convexpoly')\n boxob.setMatrix(ob.getMatrix('worldspace'))\n # set bounds type\n boxob.drawType = Blender.Object.DrawTypes['BOUNDBOX']\n boxob.rbShapeBoundType = 5 # convex hull shape not in blender Python API; Blender.Object.RBShapes['CONVEXHULL']?\n boxob.drawMode = Blender.Object.DrawModes['WIRE']","def __str__(self):\n inside_list = lambda _v, _h, a: any(x == _h and y == _v for y, x in a)\n resultant = ''\n for _v in range(1, self.size_v + 1):\n for _h in range(1, self.size_h + 1):\n if self.current_location[1] == _h and self.current_location[0] == _v:\n resultant = resultant + '@'\n elif inside_list(_v, _h, self.boxes):\n resultant = resultant + '$'\n elif inside_list(_v, _h, self.storage_locations):\n resultant = resultant + '.'\n elif inside_list(_v, _h, self.wall_squares):\n resultant = resultant + '#'\n else:\n resultant = resultant + ' '\n resultant = resultant + '\\n'\n\n return resultant","def __repr__(self):\n\t\tret = \"\"\n\t\tfor i, x in enumerate(self.squares):\n\n\t\t\tret += \"\\t\"\n\t\t\tfor j in range(32): ret += u\"\\u2015\"\n\t\t\tret += \"\\n\\t|\"\n\t\t\tfor y in x:\n\t\t\t\tret += str(y)\n\t\t\t\tret += \" | \"\n\n\t\t\tret += str(i+1) + \"\\n\"\n\n\t\tret += \"\\t\"\n\t\tfor i in range(32): ret += u\"\\u2015\"\n\t\tret += \"\\n \"\n\n\t\tfor l in self.letters:\n\t\t\tret += l+\" \"\n\t\treturn ret","def __repr__(self) -> str:\n context = \" \".join(\"{}={}\".format(k, v) for k, v in self._solution.items())\n return \"<Twilio.Supersim.V1.FleetContext {}>\".format(context)","def convex_hull(points):\n points = np.array(points)\n hull = ConvexHull(points)\n return points[hull.vertices, :]","def __str__(self):\n if self.fshader is None:\n f = \"not defined\"\n else:\n f = self.fshader.getPath()\n if self.vshader is None:\n v = \"not defined\"\n else:\n v = self.vshader.getPath()\n if self.enabled:\n e = \"enabled\"\n else:\n e = \"disabled\"\n if self.isCompiled():\n c = \"compiled | {0}\".format(e)\n else:\n c = \"not compiled | {0}\".format(e)\n return \"shader: {3}\\nfragment shader: {0}\\nvertex shader: {1}\\nstatus: {2}\".format(f, v, c, self.getName())","def find_convex_hull(ctx: Context):\n if ctx.contours is None or len(ctx.contours) == 0:\n return 0\n\n max_defects = 0\n defects = None\n contour = None\n for c in ctx.contours:\n ctx.hull = cv2.convexHull(c, False, False, False)\n if ctx.hull is not None:\n d = cv2.convexityDefects(c, ctx.hull, None)\n if d is not None:\n if len(d) <= max_defects:\n continue\n ctx.num_defects = len(d)\n max_defects = ctx.num_defects\n defects = d\n contour = c\n\n if defects is None:\n return\n\n # calculate hand center via mean of defect depth points\n x = 0\n y = 0\n for d in defects:\n depth_point = contour[d[0][2]]\n x += depth_point[0][0]\n y += depth_point[0][1]\n\n x = int(x / len(defects))\n y = int(y / len(defects))\n ctx.hand_center = (x, y)\n\n # calculate hand radius as mean of distances\n dist = 0\n for d in defects:\n depth_point = contour[d[0][2]]\n dx, dy = depth_point[0][0], depth_point[0][1]\n dist += math.sqrt(math.pow(x - dx, 2) * math.pow(y - dy, 2))\n ctx.hand_radius = int(dist / len(defects))","def main():\n print(\"\\nHello world from hull.py\\n\")\n\n all_hulls = Hull.get_hulls()\n for key in all_hulls.keys():\n print(all_hulls[key], \"\\n\")\n time.sleep(0.01)\n print(\"\\n^ These are all the hulls I can make.\")\n print(\"Total number of hulls = %i\" % (len(all_hulls)))","def extract_hull_from_shapefile ( logger, shape_file ) :\n try :\n logger.info ( \"Extract hull from shapefile \" + str(shape_file) ) \n fIn = ogr.Open ( str(shape_file) )\n layer = fIn.GetLayer(0)\n feature = layer.GetNextFeature() \n geom = feature.GetGeometryRef()\n hull_wkt = str(geom.ExportToWkt())\n return hull_wkt\n except Exception, err:\n logger.critical(\"Extract hull from shapefile failed: ERROR: %s\\n\" % str(err))\n raise","def __CalculateConvexHull(self, contour):\r\n return cv2.convexHull(contour)","def _repr_(self):\n return (\"%d-d CPR-Fano toric variety covered by %d affine patches\"\n % (self.dimension_relative(), self.fan().ngenerating_cones()))","def test_convexHullFacetArea(self):\n try:\n import pyhull\n except ImportError:\n self.skipTest(\"Pyhull (optional) is not available so cannot compute facet area.\")\n \n # make points\n N = 8\n pts = [0, 0, 0,\n 3, 0, 0,\n 0, 3, 0,\n 0, 0, 3,\n 3, 3, 0,\n 0, 3, 3,\n 3, 0, 3,\n 3, 3, 3]\n \n # calc volume\n volume, facetArea = clusters.findConvexHullVolume(N, pts)\n \n self.assertAlmostEqual(facetArea, 54.0)","def Problem11():\n return 'Ductile Coulomb-Mohr'","def _repr_(self):\n return \"Hyperbolic plane\"","def ellipseDesc(lps):\r\n unit = 100 #units in QualiTree are in [mm], hence Pgl is in [dm] ?\r\n\r\n if isinstance(lps, pgl.Translated):\r\n cx, cy, cz = lps.translation\r\n else:\r\n print\"missing Translated from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\"\r\n\r\n ori = lps.geometry\r\n\r\n if isinstance(ori, pgl.Oriented):\r\n rotMat = ori.transformation().getMatrix3()\r\n az, el, roll = rotMat.eulerAnglesZYX()\r\n else:\r\n print\"missing Oriented from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\"\r\n az = 0\r\n \r\n scal = ori.geometry\r\n\r\n if isinstance(scal, pgl.Scaled):\r\n scMat = scal.transformation().getMatrix()\r\n rx, ry, rz, rt = scMat.getDiagonal()\r\n else:\r\n print\"missing Scaled from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\"\r\n rx=ry=rz=1\r\n\r\n #x1, y1, z1 #Conversion repère MappleT (m) à reprère Qualitree (q) : Xq=Xm Yq=Zm Zq=-Ym. \r\n #Due to change of coordinate axis, rotation needs - pi <-- apparently not !\r\n #return cx*unit, cz*unit, -cy*unit, rx*unit, rz*unit, ry*unit, az-3.1415927\r\n\r\n return cx*unit, cz*unit, -cy*unit, rx*unit, rz*unit, ry*unit, az","def algorithmInfo():\n\t\treturn r\"\"\"Fister Jr., Iztok and Fister, Dusan and Yang, Xin-She. \"A Hybrid Bat Algorithm\". Elektrotehniski vestnik, 2013. 1-7.\"\"\"","def _repr_(self):\n return \"Lie algebra %s over %s\" % (self._classification,\n self.base_ring())","def __str__(self):\n return \"--> \"+self.__name+ \\\n \" :\\n dimensions : [\"+str(self.xmin)+\",\"+str(self.xmax)+\"]x[\"+ \\\n str(self.ymin)+\",\"+str(self.ymax)+\"]\"+ \\\n \"\\n width : \"+str(self.width)+\" height : \"+str(self.height)+ \\\n \"\\n background image : \"+str(self.__background)+ \\\n \"\\n image of the domain : \"+str(self.__image_filename)+ \\\n \"\\n walls : \"+str(self.__walls)+ \\\n \"\\n doors : \"+str(self.__doors)","def __str__(self):\n segments = []\n if self.comment:\n segments.append('\"%s\"' % self.comment)\n if self.sg:\n if self.dbow_words:\n segments.append('dbow+w') # also training words\n else:\n segments.append('dbow') # PV-DBOW (skip-gram-style)\n\n else: # PV-DM...\n if self.dm_concat:\n segments.append('dm/c') # ...with concatenative context layer\n else:\n if self.cbow_mean:\n segments.append('dm/m')\n else:\n segments.append('dm/s')\n segments.append('d%d' % self.docvecs.vector_size) # dimensions\n if self.negative:\n segments.append('n%d' % self.negative) # negative samples\n if self.hs:\n segments.append('hs')\n if not self.sg or (self.sg and self.dbow_words):\n segments.append('w%d' % self.window) # window size, when relevant\n if self.vocabulary.min_count > 1:\n segments.append('mc%d' % self.vocabulary.min_count)\n if self.vocabulary.sample > 0:\n segments.append('s%g' % self.vocabulary.sample)\n if self.workers > 1:\n segments.append('t%d' % self.workers)\n return '%s(%s)' % (self.__class__.__name__, ','.join(segments))","def __repr__(self) -> str:\n argument_dict = {\n \"T_e\": self.T_e,\n \"n_e\": self.n_e,\n \"particle\": self.particle,\n \"Z\": self.Z,\n }\n\n return code_repr.call_string(PlasmaBlob, (), argument_dict)","def __str__(self) -> str:\n st = \"<solid:\" + str(self.id) + \">\\n{\\n\"\n for s in self.sides:\n st += str(s) + \"\\n\"\n st += \"}\"\n return st","def plot_hull(self, **kwargs):\n from matador.plotting.hull_plotting import plot_ensemble_hull\n\n return plot_ensemble_hull(\n self, self.data_key, formation_energy_key=self.formation_key, **kwargs\n )","def __str__(self):\r\n out = \"##\"*(self.width+1)+\"\\n\"\r\n for i in range(self.height):\r\n out += \"#\"\r\n for j in range(self.width):\r\n if self.grid[i][j] == 0:\r\n out += \"##\"\r\n else:\r\n if not self.showSolution:\r\n out += \" \"\r\n elif (i,j) in self.solution:\r\n out += \"**\"\r\n else:\r\n out += \" \"\r\n out += \"#\\n\"\r\n return out + \"##\"*(self.width+1)","def visualize_pool ( self, pool_id=None ):\n try:\n pool = self._poolstack [ -1 if pool_id is None else pool_id ]\n except IndexError:\n return \"\"\n else:\n return '\\n'.join ( pool.export_rules() )","def convex_hull(L):\r\n CH=list()\r\n if L != []:\r\n P = list(L)\r\n # find the starting point of the algorithm and add it to the convex hull:\r\n ind0 = find_start(P)\r\n CH.append(P.pop(ind0))\r\n # find the next point and add it to the convex hull list CH:\r\n if P != []:\r\n ind1 = next_in_hull(CH[0], np.array([1,0]), P)\r\n CH.append(P.pop(ind1))\r\n # use the hyperplane criterion as function side_points to complete CH:\r\n while P != []:\r\n p = CH[-2]\r\n q = CH[-1]\r\n v = q - p \r\n P = side_points(CH[0], CH[-1] - CH[0], P)\r\n ind = next_in_hull(q, v, P)\r\n if P != []:\r\n CH.append(P.pop(ind))\r\n return CH","def _repr_(self):\n return \"Category of hyperbolic models of {}\".format(self.base())","def __str__(self):\n vList = []\n for vertex in self:\n vList.append(vertex.name)\n gStr = \"The DiGraph contains _vertices: {0}\".format(\" \".join(vList))\n return gStr","def eddy_floyd(points, side=\"\", p_min=[], p_max=[], show=True, save=False, detailed=True):\n# :param points: the points from which to find the convex hull\n# :param side: if \"up\", we care about the points above the line (p_min,p_max), else, below\n# :param p_min: the point on the left of the line (min = min abscissa)\n# :param p_max: the point on the right of the line\n# :param show: if True, the progress in constructing the hull will be plotted on each iteration in a window\n# :param save: if True, the progress in constructing the hull will be saved on each iteration in a .png file\n# :param detailed: if True, even non convex explored polygons are plotted\n if p_min==[] or p_max==[]:\n #Find the point the most on the left (p_min) and the most on the right (p_max)\n p_min,p_max=points[0],points[0]\n for p in points:\n if p[0]<p_min[0]: p_min=p\n if p[0]>p_max[0]: p_max=p\n\n #Divide the points in 2 subproblems (E2=above line, E1=below line)\n #Remark: p_min and p_max are neither in E2 nore in E1 \n E1,E2=[],[]\n for p in points:\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>0: E2+=[p]\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<0: E1+=[p]\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\n to_be_returned_2=eddy_floyd(E2,side=\"up\",p_min=p_min,p_max=p_max,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_2)>0:\n scatter_plot(points, [[p_max]+to_be_returned_2+[p_min]], title=\"eddy-floyd search\", show=show, save=save)\n to_be_returned_1=eddy_floyd(E1,side=\"down\",p_min=p_min,p_max=p_max,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_1)>0:\n scatter_plot(points, [[p_min]+to_be_returned_1+[p_max]], title=\"eddy-floyd search\", show=show, save=save)\n return [p_max]+to_be_returned_2+[p_min]+to_be_returned_1\n\n \"\"\"End algorithm ?\"\"\"\n #Find if points remain outside the line (either above if up or below if done)\n end=True\n i=0\n while end and i<len(points):\n p=points[i]\n if side==\"up\" and (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>0: end=False \n if side==\"down\" and (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<0: end=False \n i+=1\n\n \"\"\"Intermidiate case, look for the furthest point and divide the pb in 2 pbs\"\"\"\n if not end:\n p_extr,dist=p_min,0\n E1,E2=[],[]\n if side==\"up\":\n #Find the furthest point from the line (above)\n for p in points:\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>dist:\n p_extr,dist=p,(p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])\n \n #Divide the points which are still outside of the 2 lines in 2 subproblems\n for p in points:\n if (p[1]-p_extr[1])*(p_max[0]-p_extr[0])-(p_max[1]-p_extr[1])*(p[0]-p_extr[0])>0: E2+=[p]\n if (p[1]-p_min[1])*(p_extr[0]-p_min[0])-(p_extr[1]-p_min[1])*(p[0]-p_min[0])>0: E1+=[p]\n\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\n to_be_returned_1=eddy_floyd(E1,side=side,p_min=p_min,p_max=p_extr,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_1)>0:\n scatter_plot(points, [[p_extr]+to_be_returned_1+[p_min]], title=\"eddy-floyd search\", show=show, save=save)\n to_be_returned_2=eddy_floyd(E2,side=side,p_min=p_extr,p_max=p_max,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_2)>0:\n scatter_plot(points, [[p_max]+to_be_returned_2+[p_extr]], title=\"eddy-floyd search\", show=show, save=save)\n to_be_returned=to_be_returned_2+[p_extr]+to_be_returned_1\n if (show or save) and len(to_be_returned)>2:\n scatter_plot(points, [[p_max]+to_be_returned+[p_min]], title=\"eddy-floyd search\", show=show, save=save)\n print\n return to_be_returned \n\n if side==\"down\":\n #Find the furthest point from the line (below) \n for p in points:\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<dist:\n p_extr,dist=p,(p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])\n \n #Divide the points which are still outside of the 2 lines in 2 subproblems \n for p in points:\n if (p[1]-p_min[1])*(p_extr[0]-p_min[0])-(p_extr[1]-p_min[1])*(p[0]-p_min[0])<0: E2+=[p]\n if (p[1]-p_extr[1])*(p_max[0]-p_extr[0])-(p_max[1]-p_extr[1])*(p[0]-p_extr[0])<0: E1+=[p]\n\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\n to_be_returned_2=eddy_floyd(E2,side=side,p_min=p_min,p_max=p_extr,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_2)>0:\n scatter_plot(points, [[p_min]+to_be_returned_2+[p_extr]], title=\"eddy-floyd search\", show=show, save=save)\n print\n to_be_returned_1=eddy_floyd(E1,side=side,p_min=p_extr,p_max=p_max,show=show,save=save,detailed=detailed)\n if (show or save) and len(to_be_returned_1)>0:\n scatter_plot(points, [[p_extr]+to_be_returned_1+[p_max]], title=\"eddy-floyd search\", show=show, save=save)\n print\n to_be_returned=to_be_returned_2+[p_extr]+to_be_returned_1\n if (show or save) and len(to_be_returned)>2:\n scatter_plot(points, [[p_min]+to_be_returned+[p_max]], title=\"eddy-floyd search\", show=show, save=save)\n print\n return to_be_returned \n \n \"\"\"End case\"\"\"\n if end:\n return []\n\n \"\"\"None of these cases\"\"\"\n print(\"ERREUR\")\n return []","def __repr__(self) -> str:\n return f\"Graph: |V|= {self.v_size()}, |E|= {self.e_size()}\"","def convex_hull(self, other):\n hull_vertices = self.vertices() + other.vertices()\n hull_rays = self.rays() + other.rays()\n hull_lines = self.lines() + other.lines()\n hull_field = self.coerce_field(other)\n return Polyhedron(vertices=hull_vertices, \n rays=hull_rays, lines=hull_lines, \n field=hull_field)","def convexHull(stimulus_class, subject_list, data_dir, save_dir, save_fig=False):\n\t\n\tfig = plt.figure(figsize=(15,9))\n\tax = fig.subplots()\n\tif stimulus_class == 'TIMIT':\n\t\tprint('TIMIT')\n\t\tplt.plot([-0.2, 1.0], [-0.2, 1.0], 'black', label='unity')\n\n\t\t\n\telif stimulus_class == 'MT':\n\t\tprint('trailers')\n\t\tplt.plot([-0.1, 0.5], [-0.1, 0.5], 'black', label='unity')\n\n\telse:\n\t\tprint('Undefined stimulus class')\n\t# plt.axis('tight')\n\t# plt.axis('square')\n\n\tcorrs = []\n\tcorrs_sig = []\n\t#corrs_nonsig = []\n\tfor idx, s in enumerate(subject_list):\n\t\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as fh: #full model\n\t\t\tfullModel = fh['corrs_%s_norm' %(stimulus_class.lower())][:] \n\t\t\tfullModel[np.isinf(fullModel)]=0\n\t\t\tp_vals_full = fh['pvals_%s' %(stimulus_class.lower())][:]\n\t\t\t#full_nonsig = (fullModel[np.where(p_vals_full[0] > 0.05)])\n\t\t\tfull_sig = (fullModel[np.where(p_vals_full[0] < 0.05)])\n\n\t\t\t#binned pitch full model \n\t\twith h5py.File('%s/%s/%s_STRF_by_binned_pitch_only_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as fh: #full model\n\t\t\tpitch = fh['corrs_%s_norm' %(stimulus_class.lower())][:] \n\t\t\tpitch[np.isinf(pitch)]=0\n\t\t\tp_val_pitch = fh['pvals_%s' %(stimulus_class.lower())][:]\n\t\t\t#binned_full_nonsig = (pitch[np.where(p_vals_full[0] > 0.05)])\n\t\t\tbinned_full_sig = (pitch[np.where(p_vals_full[0] < 0.05)])\n\t\t\tprint(pitch)\n\n\t\twith h5py.File('%s/%s/%s_STRF_by_envs_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as h: #envs model only \n\t\t\tenvs = h['corrs_%s_norm' %(stimulus_class.lower())][:]\n\t\t\tenvs[np.isinf(envs)]=0\n\t\t\tp_vals_envs = h['pvals_%s' %(stimulus_class.lower())][:]\n\t\t\t#envs_nonsig = (envs[np.where(p_vals_full[0] > 0.05)])\n\t\t\tenvs_sig = (envs[np.where(p_vals_full[0] < 0.05)])\n\n\t\twith h5py.File('%s/%s/%s_STRF_by_phnfeat_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as h: #phnfeat model only \n\t\t\tphnfeat = h['corrs_%s_norm' %(stimulus_class.lower())][:]\n\t\t\tphnfeat[np.isinf(phnfeat)]=0\n\t\t\tp_vals_phnfeat = h['pvals_%s' %(stimulus_class.lower())][:]\n\t\t\t#phnfeat_nonsig = (phnfeat[np.where(p_vals_full[0] > 0.05)])\n\t\t\tphnfeat_sig = (phnfeat[np.where(p_vals_full[0] < 0.05)])\n\n\t\tcorrs.append([fullModel, envs, phnfeat, pitch])\n\t\t#corrs_nonsig.append([full_nonsig, envs_nonsig, phnfeat_nonsig, binned_full_nonsig])\n\t\tcorrs_sig.append([full_sig, envs_sig, phnfeat_sig, binned_full_sig])\n\n\tpoints = np.hstack(corrs).T\n\tpoints_sig = np.hstack(corrs_sig).T\n\t#points_nonsig = np.hstack(corrs_nonsig).T\n\n\thull1=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,1])).T) #full model, envs\n\thullv1 = hull1.vertices.copy()\n\thullv1 = np.append(hullv1, hullv1[0])\n\tprint(hullv1)\n\n\thull2=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,2])).T) #full model, phnfeat\n\thullv2 = hull2.vertices.copy()\n\thullv2 = np.append(hullv2, hullv2[0])\n\tprint(hullv2)\n\n\thull3=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,3])).T) #full model, pitch\n\thullv3 = hull3.vertices.copy()\n\thullv3 = np.append(hullv3, hullv3[0])\n\tprint(hullv3)\n\n\n\t#fill between: \n\tplt.fill(points_sig[hullv2,0], points_sig[hullv2,2], facecolor='#cd1a1e', alpha=0.4, zorder=3, label='full vs. phnfeat') #phnfeat\n\tplt.fill(points_sig[hullv3,0], points_sig[hullv3,3], facecolor='#64a7bc', alpha=0.4, zorder=1, label='full vs. pitch') #pitch \n\tplt.fill(points_sig[hullv1,0], points_sig[hullv1,1], facecolor='#808080', alpha=0.4, zorder=2, label='full vs. envs') #envs\n\n\t# plt.fill(points[hullv4,0], points[hullv4,4], facecolor='#4B8B3B', alpha=0.4, zorder=4, label='full vs. binned_pitch')\n\n\n\tplt.plot(points_sig[:,0], points_sig[:,1], '.', color='#808080', alpha=0.8) #envs\n\tplt.plot(points_sig[:,0], points_sig[:,2], '.', color='#cd1a1e', alpha=0.8) #phnfeat\n\tplt.plot(points_sig[:,0], points_sig[:,3], '.', color='#64a7bc',alpha=0.8) #pitch\n\t# plt.plot(points_sig[:,0], points_sig[:,4], '.', color='#4B8B3B', alpha=0.8) #binned pitch \n\n\t# plt.plot(points_nonsig[:,0], points_nonsig[:,1], '.', color='#CDC1C5', alpha=0.7) #envs\n\t# plt.plot(points_nonsig[:,0], points_nonsig[:,2], '.', color='#CDC1C5', alpha=0.7) #phnfeat\n\t# plt.plot(points_nonsig[:,0], points_nonsig[:,3], '.', color='#CDC1C5',alpha=0.7) #pitch\n\t# # plt.plot(points_nonsig[:,0], points_nonsig[:,4], '.', color='#CDC1C5', alpha=0.7) #binned pitch non sig\n\t\n\tplt.legend(bbox_to_anchor=(1, 1), loc='upper left')\n\tplt.xlabel('Full model correlation values (r)')\n\tplt.ylabel('Individual model correlation values (r)')\n\tplt.title('Convex-Hull for %s (Feature distribution across subjects)' %(stimulus_class))\n\tplt.axis('tight')\n\tplt.axis('square')\n\t\n\t#save figure\n\tif save_fig:\n\t\tplt.savefig('%s/%s_ConvexHull.pdf' %(save_dir, stimulus_class))","def __str__(self):\n value = str(self.puzzle) + str(\" \") + str(self.g) + str(\" \") + str(self.h)\n return value","def __repr__(self):\n return ''.join(f'\\ncompany: {self.company_name}\\nsize: {self.company_size}\\ncompany_founded: '\n f'{self.company_founded}\\ncompany_industry: {self.company_industry}\\ncompany_sector: '\n f'{self.company_sector}\\ncompany_type: {self.company_type}\\ncompany_rating: '\n f'{self.company_rating}\\ncompany_competitors: {self.company_competitors}\\ncompany_revenue: '\n f'{self.company_revenue}\\ncompany_headquarters: {self.company_headquarters}')","def __str__(self):\n string = ''\n for degree, coef in enumerate(self.coefs, 1):\n degree = degree - 1\n string += str(coef)+'x^' + str(degree) + ' + '\n string = string[0:-3] # remove the last ' + '\n return string","def plane_desc(self) -> str:\n return self.planes[0].join(' ') + self.planes[1].join(' ') + self.planes[2].join(' ')","def teselado(self,points):\n #muestrea todo el espacio de la envolvente para conseguir las fronteras de decision a intervalos regulares \n #get_hull\n area = boundingbox(points)\n #(min_x,min_y),(max_x,min_y),(max_x,max_y),(min_x,max_y)\n #sample inside hull\n lat_sample = np.arange(min_y, max_y, 0.001).tolist()\n lon_sample = np.arange(min_x,max_x, 0.001)\n sampling_space = [[x,y] for x in lat_sample for y in lon_sample]\n sampling_space = np.asarray(sampling_space, dtype=np.float32)\n prediction = kmeans_instance.predict(sampling_space)\n pol = [[list(sampling_space[index]) for index in [i for i, j in enumerate(prediction) if j == k]] for k in range(centers)]\n hull = [shapely.geometry.MultiPoint(pol[i]).convex_hull.exterior._get_coords() for i in range(len(pol))]","def get_name():\n return \"SVMd+ - simplified approach\"","def __str__(self):\n return \"Normal:\" + str(self.norm) + \"\\nColour:\" + self.colour","def description(self) -> str:\n return f\"Maximize number of {colour_name(self.colour)} unit cells \" \\\n f\"that form a blob by touching sides. \" \\\n f\"Touching corners doesn't count\"","def get_string(self):\n this_column_specifier = (\n TABLE_NUMROWS_SEP + \"l\" + TABLE_NUMROWS_SEP + TABLE_NUMROWS_SEP + \n TABLE_NUMROWS_SEP.join([\"c\" for col in xrange(self._num_cols)]) +\n TABLE_NUMROWS_SEP)\n this_column_headers = TABLE_COLSEP.join(\n [\"\"] + [str(top_header_elt) for top_header_elt in self._top_header])\n this_chart_header = CHART_HEADER_TEMPLATE.substitute(\n column_specifier = this_column_specifier,\n caption = self._caption,\n tag = self._tag,\n column_headers = this_column_headers)\n this_chart_content = (TABLE_ROWSEP + os.linesep).join(\n [TABLE_COLSEP.join([str(left_elt)] +\n [str(self._cells[top_elt][left_elt])\n for top_elt in self._top_header])\n for left_elt in self._left_header])\n return os.linesep.join([this_chart_header, this_chart_content,\n CHART_FOOTER])","def algorithmInfo():\n\t\treturn r\"\"\"TODO\"\"\"","def __str__(self):\n return_string = self.name + \"\\n\" + str(self.traits)\n\n return return_string","def descString(self):\n return \"\".join ([self.Name, \" (\", str(self.RollCount), \"d\"\\\n , str(self.RollMax), \"; \", str(self.CritRollMin), \"-\"\\\n , str(self.CritRollMax), \"x\", str (self.CritRollMult)\\\n , \") - \", str(self.Value), \" gp\"])","def __str__(self):\n\n def onoff(boolean):\n \"\"\"Retorna on/off en funcion del valor booleano\"\"\"\n if boolean:\n return \"on\"\n else:\n return \"off\"\n\n def getPropList():\n s = []\n for prop in self._getPropName():\n s.append(str(prop))\n return \", \".join(s)\n\n def getFunctList():\n s = self.getBindedNames()\n if s == \"\":\n s = \"None\"\n return s\n\n return \"Particle: {15}\\nXYZ position: ({0},{1},{2})\\nAngular velocity: ({3},{4},{5}); ({9},{10},{11})\\nLinear velocity: ({6},{7},{8})); ({12},{13},{14})\\nBinded functions: {16}\\nProperties: {17}\".format(\n round(self.getX(), PARTICLES_ROUND), round(self.getY(), PARTICLES_ROUND),\n round(self.getZ(), PARTICLES_ROUND), round(self.getAngVelX(), PARTICLES_ROUND),\n round(self.getAngVelY(), PARTICLES_ROUND), round(self.getAngVelZ(), PARTICLES_ROUND),\n round(self.getVelX(), PARTICLES_ROUND), round(self.getVelY(), PARTICLES_ROUND),\n round(self.getVelZ(), PARTICLES_ROUND), onoff(self.hasMovementAngX()), onoff(self.hasMovementAngY()),\n onoff(self.hasMovementAngZ()), onoff(self.hasMovementX()), onoff(self.hasMovementY()),\n onoff(self.hasMovementZ()), self.getName(), getFunctList(), getPropList())","def test_convex_init(self):\n print(\"Convex_Init\")\n finder = dc.dock.ConvexHullPocketFinder()","def __repr__(self):\n \n s = '#cpt palette generated by gmt_interface.py\\n'\n s += '#COLOR_MODEL = %s\\n' %self.color_model\n s += '#\\n'\n \n for seg in self.segments:\n\n #print x, seg\n xmin = seg.lower_bound\n xmax = seg.upper_bound\n\n rgb_min = seg.rgb_min\n rgb_max = rgb_min + seg.rgb_dif\n \n # Determine number of decimal points\n xmax-xmin\n \n fmin = format_string(xmin) \n fmax = format_string(xmax)\n\n s += fmin %xmin\n s += ' %d %d %d ' %(rgb_min[0], rgb_min[1], rgb_min[2]) \n s += fmax %xmax\n s += ' %d %d %d ' %(rgb_max[0], rgb_max[1], rgb_max[2])\n s += ' %s' %seg.color_segment_boundary\n s += '\\n'\n \n return s","def __str__(self):\r\n out = (\r\n ' *** Grid dimensions ***\\n'\r\n ' Origin: ( {0.ox:f}, {0.oy:f}, {0.oz:f})\\n'\r\n ' Delta: ( {0.dx:f}, {0.dy:f}, {0.dz:f})\\n'\r\n ' Size: ( {0.lx:f}, {0.ly:f}, {0.lz:f})\\n'\r\n ' N: ( {0.nx:d}, {0.ny:d}, {0.nz:d})\\n'\r\n ' type: {0.gtype}\\n'\r\n ' points: {0.points}\\n'\r\n ' cells: {0.cells}\\n'\r\n ' name: {0.gname}\\n'\r\n ).format(self)\r\n\r\n return out","def __repr__(self) -> str:\n return f\"key:{self.key},pos:{self.pos},inside:{self.get_inside()},outside:{self.get_outside()}\"","def __repr__(self):\n rep = \"alg_cluster.Cluster(\"\n rep += str(self._fips_codes) + \", \"\n rep += str(self._horiz_center) + \", \"\n rep += str(self._vert_center) + \", \"\n rep += str(self._total_population) + \", \"\n rep += str(self._averaged_risk) + \")\"\n return rep","def __repr__(self):\n rep = \"alg_cluster.Cluster(\"\n rep += str(self._fips_codes) + \", \"\n rep += str(self._horiz_center) + \", \"\n rep += str(self._vert_center) + \", \"\n rep += str(self._total_population) + \", \"\n rep += str(self._averaged_risk) + \")\"\n return rep","def __str__(self) -> str:\n\n return f\"Graph: | V |= {self.v_size()}, | E |= {self.e_size()}\"","def __str__(self):\n header = [\n ' GnoweeHeuristics:']\n header += [('Population = {}').format(self.population)]\n header += [('Sampling Method = {}').format(self.initSampling)]\n header += [('Discovery Fraction = {}').format(self.fracMutation)]\n header += [('Elitism Fraction = {}').format(self.fracElite)]\n header += [('Levy Fraction = {}').format(self.fracLevy)]\n header += [('Levy Alpha = {}').format(self.alpha)]\n header += [('Levy Gamma = {}').format(self.gamma)]\n header += [('Levy Independent Samples = {}').format(self.n)]\n header += [('Levy Scaling Parameter = {}').format(self.scalingFactor)]\n header += [('Constraint Violaition Penalty = {}').format(self.penalty)]\n header += [('Max # of Generations = {}').format(self.maxGens)]\n header += [('Max # of Function Evaluations = {}').format(self.maxFevals)]\n header += [('Convergence Tolerance = {}').format(self.convTol)]\n header += [('Stall Limit = {}').format(self.stallLimit)]\n header += [('Optimal Convergence Tolerance = {}').format(self.optConvTol)]\n header += [' Attributes Inhereted from ProblemParameters:']\n header += [('{}').format(ProblemParameters.__str__(self))]\n return ('\\n').join(header) + '\\n'","def convex_hull(image):\n\n corners = find_corners(image)\n\n\n vertices = [corners[0]]\n\n for i in range(len(corners)):\n vertices.extend(\n _convex_hull_side(\n image, corners[i], corners[(i + 1) % len(corners)]))\n\n return vertices","def __str__(self):\n reprStr = 'Help Mario build Iron Man suit!'+'\\n' +'To make the ' + self._name + ',you need:'+'\\n'\n for part in self._supplies:\n reprStr = reprStr + str(part.getCount()) + ' ' + part.getData() + '\\n'\n return reprStr","def __str__(self):\n return \"f(\" + \",\".join([str(p) for p in self.points]) + \")\"","def convex_pieces(self, config):\n # get volume\n orig_volume = self.mesh_.get_total_volume()\n \n # convert to off\n meshlabserver_cmd = 'meshlabserver -i \\\"%s\\\" -o \\\"%s\\\"' %(self.obj_filename, self.off_filename) \n os.system(meshlabserver_cmd)\n logging.info('MeshlabServer OFF Conversion Command: %s' %(meshlabserver_cmd))\n\n if not os.path.exists(off_filename):\n logging.warning('Meshlab conversion failed for %s' %(off_filename))\n return\n \n # create convex pieces\n cvx_decomp_command = config['hacd_cmd_template'] %(self.off_filename,\n config['min_num_clusters'],\n config['max_concavity'],\n config['invert_input_faces'],\n config['extra_dist_points'],\n config['add_faces_points'],\n config['connected_components_dist'],\n config['target_num_triangles'])\n logging.info('CV Decomp Command: %s' %(cvx_decomp_command))\n os.system(cvx_decomp_command) \n\n # convert each wrl to an obj and an stl\n convex_piece_files = glob.glob('%s_dec_hacd_*.wrl' %(os.path.join(self.file_path_, self.file_root_)))\n convex_piece_meshes = []\n total_volume = 0.0\n\n for convex_piece_file in convex_piece_files:\n file_root, file_ext = os.path.splitext(convex_piece_file)\n obj_filename = file_root + '.obj'\n stl_filename = file_root + '.stl'\n meshlabserver_cmd = 'meshlabserver -i \\\"%s\\\" -o \\\"%s\\\"' %(convex_piece_file, obj_filename) \n os.system(meshlabserver_cmd)\n meshlabserver_cmd = 'meshlabserver -i \\\"%s\\\" -o \\\"%s\\\"' %(convex_piece_file, stl_filename) \n os.system(meshlabserver_cmd)\n\n of = obj_file.ObjFile(obj_filename)\n convex_piece = of.read()\n total_volume += convex_piece.get_total_volume()\n convex_piece_meshes.append(of.read())\n\n root = et.Element('robot', name=\"test\")\n\n # get the masses and moments of inertia\n effective_density = orig_volume / total_volume\n prev_piece_name = None\n for convex_piece, filename in zip(convex_piece_meshes, convex_piece_files):\n convex_piece.set_center_of_mass(np.zeros(3))\n convex_piece.set_density(self.mesh_.density * effective_density)\n \n # write to xml\n piece_name = 'link_%s'%(file_root)\n file_path_wo_ext, file_ext = os.path.splitext(filename)\n file_path, file_root = os.path.split(file_path_wo_ext)\n I = convex_piece.inertia\n link = et.SubElement(root, 'link', name=piece_name)\n\n inertial = et.SubElement(link, 'inertial')\n origin = et.SubElement(inertial, 'origin', xyz=\"0 0 0\", rpy=\"0 0 0\")\n mass = et.SubElement(inertial, 'mass', value='%f'%convex_piece.mass)\n inertia = et.SubElement(inertial, 'inertia', ixx='%f'%I[0,0], ixy='%f'%I[0,1], ixz='%f'%I[0,2],\n iyy='%f'%I[1,1], iyz='%f'%I[1,2], izz='%f'%I[2,2])\n \n visual = et.SubElement(link, 'visual')\n origin = et.SubElement(visual, 'origin', xyz=\"0 0 0\", rpy=\"0 0 0\")\n geometry = et.SubElement(visual, 'geometry')\n mesh = et.SubElement(geometry, 'mesh', filename=file_path_wo_ext+'.stl')\n material = et.SubElement(visual, 'material', name='')\n color = et.SubElement(material, 'color', rgba=\"0.75 0.75 0.75 1\")\n\n collision = et.SubElement(link, 'collision')\n origin = et.SubElement(collision, 'origin', xyz=\"0 0 0\", rpy=\"0 0 0\") \n geometry = et.SubElement(collision, 'geometry')\n mesh = et.SubElement(geometry, 'mesh', filename=file_path_wo_ext+'.stl')\n\n if prev_piece_name is not None:\n joint = et.SubElement(root, 'joint', name='%s_joint'%(piece_name), type='fixed')\n origin = et.SubElement(joint, 'origin', xyz=\"0 0 0\", rpy=\"0 0 0\")\n parent = et.SubElement(joint, 'parent', link=prev_piece_name)\n child = et.SubElement(joint, 'child', link=piece_name)\n\n prev_piece_name = piece_name\n\n \"\"\"\n txt_filename = file_root + '.txt'\n f = open(txt_filename, 'w')\n f.write('mass: %f\\n' %(convex_piece.mass))\n f.write('inertia: ' + str(convex_piece.inertia) + '\\n')\n f.close()\n \"\"\"\n\n tree = et.ElementTree(root)\n tree.write('test.URDF')\n exit(0)\n\n return convex_piece_meshes","def _cell_dimensions_string(self):\n return_str = ''\n return_str += '0.0 {:2.6f} xlo xhi\\n0.0 {:2.6f} ylo yhi\\n0.0 {:2.6f} zlo zhi\\n\\n'.format(*self.cell_lengths)\n return_str += '{:2.5f} {:2.5f} {:2.5f} xy xz yz \\n\\n'.format(*self.tilt_factors)\n \n return return_str","def _FindHull(s: List[sg.Point2], p: sg.Point2, q: sg.Point2, hull_points: List[sg.Point2]):\n if len(s) == 0:\n return\n seg = sg.Segment2(p, q)\n c = max(s, key=lambda point: sg.squared_distance(seg, point))\n hull_points.insert(hull_points.index(p) + 1, c)\n s.remove(c)\n s1, s2 = split_points_triangle(s, (p, q, c))\n _FindHull(s1, p, c, hull_points)\n _FindHull(s2, c, q, hull_points)","def __str__(self):\n s = ''\n for vertex in self.vertices:\n s += vertex.__str__()\n s += \"\\n\"\n return s","def __str__(self):\n\t\treturn \"Triangle's sides: a = {}, b = {}, c = {}\".format(self.a, self.b, self.c)"],"string":"[\n \"def _repr_(self):\\n desc = ''\\n if self.n_vertices()==0:\\n desc += 'The empty polyhedron'\\n else:\\n desc += 'A ' + repr(self.dim()) + '-dimensional polyhedron'\\n desc += ' in '\\n if self.field()==QQ: desc += 'QQ'\\n else: desc += 'RDF'\\n desc += '^' + repr(self.ambient_dim()) \\n\\n if self.n_vertices()>0:\\n desc += ' defined as the convex hull of ' \\n desc += repr(self.n_vertices())\\n if self.n_vertices()==1: desc += ' vertex'\\n else: desc += ' vertices'\\n \\n if self.n_rays()>0:\\n if self.n_lines()>0: desc += \\\", \\\"\\n else: desc += \\\" and \\\"\\n desc += repr(self.n_rays())\\n if self.n_rays()==1: desc += ' ray'\\n else: desc += ' rays'\\n \\n if self.n_lines()>0:\\n if self.n_rays()>0: desc += \\\", \\\"\\n else: desc += \\\" and \\\"\\n desc += repr(self.n_lines())\\n if self.n_lines()==1: desc +=' line'\\n else: desc +=' lines'\\n\\n return desc + \\\".\\\\n\\\";\",\n \"def convex_hull(self):\\n return self._geomgen(capi.geom_convex_hull)\",\n \"def convex_hull(self):\\n return _property_geo(arctern.ST_ConvexHull, self)\",\n \"def _repr_(self):\\n return \\\"Projective hypersurface defined by %s in %s\\\"%(\\n self.defining_polynomial(), self.ambient_space())\",\n \"def _repr_(self):\\n return \\\"Affine hypersurface defined by %s in %s\\\"%(\\n self.defining_polynomial(), self.ambient_space())\",\n \"def convex_hull(points):\\n\\n # Sort the points lexicographically (tuples are compared lexicographically).\\n # Remove duplicates to detect the case we have just one unique point.\\n points = sorted(set(points))\\n\\n # Boring case: no points or a single point, possibly repeated multiple times.\\n if len(points) <= 1:\\n return points\\n\\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\\n # Returns a positive value, if OAB makes a counter-clockwise turn,\\n # negative for clockwise turn, and zero if the points are collinear.\\n def cross(o, a, b):\\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\\n\\n # Build lower hull\\n lower = []\\n for p in points:\\n cont = 1\\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\\n print(\\\"antes \\\"), print(cont), print(lower)\\n lower.pop()\\n print(\\\"despues \\\"),print(lower)\\n cont += 1\\n lower.append(p)\\n xlower ,ylower = getlists(lower)\\n plt.plot(xlower,ylower,color=\\\"yellow\\\")\\n # Build upper hull\\n upper = []\\n for p in reversed(points):\\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\\n upper.pop()\\n upper.append(p)\\n print(upper)\\n print(\\\"hello2 \\\")\\n print(cross((2,0),(2,4),(2.5,3)))\\n\\n xupper ,yupper = getlists(upper)\\n plt.plot(xupper,yupper,color=\\\"blue\\\")\\n\\n\\n return lower[:-1] + upper[:-1]\",\n \"def _repr_(self):\\n s = 'The projection of a polyhedron into ' + repr(self.dimension) \\n s += ' dimensions.'\\n return s + \\\"\\\\n\\\"\",\n \"def hull(self):\\n capacity = self._getAttribute(Attribute.hullCapacity)\\n em = self._getAttribute(Attribute.hullEM)\\n explosive = self._getAttribute(Attribute.hullExplosive)\\n kinetic = self._getAttribute(Attribute.hullKinetic)\\n thermal = self._getAttribute(Attribute.hullThermal)\\n\\n em = 1.0 - em\\n explosive = 1.0 - explosive\\n kinetic = 1.0 - kinetic\\n thermal = 1.0 - thermal\\n\\n return {\\n \\\"capacity\\\": capacity,\\n \\\"resists\\\": {\\n \\\"em\\\": em,\\n \\\"explosive\\\": explosive,\\n \\\"kinetic\\\": kinetic,\\n \\\"thermal\\\": thermal\\n }\\n }\",\n \"def convex_hull(self):\\n nodes = self._datacontroller.get_data('nodes')\\n scale = self._datacontroller.get_data('scale')\\n hull = tsputil.convex_hull_helper(nodes)\\n if hull:\\n result = construct_step(hull, 'Most Top Left Node', 'Clockwise', nodes, scale)\\n self._datacontroller.commit_change('path', result)\",\n \"def getContourRep(self):\\n\\t\\tvertex1 = [[self.startX, self.startY]]\\n\\t\\tvertex2 = [[self.startX, self.endY]]\\n\\t\\tvertex3 = [[self.endX, self.startY]]\\n\\t\\tvertex4 = [[self.endX, self.endY]]\\n\\t\\tvertices = [vertex1, vertex2, vertex3, vertex4]\\n\\t\\treturn convexHull(np.asarray(vertices, dtype = np.int32))\",\n \"def __str__(self):\\n vertices = []\\n for idx in range(3):\\n v = self.vertices[idx]\\n if v is not None:\\n vertices.append(str(v))\\n else:\\n orig_idx, dest_idx = (idx - 1) % 3, (idx + 1) % 3\\n orig, dest = self.vertices[orig_idx], self.vertices[dest_idx]\\n halfway = (orig.x + dest.x) * .5, (orig.y + dest.y) * .5\\n# print(halfway)\\n d = orig.distance(dest)\\n dx = dest.x - orig.x\\n# print(d)\\n# print(dx)\\n dx /= d\\n dy = dest.y - orig.y\\n# print(dy)\\n dy /= d\\n dx *= d\\n dy *= d\\n pt_halfway = halfway[0] + dy, halfway[1] - dx\\n# print(\\\"outside\\\", orig_idx, dest_idx, pt_halfway)\\n vertices.append(\\\"{0[0]} {0[1]}\\\".format(pt_halfway))\\n vertices.append(vertices[0])\\n return \\\"POLYGON(({0}))\\\".format(\\\", \\\".join(vertices))\",\n \"def _repr_(self):\\n desc = ''\\n if self.n_vertices()==0:\\n desc += 'The empty lattice polytope'\\n else:\\n desc += 'A ' + repr(self.affine_dimension()) + '-dimensional lattice polytope'\\n desc += ' in ZZ^' + repr(self.space_dimension())\\n\\n if self.n_vertices()>0:\\n desc += ' with '\\n desc += repr(self.n_vertices())\\n if self.n_vertices()==1: desc += ' vertex'\\n else: desc += ' vertices'\\n return desc\",\n \"def give_convex_hull(rand_points):\\n return ConvexHull(rand_points)\",\n \"def convex_hull(points):\\n\\n # Sort the points lexicographically (tuples are compared lexicographically).\\n # Remove duplicates to detect the case we have just one unique point.\\n points = sorted(set(points))\\n\\n # Boring case: no points or a single point, possibly repeated multiple times.\\n if len(points) <= 1:\\n return points\\n\\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\\n # Returns a positive value, if OAB makes a counter-clockwise turn,\\n # negative for clockwise turn, and zero if the points are collinear.\\n def cross(o, a, b):\\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\\n\\n # Build lower hull \\n lower = []\\n for p in points:\\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\\n lower.pop()\\n lower.append(p)\\n\\n # Build upper hull\\n upper = []\\n for p in reversed(points):\\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\\n upper.pop()\\n upper.append(p)\\n\\n # Concatenation of the lower and upper hulls gives the convex hull.\\n # Last point of each list is omitted because it is repeated at the beginning of the other list. \\n return lower[:-1] + upper[:-1]\",\n \"def convex_hull(self):\\n if self._faces is None:\\n if self._vertices is None:\\n return None\\n self.triangulate()\\n return self._convex_hull\",\n \"def display_and_label_hulls(self, hulls, src):\\n \\n labels = []\\n\\n for hull in hulls:\\n\\n angle = 0\\n MA = 1\\n ma = 1\\n try:\\n _,(MA,ma),angle = cv.fitEllipse(hull)\\n except:\\n pass\\n cosAngle = np.abs(np.cos(angle*np.pi/180))\\n\\n # Only human-classify hulls if it is reasonably a vertically oriented rectangle\\n # This is a hueristic to not have to waste time clasifying hulls clearly not poles\\n if (cosAngle < 1.75) and (cosAngle > 0.85) and (MA/ma < 0.28):\\n cpy = src.copy()\\n hull_img = cv.polylines(cpy, [hull], True, (0,0,255), 3)\\n cv.imshow(\\\"Hull\\\", hull_img)\\n keycode = cv.waitKey(0)\\n if keycode == 49:\\n labels.append((hull, 0))\\n print(\\\"Not a Pole\\\")\\n elif keycode == 50:\\n labels.append((hull, 1))\\n print(\\\"A Pole!\\\")\\n else:\\n raise Exception(\\\"Unexpected Key Pressed\\\")\\n else:\\n labels.append((hull, 0))\\n cv.destroyAllWindows()\\n return labels\",\n \"def __str__(self):\\n if self.getType() == FRAGMENT:\\n t = \\\"FRAGMENT\\\"\\n else:\\n t = \\\"VERTEX\\\"\\n if not self.isCompiled():\\n s = \\\"not compiled\\\"\\n else:\\n s = \\\"compiled\\\"\\n return \\\"file: {0}\\\\ntype: {1}\\\\nstatus: {2}\\\\n\\\".format(self.getPath(), t, s)\",\n \"def __str__(self):\\n return \\\"hl(\\\" + str(self.point) + \\\",\\\" + str(self.angle) + \\\")\\\"\",\n \"def convex_hull(points):\\n pointList = ExtendedTupleList(points)\\n complete_ranges = pointList.range_within(0, 1)\\n # Filters for four quadrants\\n filters = [\\n ((0, complete_ranges[1][\\\"max\\\"][2], \\\">=\\\"), (1, complete_ranges[0][\\\"max\\\"][2], \\\">=\\\")), #Q1\\n ((0, complete_ranges[1][\\\"max\\\"][1], \\\"<=\\\"), (1, complete_ranges[0][\\\"min\\\"][2], \\\">=\\\")), #Q2\\n ((0, complete_ranges[1][\\\"min\\\"][1], \\\"<=\\\"), (1, complete_ranges[0][\\\"min\\\"][1], \\\"<=\\\")), #Q3\\n ((0, complete_ranges[1][\\\"min\\\"][2], \\\">=\\\"), (1, complete_ranges[0][\\\"max\\\"][1], \\\"<=\\\")) #Q4\\n ]\\n # Sorting reversals (True means Desc sort, False means Asc sort. Y sort given first)\\n sorts = [\\n (True, True),\\n (True, False),\\n (False, False),\\n (False, True),\\n ]\\n hull = ExtendedTupleList([])\\n # In CW order of quadrants...\\n for index in [0, 3, 2, 1]:\\n # Find all the relevant points\\n quad_points = ExtendedTupleList([point for point in pointList.filter(filters[index])])\\n # Sort them properly\\n quad_points.double_sort(1, 0, reverse_outside=sorts[index][0], reverse_inside=sorts[index][1])\\n # Build a convex line segment\\n line_segment = convex_line_segment(quad_points, sorts[index][0], sorts[index][1])\\n # Reverse it, if we need to\\n if index % 2 == 1:\\n line_segment.reverse()\\n # Add all the points in, avoiding repeated points.\\n hull.extend(line_segment, avoid_repeats=True)\\n return hull\",\n \"def convex_hull(l):\\n\\tpass\",\n \"def show_convex_hull(points, input_choice, timing,percent_pts,size,hull_points = None):\\n\\texists = os.path.isdir('plots')\\n\\tif not exists: \\n\\t\\tos.mkdir('plots')\\n\\n\\n\\tfor each in points:\\n\\t\\tplt.plot(each[0],each[1],'o-')\\n\\n\\tif hull_points is not None:\\n\\t\\thull_pt_list = []\\n\\t\\tfor each in hull_points:\\n\\t\\t\\thull_pt_list.append(list(each))\\n\\n\\t\\thull_pt_arr = np.asarray(hull_pt_list)\\n\\t\\t# print(hull_pt_arr)\\n\\t\\tplt.plot(hull_pt_arr[:,0],hull_pt_arr[:,1],'k-')\\n\\t\\tfirst_coord = hull_pt_arr[0,:].reshape(1,2)\\n\\t\\tlast_coord = hull_pt_arr[len(hull_pt_arr)-1,:].reshape(1,2)\\n\\n\\t\\tlast_coord_arr = np.append(first_coord, last_coord, axis = 0)\\n\\t\\tplt.plot(last_coord_arr[:,0],last_coord_arr[:,1],'k-')\\n\\t\\tplt.title(label = 'For input : '+input_choice+percent_pts+' time taken = '+str(timing)+' s\\\\n'+'N='+str(size))\\n\\t\\n\\tplt.savefig('plots/'+'Graham_Scan_'+str(input_choice)+str(percent_pts)+'_N='+str(size)+'.png')\\n\\tplt.show()\",\n \"def to_str(self):\\n return u\\\"Superellipse[{:.4g},{:.4g}]\\\".format(self.alpha0.l, self.alpha0.r)\",\n \"def convex_hull(*args):\\n from point import Point\\n from line import Segment\\n from polygon import Polygon\\n\\n def uniquify(a):\\n # not order preserving\\n return list(set(a))\\n\\n p = args[0]\\n if isinstance(p, Point):\\n p = uniquify(args)\\n\\n if len(p) == 1:\\n return p[0]\\n elif len(p) == 2:\\n return Segment(p[0], p[1])\\n\\n def orientation(p, q, r):\\n '''Return positive if p-q-r are clockwise, neg if ccw, zero if\\n collinear.'''\\n return (q[1] - p[1])*(r[0] - p[0]) - (q[0] - p[0])*(r[1] - p[1])\\n\\n # scan to find upper and lower convex hulls of a set of 2d points.\\n U = []\\n L = []\\n p.sort()\\n for p_i in p:\\n while len(U) > 1 and orientation(U[-2], U[-1], p_i) <= 0:\\n U.pop()\\n while len(L) > 1 and orientation(L[-2], L[-1], p_i) >= 0:\\n L.pop()\\n U.append(p_i)\\n L.append(p_i)\\n U.reverse()\\n convexHull = tuple(L + U[1:-1])\\n\\n if len(convexHull) == 2:\\n return Segment(convexHull[0], convexHull[1])\\n return Polygon(convexHull)\",\n \"def visualHull(sils, length):\\n result = sils.pop(0).cone(length)\\n assert result.pnFacesInPoly()\\n i = 0\\n for s in sils:\\n # print(i)\\n assert result.pnFacesInPoly()\\n result = result.intersection(s.cone(length), True)\\n # result.plot()\\n i += 1\\n return result\",\n \"def make_convex_hull(self):\\n hull_points_d = []\\n try:\\n print \\\"self.V_bar_list_d******************\\\", self.V_bar_list_d\\n hull = ConvexHull(self.V_bar_list_d)\\n hull_vertices = hull.vertices\\n\\n for i in hull_vertices:\\n hull_points_d.append(self.V_bar_list_d[i])\\n\\n except scipy.spatial.qhull.QhullError:\\n hull_points_d = self.V_bar_list_d\\n\\n return hull_points_d\",\n \"def formatted_str(self):\\n # Verify correct vertex values\\n self.verify_vertex_values()\\n # Generate output string\\n output_string = \\\"\\\"\\n for line in range(9):\\n for row in range(9):\\n if self.grid[line][row] is None:\\n output_string += \\\".\\\"\\n else:\\n output_string += str(self.grid[line][row])\\n if row != 8:\\n output_string += \\\" \\\"\\n elif line != 8:\\n output_string += \\\"\\\\n\\\"\\n if row in [2, 5]:\\n output_string += \\\"| \\\"\\n if line in [2, 5]:\\n output_string += \\\"------+-------+------\\\\n\\\"\\n return output_string\",\n \"def _convex_hull(points):\\n\\n # Sort the points lexicographically (tuples are compared lexicographically).\\n # Remove duplicates to detect the case we have just one unique point.\\n points = sorted(set(points))\\n\\n # Boring case: no points or a single point, possibly repeated multiple times.\\n if len(points) <= 1:\\n return points\\n\\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.\\n # Returns a positive value, if OAB makes a counter-clockwise turn,\\n # negative for clockwise turn, and zero if the points are collinear.\\n def cross(o, a, b):\\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\\n\\n # Build lower hull\\n lower = []\\n for p in points:\\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\\n lower.pop()\\n lower.append(p)\\n\\n # Build upper hull\\n upper = []\\n for p in reversed(points):\\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\\n upper.pop()\\n upper.append(p)\\n\\n # Concatenation of the lower and upper hulls gives the convex hull.\\n # Last point of each list is omitted because it is repeated at the beginning of the other list.\\n return lower[:-1] + upper[:-1]\",\n \"def __str__(self):\\n puzzle_string = '—' * 13 + '\\\\n'\\n for i in range(self.PUZZLE_NUM_ROWS):\\n for j in range(self.PUZZLE_NUM_COLUMNS):\\n puzzle_string += '│{0: >2}'.format(str(self.position[i][j]))\\n if j == self.PUZZLE_NUM_COLUMNS - 1:\\n puzzle_string += '│\\\\n'\\n\\n puzzle_string += '—' * 13 + '\\\\n'\\n return puzzle_string\",\n \"def draw(self):\\n drawing = \\\"\\\"\\n \\n if self.get_gene().get_choice_at(1) is 'c':\\n drawing += 'o'\\n else:\\n drawing += 'x'\\n \\n if self.is_tft():\\n drawing += \\\"tft\\\"\\n return drawing\\n elif self.is_t2t():\\n drawing += \\\"t2t\\\"\\n return drawing\\n elif self.is_ftf():\\n drawing += \\\"ftf\\\"\\n return drawing\\n\\n rule = self.get_gene().get_defect_fraction()\\n fraction_display = 0.166\\n\\n if rule >= 1.0:\\n drawing += \\\"ddd\\\"\\n elif rule > (5*fraction_display):\\n drawing += \\\"ddc\\\"\\n elif rule > (4*fraction_display):\\n drawing += \\\"dcd\\\"\\n elif rule > (3*fraction_display):\\n drawing += \\\"dcc\\\"\\n elif rule > (2*fraction_display):\\n drawing += \\\"cdd\\\"\\n elif rule > (1*fraction_display):\\n drawing += \\\"cdc\\\"\\n elif rule > (0*fraction_display):\\n drawing += \\\"ccd\\\"\\n else:\\n drawing += \\\"ccc\\\"\\n\\n return drawing\",\n \"def construct_convex_hull(vertices: Sequence[Point]) -> Polyhedron:\\n coords = np.zeros((len(vertices),3))\\n for i,vertex in enumerate(vertices):\\n coords[i,:] = vertex.coordinates\\n hull = qconvex(\\\"i\\\", coords)\\n n_facets = int(hull[0])\\n facets = []\\n for facet_vertices_str in hull[1:]:\\n facet_vertices_idx = [int(x) for x in facet_vertices_str.split(' ')]\\n facet_vertices = [vertices[i] for i in facet_vertices_idx]\\n facet = Facet([Contour.from_vertices(facet_vertices)])\\n facets.append(facet)\\n polyhedron = Polyhedron(facets)\\n return polyhedron\",\n \"def __str__(self):\\n output = 'Pathogens:\\\\n'\\n for x in self.extant_p:\\n output += ' n %s h %f d %f host %s extant\\\\n' % (x.name, x.height, x.dist, x.host.name)\\n for x in self.not_extant_p:\\n output += ' n %s h %f d %f host %s not extant\\\\n' % (x.name, x.height, x.dist, x.host.name)\\n for x in self.not_yet_sampled_p:\\n output += ' n %s h %f d %f host %s not yet sampled\\\\n' % (x.name, x.height, x.dist, x.host.name)\\n\\n output += 'Hosts:\\\\n'\\n for x in self.extant_h:\\n output += ' %s %f %f extant\\\\n' % (x.name, x.height, x.dist)\\n for x in self.not_extant_h:\\n output += ' %s %f %f not extant\\\\n' % (x.name, x.height, x.dist)\\n for x in self.not_yet_sampled_h:\\n output += ' %s %f %f not yet sampled\\\\n' % (x.name, x.height, x.dist)\\n\\n return output\",\n \"def __str__(self) -> str:\\n if self.decorator is None:\\n decorator_str = \\\"\\\"\\n elif self.decorator:\\n decorator_str = \\\"+\\\"\\n else:\\n decorator_str = \\\"-\\\"\\n return \\\" \\\".join([\\\"The nilpotent orbit corresponding\\\",\\n f\\\"to partition {self.my_diagram}{decorator_str}\\\",\\n f\\\"in type {self.my_type.letter()} {self.lie_rank}\\\"])\",\n \"def __repr__(self):\\n return 'Polygon({%s})' % \\\", \\\".join(str(line) for line in self.lines)\",\n \"def __str__(self):\\n s = \\\"\\\"\\n for i in range(13,25):\\n if (self.p1vec[i] > 0):\\n s += \\\"|W{0:02}|\\\".format(self.p1vec[i])\\n elif (self.p2vec[25 - i] > 0):\\n s += \\\"|B{0:02}|\\\".format(self.p2vec[25 - i])\\n else:\\n s += \\\"| |\\\"\\n s += '\\\\n'\\n for i in range(12, 0,-1):\\n if (self.p1vec[i] > 0):\\n s += \\\"|W{0:02}|\\\".format(self.p1vec[i])\\n elif (self.p2vec[25 - i] > 0):\\n s += \\\"|B{0:02}|\\\".format(self.p2vec[25 - i])\\n else:\\n s += \\\"| |\\\"\\n return s\",\n \"def __str__(self) -> str:\\n if self.scalar_vector:\\n return f\\\"({self.w:-.4f} {self.x:+.4f}i {self.y:+.4f}j {self.z:+.4f}k)\\\"\\n return f\\\"({self.x:-.4f}i {self.y:+.4f}j {self.z:+.4f}k {self.w:+.4f})\\\"\",\n \"def convex_hull(self):\\n if isinstance(self.crs, GeographicalCRS):\\n raise CRSError(\\\"not implemented for geographical coordinate \\\"\\n \\\"systems. Project to a projected coordinate system.\\\")\\n\\n points = [pt for pt in self]\\n\\n # Find the lowermost (left?) point\\n pt0 = points[0]\\n idx = 0\\n for i, pt in enumerate(points[1:]):\\n if (pt.y < pt0.y) or ((pt.y == pt0.y) and (pt.x < pt0.x)):\\n pt0 = pt\\n idx = i+1\\n points.pop(idx)\\n\\n # Sort CCW relative to pt0, and drop all but farthest of any duplicates\\n points.sort(key=lambda pt: pt0.distance(pt))\\n points.sort(key=lambda pt: _cvectorgeo.polarangle(pt0.vertex, pt.vertex))\\n alpha = -1\\n drop = []\\n for i,pt in enumerate(points):\\n a = _cvectorgeo.polarangle(pt0.vertex, pt.vertex)\\n if a == alpha:\\n drop.append(i)\\n else:\\n alpha = a\\n\\n if len(drop) != 0:\\n for i in drop[::-1]:\\n points.pop(i)\\n\\n # initialize convex hull\\n if len(points) == 2:\\n return Polygon([pt0, points[0], points[1]])\\n elif len(points) == 1:\\n raise GeometryError(\\\"convex polygon not defined for two points\\\")\\n else:\\n\\n S = [pt0, points[0], points[1]]\\n for pt in points[2:]:\\n while not _cvectorgeo.isleft(S[-2].vertex, S[-1].vertex, pt.vertex):\\n S.pop()\\n S.append(pt)\\n\\n return Polygon(S, crs=self.crs)\",\n \"def convex_hull(points):\\n\\n # Sort the points lexicographically (tuples are compared lexicographically).\\n # Remove duplicates to detect the case we have just one unique point.\\n points = sorted(set(points))\\n\\n # Boring case: no points or a single point, possibly repeated multiple times.\\n if len(points) <= 1:\\n return points\\n\\n # 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross\\n # product. Returns a positive value, if OAB makes a counter-clockwise turn,\\n # negative for clockwise turn, and zero if the points are collinear.\\n def cross(o, a, b):\\n return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])\\n\\n # Build lower hull\\n lower = []\\n for p in points:\\n while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:\\n lower.pop()\\n lower.append(p)\\n\\n # Build upper hull\\n upper = []\\n for p in reversed(points):\\n while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:\\n upper.pop()\\n upper.append(p)\\n\\n return lower, upper\",\n \"def name(self):\\n return \\\"cnotdihedral\\\"\",\n \"def solution_to_string(self):\\n solution_vector_index_format = [index+1 if elem == 1 else -index-1 for index, elem in enumerate(self.solution_vector)]\\n return \\\" \\\".join(map(str, solution_vector_index_format))\",\n \"def __repr__(self) -> str:\\n return_string = str()\\n\\n return_string += f\\\"Representation of dataset with {len(self.internal_types)} elements:\\\\n\\\"\\n return_string += f\\\"List of categories:\\\\t{self.internal_types}\\\\n\\\"\\n return_string += f\\\"First and last 5 features:\\\\n\\\"\\n for i in range(5):\\n return_string += f\\\"\\\\t{self.internal_data[i]}\\\\n\\\"\\n return_string += f\\\"\\\\t...\\\\n\\\"\\n for i in range(4, -1, -1):\\n return_string += f\\\"\\\\t{self.internal_data[i]}\\\\n\\\"\\n return_string += \\\"For more information, use debugger.\\\"\\n\\n return return_string\",\n \"def hull_convex(ob, me, selected_only, precision = 0.1):\\n # find convex hull\\n vertices, triangles = pyffi.utils.quickhull.qhull3d(\\n [tuple(v.co) for v in me.verts if v.sel or not selected_only],\\n precision = precision)\\n # create convex mesh\\n box = Blender.Mesh.New('convexpoly')\\n for vert in vertices:\\n box.verts.extend(*vert)\\n for triangle in triangles:\\n box.faces.extend(triangle)\\n # link mesh to scene and set transform\\n scn = Blender.Scene.GetCurrent()\\n boxob = scn.objects.new(box, 'convexpoly')\\n boxob.setMatrix(ob.getMatrix('worldspace'))\\n # set bounds type\\n boxob.drawType = Blender.Object.DrawTypes['BOUNDBOX']\\n boxob.rbShapeBoundType = 5 # convex hull shape not in blender Python API; Blender.Object.RBShapes['CONVEXHULL']?\\n boxob.drawMode = Blender.Object.DrawModes['WIRE']\",\n \"def __str__(self):\\n inside_list = lambda _v, _h, a: any(x == _h and y == _v for y, x in a)\\n resultant = ''\\n for _v in range(1, self.size_v + 1):\\n for _h in range(1, self.size_h + 1):\\n if self.current_location[1] == _h and self.current_location[0] == _v:\\n resultant = resultant + '@'\\n elif inside_list(_v, _h, self.boxes):\\n resultant = resultant + '$'\\n elif inside_list(_v, _h, self.storage_locations):\\n resultant = resultant + '.'\\n elif inside_list(_v, _h, self.wall_squares):\\n resultant = resultant + '#'\\n else:\\n resultant = resultant + ' '\\n resultant = resultant + '\\\\n'\\n\\n return resultant\",\n \"def __repr__(self):\\n\\t\\tret = \\\"\\\"\\n\\t\\tfor i, x in enumerate(self.squares):\\n\\n\\t\\t\\tret += \\\"\\\\t\\\"\\n\\t\\t\\tfor j in range(32): ret += u\\\"\\\\u2015\\\"\\n\\t\\t\\tret += \\\"\\\\n\\\\t|\\\"\\n\\t\\t\\tfor y in x:\\n\\t\\t\\t\\tret += str(y)\\n\\t\\t\\t\\tret += \\\" | \\\"\\n\\n\\t\\t\\tret += str(i+1) + \\\"\\\\n\\\"\\n\\n\\t\\tret += \\\"\\\\t\\\"\\n\\t\\tfor i in range(32): ret += u\\\"\\\\u2015\\\"\\n\\t\\tret += \\\"\\\\n \\\"\\n\\n\\t\\tfor l in self.letters:\\n\\t\\t\\tret += l+\\\" \\\"\\n\\t\\treturn ret\",\n \"def __repr__(self) -> str:\\n context = \\\" \\\".join(\\\"{}={}\\\".format(k, v) for k, v in self._solution.items())\\n return \\\"<Twilio.Supersim.V1.FleetContext {}>\\\".format(context)\",\n \"def convex_hull(points):\\n points = np.array(points)\\n hull = ConvexHull(points)\\n return points[hull.vertices, :]\",\n \"def __str__(self):\\n if self.fshader is None:\\n f = \\\"not defined\\\"\\n else:\\n f = self.fshader.getPath()\\n if self.vshader is None:\\n v = \\\"not defined\\\"\\n else:\\n v = self.vshader.getPath()\\n if self.enabled:\\n e = \\\"enabled\\\"\\n else:\\n e = \\\"disabled\\\"\\n if self.isCompiled():\\n c = \\\"compiled | {0}\\\".format(e)\\n else:\\n c = \\\"not compiled | {0}\\\".format(e)\\n return \\\"shader: {3}\\\\nfragment shader: {0}\\\\nvertex shader: {1}\\\\nstatus: {2}\\\".format(f, v, c, self.getName())\",\n \"def find_convex_hull(ctx: Context):\\n if ctx.contours is None or len(ctx.contours) == 0:\\n return 0\\n\\n max_defects = 0\\n defects = None\\n contour = None\\n for c in ctx.contours:\\n ctx.hull = cv2.convexHull(c, False, False, False)\\n if ctx.hull is not None:\\n d = cv2.convexityDefects(c, ctx.hull, None)\\n if d is not None:\\n if len(d) <= max_defects:\\n continue\\n ctx.num_defects = len(d)\\n max_defects = ctx.num_defects\\n defects = d\\n contour = c\\n\\n if defects is None:\\n return\\n\\n # calculate hand center via mean of defect depth points\\n x = 0\\n y = 0\\n for d in defects:\\n depth_point = contour[d[0][2]]\\n x += depth_point[0][0]\\n y += depth_point[0][1]\\n\\n x = int(x / len(defects))\\n y = int(y / len(defects))\\n ctx.hand_center = (x, y)\\n\\n # calculate hand radius as mean of distances\\n dist = 0\\n for d in defects:\\n depth_point = contour[d[0][2]]\\n dx, dy = depth_point[0][0], depth_point[0][1]\\n dist += math.sqrt(math.pow(x - dx, 2) * math.pow(y - dy, 2))\\n ctx.hand_radius = int(dist / len(defects))\",\n \"def main():\\n print(\\\"\\\\nHello world from hull.py\\\\n\\\")\\n\\n all_hulls = Hull.get_hulls()\\n for key in all_hulls.keys():\\n print(all_hulls[key], \\\"\\\\n\\\")\\n time.sleep(0.01)\\n print(\\\"\\\\n^ These are all the hulls I can make.\\\")\\n print(\\\"Total number of hulls = %i\\\" % (len(all_hulls)))\",\n \"def extract_hull_from_shapefile ( logger, shape_file ) :\\n try :\\n logger.info ( \\\"Extract hull from shapefile \\\" + str(shape_file) ) \\n fIn = ogr.Open ( str(shape_file) )\\n layer = fIn.GetLayer(0)\\n feature = layer.GetNextFeature() \\n geom = feature.GetGeometryRef()\\n hull_wkt = str(geom.ExportToWkt())\\n return hull_wkt\\n except Exception, err:\\n logger.critical(\\\"Extract hull from shapefile failed: ERROR: %s\\\\n\\\" % str(err))\\n raise\",\n \"def __CalculateConvexHull(self, contour):\\r\\n return cv2.convexHull(contour)\",\n \"def _repr_(self):\\n return (\\\"%d-d CPR-Fano toric variety covered by %d affine patches\\\"\\n % (self.dimension_relative(), self.fan().ngenerating_cones()))\",\n \"def test_convexHullFacetArea(self):\\n try:\\n import pyhull\\n except ImportError:\\n self.skipTest(\\\"Pyhull (optional) is not available so cannot compute facet area.\\\")\\n \\n # make points\\n N = 8\\n pts = [0, 0, 0,\\n 3, 0, 0,\\n 0, 3, 0,\\n 0, 0, 3,\\n 3, 3, 0,\\n 0, 3, 3,\\n 3, 0, 3,\\n 3, 3, 3]\\n \\n # calc volume\\n volume, facetArea = clusters.findConvexHullVolume(N, pts)\\n \\n self.assertAlmostEqual(facetArea, 54.0)\",\n \"def Problem11():\\n return 'Ductile Coulomb-Mohr'\",\n \"def _repr_(self):\\n return \\\"Hyperbolic plane\\\"\",\n \"def ellipseDesc(lps):\\r\\n unit = 100 #units in QualiTree are in [mm], hence Pgl is in [dm] ?\\r\\n\\r\\n if isinstance(lps, pgl.Translated):\\r\\n cx, cy, cz = lps.translation\\r\\n else:\\r\\n print\\\"missing Translated from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\\\"\\r\\n\\r\\n ori = lps.geometry\\r\\n\\r\\n if isinstance(ori, pgl.Oriented):\\r\\n rotMat = ori.transformation().getMatrix3()\\r\\n az, el, roll = rotMat.eulerAnglesZYX()\\r\\n else:\\r\\n print\\\"missing Oriented from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\\\"\\r\\n az = 0\\r\\n \\r\\n scal = ori.geometry\\r\\n\\r\\n if isinstance(scal, pgl.Scaled):\\r\\n scMat = scal.transformation().getMatrix()\\r\\n rx, ry, rz, rt = scMat.getDiagonal()\\r\\n else:\\r\\n print\\\"missing Scaled from the bounding ellipse as a Translated(Rotated(Scaled(Sphere)))\\\"\\r\\n rx=ry=rz=1\\r\\n\\r\\n #x1, y1, z1 #Conversion repère MappleT (m) à reprère Qualitree (q) : Xq=Xm Yq=Zm Zq=-Ym. \\r\\n #Due to change of coordinate axis, rotation needs - pi <-- apparently not !\\r\\n #return cx*unit, cz*unit, -cy*unit, rx*unit, rz*unit, ry*unit, az-3.1415927\\r\\n\\r\\n return cx*unit, cz*unit, -cy*unit, rx*unit, rz*unit, ry*unit, az\",\n \"def algorithmInfo():\\n\\t\\treturn r\\\"\\\"\\\"Fister Jr., Iztok and Fister, Dusan and Yang, Xin-She. \\\"A Hybrid Bat Algorithm\\\". Elektrotehniski vestnik, 2013. 1-7.\\\"\\\"\\\"\",\n \"def _repr_(self):\\n return \\\"Lie algebra %s over %s\\\" % (self._classification,\\n self.base_ring())\",\n \"def __str__(self):\\n return \\\"--> \\\"+self.__name+ \\\\\\n \\\" :\\\\n dimensions : [\\\"+str(self.xmin)+\\\",\\\"+str(self.xmax)+\\\"]x[\\\"+ \\\\\\n str(self.ymin)+\\\",\\\"+str(self.ymax)+\\\"]\\\"+ \\\\\\n \\\"\\\\n width : \\\"+str(self.width)+\\\" height : \\\"+str(self.height)+ \\\\\\n \\\"\\\\n background image : \\\"+str(self.__background)+ \\\\\\n \\\"\\\\n image of the domain : \\\"+str(self.__image_filename)+ \\\\\\n \\\"\\\\n walls : \\\"+str(self.__walls)+ \\\\\\n \\\"\\\\n doors : \\\"+str(self.__doors)\",\n \"def __str__(self):\\n segments = []\\n if self.comment:\\n segments.append('\\\"%s\\\"' % self.comment)\\n if self.sg:\\n if self.dbow_words:\\n segments.append('dbow+w') # also training words\\n else:\\n segments.append('dbow') # PV-DBOW (skip-gram-style)\\n\\n else: # PV-DM...\\n if self.dm_concat:\\n segments.append('dm/c') # ...with concatenative context layer\\n else:\\n if self.cbow_mean:\\n segments.append('dm/m')\\n else:\\n segments.append('dm/s')\\n segments.append('d%d' % self.docvecs.vector_size) # dimensions\\n if self.negative:\\n segments.append('n%d' % self.negative) # negative samples\\n if self.hs:\\n segments.append('hs')\\n if not self.sg or (self.sg and self.dbow_words):\\n segments.append('w%d' % self.window) # window size, when relevant\\n if self.vocabulary.min_count > 1:\\n segments.append('mc%d' % self.vocabulary.min_count)\\n if self.vocabulary.sample > 0:\\n segments.append('s%g' % self.vocabulary.sample)\\n if self.workers > 1:\\n segments.append('t%d' % self.workers)\\n return '%s(%s)' % (self.__class__.__name__, ','.join(segments))\",\n \"def __repr__(self) -> str:\\n argument_dict = {\\n \\\"T_e\\\": self.T_e,\\n \\\"n_e\\\": self.n_e,\\n \\\"particle\\\": self.particle,\\n \\\"Z\\\": self.Z,\\n }\\n\\n return code_repr.call_string(PlasmaBlob, (), argument_dict)\",\n \"def __str__(self) -> str:\\n st = \\\"<solid:\\\" + str(self.id) + \\\">\\\\n{\\\\n\\\"\\n for s in self.sides:\\n st += str(s) + \\\"\\\\n\\\"\\n st += \\\"}\\\"\\n return st\",\n \"def plot_hull(self, **kwargs):\\n from matador.plotting.hull_plotting import plot_ensemble_hull\\n\\n return plot_ensemble_hull(\\n self, self.data_key, formation_energy_key=self.formation_key, **kwargs\\n )\",\n \"def __str__(self):\\r\\n out = \\\"##\\\"*(self.width+1)+\\\"\\\\n\\\"\\r\\n for i in range(self.height):\\r\\n out += \\\"#\\\"\\r\\n for j in range(self.width):\\r\\n if self.grid[i][j] == 0:\\r\\n out += \\\"##\\\"\\r\\n else:\\r\\n if not self.showSolution:\\r\\n out += \\\" \\\"\\r\\n elif (i,j) in self.solution:\\r\\n out += \\\"**\\\"\\r\\n else:\\r\\n out += \\\" \\\"\\r\\n out += \\\"#\\\\n\\\"\\r\\n return out + \\\"##\\\"*(self.width+1)\",\n \"def visualize_pool ( self, pool_id=None ):\\n try:\\n pool = self._poolstack [ -1 if pool_id is None else pool_id ]\\n except IndexError:\\n return \\\"\\\"\\n else:\\n return '\\\\n'.join ( pool.export_rules() )\",\n \"def convex_hull(L):\\r\\n CH=list()\\r\\n if L != []:\\r\\n P = list(L)\\r\\n # find the starting point of the algorithm and add it to the convex hull:\\r\\n ind0 = find_start(P)\\r\\n CH.append(P.pop(ind0))\\r\\n # find the next point and add it to the convex hull list CH:\\r\\n if P != []:\\r\\n ind1 = next_in_hull(CH[0], np.array([1,0]), P)\\r\\n CH.append(P.pop(ind1))\\r\\n # use the hyperplane criterion as function side_points to complete CH:\\r\\n while P != []:\\r\\n p = CH[-2]\\r\\n q = CH[-1]\\r\\n v = q - p \\r\\n P = side_points(CH[0], CH[-1] - CH[0], P)\\r\\n ind = next_in_hull(q, v, P)\\r\\n if P != []:\\r\\n CH.append(P.pop(ind))\\r\\n return CH\",\n \"def _repr_(self):\\n return \\\"Category of hyperbolic models of {}\\\".format(self.base())\",\n \"def __str__(self):\\n vList = []\\n for vertex in self:\\n vList.append(vertex.name)\\n gStr = \\\"The DiGraph contains _vertices: {0}\\\".format(\\\" \\\".join(vList))\\n return gStr\",\n \"def eddy_floyd(points, side=\\\"\\\", p_min=[], p_max=[], show=True, save=False, detailed=True):\\n# :param points: the points from which to find the convex hull\\n# :param side: if \\\"up\\\", we care about the points above the line (p_min,p_max), else, below\\n# :param p_min: the point on the left of the line (min = min abscissa)\\n# :param p_max: the point on the right of the line\\n# :param show: if True, the progress in constructing the hull will be plotted on each iteration in a window\\n# :param save: if True, the progress in constructing the hull will be saved on each iteration in a .png file\\n# :param detailed: if True, even non convex explored polygons are plotted\\n if p_min==[] or p_max==[]:\\n #Find the point the most on the left (p_min) and the most on the right (p_max)\\n p_min,p_max=points[0],points[0]\\n for p in points:\\n if p[0]<p_min[0]: p_min=p\\n if p[0]>p_max[0]: p_max=p\\n\\n #Divide the points in 2 subproblems (E2=above line, E1=below line)\\n #Remark: p_min and p_max are neither in E2 nore in E1 \\n E1,E2=[],[]\\n for p in points:\\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>0: E2+=[p]\\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<0: E1+=[p]\\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\\n to_be_returned_2=eddy_floyd(E2,side=\\\"up\\\",p_min=p_min,p_max=p_max,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_2)>0:\\n scatter_plot(points, [[p_max]+to_be_returned_2+[p_min]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n to_be_returned_1=eddy_floyd(E1,side=\\\"down\\\",p_min=p_min,p_max=p_max,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_1)>0:\\n scatter_plot(points, [[p_min]+to_be_returned_1+[p_max]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n return [p_max]+to_be_returned_2+[p_min]+to_be_returned_1\\n\\n \\\"\\\"\\\"End algorithm ?\\\"\\\"\\\"\\n #Find if points remain outside the line (either above if up or below if done)\\n end=True\\n i=0\\n while end and i<len(points):\\n p=points[i]\\n if side==\\\"up\\\" and (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>0: end=False \\n if side==\\\"down\\\" and (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<0: end=False \\n i+=1\\n\\n \\\"\\\"\\\"Intermidiate case, look for the furthest point and divide the pb in 2 pbs\\\"\\\"\\\"\\n if not end:\\n p_extr,dist=p_min,0\\n E1,E2=[],[]\\n if side==\\\"up\\\":\\n #Find the furthest point from the line (above)\\n for p in points:\\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])>dist:\\n p_extr,dist=p,(p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])\\n \\n #Divide the points which are still outside of the 2 lines in 2 subproblems\\n for p in points:\\n if (p[1]-p_extr[1])*(p_max[0]-p_extr[0])-(p_max[1]-p_extr[1])*(p[0]-p_extr[0])>0: E2+=[p]\\n if (p[1]-p_min[1])*(p_extr[0]-p_min[0])-(p_extr[1]-p_min[1])*(p[0]-p_min[0])>0: E1+=[p]\\n\\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\\n to_be_returned_1=eddy_floyd(E1,side=side,p_min=p_min,p_max=p_extr,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_1)>0:\\n scatter_plot(points, [[p_extr]+to_be_returned_1+[p_min]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n to_be_returned_2=eddy_floyd(E2,side=side,p_min=p_extr,p_max=p_max,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_2)>0:\\n scatter_plot(points, [[p_max]+to_be_returned_2+[p_extr]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n to_be_returned=to_be_returned_2+[p_extr]+to_be_returned_1\\n if (show or save) and len(to_be_returned)>2:\\n scatter_plot(points, [[p_max]+to_be_returned+[p_min]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n print\\n return to_be_returned \\n\\n if side==\\\"down\\\":\\n #Find the furthest point from the line (below) \\n for p in points:\\n if (p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])<dist:\\n p_extr,dist=p,(p[1]-p_min[1])*(p_max[0]-p_min[0])-(p_max[1]-p_min[1])*(p[0]-p_min[0])\\n \\n #Divide the points which are still outside of the 2 lines in 2 subproblems \\n for p in points:\\n if (p[1]-p_min[1])*(p_extr[0]-p_min[0])-(p_extr[1]-p_min[1])*(p[0]-p_min[0])<0: E2+=[p]\\n if (p[1]-p_extr[1])*(p_max[0]-p_extr[0])-(p_max[1]-p_extr[1])*(p[0]-p_extr[0])<0: E1+=[p]\\n\\n #Go to next step and plot results, the element to return is first divided in 2 parts to plot them seperately\\n to_be_returned_2=eddy_floyd(E2,side=side,p_min=p_min,p_max=p_extr,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_2)>0:\\n scatter_plot(points, [[p_min]+to_be_returned_2+[p_extr]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n print\\n to_be_returned_1=eddy_floyd(E1,side=side,p_min=p_extr,p_max=p_max,show=show,save=save,detailed=detailed)\\n if (show or save) and len(to_be_returned_1)>0:\\n scatter_plot(points, [[p_extr]+to_be_returned_1+[p_max]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n print\\n to_be_returned=to_be_returned_2+[p_extr]+to_be_returned_1\\n if (show or save) and len(to_be_returned)>2:\\n scatter_plot(points, [[p_min]+to_be_returned+[p_max]], title=\\\"eddy-floyd search\\\", show=show, save=save)\\n print\\n return to_be_returned \\n \\n \\\"\\\"\\\"End case\\\"\\\"\\\"\\n if end:\\n return []\\n\\n \\\"\\\"\\\"None of these cases\\\"\\\"\\\"\\n print(\\\"ERREUR\\\")\\n return []\",\n \"def __repr__(self) -> str:\\n return f\\\"Graph: |V|= {self.v_size()}, |E|= {self.e_size()}\\\"\",\n \"def convex_hull(self, other):\\n hull_vertices = self.vertices() + other.vertices()\\n hull_rays = self.rays() + other.rays()\\n hull_lines = self.lines() + other.lines()\\n hull_field = self.coerce_field(other)\\n return Polyhedron(vertices=hull_vertices, \\n rays=hull_rays, lines=hull_lines, \\n field=hull_field)\",\n \"def convexHull(stimulus_class, subject_list, data_dir, save_dir, save_fig=False):\\n\\t\\n\\tfig = plt.figure(figsize=(15,9))\\n\\tax = fig.subplots()\\n\\tif stimulus_class == 'TIMIT':\\n\\t\\tprint('TIMIT')\\n\\t\\tplt.plot([-0.2, 1.0], [-0.2, 1.0], 'black', label='unity')\\n\\n\\t\\t\\n\\telif stimulus_class == 'MT':\\n\\t\\tprint('trailers')\\n\\t\\tplt.plot([-0.1, 0.5], [-0.1, 0.5], 'black', label='unity')\\n\\n\\telse:\\n\\t\\tprint('Undefined stimulus class')\\n\\t# plt.axis('tight')\\n\\t# plt.axis('square')\\n\\n\\tcorrs = []\\n\\tcorrs_sig = []\\n\\t#corrs_nonsig = []\\n\\tfor idx, s in enumerate(subject_list):\\n\\t\\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as fh: #full model\\n\\t\\t\\tfullModel = fh['corrs_%s_norm' %(stimulus_class.lower())][:] \\n\\t\\t\\tfullModel[np.isinf(fullModel)]=0\\n\\t\\t\\tp_vals_full = fh['pvals_%s' %(stimulus_class.lower())][:]\\n\\t\\t\\t#full_nonsig = (fullModel[np.where(p_vals_full[0] > 0.05)])\\n\\t\\t\\tfull_sig = (fullModel[np.where(p_vals_full[0] < 0.05)])\\n\\n\\t\\t\\t#binned pitch full model \\n\\t\\twith h5py.File('%s/%s/%s_STRF_by_binned_pitch_only_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as fh: #full model\\n\\t\\t\\tpitch = fh['corrs_%s_norm' %(stimulus_class.lower())][:] \\n\\t\\t\\tpitch[np.isinf(pitch)]=0\\n\\t\\t\\tp_val_pitch = fh['pvals_%s' %(stimulus_class.lower())][:]\\n\\t\\t\\t#binned_full_nonsig = (pitch[np.where(p_vals_full[0] > 0.05)])\\n\\t\\t\\tbinned_full_sig = (pitch[np.where(p_vals_full[0] < 0.05)])\\n\\t\\t\\tprint(pitch)\\n\\n\\t\\twith h5py.File('%s/%s/%s_STRF_by_envs_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as h: #envs model only \\n\\t\\t\\tenvs = h['corrs_%s_norm' %(stimulus_class.lower())][:]\\n\\t\\t\\tenvs[np.isinf(envs)]=0\\n\\t\\t\\tp_vals_envs = h['pvals_%s' %(stimulus_class.lower())][:]\\n\\t\\t\\t#envs_nonsig = (envs[np.where(p_vals_full[0] > 0.05)])\\n\\t\\t\\tenvs_sig = (envs[np.where(p_vals_full[0] < 0.05)])\\n\\n\\t\\twith h5py.File('%s/%s/%s_STRF_by_phnfeat_%s.hf5'%(data_dir, s, s, stimulus_class), 'r') as h: #phnfeat model only \\n\\t\\t\\tphnfeat = h['corrs_%s_norm' %(stimulus_class.lower())][:]\\n\\t\\t\\tphnfeat[np.isinf(phnfeat)]=0\\n\\t\\t\\tp_vals_phnfeat = h['pvals_%s' %(stimulus_class.lower())][:]\\n\\t\\t\\t#phnfeat_nonsig = (phnfeat[np.where(p_vals_full[0] > 0.05)])\\n\\t\\t\\tphnfeat_sig = (phnfeat[np.where(p_vals_full[0] < 0.05)])\\n\\n\\t\\tcorrs.append([fullModel, envs, phnfeat, pitch])\\n\\t\\t#corrs_nonsig.append([full_nonsig, envs_nonsig, phnfeat_nonsig, binned_full_nonsig])\\n\\t\\tcorrs_sig.append([full_sig, envs_sig, phnfeat_sig, binned_full_sig])\\n\\n\\tpoints = np.hstack(corrs).T\\n\\tpoints_sig = np.hstack(corrs_sig).T\\n\\t#points_nonsig = np.hstack(corrs_nonsig).T\\n\\n\\thull1=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,1])).T) #full model, envs\\n\\thullv1 = hull1.vertices.copy()\\n\\thullv1 = np.append(hullv1, hullv1[0])\\n\\tprint(hullv1)\\n\\n\\thull2=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,2])).T) #full model, phnfeat\\n\\thullv2 = hull2.vertices.copy()\\n\\thullv2 = np.append(hullv2, hullv2[0])\\n\\tprint(hullv2)\\n\\n\\thull3=ConvexHull(np.vstack((points_sig[:,0] , points_sig[:,3])).T) #full model, pitch\\n\\thullv3 = hull3.vertices.copy()\\n\\thullv3 = np.append(hullv3, hullv3[0])\\n\\tprint(hullv3)\\n\\n\\n\\t#fill between: \\n\\tplt.fill(points_sig[hullv2,0], points_sig[hullv2,2], facecolor='#cd1a1e', alpha=0.4, zorder=3, label='full vs. phnfeat') #phnfeat\\n\\tplt.fill(points_sig[hullv3,0], points_sig[hullv3,3], facecolor='#64a7bc', alpha=0.4, zorder=1, label='full vs. pitch') #pitch \\n\\tplt.fill(points_sig[hullv1,0], points_sig[hullv1,1], facecolor='#808080', alpha=0.4, zorder=2, label='full vs. envs') #envs\\n\\n\\t# plt.fill(points[hullv4,0], points[hullv4,4], facecolor='#4B8B3B', alpha=0.4, zorder=4, label='full vs. binned_pitch')\\n\\n\\n\\tplt.plot(points_sig[:,0], points_sig[:,1], '.', color='#808080', alpha=0.8) #envs\\n\\tplt.plot(points_sig[:,0], points_sig[:,2], '.', color='#cd1a1e', alpha=0.8) #phnfeat\\n\\tplt.plot(points_sig[:,0], points_sig[:,3], '.', color='#64a7bc',alpha=0.8) #pitch\\n\\t# plt.plot(points_sig[:,0], points_sig[:,4], '.', color='#4B8B3B', alpha=0.8) #binned pitch \\n\\n\\t# plt.plot(points_nonsig[:,0], points_nonsig[:,1], '.', color='#CDC1C5', alpha=0.7) #envs\\n\\t# plt.plot(points_nonsig[:,0], points_nonsig[:,2], '.', color='#CDC1C5', alpha=0.7) #phnfeat\\n\\t# plt.plot(points_nonsig[:,0], points_nonsig[:,3], '.', color='#CDC1C5',alpha=0.7) #pitch\\n\\t# # plt.plot(points_nonsig[:,0], points_nonsig[:,4], '.', color='#CDC1C5', alpha=0.7) #binned pitch non sig\\n\\t\\n\\tplt.legend(bbox_to_anchor=(1, 1), loc='upper left')\\n\\tplt.xlabel('Full model correlation values (r)')\\n\\tplt.ylabel('Individual model correlation values (r)')\\n\\tplt.title('Convex-Hull for %s (Feature distribution across subjects)' %(stimulus_class))\\n\\tplt.axis('tight')\\n\\tplt.axis('square')\\n\\t\\n\\t#save figure\\n\\tif save_fig:\\n\\t\\tplt.savefig('%s/%s_ConvexHull.pdf' %(save_dir, stimulus_class))\",\n \"def __str__(self):\\n value = str(self.puzzle) + str(\\\" \\\") + str(self.g) + str(\\\" \\\") + str(self.h)\\n return value\",\n \"def __repr__(self):\\n return ''.join(f'\\\\ncompany: {self.company_name}\\\\nsize: {self.company_size}\\\\ncompany_founded: '\\n f'{self.company_founded}\\\\ncompany_industry: {self.company_industry}\\\\ncompany_sector: '\\n f'{self.company_sector}\\\\ncompany_type: {self.company_type}\\\\ncompany_rating: '\\n f'{self.company_rating}\\\\ncompany_competitors: {self.company_competitors}\\\\ncompany_revenue: '\\n f'{self.company_revenue}\\\\ncompany_headquarters: {self.company_headquarters}')\",\n \"def __str__(self):\\n string = ''\\n for degree, coef in enumerate(self.coefs, 1):\\n degree = degree - 1\\n string += str(coef)+'x^' + str(degree) + ' + '\\n string = string[0:-3] # remove the last ' + '\\n return string\",\n \"def plane_desc(self) -> str:\\n return self.planes[0].join(' ') + self.planes[1].join(' ') + self.planes[2].join(' ')\",\n \"def teselado(self,points):\\n #muestrea todo el espacio de la envolvente para conseguir las fronteras de decision a intervalos regulares \\n #get_hull\\n area = boundingbox(points)\\n #(min_x,min_y),(max_x,min_y),(max_x,max_y),(min_x,max_y)\\n #sample inside hull\\n lat_sample = np.arange(min_y, max_y, 0.001).tolist()\\n lon_sample = np.arange(min_x,max_x, 0.001)\\n sampling_space = [[x,y] for x in lat_sample for y in lon_sample]\\n sampling_space = np.asarray(sampling_space, dtype=np.float32)\\n prediction = kmeans_instance.predict(sampling_space)\\n pol = [[list(sampling_space[index]) for index in [i for i, j in enumerate(prediction) if j == k]] for k in range(centers)]\\n hull = [shapely.geometry.MultiPoint(pol[i]).convex_hull.exterior._get_coords() for i in range(len(pol))]\",\n \"def get_name():\\n return \\\"SVMd+ - simplified approach\\\"\",\n \"def __str__(self):\\n return \\\"Normal:\\\" + str(self.norm) + \\\"\\\\nColour:\\\" + self.colour\",\n \"def description(self) -> str:\\n return f\\\"Maximize number of {colour_name(self.colour)} unit cells \\\" \\\\\\n f\\\"that form a blob by touching sides. \\\" \\\\\\n f\\\"Touching corners doesn't count\\\"\",\n \"def get_string(self):\\n this_column_specifier = (\\n TABLE_NUMROWS_SEP + \\\"l\\\" + TABLE_NUMROWS_SEP + TABLE_NUMROWS_SEP + \\n TABLE_NUMROWS_SEP.join([\\\"c\\\" for col in xrange(self._num_cols)]) +\\n TABLE_NUMROWS_SEP)\\n this_column_headers = TABLE_COLSEP.join(\\n [\\\"\\\"] + [str(top_header_elt) for top_header_elt in self._top_header])\\n this_chart_header = CHART_HEADER_TEMPLATE.substitute(\\n column_specifier = this_column_specifier,\\n caption = self._caption,\\n tag = self._tag,\\n column_headers = this_column_headers)\\n this_chart_content = (TABLE_ROWSEP + os.linesep).join(\\n [TABLE_COLSEP.join([str(left_elt)] +\\n [str(self._cells[top_elt][left_elt])\\n for top_elt in self._top_header])\\n for left_elt in self._left_header])\\n return os.linesep.join([this_chart_header, this_chart_content,\\n CHART_FOOTER])\",\n \"def algorithmInfo():\\n\\t\\treturn r\\\"\\\"\\\"TODO\\\"\\\"\\\"\",\n \"def __str__(self):\\n return_string = self.name + \\\"\\\\n\\\" + str(self.traits)\\n\\n return return_string\",\n \"def descString(self):\\n return \\\"\\\".join ([self.Name, \\\" (\\\", str(self.RollCount), \\\"d\\\"\\\\\\n , str(self.RollMax), \\\"; \\\", str(self.CritRollMin), \\\"-\\\"\\\\\\n , str(self.CritRollMax), \\\"x\\\", str (self.CritRollMult)\\\\\\n , \\\") - \\\", str(self.Value), \\\" gp\\\"])\",\n \"def __str__(self):\\n\\n def onoff(boolean):\\n \\\"\\\"\\\"Retorna on/off en funcion del valor booleano\\\"\\\"\\\"\\n if boolean:\\n return \\\"on\\\"\\n else:\\n return \\\"off\\\"\\n\\n def getPropList():\\n s = []\\n for prop in self._getPropName():\\n s.append(str(prop))\\n return \\\", \\\".join(s)\\n\\n def getFunctList():\\n s = self.getBindedNames()\\n if s == \\\"\\\":\\n s = \\\"None\\\"\\n return s\\n\\n return \\\"Particle: {15}\\\\nXYZ position: ({0},{1},{2})\\\\nAngular velocity: ({3},{4},{5}); ({9},{10},{11})\\\\nLinear velocity: ({6},{7},{8})); ({12},{13},{14})\\\\nBinded functions: {16}\\\\nProperties: {17}\\\".format(\\n round(self.getX(), PARTICLES_ROUND), round(self.getY(), PARTICLES_ROUND),\\n round(self.getZ(), PARTICLES_ROUND), round(self.getAngVelX(), PARTICLES_ROUND),\\n round(self.getAngVelY(), PARTICLES_ROUND), round(self.getAngVelZ(), PARTICLES_ROUND),\\n round(self.getVelX(), PARTICLES_ROUND), round(self.getVelY(), PARTICLES_ROUND),\\n round(self.getVelZ(), PARTICLES_ROUND), onoff(self.hasMovementAngX()), onoff(self.hasMovementAngY()),\\n onoff(self.hasMovementAngZ()), onoff(self.hasMovementX()), onoff(self.hasMovementY()),\\n onoff(self.hasMovementZ()), self.getName(), getFunctList(), getPropList())\",\n \"def test_convex_init(self):\\n print(\\\"Convex_Init\\\")\\n finder = dc.dock.ConvexHullPocketFinder()\",\n \"def __repr__(self):\\n \\n s = '#cpt palette generated by gmt_interface.py\\\\n'\\n s += '#COLOR_MODEL = %s\\\\n' %self.color_model\\n s += '#\\\\n'\\n \\n for seg in self.segments:\\n\\n #print x, seg\\n xmin = seg.lower_bound\\n xmax = seg.upper_bound\\n\\n rgb_min = seg.rgb_min\\n rgb_max = rgb_min + seg.rgb_dif\\n \\n # Determine number of decimal points\\n xmax-xmin\\n \\n fmin = format_string(xmin) \\n fmax = format_string(xmax)\\n\\n s += fmin %xmin\\n s += ' %d %d %d ' %(rgb_min[0], rgb_min[1], rgb_min[2]) \\n s += fmax %xmax\\n s += ' %d %d %d ' %(rgb_max[0], rgb_max[1], rgb_max[2])\\n s += ' %s' %seg.color_segment_boundary\\n s += '\\\\n'\\n \\n return s\",\n \"def __str__(self):\\r\\n out = (\\r\\n ' *** Grid dimensions ***\\\\n'\\r\\n ' Origin: ( {0.ox:f}, {0.oy:f}, {0.oz:f})\\\\n'\\r\\n ' Delta: ( {0.dx:f}, {0.dy:f}, {0.dz:f})\\\\n'\\r\\n ' Size: ( {0.lx:f}, {0.ly:f}, {0.lz:f})\\\\n'\\r\\n ' N: ( {0.nx:d}, {0.ny:d}, {0.nz:d})\\\\n'\\r\\n ' type: {0.gtype}\\\\n'\\r\\n ' points: {0.points}\\\\n'\\r\\n ' cells: {0.cells}\\\\n'\\r\\n ' name: {0.gname}\\\\n'\\r\\n ).format(self)\\r\\n\\r\\n return out\",\n \"def __repr__(self) -> str:\\n return f\\\"key:{self.key},pos:{self.pos},inside:{self.get_inside()},outside:{self.get_outside()}\\\"\",\n \"def __repr__(self):\\n rep = \\\"alg_cluster.Cluster(\\\"\\n rep += str(self._fips_codes) + \\\", \\\"\\n rep += str(self._horiz_center) + \\\", \\\"\\n rep += str(self._vert_center) + \\\", \\\"\\n rep += str(self._total_population) + \\\", \\\"\\n rep += str(self._averaged_risk) + \\\")\\\"\\n return rep\",\n \"def __repr__(self):\\n rep = \\\"alg_cluster.Cluster(\\\"\\n rep += str(self._fips_codes) + \\\", \\\"\\n rep += str(self._horiz_center) + \\\", \\\"\\n rep += str(self._vert_center) + \\\", \\\"\\n rep += str(self._total_population) + \\\", \\\"\\n rep += str(self._averaged_risk) + \\\")\\\"\\n return rep\",\n \"def __str__(self) -> str:\\n\\n return f\\\"Graph: | V |= {self.v_size()}, | E |= {self.e_size()}\\\"\",\n \"def __str__(self):\\n header = [\\n ' GnoweeHeuristics:']\\n header += [('Population = {}').format(self.population)]\\n header += [('Sampling Method = {}').format(self.initSampling)]\\n header += [('Discovery Fraction = {}').format(self.fracMutation)]\\n header += [('Elitism Fraction = {}').format(self.fracElite)]\\n header += [('Levy Fraction = {}').format(self.fracLevy)]\\n header += [('Levy Alpha = {}').format(self.alpha)]\\n header += [('Levy Gamma = {}').format(self.gamma)]\\n header += [('Levy Independent Samples = {}').format(self.n)]\\n header += [('Levy Scaling Parameter = {}').format(self.scalingFactor)]\\n header += [('Constraint Violaition Penalty = {}').format(self.penalty)]\\n header += [('Max # of Generations = {}').format(self.maxGens)]\\n header += [('Max # of Function Evaluations = {}').format(self.maxFevals)]\\n header += [('Convergence Tolerance = {}').format(self.convTol)]\\n header += [('Stall Limit = {}').format(self.stallLimit)]\\n header += [('Optimal Convergence Tolerance = {}').format(self.optConvTol)]\\n header += [' Attributes Inhereted from ProblemParameters:']\\n header += [('{}').format(ProblemParameters.__str__(self))]\\n return ('\\\\n').join(header) + '\\\\n'\",\n \"def convex_hull(image):\\n\\n corners = find_corners(image)\\n\\n\\n vertices = [corners[0]]\\n\\n for i in range(len(corners)):\\n vertices.extend(\\n _convex_hull_side(\\n image, corners[i], corners[(i + 1) % len(corners)]))\\n\\n return vertices\",\n \"def __str__(self):\\n reprStr = 'Help Mario build Iron Man suit!'+'\\\\n' +'To make the ' + self._name + ',you need:'+'\\\\n'\\n for part in self._supplies:\\n reprStr = reprStr + str(part.getCount()) + ' ' + part.getData() + '\\\\n'\\n return reprStr\",\n \"def __str__(self):\\n return \\\"f(\\\" + \\\",\\\".join([str(p) for p in self.points]) + \\\")\\\"\",\n \"def convex_pieces(self, config):\\n # get volume\\n orig_volume = self.mesh_.get_total_volume()\\n \\n # convert to off\\n meshlabserver_cmd = 'meshlabserver -i \\\\\\\"%s\\\\\\\" -o \\\\\\\"%s\\\\\\\"' %(self.obj_filename, self.off_filename) \\n os.system(meshlabserver_cmd)\\n logging.info('MeshlabServer OFF Conversion Command: %s' %(meshlabserver_cmd))\\n\\n if not os.path.exists(off_filename):\\n logging.warning('Meshlab conversion failed for %s' %(off_filename))\\n return\\n \\n # create convex pieces\\n cvx_decomp_command = config['hacd_cmd_template'] %(self.off_filename,\\n config['min_num_clusters'],\\n config['max_concavity'],\\n config['invert_input_faces'],\\n config['extra_dist_points'],\\n config['add_faces_points'],\\n config['connected_components_dist'],\\n config['target_num_triangles'])\\n logging.info('CV Decomp Command: %s' %(cvx_decomp_command))\\n os.system(cvx_decomp_command) \\n\\n # convert each wrl to an obj and an stl\\n convex_piece_files = glob.glob('%s_dec_hacd_*.wrl' %(os.path.join(self.file_path_, self.file_root_)))\\n convex_piece_meshes = []\\n total_volume = 0.0\\n\\n for convex_piece_file in convex_piece_files:\\n file_root, file_ext = os.path.splitext(convex_piece_file)\\n obj_filename = file_root + '.obj'\\n stl_filename = file_root + '.stl'\\n meshlabserver_cmd = 'meshlabserver -i \\\\\\\"%s\\\\\\\" -o \\\\\\\"%s\\\\\\\"' %(convex_piece_file, obj_filename) \\n os.system(meshlabserver_cmd)\\n meshlabserver_cmd = 'meshlabserver -i \\\\\\\"%s\\\\\\\" -o \\\\\\\"%s\\\\\\\"' %(convex_piece_file, stl_filename) \\n os.system(meshlabserver_cmd)\\n\\n of = obj_file.ObjFile(obj_filename)\\n convex_piece = of.read()\\n total_volume += convex_piece.get_total_volume()\\n convex_piece_meshes.append(of.read())\\n\\n root = et.Element('robot', name=\\\"test\\\")\\n\\n # get the masses and moments of inertia\\n effective_density = orig_volume / total_volume\\n prev_piece_name = None\\n for convex_piece, filename in zip(convex_piece_meshes, convex_piece_files):\\n convex_piece.set_center_of_mass(np.zeros(3))\\n convex_piece.set_density(self.mesh_.density * effective_density)\\n \\n # write to xml\\n piece_name = 'link_%s'%(file_root)\\n file_path_wo_ext, file_ext = os.path.splitext(filename)\\n file_path, file_root = os.path.split(file_path_wo_ext)\\n I = convex_piece.inertia\\n link = et.SubElement(root, 'link', name=piece_name)\\n\\n inertial = et.SubElement(link, 'inertial')\\n origin = et.SubElement(inertial, 'origin', xyz=\\\"0 0 0\\\", rpy=\\\"0 0 0\\\")\\n mass = et.SubElement(inertial, 'mass', value='%f'%convex_piece.mass)\\n inertia = et.SubElement(inertial, 'inertia', ixx='%f'%I[0,0], ixy='%f'%I[0,1], ixz='%f'%I[0,2],\\n iyy='%f'%I[1,1], iyz='%f'%I[1,2], izz='%f'%I[2,2])\\n \\n visual = et.SubElement(link, 'visual')\\n origin = et.SubElement(visual, 'origin', xyz=\\\"0 0 0\\\", rpy=\\\"0 0 0\\\")\\n geometry = et.SubElement(visual, 'geometry')\\n mesh = et.SubElement(geometry, 'mesh', filename=file_path_wo_ext+'.stl')\\n material = et.SubElement(visual, 'material', name='')\\n color = et.SubElement(material, 'color', rgba=\\\"0.75 0.75 0.75 1\\\")\\n\\n collision = et.SubElement(link, 'collision')\\n origin = et.SubElement(collision, 'origin', xyz=\\\"0 0 0\\\", rpy=\\\"0 0 0\\\") \\n geometry = et.SubElement(collision, 'geometry')\\n mesh = et.SubElement(geometry, 'mesh', filename=file_path_wo_ext+'.stl')\\n\\n if prev_piece_name is not None:\\n joint = et.SubElement(root, 'joint', name='%s_joint'%(piece_name), type='fixed')\\n origin = et.SubElement(joint, 'origin', xyz=\\\"0 0 0\\\", rpy=\\\"0 0 0\\\")\\n parent = et.SubElement(joint, 'parent', link=prev_piece_name)\\n child = et.SubElement(joint, 'child', link=piece_name)\\n\\n prev_piece_name = piece_name\\n\\n \\\"\\\"\\\"\\n txt_filename = file_root + '.txt'\\n f = open(txt_filename, 'w')\\n f.write('mass: %f\\\\n' %(convex_piece.mass))\\n f.write('inertia: ' + str(convex_piece.inertia) + '\\\\n')\\n f.close()\\n \\\"\\\"\\\"\\n\\n tree = et.ElementTree(root)\\n tree.write('test.URDF')\\n exit(0)\\n\\n return convex_piece_meshes\",\n \"def _cell_dimensions_string(self):\\n return_str = ''\\n return_str += '0.0 {:2.6f} xlo xhi\\\\n0.0 {:2.6f} ylo yhi\\\\n0.0 {:2.6f} zlo zhi\\\\n\\\\n'.format(*self.cell_lengths)\\n return_str += '{:2.5f} {:2.5f} {:2.5f} xy xz yz \\\\n\\\\n'.format(*self.tilt_factors)\\n \\n return return_str\",\n \"def _FindHull(s: List[sg.Point2], p: sg.Point2, q: sg.Point2, hull_points: List[sg.Point2]):\\n if len(s) == 0:\\n return\\n seg = sg.Segment2(p, q)\\n c = max(s, key=lambda point: sg.squared_distance(seg, point))\\n hull_points.insert(hull_points.index(p) + 1, c)\\n s.remove(c)\\n s1, s2 = split_points_triangle(s, (p, q, c))\\n _FindHull(s1, p, c, hull_points)\\n _FindHull(s2, c, q, hull_points)\",\n \"def __str__(self):\\n s = ''\\n for vertex in self.vertices:\\n s += vertex.__str__()\\n s += \\\"\\\\n\\\"\\n return s\",\n \"def __str__(self):\\n\\t\\treturn \\\"Triangle's sides: a = {}, b = {}, c = {}\\\".format(self.a, self.b, self.c)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66425604","0.63532376","0.6281747","0.60994506","0.60871357","0.5944821","0.5937618","0.5842721","0.5841963","0.5745582","0.57072836","0.5683671","0.5624012","0.5577006","0.55180144","0.54937017","0.5490255","0.5487594","0.54810053","0.5431776","0.5420677","0.5419913","0.54195774","0.54107594","0.53963655","0.5381174","0.5371979","0.5314691","0.530822","0.52644336","0.5242529","0.52290845","0.5220777","0.52122915","0.5207063","0.51987255","0.51907456","0.518947","0.51873845","0.5183911","0.5182662","0.51581913","0.5151492","0.5150237","0.51456785","0.51367974","0.5129904","0.51298225","0.5126742","0.51249313","0.5115022","0.5113653","0.5113026","0.51114845","0.5110803","0.5108071","0.51045597","0.5080294","0.50765896","0.5075157","0.5067536","0.5066869","0.50636435","0.505019","0.50388986","0.5033782","0.5032251","0.5028292","0.5022239","0.50192374","0.5007877","0.49961972","0.49892825","0.4970937","0.49567795","0.49531296","0.4952428","0.49523526","0.4950328","0.49483976","0.4944735","0.49410874","0.49403048","0.49345824","0.49335748","0.4933514","0.4932789","0.49310324","0.49185538","0.49185538","0.49133837","0.49021992","0.48980108","0.48966348","0.4896365","0.48920193","0.48897263","0.48837963","0.4882637","0.48821265"],"string":"[\n \"0.66425604\",\n \"0.63532376\",\n \"0.6281747\",\n \"0.60994506\",\n \"0.60871357\",\n \"0.5944821\",\n \"0.5937618\",\n \"0.5842721\",\n \"0.5841963\",\n \"0.5745582\",\n \"0.57072836\",\n \"0.5683671\",\n \"0.5624012\",\n \"0.5577006\",\n \"0.55180144\",\n \"0.54937017\",\n \"0.5490255\",\n \"0.5487594\",\n \"0.54810053\",\n \"0.5431776\",\n \"0.5420677\",\n \"0.5419913\",\n \"0.54195774\",\n \"0.54107594\",\n \"0.53963655\",\n \"0.5381174\",\n \"0.5371979\",\n \"0.5314691\",\n \"0.530822\",\n \"0.52644336\",\n \"0.5242529\",\n \"0.52290845\",\n \"0.5220777\",\n \"0.52122915\",\n \"0.5207063\",\n \"0.51987255\",\n \"0.51907456\",\n \"0.518947\",\n \"0.51873845\",\n \"0.5183911\",\n \"0.5182662\",\n \"0.51581913\",\n \"0.5151492\",\n \"0.5150237\",\n \"0.51456785\",\n \"0.51367974\",\n \"0.5129904\",\n \"0.51298225\",\n \"0.5126742\",\n \"0.51249313\",\n \"0.5115022\",\n \"0.5113653\",\n \"0.5113026\",\n \"0.51114845\",\n \"0.5110803\",\n \"0.5108071\",\n \"0.51045597\",\n \"0.5080294\",\n \"0.50765896\",\n \"0.5075157\",\n \"0.5067536\",\n \"0.5066869\",\n \"0.50636435\",\n \"0.505019\",\n \"0.50388986\",\n \"0.5033782\",\n \"0.5032251\",\n \"0.5028292\",\n \"0.5022239\",\n \"0.50192374\",\n \"0.5007877\",\n \"0.49961972\",\n \"0.49892825\",\n \"0.4970937\",\n \"0.49567795\",\n \"0.49531296\",\n \"0.4952428\",\n \"0.49523526\",\n \"0.4950328\",\n \"0.49483976\",\n \"0.4944735\",\n \"0.49410874\",\n \"0.49403048\",\n \"0.49345824\",\n \"0.49335748\",\n \"0.4933514\",\n \"0.4932789\",\n \"0.49310324\",\n \"0.49185538\",\n \"0.49185538\",\n \"0.49133837\",\n \"0.49021992\",\n \"0.48980108\",\n \"0.48966348\",\n \"0.4896365\",\n \"0.48920193\",\n \"0.48897263\",\n \"0.48837963\",\n \"0.4882637\",\n \"0.48821265\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75023854"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6890,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the dimension of this matrix."},"document":{"kind":"string","value":"def dim(self):\n return self._d"},"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 dimension(self):\n return self.__N","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def dim(self):\n return len(self.shape)","def dim(self):\n return len(self.shape)","def dimensionality(self):\n return int(self.nDims)","def dim(self) -> int:\n return self._n_dim","def n_dim(self):\n return self._n_dim","def dimension(self):\n return self._dim","def dimension_size(self):\n return self._dim","def get_dimension_number(self) -> int:\n return np.squeeze(self._channel_arrays[0]).ndim","def num_dim(self):\n return len(self._dimensions)","def num_dim(self):\n return len(self._dimensions)","def dim(self):\n return self.__dim__","def dim(self):\n if '_dim' in self.__dict__:\n return self._dim\n\n if len(self._Vrepresentation)==0:\n self._dim = -1\n return self._dim\n\n origin = vector(self._Vrepresentation[0])\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\n self._dim = matrix(v_list).rank()\n return self._dim","def dim(self):\n return len(self._n)","def get_dim(self):\n return self._dim","def dim(self) -> int:\n return self.atoms.shape[:-1]","def get_dimension(self) -> int:\n return self.embedder.get_dimension()","def get_dim(self):\n return self.dim","def dim(self):\n return self._dim","def dimension_count(self):\n return self._dimensionCount","def get_dimension_length(self):\n pass","def get_in_dim(self) -> int:\n return self.in_dim","def dimension(self):\n return 3*self.genus - 3 + self.n","def dimensionality(self):\n if self.vector.shape is ():\n return 0\n if len(self.vector.shape) is 1:\n return 1\n _, dim = self.vector.shape\n return dim","def size(self)->int:\n\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])","def width(self) -> int:\n return self._obj[self.x_dim].size","def dimension(self):\n\t\treturn self.d","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def size(self):\n\t\treturn self.dims","def ndim(self):\n return self.__value.ndim","def ndim(self) -> int:\n return self[0].ndim","def _get_observation_dimension(self):\n return len(self._get_observation_np())","def getDimension(self):\n dim = len(self.__axis_labels__)\n if dim == 0:\n # Labels weren't set, so how about the data\n dim = self[0].dim()\n return dim","def ndim(self):\n return self._ndim","def dim(self):\n return self.m, self.n","def __len__(self) -> int:\n\n return self.shape.shape[1]","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def size(self):\n return int(misc.intprod(self.shape))","def dim(self):\n\t\treturn self.D","def dim(self) -> int:\n pass","def n_dims(self):\n return len(self.dimensions)","def ndim(self):\n if self._ndim is None:\n self._ndim = self.get_mesh_dimension()\n\n return self._ndim","def ndim(self):\n # type: () -> int\n return len(self.shape)","def ndim(self):\n return len(self._shape)","def dim(self,mat):\n result = np.shape(mat)\n self.dimensions = result\n return self.dimensions","def __len__(self):\n return self.N.shape[0]","def dimension(self) -> float:\n return self._dimensions","def dimension(self):\n return np.prod(np.asarray(self.subsystem_dims))","def getdim(self):\n return round(self.w() / self.c)","def width(self):\n return self.board.shape[1]","def ndim(self):\n return self.data.ndim","def dim(self) -> int:","def get_ndim(self):\n return self.ndim","def get_dims(self):\n row_lbl, col_lbl = self.get_idxvals()\n return len(row_lbl), len(col_lbl)","def getDimension(self):\n return len(self.components)","def size(self) -> int:\n return int(np.multiply(*self.shape))","def dimension(self) -> int:\n return self.options.dimension","def __len__(self):\n # type: () -> int\n return self.shape[0]","def getNumDimensions(self):\n return len(self.di.keys())","def __len__(self):\n return self.n_node.shape[0]","def ndim(self):\n return self.X.ndim","def ndim(self):\n\n self._check_assigned()\n\n if (\n self.lazy\n and self.transformer is not None\n and hasattr(self.transformer, \"get_transformed_shape\")\n ):\n return len(self.transformer.get_transformed_shape(self.values))\n else:\n return self.__array__().ndim","def dim(self) -> tuple:\n if self.has_tensor(): return self.as_tensor().dim()\n else:\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]","def n_dims(self):\n return self.pdm.n_dims","def get_ncols(self):\n return self.ncols","def get_ncols(self):\n return self.ncols","def dimension(self):\n return len(self.qubit_values)","def size(self):\n if type(self._shape).__name__ == 'tuple':\n return self._shape[-1]\n else:\n return self._shape","def getlen(self):\n if self.onlydiag():\n return self.lendiag()\n else:\n return len(self)","def getDim(self):\n return \"%dx%d\" % (self.rows, self.cols)","def dim(self):\n if self._classifier is None:\n with self:\n return self._classifier.features_dim\n\n return self._classifier.features_dim","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def get_size(self):\n # return the size along the index dimension\n size = 0\n if self._data is not None:\n size = shape(self._data)[self.index_dimension]\n\n return size","def get_size(self):\n return self.get_params().shape[0]","def get_width(self):\n width = np.size(self.img, 0)\n return width","def dims(self):\n return self[0].dims","def ndim(self):\n return np.ndim(self.MJD)","def get_data_dim(self):\n return self.data_dim","def __len__(self):\n ret = self.data.shape[0]\n return ret","def ndim(self) -> int:\n\n return 1 + len(self.shape)","def get_dimensionality(self) -> int:\n return self.dimensionality","def ndim(self):\n return self.initial_value.ndim","def num_cols(self):\n return (len(self.rows[0]))","def get_dimension_width(self):\n pass","def num_cols(self):\n return len(self.rows[0])","def xdim(self):\n return len(self._x)","def ndim(self):\n return len(self.nvars)","def size(self):\n return numpy.prod(self.shape)","def size(self):\n return self.__row_count * self.__col_count","def __len__(self):\n return self.flatten_dim(self.shape[0])","def num_dims(self):\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]"],"string":"[\n \"def dimension(self):\\n return self.__N\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def dimensionality(self):\\n return int(self.nDims)\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def n_dim(self):\\n return self._n_dim\",\n \"def dimension(self):\\n return self._dim\",\n \"def dimension_size(self):\\n return self._dim\",\n \"def get_dimension_number(self) -> int:\\n return np.squeeze(self._channel_arrays[0]).ndim\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def dim(self):\\n return self.__dim__\",\n \"def dim(self):\\n if '_dim' in self.__dict__:\\n return self._dim\\n\\n if len(self._Vrepresentation)==0:\\n self._dim = -1\\n return self._dim\\n\\n origin = vector(self._Vrepresentation[0])\\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\\n self._dim = matrix(v_list).rank()\\n return self._dim\",\n \"def dim(self):\\n return len(self._n)\",\n \"def get_dim(self):\\n return self._dim\",\n \"def dim(self) -> int:\\n return self.atoms.shape[:-1]\",\n \"def get_dimension(self) -> int:\\n return self.embedder.get_dimension()\",\n \"def get_dim(self):\\n return self.dim\",\n \"def dim(self):\\n return self._dim\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def get_dimension_length(self):\\n pass\",\n \"def get_in_dim(self) -> int:\\n return self.in_dim\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def dimensionality(self):\\n if self.vector.shape is ():\\n return 0\\n if len(self.vector.shape) is 1:\\n return 1\\n _, dim = self.vector.shape\\n return dim\",\n \"def size(self)->int:\\n\\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])\",\n \"def width(self) -> int:\\n return self._obj[self.x_dim].size\",\n \"def dimension(self):\\n\\t\\treturn self.d\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def ndim(self):\\n return self.__value.ndim\",\n \"def ndim(self) -> int:\\n return self[0].ndim\",\n \"def _get_observation_dimension(self):\\n return len(self._get_observation_np())\",\n \"def getDimension(self):\\n dim = len(self.__axis_labels__)\\n if dim == 0:\\n # Labels weren't set, so how about the data\\n dim = self[0].dim()\\n return dim\",\n \"def ndim(self):\\n return self._ndim\",\n \"def dim(self):\\n return self.m, self.n\",\n \"def __len__(self) -> int:\\n\\n return self.shape.shape[1]\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def size(self):\\n return int(misc.intprod(self.shape))\",\n \"def dim(self):\\n\\t\\treturn self.D\",\n \"def dim(self) -> int:\\n pass\",\n \"def n_dims(self):\\n return len(self.dimensions)\",\n \"def ndim(self):\\n if self._ndim is None:\\n self._ndim = self.get_mesh_dimension()\\n\\n return self._ndim\",\n \"def ndim(self):\\n # type: () -> int\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self._shape)\",\n \"def dim(self,mat):\\n result = np.shape(mat)\\n self.dimensions = result\\n return self.dimensions\",\n \"def __len__(self):\\n return self.N.shape[0]\",\n \"def dimension(self) -> float:\\n return self._dimensions\",\n \"def dimension(self):\\n return np.prod(np.asarray(self.subsystem_dims))\",\n \"def getdim(self):\\n return round(self.w() / self.c)\",\n \"def width(self):\\n return self.board.shape[1]\",\n \"def ndim(self):\\n return self.data.ndim\",\n \"def dim(self) -> int:\",\n \"def get_ndim(self):\\n return self.ndim\",\n \"def get_dims(self):\\n row_lbl, col_lbl = self.get_idxvals()\\n return len(row_lbl), len(col_lbl)\",\n \"def getDimension(self):\\n return len(self.components)\",\n \"def size(self) -> int:\\n return int(np.multiply(*self.shape))\",\n \"def dimension(self) -> int:\\n return self.options.dimension\",\n \"def __len__(self):\\n # type: () -> int\\n return self.shape[0]\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def __len__(self):\\n return self.n_node.shape[0]\",\n \"def ndim(self):\\n return self.X.ndim\",\n \"def ndim(self):\\n\\n self._check_assigned()\\n\\n if (\\n self.lazy\\n and self.transformer is not None\\n and hasattr(self.transformer, \\\"get_transformed_shape\\\")\\n ):\\n return len(self.transformer.get_transformed_shape(self.values))\\n else:\\n return self.__array__().ndim\",\n \"def dim(self) -> tuple:\\n if self.has_tensor(): return self.as_tensor().dim()\\n else:\\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]\",\n \"def n_dims(self):\\n return self.pdm.n_dims\",\n \"def get_ncols(self):\\n return self.ncols\",\n \"def get_ncols(self):\\n return self.ncols\",\n \"def dimension(self):\\n return len(self.qubit_values)\",\n \"def size(self):\\n if type(self._shape).__name__ == 'tuple':\\n return self._shape[-1]\\n else:\\n return self._shape\",\n \"def getlen(self):\\n if self.onlydiag():\\n return self.lendiag()\\n else:\\n return len(self)\",\n \"def getDim(self):\\n return \\\"%dx%d\\\" % (self.rows, self.cols)\",\n \"def dim(self):\\n if self._classifier is None:\\n with self:\\n return self._classifier.features_dim\\n\\n return self._classifier.features_dim\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def get_size(self):\\n # return the size along the index dimension\\n size = 0\\n if self._data is not None:\\n size = shape(self._data)[self.index_dimension]\\n\\n return size\",\n \"def get_size(self):\\n return self.get_params().shape[0]\",\n \"def get_width(self):\\n width = np.size(self.img, 0)\\n return width\",\n \"def dims(self):\\n return self[0].dims\",\n \"def ndim(self):\\n return np.ndim(self.MJD)\",\n \"def get_data_dim(self):\\n return self.data_dim\",\n \"def __len__(self):\\n ret = self.data.shape[0]\\n return ret\",\n \"def ndim(self) -> int:\\n\\n return 1 + len(self.shape)\",\n \"def get_dimensionality(self) -> int:\\n return self.dimensionality\",\n \"def ndim(self):\\n return self.initial_value.ndim\",\n \"def num_cols(self):\\n return (len(self.rows[0]))\",\n \"def get_dimension_width(self):\\n pass\",\n \"def num_cols(self):\\n return len(self.rows[0])\",\n \"def xdim(self):\\n return len(self._x)\",\n \"def ndim(self):\\n return len(self.nvars)\",\n \"def size(self):\\n return numpy.prod(self.shape)\",\n \"def size(self):\\n return self.__row_count * self.__col_count\",\n \"def __len__(self):\\n return self.flatten_dim(self.shape[0])\",\n \"def num_dims(self):\\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84898525","0.84692967","0.83745944","0.83745944","0.8322008","0.8309151","0.8180309","0.81371695","0.8114333","0.8109193","0.8031762","0.8031762","0.8015657","0.7960735","0.7944764","0.7926571","0.79092103","0.78969157","0.787916","0.78600526","0.77845377","0.7781574","0.7778791","0.77745813","0.77599967","0.7751557","0.7744779","0.7742446","0.77330893","0.77330893","0.77330893","0.77330893","0.77330893","0.77330893","0.7731611","0.7727149","0.77266836","0.7701998","0.76977724","0.7696135","0.76950914","0.76935756","0.76935065","0.76935065","0.76935065","0.76935065","0.7692694","0.7685191","0.7676192","0.76736253","0.7658482","0.76359004","0.762045","0.7610858","0.7610824","0.75945246","0.7576626","0.75693196","0.7557148","0.7542722","0.7534768","0.75231385","0.75181526","0.75095457","0.7506465","0.74899155","0.7478707","0.74746126","0.74731606","0.74675727","0.7453274","0.7452009","0.7446748","0.74396485","0.74396485","0.7427004","0.7420446","0.74112725","0.74075073","0.7403833","0.7398055","0.7386803","0.737916","0.7377042","0.73727417","0.7371488","0.73589927","0.7350143","0.73486733","0.73446333","0.7335781","0.73234046","0.7322276","0.7317851","0.7316576","0.7315838","0.7313707","0.73112106","0.72944826","0.72916675"],"string":"[\n \"0.84898525\",\n \"0.84692967\",\n \"0.83745944\",\n \"0.83745944\",\n \"0.8322008\",\n \"0.8309151\",\n \"0.8180309\",\n \"0.81371695\",\n \"0.8114333\",\n \"0.8109193\",\n \"0.8031762\",\n \"0.8031762\",\n \"0.8015657\",\n \"0.7960735\",\n \"0.7944764\",\n \"0.7926571\",\n \"0.79092103\",\n \"0.78969157\",\n \"0.787916\",\n \"0.78600526\",\n \"0.77845377\",\n \"0.7781574\",\n \"0.7778791\",\n \"0.77745813\",\n \"0.77599967\",\n \"0.7751557\",\n \"0.7744779\",\n \"0.7742446\",\n \"0.77330893\",\n \"0.77330893\",\n \"0.77330893\",\n \"0.77330893\",\n \"0.77330893\",\n \"0.77330893\",\n \"0.7731611\",\n \"0.7727149\",\n \"0.77266836\",\n \"0.7701998\",\n \"0.76977724\",\n \"0.7696135\",\n \"0.76950914\",\n \"0.76935756\",\n \"0.76935065\",\n \"0.76935065\",\n \"0.76935065\",\n \"0.76935065\",\n \"0.7692694\",\n \"0.7685191\",\n \"0.7676192\",\n \"0.76736253\",\n \"0.7658482\",\n \"0.76359004\",\n \"0.762045\",\n \"0.7610858\",\n \"0.7610824\",\n \"0.75945246\",\n \"0.7576626\",\n \"0.75693196\",\n \"0.7557148\",\n \"0.7542722\",\n \"0.7534768\",\n \"0.75231385\",\n \"0.75181526\",\n \"0.75095457\",\n \"0.7506465\",\n \"0.74899155\",\n \"0.7478707\",\n \"0.74746126\",\n \"0.74731606\",\n \"0.74675727\",\n \"0.7453274\",\n \"0.7452009\",\n \"0.7446748\",\n \"0.74396485\",\n \"0.74396485\",\n \"0.7427004\",\n \"0.7420446\",\n \"0.74112725\",\n \"0.74075073\",\n \"0.7403833\",\n \"0.7398055\",\n \"0.7386803\",\n \"0.737916\",\n \"0.7377042\",\n \"0.73727417\",\n \"0.7371488\",\n \"0.73589927\",\n \"0.7350143\",\n \"0.73486733\",\n \"0.73446333\",\n \"0.7335781\",\n \"0.73234046\",\n \"0.7322276\",\n \"0.7317851\",\n \"0.7316576\",\n \"0.7315838\",\n \"0.7313707\",\n \"0.73112106\",\n \"0.72944826\",\n \"0.72916675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7624366"},"document_rank":{"kind":"string","value":"52"}}},{"rowIdx":6891,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the number of variables used in this matrix."},"document":{"kind":"string","value":"def num_vars(self):\n return self._nvars"},"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_num_variables(self):\n return len(self.variables)","def num_vars(self):\n return self.nvars","def nvar(self):\n return len(self.__vars)","def GetNumberOfVariables(self):\n\n # nvar = 0\n # for i in self.variables_order:\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\n # if i!=0:\n # if mesh.element_type == \"tri\":\n # nvar += (i+1)*(i+2) // 2\n # elif mesh.element_type == \"tet\":\n # nvar += (i+1)*(i+2)*(i+3) // 6\n # elif mesh.element_type == \"quad\":\n # nvar += (i+1)**2\n # elif mesh.element_type == \"hex\":\n # nvar += (i+1)**3\n\n # nvar = sum(self.variables_order)\n if self.nvar == None:\n self.nvar = self.ndim\n return self.nvar","def nVariables(self):\n return len(self.variables)","def countVars(self):\n return len(self.initializedVars[\"GF\"]) + len(self.initializedVars[\"LF\"]) + len(self.initializedVars[\"TF\"])","def num_vars(self):\n return len(self.bounds.lb)","def variables_num(self):\n return 1","def n_variables(self):\n return sum([p.n_variables for p in self.parameters])","def __len__(self) -> int:\n return len(self.variables)","def count_vars(scope=''):\n v = get_vars(scope)\n return sum([np.prod(var.shape.as_list()) for var in v])","def variables_used (self) :\r\n\t\t## These names possibly contain dimension specification!\r\n\t\treturn self.variable_names","def _getNumVariables(self, graph_def):\n return sum(node.op == \"ReadVariableOp\" for node in graph_def.node)","def ndim(self):\n return len(self.nvars)","def number_of_variables(dataset, name_of_variable):\r\n first_row = dataset[0].keys()\r\n num = 0\r\n for variable in first_row:\r\n if name_of_variable in variable:\r\n num += 1 \r\n return num","def nvar(self):\n return self.h.shape[0]","def nvar(self):\n return len(self.v)","def num_cols(self):\n return len(self.column_names())","def __checkNrVars(self):\n variables = set()\n for q in self.__quantifierList:\n for var in q.getVariableNames():\n variables.add(\"%s\" % var)\n for c in self.__clauseList:\n for var in c.getVariableNames():\n variables.add(\"%s\" % var)\n \n return len(variables)","def GetNumberCols(self):\n return len(self.__colsKey)","def numpoints(self):\n return len(self.pars) + 1 # so dof is 1","def num_dof(self) -> int:\n return len(self)","def dim(self):\n return self.ambient_dim() - self.n_equations()","def ndims(self, varname):\n if self.handle == None: return None\n try:\n var = self.handle.variables[varname]\n except KeyError:\n return None\n return len(var.dimensions)","def columns_count(self):\n if self.value.count != 0:\n return len(self.value[0])\n else:\n return 0","def count_params():\n param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\n return param_count","def __len__(self):\n return len(self._varvals)","def get_num_cols(self):\n return self._num_cols","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def _get_observation_dimension(self):\n return len(self._get_observation_np())","def calculate_num_params(self):\n num_params = 0\n for p in self.parameters():\n num_params += p.data.view(-1).size(0)\n return num_params","def getNbColumns(self):\n return self.data.shape[0]","def getNumDimensions(self):\n return len(self.di.keys())","def get_num_features(self):\r\n \r\n return len(self[0]['x'])","def num_params():\n total_num = 0\n for var in tf.trainable_variables():\n shape = var.get_shape()\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\n return total_num","def __len__(self) -> int:\n\n return self.layout.gaDims","def dim(self):\n return len(self._n)","def getNumCols(self):\n return self.__cols","def ncolumns(self):\n return self.__ncols","def GetNumColumns(self):\n return len(self.columns)","def n_items(self) -> int:\n return len(self._data_vars)","def num_small_vars(self):\n return sum(\n case.num_small_vars for case in self.case_set.all() if case.num_small_vars is not None\n )","def getNumGrids(self):\n c = list(self.gridVars.keys())\n return len(list(self.gridVars[c[0]].values()))","def get_dof(self):\n return len(self.a_n)","def num_cols(self):\n return len(self.rows[0])","def n_thres(self):\n return np.size(self.thres)","def getNoOfCols(self):\n return _patchExtractor.patchExtractor_getNoOfCols(self)","def num_cols(self):\n return (len(self.rows[0]))","def num_parameters(self) -> int:\n return len(self.w) + prod(self.v.shape) - len(self.v)","def get_location_count(self):\n return len(self.matrix)","def dimensions(self):\n return len(self.parameter_names)","def numdofs(self):\n return self.kv.size - self.p - 1","def size_of_variable(self, variable):\n index_structures = variable.index_structures\n if not index_structures:\n return 1\n mapping = [self.mod_index[ind].mapping for ind in index_structures]\n blocking = [self.mod_index[ind].blocking for ind in index_structures]\n size = []\n for i in range(len(mapping)):\n if mapping[i] and blocking[i]:\n length = 0\n for blk in blocking[i]:\n if blk == 0:\n length += 1\n else:\n length += blk\n size.append(length)\n else:\n return None\n return size","def numel(self):\n return self.t.size","def voxel_count(self):\n return self.cols * self.rows * self.sections","def dims(self):\n return self.v.dims() # TODO: check (empty? etc)\n #return self.t.shape # TODO: check (empty? etc)\n # TODO: convert to tuple? here / in varset?","def size(self, varname):\n if self.handle == None: return []\n try:\n var = self.handle.variables[varname]\n except KeyError:\n return []\n \n def dimlen(d):\n dim = self.handle.dimensions[d]\n if dim != None:\n t = type(dim).__name__\n if t == 'int':\n return dim\n return len(dim)\n return 0\n return map(lambda d: dimlen(d), var.dimensions)","def numel(self) -> int:\n return sum(p.numel() for p in self.parameters)","def num_dim(self):\n return len(self._dimensions)","def num_dim(self):\n return len(self._dimensions)","def GetGlobalNumCols(self):\n return _hypre.HypreParMatrix_GetGlobalNumCols(self)","def ncolumns(self):\n return len(self.__column_list)","def GetNumCols(self):\n return _hypre.HypreParMatrix_GetNumCols(self)","def dim(self):\n if '_dim' in self.__dict__:\n return self._dim\n\n if len(self._Vrepresentation)==0:\n self._dim = -1\n return self._dim\n\n origin = vector(self._Vrepresentation[0])\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\n self._dim = matrix(v_list).rank()\n return self._dim","def variables_used (self) :\r\n\t\treturn []","def next_variable(self):\n\n self.nvars += 1\n return self.nvars","def __len__(self):\n return np.size(self.A,0)","def n_cols(self):\n\n return len(self.plaincolumns)","def dimension_count(self):\n return self._dimensionCount","def num_cells_global(self):\n return self.get_dim_attribute('num_cells')","def get_number_of_dofs(self) -> int:\n\n return len(self.nodes) * Node.number_of_dofs","def size(self, level=None):\n level = level or self.local_variables\n names = {}\n while level:\n for name in level.bindings:\n names[name] = 1\n level = level.parent\n return len(names)","def getNumElements(self):\n return 1 + sum(m.getNumElements() for m in self.members)","def dim(self) -> int:\n return self._n_dim","def dim(self) -> int:\n return self.atoms.shape[:-1]","def count_parameters(self):\n return sum(p.numel() for p in self.parameters() if p.requires_grad)/1e6","def count_parameters(self):\n return sum(p.numel() for p in self.parameters() if p.requires_grad)/1e6","def dim(self):\n if self._classifier is None:\n with self:\n return self._classifier.features_dim\n\n return self._classifier.features_dim","def __len__(self):\n return self.dbms.get_nb_fields(self.table, self.db)","def number_of_columns(self):\n return len(self._columns)","def n_cf(self):\n return np.size(self._ref_ii, 0)","def count_params(model):\n total = 0\n for x in model.trainable_variables:\n total += np.prod(x.shape)\n return total","def nfactors(self):\n return self.L.nnz","def count_dims(da):\n return len(da.dims)","def num_dof(self) -> int:\n return self._num_dof","def N(self):\n return self.get_dof()","def columns(self) -> int:\n return self.__squares[0].__len__()","def column_count(self):\n return self.column_length","def columnCount( self ):\n if not self.o_data is None:\n if self.isItemMultiDimensional():\n return len(self.o_data)\n else:\n return 1\n else:\n return 1","def _N(self):\n return len(self._array)","def getNumBvars(self):\n return _libsbml.ASTNode_getNumBvars(self)","def size(self):\n return self.__row_count * self.__col_count","def dimension(self):\n return self.__N","def get_size(self):\n lines = len(self.coefficients)\n columns = 0 if lines == 0 else len(self.coefficients[0])\n return lines, columns","def get_number_of_atoms_to_optimize(self):\n v = self.c.get(simulation_cell=True)\n return len(v.data.stoichiometry)","def col_count(self):\n if isinstance(self.data, pd.DataFrame) is False:\n return None\n else:\n return self.data.shape[1]","def num_nodes(self):\n return ((len(self.tensor_u)+1) * (len(self.tensor_v)+1) *\n (len(self.tensor_w)+1))","def col_count(self):\n return self.__col_count","def count(self):\r\n return self.data_array.size","def n_dim(self):\n return self._n_dim"],"string":"[\n \"def get_num_variables(self):\\n return len(self.variables)\",\n \"def num_vars(self):\\n return self.nvars\",\n \"def nvar(self):\\n return len(self.__vars)\",\n \"def GetNumberOfVariables(self):\\n\\n # nvar = 0\\n # for i in self.variables_order:\\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\\n # if i!=0:\\n # if mesh.element_type == \\\"tri\\\":\\n # nvar += (i+1)*(i+2) // 2\\n # elif mesh.element_type == \\\"tet\\\":\\n # nvar += (i+1)*(i+2)*(i+3) // 6\\n # elif mesh.element_type == \\\"quad\\\":\\n # nvar += (i+1)**2\\n # elif mesh.element_type == \\\"hex\\\":\\n # nvar += (i+1)**3\\n\\n # nvar = sum(self.variables_order)\\n if self.nvar == None:\\n self.nvar = self.ndim\\n return self.nvar\",\n \"def nVariables(self):\\n return len(self.variables)\",\n \"def countVars(self):\\n return len(self.initializedVars[\\\"GF\\\"]) + len(self.initializedVars[\\\"LF\\\"]) + len(self.initializedVars[\\\"TF\\\"])\",\n \"def num_vars(self):\\n return len(self.bounds.lb)\",\n \"def variables_num(self):\\n return 1\",\n \"def n_variables(self):\\n return sum([p.n_variables for p in self.parameters])\",\n \"def __len__(self) -> int:\\n return len(self.variables)\",\n \"def count_vars(scope=''):\\n v = get_vars(scope)\\n return sum([np.prod(var.shape.as_list()) for var in v])\",\n \"def variables_used (self) :\\r\\n\\t\\t## These names possibly contain dimension specification!\\r\\n\\t\\treturn self.variable_names\",\n \"def _getNumVariables(self, graph_def):\\n return sum(node.op == \\\"ReadVariableOp\\\" for node in graph_def.node)\",\n \"def ndim(self):\\n return len(self.nvars)\",\n \"def number_of_variables(dataset, name_of_variable):\\r\\n first_row = dataset[0].keys()\\r\\n num = 0\\r\\n for variable in first_row:\\r\\n if name_of_variable in variable:\\r\\n num += 1 \\r\\n return num\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def nvar(self):\\n return len(self.v)\",\n \"def num_cols(self):\\n return len(self.column_names())\",\n \"def __checkNrVars(self):\\n variables = set()\\n for q in self.__quantifierList:\\n for var in q.getVariableNames():\\n variables.add(\\\"%s\\\" % var)\\n for c in self.__clauseList:\\n for var in c.getVariableNames():\\n variables.add(\\\"%s\\\" % var)\\n \\n return len(variables)\",\n \"def GetNumberCols(self):\\n return len(self.__colsKey)\",\n \"def numpoints(self):\\n return len(self.pars) + 1 # so dof is 1\",\n \"def num_dof(self) -> int:\\n return len(self)\",\n \"def dim(self):\\n return self.ambient_dim() - self.n_equations()\",\n \"def ndims(self, varname):\\n if self.handle == None: return None\\n try:\\n var = self.handle.variables[varname]\\n except KeyError:\\n return None\\n return len(var.dimensions)\",\n \"def columns_count(self):\\n if self.value.count != 0:\\n return len(self.value[0])\\n else:\\n return 0\",\n \"def count_params():\\n param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\\n return param_count\",\n \"def __len__(self):\\n return len(self._varvals)\",\n \"def get_num_cols(self):\\n return self._num_cols\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def _get_observation_dimension(self):\\n return len(self._get_observation_np())\",\n \"def calculate_num_params(self):\\n num_params = 0\\n for p in self.parameters():\\n num_params += p.data.view(-1).size(0)\\n return num_params\",\n \"def getNbColumns(self):\\n return self.data.shape[0]\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def get_num_features(self):\\r\\n \\r\\n return len(self[0]['x'])\",\n \"def num_params():\\n total_num = 0\\n for var in tf.trainable_variables():\\n shape = var.get_shape()\\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\\n return total_num\",\n \"def __len__(self) -> int:\\n\\n return self.layout.gaDims\",\n \"def dim(self):\\n return len(self._n)\",\n \"def getNumCols(self):\\n return self.__cols\",\n \"def ncolumns(self):\\n return self.__ncols\",\n \"def GetNumColumns(self):\\n return len(self.columns)\",\n \"def n_items(self) -> int:\\n return len(self._data_vars)\",\n \"def num_small_vars(self):\\n return sum(\\n case.num_small_vars for case in self.case_set.all() if case.num_small_vars is not None\\n )\",\n \"def getNumGrids(self):\\n c = list(self.gridVars.keys())\\n return len(list(self.gridVars[c[0]].values()))\",\n \"def get_dof(self):\\n return len(self.a_n)\",\n \"def num_cols(self):\\n return len(self.rows[0])\",\n \"def n_thres(self):\\n return np.size(self.thres)\",\n \"def getNoOfCols(self):\\n return _patchExtractor.patchExtractor_getNoOfCols(self)\",\n \"def num_cols(self):\\n return (len(self.rows[0]))\",\n \"def num_parameters(self) -> int:\\n return len(self.w) + prod(self.v.shape) - len(self.v)\",\n \"def get_location_count(self):\\n return len(self.matrix)\",\n \"def dimensions(self):\\n return len(self.parameter_names)\",\n \"def numdofs(self):\\n return self.kv.size - self.p - 1\",\n \"def size_of_variable(self, variable):\\n index_structures = variable.index_structures\\n if not index_structures:\\n return 1\\n mapping = [self.mod_index[ind].mapping for ind in index_structures]\\n blocking = [self.mod_index[ind].blocking for ind in index_structures]\\n size = []\\n for i in range(len(mapping)):\\n if mapping[i] and blocking[i]:\\n length = 0\\n for blk in blocking[i]:\\n if blk == 0:\\n length += 1\\n else:\\n length += blk\\n size.append(length)\\n else:\\n return None\\n return size\",\n \"def numel(self):\\n return self.t.size\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def dims(self):\\n return self.v.dims() # TODO: check (empty? etc)\\n #return self.t.shape # TODO: check (empty? etc)\\n # TODO: convert to tuple? here / in varset?\",\n \"def size(self, varname):\\n if self.handle == None: return []\\n try:\\n var = self.handle.variables[varname]\\n except KeyError:\\n return []\\n \\n def dimlen(d):\\n dim = self.handle.dimensions[d]\\n if dim != None:\\n t = type(dim).__name__\\n if t == 'int':\\n return dim\\n return len(dim)\\n return 0\\n return map(lambda d: dimlen(d), var.dimensions)\",\n \"def numel(self) -> int:\\n return sum(p.numel() for p in self.parameters)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def GetGlobalNumCols(self):\\n return _hypre.HypreParMatrix_GetGlobalNumCols(self)\",\n \"def ncolumns(self):\\n return len(self.__column_list)\",\n \"def GetNumCols(self):\\n return _hypre.HypreParMatrix_GetNumCols(self)\",\n \"def dim(self):\\n if '_dim' in self.__dict__:\\n return self._dim\\n\\n if len(self._Vrepresentation)==0:\\n self._dim = -1\\n return self._dim\\n\\n origin = vector(self._Vrepresentation[0])\\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\\n self._dim = matrix(v_list).rank()\\n return self._dim\",\n \"def variables_used (self) :\\r\\n\\t\\treturn []\",\n \"def next_variable(self):\\n\\n self.nvars += 1\\n return self.nvars\",\n \"def __len__(self):\\n return np.size(self.A,0)\",\n \"def n_cols(self):\\n\\n return len(self.plaincolumns)\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def num_cells_global(self):\\n return self.get_dim_attribute('num_cells')\",\n \"def get_number_of_dofs(self) -> int:\\n\\n return len(self.nodes) * Node.number_of_dofs\",\n \"def size(self, level=None):\\n level = level or self.local_variables\\n names = {}\\n while level:\\n for name in level.bindings:\\n names[name] = 1\\n level = level.parent\\n return len(names)\",\n \"def getNumElements(self):\\n return 1 + sum(m.getNumElements() for m in self.members)\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def dim(self) -> int:\\n return self.atoms.shape[:-1]\",\n \"def count_parameters(self):\\n return sum(p.numel() for p in self.parameters() if p.requires_grad)/1e6\",\n \"def count_parameters(self):\\n return sum(p.numel() for p in self.parameters() if p.requires_grad)/1e6\",\n \"def dim(self):\\n if self._classifier is None:\\n with self:\\n return self._classifier.features_dim\\n\\n return self._classifier.features_dim\",\n \"def __len__(self):\\n return self.dbms.get_nb_fields(self.table, self.db)\",\n \"def number_of_columns(self):\\n return len(self._columns)\",\n \"def n_cf(self):\\n return np.size(self._ref_ii, 0)\",\n \"def count_params(model):\\n total = 0\\n for x in model.trainable_variables:\\n total += np.prod(x.shape)\\n return total\",\n \"def nfactors(self):\\n return self.L.nnz\",\n \"def count_dims(da):\\n return len(da.dims)\",\n \"def num_dof(self) -> int:\\n return self._num_dof\",\n \"def N(self):\\n return self.get_dof()\",\n \"def columns(self) -> int:\\n return self.__squares[0].__len__()\",\n \"def column_count(self):\\n return self.column_length\",\n \"def columnCount( self ):\\n if not self.o_data is None:\\n if self.isItemMultiDimensional():\\n return len(self.o_data)\\n else:\\n return 1\\n else:\\n return 1\",\n \"def _N(self):\\n return len(self._array)\",\n \"def getNumBvars(self):\\n return _libsbml.ASTNode_getNumBvars(self)\",\n \"def size(self):\\n return self.__row_count * self.__col_count\",\n \"def dimension(self):\\n return self.__N\",\n \"def get_size(self):\\n lines = len(self.coefficients)\\n columns = 0 if lines == 0 else len(self.coefficients[0])\\n return lines, columns\",\n \"def get_number_of_atoms_to_optimize(self):\\n v = self.c.get(simulation_cell=True)\\n return len(v.data.stoichiometry)\",\n \"def col_count(self):\\n if isinstance(self.data, pd.DataFrame) is False:\\n return None\\n else:\\n return self.data.shape[1]\",\n \"def num_nodes(self):\\n return ((len(self.tensor_u)+1) * (len(self.tensor_v)+1) *\\n (len(self.tensor_w)+1))\",\n \"def col_count(self):\\n return self.__col_count\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def n_dim(self):\\n return self._n_dim\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.826646","0.80817354","0.79613394","0.7953327","0.79433763","0.7778536","0.7749949","0.75871086","0.74991745","0.74765337","0.74339026","0.72988725","0.71537995","0.71156085","0.7080469","0.69808406","0.691234","0.67460585","0.6729376","0.6723816","0.6715447","0.6695859","0.66817945","0.6674521","0.66462207","0.66337615","0.6630602","0.6628727","0.6617903","0.6597347","0.65870893","0.6580963","0.6578233","0.6574441","0.6557713","0.6536364","0.6519671","0.65078735","0.6497983","0.6497858","0.6496423","0.64925754","0.64911383","0.6488006","0.6474853","0.64673465","0.6466444","0.64625627","0.6450822","0.6450215","0.64452225","0.6442914","0.6439309","0.64381504","0.6437481","0.6434369","0.643062","0.64295954","0.6418409","0.6418409","0.64174145","0.64139867","0.63977045","0.6395228","0.6390997","0.63760775","0.63718116","0.63648176","0.6358056","0.635411","0.6352261","0.6330479","0.6330457","0.63292223","0.6317109","0.6309389","0.6309389","0.6302493","0.63020617","0.6301152","0.6300458","0.62988526","0.62936676","0.6292335","0.6289663","0.62854064","0.6282889","0.62814915","0.6281423","0.62775314","0.6277122","0.62750447","0.6268813","0.62649155","0.6264652","0.6257723","0.6256259","0.6250056","0.6246107","0.62442696"],"string":"[\n \"0.826646\",\n \"0.80817354\",\n \"0.79613394\",\n \"0.7953327\",\n \"0.79433763\",\n \"0.7778536\",\n \"0.7749949\",\n \"0.75871086\",\n \"0.74991745\",\n \"0.74765337\",\n \"0.74339026\",\n \"0.72988725\",\n \"0.71537995\",\n \"0.71156085\",\n \"0.7080469\",\n \"0.69808406\",\n \"0.691234\",\n \"0.67460585\",\n \"0.6729376\",\n \"0.6723816\",\n \"0.6715447\",\n \"0.6695859\",\n \"0.66817945\",\n \"0.6674521\",\n \"0.66462207\",\n \"0.66337615\",\n \"0.6630602\",\n \"0.6628727\",\n \"0.6617903\",\n \"0.6597347\",\n \"0.65870893\",\n \"0.6580963\",\n \"0.6578233\",\n \"0.6574441\",\n \"0.6557713\",\n \"0.6536364\",\n \"0.6519671\",\n \"0.65078735\",\n \"0.6497983\",\n \"0.6497858\",\n \"0.6496423\",\n \"0.64925754\",\n \"0.64911383\",\n \"0.6488006\",\n \"0.6474853\",\n \"0.64673465\",\n \"0.6466444\",\n \"0.64625627\",\n \"0.6450822\",\n \"0.6450215\",\n \"0.64452225\",\n \"0.6442914\",\n \"0.6439309\",\n \"0.64381504\",\n \"0.6437481\",\n \"0.6434369\",\n \"0.643062\",\n \"0.64295954\",\n \"0.6418409\",\n \"0.6418409\",\n \"0.64174145\",\n \"0.64139867\",\n \"0.63977045\",\n \"0.6395228\",\n \"0.6390997\",\n \"0.63760775\",\n \"0.63718116\",\n \"0.63648176\",\n \"0.6358056\",\n \"0.635411\",\n \"0.6352261\",\n \"0.6330479\",\n \"0.6330457\",\n \"0.63292223\",\n \"0.6317109\",\n \"0.6309389\",\n \"0.6309389\",\n \"0.6302493\",\n \"0.63020617\",\n \"0.6301152\",\n \"0.6300458\",\n \"0.62988526\",\n \"0.62936676\",\n \"0.6292335\",\n \"0.6289663\",\n \"0.62854064\",\n \"0.6282889\",\n \"0.62814915\",\n \"0.6281423\",\n \"0.62775314\",\n \"0.6277122\",\n \"0.62750447\",\n \"0.6268813\",\n \"0.62649155\",\n \"0.6264652\",\n \"0.6257723\",\n \"0.6256259\",\n \"0.6250056\",\n \"0.6246107\",\n \"0.62442696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8000086"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6892,"cells":{"query":{"kind":"string","value":"r\"\"\" To obtain an item of the matrix"},"document":{"kind":"string","value":"def __getitem__(self, data):\n i,j = data\n return self._data[i][j]"},"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 __getitem__(self, item):\n if type(item) is int:\n # select row by default\n if self.shape[0] == 1: # iterate by column if it's a row vector\n return self.values[0][item]\n elif self.shape[1] == 1: # iterate by row if it's a column vector\n return self.values[item][0]\n return Matrix([self.values[item]])\n elif type(item) is list:\n return Matrix([self.values[i] for i in item])\n elif type(item) is tuple and len(item) == 2 and type(item[0]) is int and type(item[1]) is int:\n r, c = item\n return self.values[r][c]\n elif type(item) is slice:\n return Matrix(self.values[item])\n else:\n for i in item:\n if type(i) not in (int, slice):\n raise ValueError(f\"Bad index type {type(i)}\")\n if len(item) != 2:\n raise ValueError(f\"Don't understand index: {item}\")\n if self.shape == (0, 0):\n return Matrix([[]])\n row_slice, col_slice = item\n rows = self.values[row_slice] # M[0, :] to work\n if type(rows[0]) is not list:\n rows = [rows]\n subset = [row[col_slice] for row in rows]\n if type(subset) in (int, float, complex):\n return Matrix([[subset]])\n elif type(subset) in (list, tuple) and type(subset[0]) in (int, float, complex):\n return Matrix([subset])\n else:\n return Matrix(subset)","def getitem(self, i, j):\n # XXX: flint matrices do not support negative indices\n # XXX: They also raise ValueError instead of IndexError\n m, n = self.shape\n if i < 0:\n i += m\n if j < 0:\n j += n\n try:\n return self.rep[i, j]\n except ValueError:\n raise IndexError(f\"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}\")","def get_element(self,mat,row,column):\n result = mat[row-1][column-1]\n self.element = result\n return self.element","def __getitem__(self, item):\n return self.row[item]","def __getitem__(self, item):\n return self.cube[item]","def _getMatrixRow(self):\n item = self._item()\n if item is not None:\n matrix = item.getMatrix()\n return qt.QVector3D(*matrix[self._index, :])\n else:\n return None","def getItem(self, i, j):\n if i < 0:\n raise IndexError('Row index must be nonnegative.')\n if j < 0:\n raise IndexError('Column index must be nonnegative.')\n\n return self.__m[i - 1][j - 1]","def __getitem__(self, key):\n # TODO: fix 1-by-1 case, deprecate support for vector indexing.\n # TODO: add isvector() method\n # TODO: add method that distinguishes between 1x1, 1xn, mx1, mxn\n # TODO: make sure that there's distinct ways to index a 1 by 1 matrix\n # and retrieve a value.\n rows, cols, is_view = self._cleankey(key)\n if not (is_view): #simple index case\n i, j = rows[0], cols[0]\n return self.data[i, j]\n return MPView(self, rows, cols)","def retrievematrixelement(self, coord):\n currentelement = self.matrix\n for u in coord:\n currentelement = currentelement[u]\n\n return currentelement","def get_row(A: Matrix, i: int) -> Vector:\n return A[i]","def get_row(A: Matrix, i: int) -> Vector:\n return A[i]","def get_row(A: Matrix, i: int) -> Vector:\n return A[i]","def matGet(mat, r, c):\n return mat[r][c]","def __getitem__(self, item):\n return self.elements[item]","def __getitem__(self,key):\n if type(key) is tuple:\n return self.list[LTMatrix.getPosition(*key)]\n else:\n return self.list[key]","def __getitem__(self, index):\n return (index, self.data_cube[0, index, :])","def get_row(A: Matrix, i: int) -> Vector:\n return A[i] # A[i] is already the ith row","def get_item(array, index):\n row, column = index\n return array[row][column]","def __getitem__(self,pt):\n return self.maze[pt.y][pt.x]","def __getitem__(self, item) -> SurveyRow:\n return self.rows[item]","def row(self, index):\n return self.matrix_list[index - 1]","def __getitem__ (self, idx):\n return self.row(idx[0])[idx[1]]","def item(self):\n return np.array(self).item()","def item(self, i, path=None):\n if path is None:\n assert list(self.sequences.keys())[0] is NoDim, \"Cannot access item without path if the array has more than one dimension.\"\n path = NoDim\n return self.sequences[path][i]","def get(self,row,col):\r\n return self.puzzle[row][col]","def test_get_indices_one_existing_item_scalar(self):\r\n item_to_find = 'PC.355'\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [1])","def __getitem__(self, item):\n index = self.reindex(item)\n return self.parent[index]","def __getitem__(self, i):\n return self.__x[i]","def __getitem__(self, key):\n x, y = key\n if y >= self.block_height:\n return False\n return self.matrix[y][x]","def test_col_get_item():\n pm1 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\n pm2 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\n pm3 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\n\n col = magpy.Collection(pm1, pm2, pm3)\n assert col[1] == pm2, \"get_item failed\"\n assert len(col) == 3, \"__len__ failed\"","def __getitem__(self, i):\n return self._ar[i]","def __getitem__(self, idx):\n if len(idx) == 1:\n return self.rows[idx[0]]\n else:\n return self.rows[idx[0]][idx[1]]","def row (self, i):\n return Vector(self._m[i])","def __getitem__(self, item):\n try:\n return self._values[item]\n except KeyError:\n raise FactInvalidIndex(str(item))","def __getitem__(self, item):\r\n\r\n return self.data.__getitem__(item)","def __pos__(self):\r\n return mat4(map(lambda x: +x, self.mlist))","def __getitem__(self,idx):\n return self.g[idx]","def __getitem__(self, item):\n return self.data[item]","def __getitem__(self, item):\n return self.data[item]","def __getitem__(self, item):\n return self.data[item]","def __getitem__(self, index):\n if not (type(index) in MATRIX_VALID_INTS):\n return NotImplemented\n return self._value[index]","def getItem(self,row,column,default=None):\n data = self.data\n if row in data and column in data[row]:\n return data[row][column]\n else:\n return default","def getByLable(self, a, b):\n\t\treturn self.matrix[self.access[a]][self.access[b]]","def get_item(x, is_cuda):\r\n if is_cuda:\r\n x = x.cpu().detach().numpy()\r\n else:\r\n x = x.detach().numpy()\r\n return x","def __getitem__(self, item):\n return self.top[item]","def __getitem__(self, item):\n return self._data[item]","def __getitem__(self, item):\n u, v = item\n return self.__getitem(u, v)","def __getitem__(self, index):\n x, y = index\n if 0 <= x < self.width and 0 <= y < self.height:\n return self.cells[x + y * self.width]\n else:\n return None","def __getitem__(self, idx):\n return self.getitem(idx)","def __getitem__(self, i):\n mondict = self.load_seq(i)\n N_max = mondict['xs'].shape[0]\n u = mondict['us']\n x = mondict['xs']\n return u, x","def __getitem__(self, item):\r\n return item.get_value(borrow=True)","def __getitem__(self, i_j):\n\t\t\n\t\ttry:\n\t\t\tif i_j != Ellipsis:\n\t\t\t\treturn self.item_cache[i_j]\n\t\texcept TypeError:\n\t\t\t'''\n\t\t\tc_i_j = []\n\t\t\tfor n in (0, 1):\n\t\t\t\ttry:\n\t\t\t\t\tc_i_j.append((i_j[n].start, i_j[n].stop, i_j[n].step))\n\t\t\t\texcept AttributeError:\n\t\t\t\t\tc_i_j.append(i_j[n])\n\t\t\tc_i_j = tuple(c_i_j)\n\t\t\ttry:\n\t\t\t\treturn self.item_cache[c_i_j]\n\t\t\texcept KeyError:\n\t\t\t\tpass\n\t\t\t'''\n\t\t\tpass\n\t\t\tc_i_j = i_j\n\t\texcept (AttributeError, KeyError):\n\t\t\tc_i_j = i_j\n\t\t\n\t\tdef getitem(direction, indices_i, indices_j):\n\t\t\tif direction == self.__direction.scalar:\n\t\t\t\treturn self.value[self.row_dimension * indices_i + indices_j]\n\t\t\telif direction == self.__direction.row:\n\t\t\t\tj = indices_j\n\t\t\t\treturn self.algebra.vector_algebra(self.value[self.row_dimension * _i + j] for _i in indices_i)\n\t\t\telif direction == self.__direction.column:\n\t\t\t\ti = indices_i\n\t\t\t\treturn self.algebra.vector_algebra(self.value[self.row_dimension * i + _j] for _j in indices_j)\n\t\t\telif direction == self.__direction.matrix:\n\t\t\t\tselection = {}\n\t\t\t\tfor (m, i), (n, j) in zip(enumerate(indices_i), enumerate(indices_j)):\n\t\t\t\t\tselection[m, n] = i, j\n\t\t\t\treturn self.algebra((lambda _m, _n: self.value[self.row_dimension * selection[_m, _n][0] + selection[_m, _n][1]]), row_dimension=len(indices_i), column_dimension=len(indices_j))\n\t\t\telif direction == self.__direction.copy:\n\t\t\t\t#return self.algebra(self.value, row_dimension=self.row_dimension, column_dimension=self.column_dimension)\n\t\t\t\treturn self.algebra(self)\n\t\t\telse:\n\t\t\t\traise RuntimeError(\"Unknown direction value: `{}`\".format(repr(direction)))\n\t\t\n\t\tresult = self.__analyze_indices(i_j, getitem)\n\t\t\n\t\tif __debug__:\n\t\t\ttry:\n\t\t\t\tif i_j != Ellipsis:\n\t\t\t\t\tassert self.item_cache[c_i_j] == result, f\"{repr(c_i_j)}, {id(self)}\"\n\t\t\texcept (AttributeError, KeyError, TypeError):\n\t\t\t\tpass\n\t\t\n\t\ttry:\n\t\t\tif i_j != Ellipsis:\n\t\t\t\tself.item_cache[c_i_j] = result\n\t\texcept (AttributeError, TypeError):\n\t\t\tpass\n\t\t\n\t\treturn result","def __getitem__(self, idx):\n return self.GetArray(idx)","def __getitem__(self, idx):\n return self.GetArray(idx)","def getItem(self, column, position):\n return self.data[column, position]","def __getitem__(self, itm):\n return self.wrappers[itm]","def __getitem__(self, item):\n return self.__dict__[item]","def getrow(self, i):\n new = lil_matrix((1, self.shape[1]), dtype=self.dtype)\n new.rows[0] = self.rows[i][:]\n new.data[0] = self.data[i][:]\n return new","def __getitem__(self, index):\n if isinstance(index, (tuple, list)) and len(index) == 2:\n return self.cells[index[1]][index[0]]\n return self.cells[index]","def __getitem__(self, index):\n item = self.data[index]\n return item","def __getitem__(self, k):\n return self._board[k]","def __getitem__(self, inds):\n i, j = inds\n return self.array[i][j]","def item(self) -> Tuple[Scalar, ...]:\n return self._psdf.head(2)._to_internal_pandas().index.item()","def __getitem__(self, rc):\r\n row, col = rc\r\n index = self.row_column_to_index(row, col)\r\n return self.values[index]","def __getitem__(self, index):\n return self.array[index]","def __getitem__(self, item):","def __getitem__(self, idx):\n return self.items[idx]","def __getitem__(self, j):\n\t\treturn self._coords[j]","def get_elem (A, i, j):\n\treturn A[j][i]","def __call__(self, pos):\n return self.__getitem__(pos)","def __call__(self, pos):\n return self.__getitem__(pos)","def __getitem__(self,index):\n return self._data[index[0]][index[1]]","def __getitem__(self,i):\n return self._items[i]","def __getitem__(self, item) -> NumericalAttribute:\n return self._item_dict[item]","def __getitem__(self, idx):\n return self.data.iloc[idx]","def __getitem__(self, args):\n return self.tabel[args]","def __getitem__(self, index):\n return self.dataset[index]","def get_matrix(self):\n return self._matrix[:3, :]","def __getitem__(self, index):\n return self.cellData[index]","def get_item(self, items, y, x):\n if self.maze[y][x] != \" \" and self.maze[y][x] in items:\n return self.maze[y][x]\n else:\n return None","def __getitem__(self, item) -> Union[MoleculeDatapoint, List[MoleculeDatapoint]]:\n return self.data[item]","def __getitem__(self, node):\n\n return self.adj_list[node]","def __getitem__(self, item):\r\n return self.select(item)","def __getitem__ ( self , index ):\n\t\treturn self . data [ index ]","def __getitem__(self, item):\n pass","def __getitem__(self, item):\n pass","def __getitem__(self, item):\n return self.default_dataset[item]","def __getitem__(self, key):\n if self.expr_list: return self.expr_list[key]\n else:\n if key < 0: key += len(self)\n if self.expr_tensor is not None:\n return torch.index_select(self.expr_tensor, dim=1, index=torch.LongTensor([key]).to(xnmt.device)).squeeze(1)\n else:\n return torch.index_select(self.expr_transposed_tensor, dim=-1, index=torch.LongTensor([key]).to(xnmt.device)).squeeze(-1)","def get_stain_matrix(I):","def __getitem__(self, x):\n return self.data[self.name][x]","def __getitem__(self, key):\n if self.expr_list: return self.expr_list[key]\n else:\n if key < 0: key += len(self)\n if self.expr_tensor:\n return dy.pick(self.expr_tensor, key, dim=len(self.expr_tensor.dim()[0])-1)\n else:\n return dy.pick(self.expr_transposed_tensor, key, dim=0)","def get_tile(self, point):\n print \"Getting tile for %s\" % repr(point)\n return self.matrix[point.y][point.x]","def get_map_item(self, idx, col=0, absolute=False):\n\n return self.itemDataMap[self.itemIndexMap[idx] if not absolute else idx][self.get_real_col(col)]","def __getitem__(self, i):\n return self.data[i]","def __getitem__(self, x):\n return self.query(x)","def get_tile(self, row, col):\r\n # replace with your code\r\n return self._cells[row][col]","def get_item(self):\n raise NotImplementedError","def __getitem__(self, keep):\n return self.get([self], keep)[0]","def __getitem__(self, rq):\n return self._data[rq]","def __getitem__(self, *args):\n return _osgAnimation.vectorMatrixKeyframe___getitem__(self, *args)"],"string":"[\n \"def __getitem__(self, item):\\n if type(item) is int:\\n # select row by default\\n if self.shape[0] == 1: # iterate by column if it's a row vector\\n return self.values[0][item]\\n elif self.shape[1] == 1: # iterate by row if it's a column vector\\n return self.values[item][0]\\n return Matrix([self.values[item]])\\n elif type(item) is list:\\n return Matrix([self.values[i] for i in item])\\n elif type(item) is tuple and len(item) == 2 and type(item[0]) is int and type(item[1]) is int:\\n r, c = item\\n return self.values[r][c]\\n elif type(item) is slice:\\n return Matrix(self.values[item])\\n else:\\n for i in item:\\n if type(i) not in (int, slice):\\n raise ValueError(f\\\"Bad index type {type(i)}\\\")\\n if len(item) != 2:\\n raise ValueError(f\\\"Don't understand index: {item}\\\")\\n if self.shape == (0, 0):\\n return Matrix([[]])\\n row_slice, col_slice = item\\n rows = self.values[row_slice] # M[0, :] to work\\n if type(rows[0]) is not list:\\n rows = [rows]\\n subset = [row[col_slice] for row in rows]\\n if type(subset) in (int, float, complex):\\n return Matrix([[subset]])\\n elif type(subset) in (list, tuple) and type(subset[0]) in (int, float, complex):\\n return Matrix([subset])\\n else:\\n return Matrix(subset)\",\n \"def getitem(self, i, j):\\n # XXX: flint matrices do not support negative indices\\n # XXX: They also raise ValueError instead of IndexError\\n m, n = self.shape\\n if i < 0:\\n i += m\\n if j < 0:\\n j += n\\n try:\\n return self.rep[i, j]\\n except ValueError:\\n raise IndexError(f\\\"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}\\\")\",\n \"def get_element(self,mat,row,column):\\n result = mat[row-1][column-1]\\n self.element = result\\n return self.element\",\n \"def __getitem__(self, item):\\n return self.row[item]\",\n \"def __getitem__(self, item):\\n return self.cube[item]\",\n \"def _getMatrixRow(self):\\n item = self._item()\\n if item is not None:\\n matrix = item.getMatrix()\\n return qt.QVector3D(*matrix[self._index, :])\\n else:\\n return None\",\n \"def getItem(self, i, j):\\n if i < 0:\\n raise IndexError('Row index must be nonnegative.')\\n if j < 0:\\n raise IndexError('Column index must be nonnegative.')\\n\\n return self.__m[i - 1][j - 1]\",\n \"def __getitem__(self, key):\\n # TODO: fix 1-by-1 case, deprecate support for vector indexing.\\n # TODO: add isvector() method\\n # TODO: add method that distinguishes between 1x1, 1xn, mx1, mxn\\n # TODO: make sure that there's distinct ways to index a 1 by 1 matrix\\n # and retrieve a value.\\n rows, cols, is_view = self._cleankey(key)\\n if not (is_view): #simple index case\\n i, j = rows[0], cols[0]\\n return self.data[i, j]\\n return MPView(self, rows, cols)\",\n \"def retrievematrixelement(self, coord):\\n currentelement = self.matrix\\n for u in coord:\\n currentelement = currentelement[u]\\n\\n return currentelement\",\n \"def get_row(A: Matrix, i: int) -> Vector:\\n return A[i]\",\n \"def get_row(A: Matrix, i: int) -> Vector:\\n return A[i]\",\n \"def get_row(A: Matrix, i: int) -> Vector:\\n return A[i]\",\n \"def matGet(mat, r, c):\\n return mat[r][c]\",\n \"def __getitem__(self, item):\\n return self.elements[item]\",\n \"def __getitem__(self,key):\\n if type(key) is tuple:\\n return self.list[LTMatrix.getPosition(*key)]\\n else:\\n return self.list[key]\",\n \"def __getitem__(self, index):\\n return (index, self.data_cube[0, index, :])\",\n \"def get_row(A: Matrix, i: int) -> Vector:\\n return A[i] # A[i] is already the ith row\",\n \"def get_item(array, index):\\n row, column = index\\n return array[row][column]\",\n \"def __getitem__(self,pt):\\n return self.maze[pt.y][pt.x]\",\n \"def __getitem__(self, item) -> SurveyRow:\\n return self.rows[item]\",\n \"def row(self, index):\\n return self.matrix_list[index - 1]\",\n \"def __getitem__ (self, idx):\\n return self.row(idx[0])[idx[1]]\",\n \"def item(self):\\n return np.array(self).item()\",\n \"def item(self, i, path=None):\\n if path is None:\\n assert list(self.sequences.keys())[0] is NoDim, \\\"Cannot access item without path if the array has more than one dimension.\\\"\\n path = NoDim\\n return self.sequences[path][i]\",\n \"def get(self,row,col):\\r\\n return self.puzzle[row][col]\",\n \"def test_get_indices_one_existing_item_scalar(self):\\r\\n item_to_find = 'PC.355'\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [1])\",\n \"def __getitem__(self, item):\\n index = self.reindex(item)\\n return self.parent[index]\",\n \"def __getitem__(self, i):\\n return self.__x[i]\",\n \"def __getitem__(self, key):\\n x, y = key\\n if y >= self.block_height:\\n return False\\n return self.matrix[y][x]\",\n \"def test_col_get_item():\\n pm1 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\\n pm2 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\\n pm3 = magpy.magnet.Cuboid((1, 2, 3), (1, 2, 3))\\n\\n col = magpy.Collection(pm1, pm2, pm3)\\n assert col[1] == pm2, \\\"get_item failed\\\"\\n assert len(col) == 3, \\\"__len__ failed\\\"\",\n \"def __getitem__(self, i):\\n return self._ar[i]\",\n \"def __getitem__(self, idx):\\n if len(idx) == 1:\\n return self.rows[idx[0]]\\n else:\\n return self.rows[idx[0]][idx[1]]\",\n \"def row (self, i):\\n return Vector(self._m[i])\",\n \"def __getitem__(self, item):\\n try:\\n return self._values[item]\\n except KeyError:\\n raise FactInvalidIndex(str(item))\",\n \"def __getitem__(self, item):\\r\\n\\r\\n return self.data.__getitem__(item)\",\n \"def __pos__(self):\\r\\n return mat4(map(lambda x: +x, self.mlist))\",\n \"def __getitem__(self,idx):\\n return self.g[idx]\",\n \"def __getitem__(self, item):\\n return self.data[item]\",\n \"def __getitem__(self, item):\\n return self.data[item]\",\n \"def __getitem__(self, item):\\n return self.data[item]\",\n \"def __getitem__(self, index):\\n if not (type(index) in MATRIX_VALID_INTS):\\n return NotImplemented\\n return self._value[index]\",\n \"def getItem(self,row,column,default=None):\\n data = self.data\\n if row in data and column in data[row]:\\n return data[row][column]\\n else:\\n return default\",\n \"def getByLable(self, a, b):\\n\\t\\treturn self.matrix[self.access[a]][self.access[b]]\",\n \"def get_item(x, is_cuda):\\r\\n if is_cuda:\\r\\n x = x.cpu().detach().numpy()\\r\\n else:\\r\\n x = x.detach().numpy()\\r\\n return x\",\n \"def __getitem__(self, item):\\n return self.top[item]\",\n \"def __getitem__(self, item):\\n return self._data[item]\",\n \"def __getitem__(self, item):\\n u, v = item\\n return self.__getitem(u, v)\",\n \"def __getitem__(self, index):\\n x, y = index\\n if 0 <= x < self.width and 0 <= y < self.height:\\n return self.cells[x + y * self.width]\\n else:\\n return None\",\n \"def __getitem__(self, idx):\\n return self.getitem(idx)\",\n \"def __getitem__(self, i):\\n mondict = self.load_seq(i)\\n N_max = mondict['xs'].shape[0]\\n u = mondict['us']\\n x = mondict['xs']\\n return u, x\",\n \"def __getitem__(self, item):\\r\\n return item.get_value(borrow=True)\",\n \"def __getitem__(self, i_j):\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tif i_j != Ellipsis:\\n\\t\\t\\t\\treturn self.item_cache[i_j]\\n\\t\\texcept TypeError:\\n\\t\\t\\t'''\\n\\t\\t\\tc_i_j = []\\n\\t\\t\\tfor n in (0, 1):\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tc_i_j.append((i_j[n].start, i_j[n].stop, i_j[n].step))\\n\\t\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\t\\tc_i_j.append(i_j[n])\\n\\t\\t\\tc_i_j = tuple(c_i_j)\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn self.item_cache[c_i_j]\\n\\t\\t\\texcept KeyError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\t'''\\n\\t\\t\\tpass\\n\\t\\t\\tc_i_j = i_j\\n\\t\\texcept (AttributeError, KeyError):\\n\\t\\t\\tc_i_j = i_j\\n\\t\\t\\n\\t\\tdef getitem(direction, indices_i, indices_j):\\n\\t\\t\\tif direction == self.__direction.scalar:\\n\\t\\t\\t\\treturn self.value[self.row_dimension * indices_i + indices_j]\\n\\t\\t\\telif direction == self.__direction.row:\\n\\t\\t\\t\\tj = indices_j\\n\\t\\t\\t\\treturn self.algebra.vector_algebra(self.value[self.row_dimension * _i + j] for _i in indices_i)\\n\\t\\t\\telif direction == self.__direction.column:\\n\\t\\t\\t\\ti = indices_i\\n\\t\\t\\t\\treturn self.algebra.vector_algebra(self.value[self.row_dimension * i + _j] for _j in indices_j)\\n\\t\\t\\telif direction == self.__direction.matrix:\\n\\t\\t\\t\\tselection = {}\\n\\t\\t\\t\\tfor (m, i), (n, j) in zip(enumerate(indices_i), enumerate(indices_j)):\\n\\t\\t\\t\\t\\tselection[m, n] = i, j\\n\\t\\t\\t\\treturn self.algebra((lambda _m, _n: self.value[self.row_dimension * selection[_m, _n][0] + selection[_m, _n][1]]), row_dimension=len(indices_i), column_dimension=len(indices_j))\\n\\t\\t\\telif direction == self.__direction.copy:\\n\\t\\t\\t\\t#return self.algebra(self.value, row_dimension=self.row_dimension, column_dimension=self.column_dimension)\\n\\t\\t\\t\\treturn self.algebra(self)\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise RuntimeError(\\\"Unknown direction value: `{}`\\\".format(repr(direction)))\\n\\t\\t\\n\\t\\tresult = self.__analyze_indices(i_j, getitem)\\n\\t\\t\\n\\t\\tif __debug__:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif i_j != Ellipsis:\\n\\t\\t\\t\\t\\tassert self.item_cache[c_i_j] == result, f\\\"{repr(c_i_j)}, {id(self)}\\\"\\n\\t\\t\\texcept (AttributeError, KeyError, TypeError):\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tif i_j != Ellipsis:\\n\\t\\t\\t\\tself.item_cache[c_i_j] = result\\n\\t\\texcept (AttributeError, TypeError):\\n\\t\\t\\tpass\\n\\t\\t\\n\\t\\treturn result\",\n \"def __getitem__(self, idx):\\n return self.GetArray(idx)\",\n \"def __getitem__(self, idx):\\n return self.GetArray(idx)\",\n \"def getItem(self, column, position):\\n return self.data[column, position]\",\n \"def __getitem__(self, itm):\\n return self.wrappers[itm]\",\n \"def __getitem__(self, item):\\n return self.__dict__[item]\",\n \"def getrow(self, i):\\n new = lil_matrix((1, self.shape[1]), dtype=self.dtype)\\n new.rows[0] = self.rows[i][:]\\n new.data[0] = self.data[i][:]\\n return new\",\n \"def __getitem__(self, index):\\n if isinstance(index, (tuple, list)) and len(index) == 2:\\n return self.cells[index[1]][index[0]]\\n return self.cells[index]\",\n \"def __getitem__(self, index):\\n item = self.data[index]\\n return item\",\n \"def __getitem__(self, k):\\n return self._board[k]\",\n \"def __getitem__(self, inds):\\n i, j = inds\\n return self.array[i][j]\",\n \"def item(self) -> Tuple[Scalar, ...]:\\n return self._psdf.head(2)._to_internal_pandas().index.item()\",\n \"def __getitem__(self, rc):\\r\\n row, col = rc\\r\\n index = self.row_column_to_index(row, col)\\r\\n return self.values[index]\",\n \"def __getitem__(self, index):\\n return self.array[index]\",\n \"def __getitem__(self, item):\",\n \"def __getitem__(self, idx):\\n return self.items[idx]\",\n \"def __getitem__(self, j):\\n\\t\\treturn self._coords[j]\",\n \"def get_elem (A, i, j):\\n\\treturn A[j][i]\",\n \"def __call__(self, pos):\\n return self.__getitem__(pos)\",\n \"def __call__(self, pos):\\n return self.__getitem__(pos)\",\n \"def __getitem__(self,index):\\n return self._data[index[0]][index[1]]\",\n \"def __getitem__(self,i):\\n return self._items[i]\",\n \"def __getitem__(self, item) -> NumericalAttribute:\\n return self._item_dict[item]\",\n \"def __getitem__(self, idx):\\n return self.data.iloc[idx]\",\n \"def __getitem__(self, args):\\n return self.tabel[args]\",\n \"def __getitem__(self, index):\\n return self.dataset[index]\",\n \"def get_matrix(self):\\n return self._matrix[:3, :]\",\n \"def __getitem__(self, index):\\n return self.cellData[index]\",\n \"def get_item(self, items, y, x):\\n if self.maze[y][x] != \\\" \\\" and self.maze[y][x] in items:\\n return self.maze[y][x]\\n else:\\n return None\",\n \"def __getitem__(self, item) -> Union[MoleculeDatapoint, List[MoleculeDatapoint]]:\\n return self.data[item]\",\n \"def __getitem__(self, node):\\n\\n return self.adj_list[node]\",\n \"def __getitem__(self, item):\\r\\n return self.select(item)\",\n \"def __getitem__ ( self , index ):\\n\\t\\treturn self . data [ index ]\",\n \"def __getitem__(self, item):\\n pass\",\n \"def __getitem__(self, item):\\n pass\",\n \"def __getitem__(self, item):\\n return self.default_dataset[item]\",\n \"def __getitem__(self, key):\\n if self.expr_list: return self.expr_list[key]\\n else:\\n if key < 0: key += len(self)\\n if self.expr_tensor is not None:\\n return torch.index_select(self.expr_tensor, dim=1, index=torch.LongTensor([key]).to(xnmt.device)).squeeze(1)\\n else:\\n return torch.index_select(self.expr_transposed_tensor, dim=-1, index=torch.LongTensor([key]).to(xnmt.device)).squeeze(-1)\",\n \"def get_stain_matrix(I):\",\n \"def __getitem__(self, x):\\n return self.data[self.name][x]\",\n \"def __getitem__(self, key):\\n if self.expr_list: return self.expr_list[key]\\n else:\\n if key < 0: key += len(self)\\n if self.expr_tensor:\\n return dy.pick(self.expr_tensor, key, dim=len(self.expr_tensor.dim()[0])-1)\\n else:\\n return dy.pick(self.expr_transposed_tensor, key, dim=0)\",\n \"def get_tile(self, point):\\n print \\\"Getting tile for %s\\\" % repr(point)\\n return self.matrix[point.y][point.x]\",\n \"def get_map_item(self, idx, col=0, absolute=False):\\n\\n return self.itemDataMap[self.itemIndexMap[idx] if not absolute else idx][self.get_real_col(col)]\",\n \"def __getitem__(self, i):\\n return self.data[i]\",\n \"def __getitem__(self, x):\\n return self.query(x)\",\n \"def get_tile(self, row, col):\\r\\n # replace with your code\\r\\n return self._cells[row][col]\",\n \"def get_item(self):\\n raise NotImplementedError\",\n \"def __getitem__(self, keep):\\n return self.get([self], keep)[0]\",\n \"def __getitem__(self, rq):\\n return self._data[rq]\",\n \"def __getitem__(self, *args):\\n return _osgAnimation.vectorMatrixKeyframe___getitem__(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75138944","0.7311626","0.7112711","0.7027379","0.69761306","0.68627983","0.6828977","0.6801616","0.67811024","0.6719613","0.6719613","0.6719613","0.6648522","0.6594458","0.6576159","0.65010285","0.64954424","0.6479522","0.6468668","0.6449649","0.6440751","0.6394753","0.6376016","0.63435096","0.6336273","0.63342947","0.63190305","0.62635773","0.62488973","0.62280035","0.6220941","0.62119496","0.62093467","0.6203135","0.6181611","0.61763054","0.61631024","0.61514103","0.61514103","0.61514103","0.61499727","0.6145736","0.61297566","0.61295646","0.61290073","0.6124381","0.610882","0.60986596","0.6083407","0.608233","0.60788774","0.6075778","0.60738254","0.60738254","0.6070422","0.60656","0.6065153","0.60554224","0.6051583","0.6036876","0.6028241","0.60198665","0.6015904","0.60121596","0.6010473","0.60100436","0.6008482","0.60056436","0.59932125","0.59928143","0.59928143","0.59911394","0.5987451","0.59829736","0.59809536","0.59658206","0.59635574","0.5947133","0.5937196","0.5934427","0.59309196","0.5925652","0.59209585","0.59205997","0.5916795","0.5916795","0.59142846","0.5911844","0.59108776","0.5906915","0.5897352","0.58968437","0.58915883","0.5891361","0.5889527","0.58849245","0.5879714","0.5876176","0.58736414","0.5869378"],"string":"[\n \"0.75138944\",\n \"0.7311626\",\n \"0.7112711\",\n \"0.7027379\",\n \"0.69761306\",\n \"0.68627983\",\n \"0.6828977\",\n \"0.6801616\",\n \"0.67811024\",\n \"0.6719613\",\n \"0.6719613\",\n \"0.6719613\",\n \"0.6648522\",\n \"0.6594458\",\n \"0.6576159\",\n \"0.65010285\",\n \"0.64954424\",\n \"0.6479522\",\n \"0.6468668\",\n \"0.6449649\",\n \"0.6440751\",\n \"0.6394753\",\n \"0.6376016\",\n \"0.63435096\",\n \"0.6336273\",\n \"0.63342947\",\n \"0.63190305\",\n \"0.62635773\",\n \"0.62488973\",\n \"0.62280035\",\n \"0.6220941\",\n \"0.62119496\",\n \"0.62093467\",\n \"0.6203135\",\n \"0.6181611\",\n \"0.61763054\",\n \"0.61631024\",\n \"0.61514103\",\n \"0.61514103\",\n \"0.61514103\",\n \"0.61499727\",\n \"0.6145736\",\n \"0.61297566\",\n \"0.61295646\",\n \"0.61290073\",\n \"0.6124381\",\n \"0.610882\",\n \"0.60986596\",\n \"0.6083407\",\n \"0.608233\",\n \"0.60788774\",\n \"0.6075778\",\n \"0.60738254\",\n \"0.60738254\",\n \"0.6070422\",\n \"0.60656\",\n \"0.6065153\",\n \"0.60554224\",\n \"0.6051583\",\n \"0.6036876\",\n \"0.6028241\",\n \"0.60198665\",\n \"0.6015904\",\n \"0.60121596\",\n \"0.6010473\",\n \"0.60100436\",\n \"0.6008482\",\n \"0.60056436\",\n \"0.59932125\",\n \"0.59928143\",\n \"0.59928143\",\n \"0.59911394\",\n \"0.5987451\",\n \"0.59829736\",\n \"0.59809536\",\n \"0.59658206\",\n \"0.59635574\",\n \"0.5947133\",\n \"0.5937196\",\n \"0.5934427\",\n \"0.59309196\",\n \"0.5925652\",\n \"0.59209585\",\n \"0.59205997\",\n \"0.5916795\",\n \"0.5916795\",\n \"0.59142846\",\n \"0.5911844\",\n \"0.59108776\",\n \"0.5906915\",\n \"0.5897352\",\n \"0.58968437\",\n \"0.58915883\",\n \"0.5891361\",\n \"0.5889527\",\n \"0.58849245\",\n \"0.5879714\",\n \"0.5876176\",\n \"0.58736414\",\n \"0.5869378\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61327946"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":6893,"cells":{"query":{"kind":"string","value":"r\"\"\" Multiplication of matrices"},"document":{"kind":"string","value":"def __mul__(self, other):\n if type(self) != type(other) and \\\n not isinstance(self, SymbolicMaxPlusMatrix) and \\\n not isinstance(other, SymbolicMaxPlusMatrix):\n raise TypeError(\"can not multiply {} with {}\".format(type(self),type(other)))\n if self._d != other._d:\n raise TypeError(\"dimension or number of variable mismatch\")\n d = self._d\n new_data = [[None]*d for _ in range(d)]\n for i in range(d):\n for j in range(d):\n vertices = set()\n for k in range(d):\n l = [x+y for x in self[i,k] for y in other[k,j]]\n for v in l: v.set_immutable()\n vertices.update(l)\n new_data[i][j] = self.convex_hull(vertices)\n\n return SymbolicMaxPlusMatrix(d, self._nvars, tuple(new_data), self.convex_hull)"},"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 matrix_mult(m1, m2):\n pass","def Multiply(M1,M2):\r\n M3=[]\r\n w=0\r\n while w<len(M2[0]):\r\n tap=[]\r\n t=0\r\n while t<len(M2):\r\n tap.append(M2[t][w])\r\n t=t+1\r\n M3.append(tap)\r\n w=w+1\r\n M=[]\r\n # Multiplying matrices\r\n k=0\r\n sums=0\r\n while k<len(M1):\r\n j=0\r\n mpy=[]\r\n while j<len(M3):\r\n p=0\r\n sums=0\r\n while p<len(M3[j]):\r\n temp = (M1[k][p])*(M3[j][p])\r\n sums=sums+temp\r\n p=p+1\r\n mpy.append(sums)\r\n j=j+1\r\n M.append(mpy)\r\n k=k+1\r\n return M","def multiply_matrices(a, b):\n try:\n x = len(b[0])\n except:\n b = make_2D(b)\n try:\n x = len(a[0])\n except:\n a = make_2D(a)\n if len(a[0]) != len(b):\n print 'error: matrices cannot be multiplied'\n return\n out = np.zeros((len(a), len(b[0])))\n for i in range(len(out)):\n for j in range(len(out[0])):\n sum = 0\n for k in range(len(a[i])):\n sum += a[i][k] * b[k][j]\n out[i][j] = sum\n return out","def mul(self,mat1,mat2):\n if(isinstance(mat2,int)==True):\n result = [[mat1[i][j] * mat2 for j in range(len(mat1[0]))] for i in range(len(mat1))]\n self.out = result\n return self.out\n elif(len(mat1[0])==len(mat2)):\n result = [[sum(a*b for a,b in zip(i,j)) for j in zip(*mat2)] for i in mat1]\n self.out = result\n return self.out","def mat_mul(mat1, mat2):\n\n if len(mat1[0]) == len(mat2):\n\n mat2 = matrix_transpose(mat2)\n response = []\n\n for row in range(len(mat1)):\n response.append(\n [\n sum(dot_product(mat1[row], mat2[column]))\n for column in range(len(mat2))\n ]\n )\n\n return response\n\n else:\n return None","def matMul(a, b):\n sa=matShape(a)\n sb=matShape(b)\n if sa[1]!=sb[0]: raise ValueError\n ret=matZeros((sa[0],sb[1]))\n for i in range(sa[0]):\n for j in range(sb[1]):\n val=0.0\n for k in range(sa[1]):\n val+=matGet(a,i,k)*matGet(b,k,j)\n matSet(ret,i,j,val)\n return ret","def __mul__(self,m):\n if type(m) != Matrix:\n raise TypeError('The second argument is not a matrix lol')\n if self.ncols != m.nrows:\n raise ValueError('matrix dot argument has incorrect number of rows')\n new = Matrix(self.nrows,m.ncols)\n columns = m.getCols()\n rowindex = 0\n colindex = 0 \n for row in self.matrix:\n colindex = 0 \n for col in columns:\n summ = 0\n for i,j in zip(row,col):\n summ+= i*j \n new.matrix[rowindex][colindex] = summ\n print new.matrix\n colindex += 1 \n rowindex+=1\n return new","def matrix_mult_matrix(matrix_a, matrix_b):\n m = len(matrix_a)\n n = len(matrix_b)\n result = []\n matrix_b_t = transpose_matrix(matrix_b)\n for i in xrange(m):\n row = []\n\tfor j in xrange(m):\n row.append(dot_product(matrix_a[i], matrix_b_t[j]))\n\tresult.append(row)\n return result","def matmul(a, b):\n raise NotImplementedError","def lazy_matrix_mul(m_a, m_b):\n return np.dot(m_a, m_b)","def multiply_matrices(list):\n # Section 1: Start matrix product using 1st matrix in list\n matrix_product = list[0]\n\n # Section 2: Loop thru list to create product\n for matrix in list[1:]:\n matrix_product = matrix_multiply(matrix_product, matrix)\n\n return matrix_product","def __matmul__(self, q: np.ndarray) -> np.ndarray:\n return self.product(q)","def lazy_matrix_mul(m_a, m_b):\n m_a = np.array(m_a)\n m_b = np.array(m_b)\n\n return m_a.dot(m_b)","def mat_mul(mat1, mat2):\n\n rows1 = len(mat1)\n cols1 = len(mat1[0])\n rows2 = len(mat2)\n cols2 = len(mat2[0])\n\n if cols1 != rows2:\n return None\n else:\n new_matrix = []\n for x in range(rows1):\n aux_row = []\n for y in range(cols2):\n aux_sum = []\n for z in range(cols1):\n aux_sum.append(mat1[x][z] * mat2[z][y])\n aux_row.append(sum(aux_sum))\n new_matrix.append(aux_row)\n\n return new_matrix","def __mul__(self, other):\n # \n # TODO - your code here\n #\n \n result = [];\n row_result = [];\n product = 0;\n \n if(self.w != other.h):\n raise(ValueError, \"Matrices can not multiply for their dimesion doesn't match\"); \n \n for row in self.g:\n row_result = [];\n for j in range(other.w):\n product = dot_product(row,other.get_column(j));\n row_result.append(product);\n result.append(row_result);\n \n return Matrix(result);","def matrix_mult(m1, m2):\n output = []\n for rowIndex, row in enumerate(m1): #go through rows in m1\n new_row = []\n for columnIndex in range(len(m2[0])): #go through indices for each column of m2\n sum = 0\n for index3 in range(len(row)):\n product = m1[rowIndex][index3] * m2[index3][columnIndex]\n sum += product\n new_row.append(sum)\n output.append(new_row)\n return output\n \n \n #output = []\n #first for loop corresponds to the rows of my output matrix and loops through the rows of m1 (enumerate)\n #create an empty new row\n # second for loop, loops through columns of m2\n # create sum variable, initialize it with zero\n # third for loop, multiplies the index of the row in m1 times the index of the column in m2\n # add sum to product and assign this to the sum variable\n # append sum to new row\n # append new row to output\n # return output","def __mul__(self, other):\n if self.n != other.m:\n raise TypeError(\"Illegal dimensions for mul operator\")\n tmp = [[0 for _ in xrange(self.n)] for _ in xrange(other.m)]\n for i in xrange(self.n):\n for j in xrange(other.m):\n for k in xrange(other.n):\n tmp[i][j] += self.values[i][k] * other.values[k][j]\n res = []\n for i in tmp:\n res += i\n return simplematrix(self.n, other.m, res)","def matrix_mult(m1, m2):\n\ttemp = []\n\tfor i in range(len(m1)):\n\t\te = []\n\t\tfor j in range(len(m2[0])):\n\t\t\te.append(row_times_column(m1,i,m2,j))\n\t\ttemp.append(e)\n\treturn temp","def matrixMul(self, matrix, matrix2):\n matrix0 = matrix[:]\n matrix[0] = matrix0[0] * matrix2[0] + matrix0[2]*matrix2[1] # + matrix0[4]*0\n matrix[1] = matrix0[1] * matrix2[0] + matrix0[3]*matrix2[1] # + matrix0[5]*0\n matrix[2] = matrix0[0] * matrix2[2] + matrix0[2]*matrix2[3] # + matrix0[4]*0\n matrix[3] = matrix0[1] * matrix2[2] + matrix0[3]*matrix2[3] # + matrix0[5]*0\n matrix[4] = matrix0[0] * matrix2[4] + matrix0[2]*matrix2[5] + matrix0[4]\n matrix[5] = matrix0[1] * matrix2[4] + matrix0[3]*matrix2[5] + matrix0[5]","def lazy_matrix_mul(m_a, m_b):\n return np.matmul(np.array(m_a), np.array(m_b))","def multiM(*args):\r\n filas_1,filas_2 = len(args[0]),len(args[1])\r\n columnas_1,columnas_2 = len(args[0][0]),len(args[1][0])\r\n matriz_r = []\r\n for k in range(filas_1):\r\n matriz_r.append([0]*columnas_2)\r\n for i in range(columnas_2):\r\n matriz_r[k][i] = 0\r\n for i in range(filas_1):\r\n for j in range(columnas_1):\r\n for k in range(columnas_2):\r\n matriz_r[i][k] = matriz_r[i][k] + args[0][i][j] * args[1][j][k]\r\n return matriz_r","def matrixMultiply(a, colsA, b, colsB):\r\n\trowsA = len(a)\r\n\trowsB = len(b)\r\n\r\n\t# rowsA x colsA ... rowsB x colsB \r\n\tassert rowsA == colsB, \"matrix dimensions not fit for multiplication\"\r\n\r\n\t# result size: rowsA x colsB\r\n\tr = rowsA * [None]\r\n\tfor i in range(rowsA):\r\n\t\tr[i] = colsB * [None]\r\n\t\tfor j in range(colsB):\r\n\t\t\t\tr[i][j] = sum( a[i][k]* b[k][j] for k in range(colsA))\r\n\treturn r","def __mul__(self, other):\n #\n # TODO - your code here\n #\n final_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(other.w):\n # take dot-product of row of\n # matrix in 1st arg with col of\n # matrix in 2nd arg\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\n final_matrix.append(temp_row)\n return Matrix(final_matrix)\n # TODO - your code here","def matrix_mul(m_a, m_b):\n rows_a = 0\n cols_a = 0\n rows_b = 0\n cols_b = 0\n if type(m_a) is not list:\n raise TypeError(\"m_a must be a list\")\n if type(m_b) is not list:\n raise TypeError(\"m_b must be a list\")\n length = []\n for row in m_a:\n if type(row) is not list:\n raise TypeError(\"m_a must be a list of lists\")\n for row in m_b:\n if type(row) is not list:\n raise TypeError(\"m_b must be a list of lists\")\n if m_a == [] or m_a == [[]]:\n raise ValueError(\"m_a can't be empty\")\n if m_b == [] or m_b == [[]]:\n raise ValueError(\"m_b can't be empty\")\n for row in m_a:\n cols_a = 0\n for elem in row:\n if type(elem) is not int and type(elem) is not float:\n raise TypeError(\"m_a should contain only integers or floats\")\n cols_a += 1\n for row in m_b:\n cols_b = 0\n for elem in row:\n if type(elem) is not int and type(elem) is not float:\n raise TypeError(\"m_b should contain only integers or floats\")\n cols_b += 1\n for row in m_a:\n length.append(len(row))\n rows_a += 1\n if not len(set(length)) <= 1:\n raise TypeError(\"each row of m_a must be of the same size\")\n length.clear()\n for row in m_b:\n length.append(len(row))\n rows_b += 1\n if not len(set(length)) <= 1:\n raise TypeError(\"each row of m_b must be of the same size\")\n if cols_a != rows_b:\n raise ValueError(\"m_a and m_b can't be multiplied\")\n new = [[0 for i in range(cols_b)] for j in range(rows_a)]\n for new_rows in range(rows_a):\n for new_cols in range(cols_b):\n for i in range(cols_a):\n new[new_rows][new_cols] += m_a[new_rows][i] * m_b[i][new_cols]\n return new","def mmultiply(self, matrix):\n try:\n result_matrix = [[0 for row in range(len(self.matrix))] for col in range(len(matrix[0]))]\n for i in range(len(self.matrix)):\n for j in range(len(matrix[0])):\n for k in range(len(matrix)):\n result_matrix[i][j] += self.matrix[i][k] * matrix[k][j]\n self.matrix = result_matrix\n except IndexError:\n pass\n pass","def np_matmul(mat1, mat2):\n return np.matmul(mat1, mat2)","def matrix_multiply(m1, m2):\n\n\tproduct = numpy.matmul(m1, m2)\n\tif type(product) == numpy.int64:\n\t\treturn float(product)\n\telse:\n\t\tresult = list(product)\n\t\treturn result","def matrix_mult(A,B):\n\n m = len(A)\n p = len(B)\n n = len(B[0])\n AB = []\n for i in range(m):\n AB.append([])\n for j in range(n):\n total = 0\n for k in range(p):\n total += A[i][k] * B[k][j]\n AB[i].append(total)\n return AB","def __matmul__(self, B):\n m, n = self.shape\n n_, r = B.shape\n assert n == n_, (\"Cannot multiply shapes \"\n \"({}, {}) and ({}, {})\".format(m, n, n_, r))\n mul_ = dict()\n # compute A_ik = sum_j A_ij*B_jk\n for i in range(m):\n for k in range(r):\n prod = mpfr(0)\n for j in range(n):\n prod += self[i, j] * B[j, k]\n mul_[i, k] = prod\n return MPMatrix((m, r), mul_)","def matrixMultiplication(firstMatrix, secondMatrix):\n if len(firstMatrix[0]) == len(secondMatrix): # Checks whether the matrices can be multiplied or not or not\n finalMatrix = []\n for y in range(len(firstMatrix)): # 2\n currentMatrix = []\n for i in range(len(secondMatrix[0])):\n currentSum = 0\n for j in range(len(secondMatrix)):\n currentSum += secondMatrix[j][i] * firstMatrix[y][j]\n currentMatrix.append(currentSum)\n print(\"This is my current matrix: \" + str(currentMatrix))\n finalMatrix.append(currentMatrix)\n print(\"This product of the two matrices is :) \" + str(finalMatrix))\n else:\n print(\"This operation cannot be done, make sure the rows of the first matrix is the same as the number of columns in the second matrix\")","def matrix_multiply(self, Am, Bm):\r\n # Section 1: Ensure A & B dimensions are correct for multiplication\r\n rowsA = len(Am)\r\n colsA = len(Am[0])\r\n rowsB = len(Bm)\r\n colsB = len(Bm[0])\r\n if colsA != rowsB:\r\n raise ArithmeticError(\r\n 'Number of A columns must equal number of B rows.')\r\n \r\n # Section 2: Store matrix multiplication in a new matrix\r\n C = self.zeros_matrix(rowsA, colsB)\r\n for i in range(rowsA):\r\n for j in range(colsB):\r\n total = 0\r\n for ii in range(colsA):\r\n total += Am[i][ii] * Bm[ii][j]\r\n C[i][j] = total\r\n \r\n return C","def matmul():\n\n if RESULT_IN_NVRAM:\n matrix_c = ResultMatrixInDaos()\n else:\n matrix_c = ResultMatrixInMemory()\n\n # This could be trivially optimized by reordering indexes\n # and caching either a_block or b_block (assuming C in-memory).\n # *However* it would result in unfair comparisons with the \n # previous implementation used elsewhere.\n # Using the naive algorithm makes sense for a raw comparison.\n for i in range(MATRIXSIZE):\n for j in range(MATRIXSIZE):\n partial_result_block = np.zeros((BLOCKSIZE, BLOCKSIZE))\n\n for k in range(MATRIXSIZE):\n a_block = np.fromstring(\n DAOS_KV[\"A%02d%02d\" % (i, k)],\n dtype=NP_FROMSTRING_DTYPE\n ).reshape((BLOCKSIZE, BLOCKSIZE))\n\n b_block = np.fromstring(\n DAOS_KV[\"B%02d%02d\" % (k, j)],\n dtype=NP_FROMSTRING_DTYPE\n ).reshape((BLOCKSIZE, BLOCKSIZE))\n\n partial_result_block += a_block @ b_block\n \n matrix_c[i,j] = partial_result_block\n\n return matrix_c","def matrix_multiply(A,B):\n rowsA = len(A)\n colsA = len(A[0])\n\n rowsB = len(B)\n colsB = len(B[0])\n\n if colsA != rowsB:\n raise ArithmeticError('Number of A columns must equal number of B rows.')\n\n C = zeros_matrix(rowsA, colsB)\n\n for i in range(rowsA):\n for j in range(colsB):\n total = 0\n for ii in range(colsA):\n total += A[i][ii] * B[ii][j]\n C[i][j] = total\n\n return C","def _mul(*args):\n\treturn functools.reduce(numpy.dot, args)","def matrixMultiplication(self, n, id, context):\n\n print(\"id: {}\".format(id))\n # Create one matrix\n f = 1\n m1 = []\n for x in range(n):\n row = []\n for y in range(n):\n row.append(f)\n f = f + 1\n m1.append(row)\n # The second matrix is equal to the first matrix\n m2 = m1\n print(\"m2: {}\".format(m2))\n\n # Multiply matrices\n m3 = []\n for i in range(n):\n row = []\n for j in range(n):\n sum = 0\n for k in range(n):\n sum = sum + m1[i][k] * m2[k][j]\n row.append(sum)\n m3.append(row)\n\n sum = 0\n # add the entries\n for i in range(n):\n for j in range(n):\n sum = sum + m3[i][j]\n\n print(\"Result of multiplication is {}\".format(sum))\n return sum","def matrix_mul(m_a, m_b):\n if not isinstance(m_a, list):\n raise TypeError(\"m_a must be a list\")\n if not isinstance(m_b, list):\n raise TypeError(\"m_b must be a list\")\n if len(list(filter(lambda i: not isinstance(i, list), m_a))) > 0:\n raise TypeError(\"m_a must be a list of lists\")\n if len(list(filter(lambda i: not isinstance(i, list), m_b))) > 0:\n raise TypeError(\"m_b must be a list of lists\")\n if m_a is None or m_a == [] or m_a == [[]]:\n raise ValueError(\"m_a can't be empty\")\n if m_b is None or m_b == [] or m_b == [[]]:\n raise ValueError(\"m_b can't be empty\")\n for r in m_a:\n for v in r:\n if not isinstance(v, (int, float)):\n raise ValueError(\"m_a should contain only integers or floats\")\n for r in m_b:\n for v in r:\n if not isinstance(v, (int, float)):\n raise ValueError(\"m_b should contain only integers or floats\")\n if max(map(lambda i: len(i), m_a)) != min(map(lambda i: len(i), m_a)):\n raise TypeError(\"each row of m_a must be of the same size\")\n if max(map(lambda i: len(i), m_b)) != min(map(lambda i: len(i), m_b)):\n raise TypeError(\"each row of m_b must be of the same size\")\n try:\n w = (len(m_a) + (0, 1)[len(m_a) == 1])\n m_c = [(['x'] * w) for b in range(len(m_b[0]))]\n for i in range(len(m_a)):\n for j in range(len(m_b[0])):\n s = 0\n for k in range(len(m_a[0])):\n s += (m_a[i][k] * m_b[k][j])\n m_c[i][j] = s\n return list(filter(lambda r: r != (['x'] * w), m_c))\n except:\n raise ValueError(\"m_a and m_b can't be multiplied\")","def lazy_matrix_mul(m_a, m_b):\n return (np.matmul(m_a, m_b))","def matrixMult( self, matrix0, matrix1 ):\r\n result = {}\r\n keys = sorted( set( matrix0.keys() ) )\r\n count = range( len( matrix0.keys() ) )\r\n \r\n for key in keys:\r\n result[ key ] = []\r\n for i in count:\r\n sum = 0\r\n for j in count:\r\n sum += matrix0[ key ][j] * matrix1[ keys[j] ][i]\r\n result[ key ].insert( i, sum )\r\n \r\n return result","def multiply(a, b):\n columns_of_a = len(a[0])\n lines_of_b = len(b)\n if columns_of_a != lines_of_b:\n # Check matrix dimensions\n print \"Incompatible sizes!\"\n else:\n lines_of_a = len(a)\n columns_of_b = len(b[0])\n #C = []\n #for i in range (lines_of_a):\n # C.append(columns_of_b * [0])\n c = [columns_of_b * [0] for i in range(lines_of_a)]\n for i in range(lines_of_a):\n for j in range(columns_of_b):\n for k in range(lines_of_b):\n c[i][j] += a[i][k] * b[k][j]\n return c","def matmul(xs: List[List[float]],\n ys: List[List[float]]) -> List[List[float]]:\n product = []\n for x_row in range(len(xs)):\n row = []\n for y_col in range(len(ys[0])):\n col = [ys[y_row][y_col] for y_row in range(len(ys))]\n row.append(Math.dot(xs[x_row], col))\n product.append(row)\n return product","def multiply_matrices(A, B):\n # Section 1: Ensure A & B dimensions are correct for multiplication\n rowsA = len(A)\n colsA = len(A[0])\n rowsB = len(B)\n colsB = len(B[0])\n if colsA != rowsB:\n raise ArithmeticError(\n 'Number of A columns must equal number of B rows.')\n\n # Section 2: Store matrix multiplication in a new matrix\n C = zeros_matrix(rowsA, colsB)\n for i in range(rowsA):\n for j in range(colsB):\n total = 0\n for ii in range(colsA):\n total += A[i][ii] * B[ii][j]\n C[i][j] = total\n\n return C","def matrix_mult(M, vector1, vector2):\n out = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return out","def matrix_mult(M, vector1, vector2):\n out = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return out","def matrix_mul(m_a, m_b):\n if not isinstance(m_a, list):\n raise TypeError(\"m_a must be a list\")\n if not isinstance(m_b, list):\n raise TypeError(\"m_b must be a list\")\n if not all(isinstance(lst, list) for lst in m_a):\n raise TypeError(\"m_a must be a list of lists\")\n if not all(isinstance(lst, list) for lst in m_b):\n raise TypeError(\"m_b must be a list of lists\")\n if m_a in [[], [[]]]:\n raise ValueError(\"m_a can't be empty\")\n if m_b in [[], [[]]]:\n raise ValueError(\"m_b can't be empty\")\n if not all(all(isinstance(i, (int, float)) for i in lst) for lst in m_a):\n raise TypeError(\"m_a should contain only integers or floats\")\n if not all(all(isinstance(i, (int, float)) for i in lst) for lst in m_b):\n raise TypeError(\"m_b should contain only integers or floats\")\n if not all(len(i) == len(m_a[0]) for i in m_a):\n raise TypeError(\"each row of m_a must be of the same size\")\n if not all(len(i) == len(m_b[0]) for i in m_b):\n raise TypeError(\"each row of m_b must be of the same size\")\n if not len(m_a[0]) == len(m_b):\n raise ValueError(\"m_a and m_b can't be multiplied\")\n new_matrix = [[0 for i in m_b[0]] for j in m_a]\n for i in range(len(m_a)):\n for j in range(len(m_b[0])):\n for k in range(len(m_b)):\n new_matrix[i][j] += m_a[i][k] * m_b[k][j]\n return new_matrix","def np_matmul(mat1, mat2):\n return mat1.dot(mat2)","def matmul(x, y):\n return np.matmul(x, y)","def MultiplyMatrix(matrixA, matrixB):\r\n # result matrix initialized as singularity matrix\r\n result = [[0 for y in range(len(matrixB[0]))] for x in range(len(matrixA))]\r\n for i in range(len(matrixA)):\r\n # iterate through columns of Y\r\n for j in range(len(matrixB[0])):\r\n # iterate through rows of Y\r\n for k in range(len(matrixB)):\r\n result[i][j] += matrixA[i][k] * matrixB[k][j]\r\n return result","def _multi_matmul(arrays, order, i, j, constant=False) -> Tensor:\n if i == j:\n return arrays[i]\n else:\n return matmul(\n _multi_matmul(arrays, order, i, order[i, j], constant),\n _multi_matmul(arrays, order, order[i, j] + 1, j, constant),\n constant,\n )","def __mul__(self, other):\r\n T = type(other)\r\n # mat4*scalar\r\n if T==types.FloatType or T==types.IntType or T==types.LongType:\r\n return mat4(map(lambda x,other=other: x*other, self.mlist))\r\n # mat4*vec3\r\n if isinstance(other, _vec3):\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n w = float(m41*other.x + m42*other.y + m43*other.z + m44)\r\n return _vec3(m11*other.x + m12*other.y + m13*other.z + m14, \r\n m21*other.x + m22*other.y + m23*other.z + m24, \r\n m31*other.x + m32*other.y + m33*other.z + m34)/w\r\n # mat4*vec4\r\n if isinstance(other, _vec4):\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n return _vec4(m11*other.x + m12*other.y + m13*other.z + m14*other.w, \r\n m21*other.x + m22*other.y + m23*other.z + m24*other.w, \r\n m31*other.x + m32*other.y + m33*other.z + m34*other.w,\r\n m41*other.x + m42*other.y + m43*other.z + m44*other.w)\r\n # mat4*mat4\r\n if isinstance(other, mat4):\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n n11,n12,n13,n14,n21,n22,n23,n24,n31,n32,n33,n34,n41,n42,n43,n44 = other.mlist\r\n return mat4( m11*n11+m12*n21+m13*n31+m14*n41,\r\n m11*n12+m12*n22+m13*n32+m14*n42,\r\n m11*n13+m12*n23+m13*n33+m14*n43,\r\n m11*n14+m12*n24+m13*n34+m14*n44,\r\n\r\n m21*n11+m22*n21+m23*n31+m24*n41,\r\n m21*n12+m22*n22+m23*n32+m24*n42,\r\n m21*n13+m22*n23+m23*n33+m24*n43,\r\n m21*n14+m22*n24+m23*n34+m24*n44,\r\n\r\n m31*n11+m32*n21+m33*n31+m34*n41,\r\n m31*n12+m32*n22+m33*n32+m34*n42,\r\n m31*n13+m32*n23+m33*n33+m34*n43,\r\n m31*n14+m32*n24+m33*n34+m34*n44,\r\n\r\n m41*n11+m42*n21+m43*n31+m44*n41,\r\n m41*n12+m42*n22+m43*n32+m44*n42,\r\n m41*n13+m42*n23+m43*n33+m44*n43,\r\n m41*n14+m42*n24+m43*n34+m44*n44)\r\n # unsupported\r\n else:\r\n raise TypeError, \"unsupported operand type for *\"","def Mult(A, B, C_, IM, M):\n for i in range(M):\n for j in range(M):\n for k in range(M):\n C_[i, j] = A[i, j] * B[i, j]","def matmul(A, B):\n\n A._check('*', B, A.shape[1], B.shape[0])\n return A.from_rep(A.rep.matmul(B.rep))","def matrixMul(a, b):\n # Initializing Empty Matrix\n c = [[0, 0], [0, 0]]\n # 2x2 matrix multiplication. Essentially O(1)\n for i in range(2):\n for j in range(2):\n for k in range(2):\n c[i][j] = (c[i][j] + (a[i][k] * b[k][j]))\n\n # Returning the products\n return c","def mult(m1, m2):\n assert np.shape(m1) == (2, 3)\n assert np.shape(m2) == (2, 3)\n\n m1_temp = np.vstack((m1, [0, 0, 1]))\n m2_temp = np.vstack((m2, [0, 0, 1]))\n result = m1_temp * m2_temp\n\n return result[:2, :]","def recursive_multiply(a, b):\n if len(a) == 2:\n return naive_multiply(a, b)\n\n a11 = a[0:int(len(a) / 2)]\n for index, row in enumerate(a11):\n a11[index] = row[0:int(len(row) / 2)]\n\n a12 = a[0:int(len(a) / 2)]\n for index, row in enumerate(a12):\n a12[index] = row[int(len(a) / 2):len(a)]\n\n a21 = a[int(len(a) / 2):len(a)]\n for index, row in enumerate(a21):\n a21[index] = row[0:int(len(row) / 2)]\n\n a22 = a[int(len(a) / 2):len(a)]\n for index, row in enumerate(a22):\n a22[index] = row[int(len(a) / 2):len(a)]\n\n b11 = b[0:int(len(b) / 2)]\n for index, row in enumerate(b11):\n b11[index] = row[0:int(len(row) / 2)]\n\n b12 = b[0:int(len(b) / 2)]\n for index, row in enumerate(b12):\n b12[index] = row[int(len(b) / 2):len(b)]\n\n b21 = b[int(len(b) / 2):len(b)]\n for index, row in enumerate(b21):\n b21[index] = row[0:int(len(row) / 2)]\n\n b22 = b[int(len(b) / 2):len(b)]\n for index, row in enumerate(b22):\n b22[index] = row[int(len(b) / 2):len(b)]\n\n c11 = matrix_add(recursive_multiply(a11, b11), recursive_multiply(a12, b21)) # C11 = A11*B11 + A12*B21\n c12 = matrix_add(recursive_multiply(a11, b12), recursive_multiply(a12, b22)) # C12 = A11*B12 + A12*B22\n c21 = matrix_add(recursive_multiply(a21, b11), recursive_multiply(a22, b21)) # C21 = A21*B11 + A22*B21\n c22 = matrix_add(recursive_multiply(a21, b12), recursive_multiply(a22, b22)) # C22 = A21*B12 + A22*B22\n\n # Append c12 to c11\n for row_index, row in enumerate(c11):\n for col_index, col in enumerate(c12):\n row.append(c12[row_index][col_index])\n\n # Append c22 to c21\n for row_index, row in enumerate(c21):\n for col_index, col in enumerate(c12):\n row.append(c22[row_index][col_index])\n\n # Append c21 to c11\n for i in c21:\n c11.append(i)\n\n return c11","def matrix_multiply(A, B):\n # Section 1: Ensure A & B dimensions are correct for multiplication\n rowsA = len(A); colsA = len(A[0])\n rowsB = len(B); colsB = len(B[0])\n if colsA != rowsB:\n raise ArithmeticError(\n 'Number of A columns must equal number of B rows.')\n\n # Section 2: Store matrix multiplication in a new matrix\n C = zeros_matrix(rowsA, colsB)\n for i in range(rowsA):\n for j in range(colsB):\n total = 0\n for ii in range(colsA):\n total += A[i][ii] * B[ii][j]\n C[i][j] = total\n\n return C","def square_matrix_multiply(a, b):\n n = len(a)\n c = [[0]*n for _ in range(n)]\n for i in range(n):\n for j in range(n):\n sm = 0\n for k in range(n):\n sm += (a[i][k] * b[k][j])\n c[i][j] = sm\n\n return c","def multiply(A, B):\n\n if len(A[0]) != len(B):\n raise Exception(\"Matrix dimensions do not match for matrix multiplication: %d x %d and %d x %d\" % (len(A), len(A[0]), len(B), len(B[0])))\n\n result = [[0] * len(B[0]) for i in range(len(A))]\n\n for i in range(len(A)):\n for j in range(len(B[0])):\n\n result[i][j] = LinAl.dot(A[i], LinAl.transpose(B)[j])\n\n return result","def matrix_product(mat1: List[List[int]], mat2: List[List[int]]):\n if len(mat1) == 0 or len(mat2) == 0:\n raise ValueError(\"One of matrix is empty\")\n n, k1 = len(mat1), len(mat1[0])\n k2, m = len(mat2), len(mat2[0])\n if k1 != k2:\n raise ValueError(\n f\"Can't multiply two matrices with shapes {n}x{k1} and {k2}x{m}\"\n )\n mat2_t = matrix_transpose(mat2)\n return [[vec_product(vec1, vec2) for vec2 in mat2_t] for vec1 in mat1]","def __mul__(self, other):\n\n # Scalar multiplication\n if isinstance(other, (int, long, float, complex)):\n return Matrix(self.rows, self.columns, [other * x for x in self.data])\n\n if not issubclass(type(other), Matrix):\n raise TypeError(type(other))\n\n if self.columns != other.rows:\n raise ValueError(\"Undefined multiplication for these matrices\")\n\n result = []\n for i in range(1, self.rows + 1):\n row = self.row(i)\n result.extend([dot_product(row, other.column(j)) for j in range(1, other.columns + 1)])\n\n return Matrix(self.rows, other.columns, data = result)","def __matmul__(self, other):\n return F.MatMul.apply(self, other)","def __mul__(self, other):\n if isinstance(other, Vector):\n # Matrix vector product\n v = Vector(list())\n for n in range(len(other.vectors)):\n v += scale(other.vectors[n][n], self.vectors[n])\n return v\n elif isinstance(other, Matrix):\n # Matrix matrix product\n if self.n != other.m:\n raise ValueError(\"Wrong fucking sizes, nøøb\")\n\n selfVectors = self.vectors\n selfColVectors = self.transpose()\n otherVectors = other.vectors\n otherColVectors = other.transpose()\n vectors = list()\n for col in range(other.n):\n cordinator = []\n\n for row in range(self.m):\n coord = 0\n\n for k in range(other.m):\n coord += (\n selfVectors[row].coords[k]\n * otherColVectors.vectors[col].coords[k]\n )\n\n cordinator.append(coord)\n\n v = Vector(cordinator)\n vectors.append(v)\n matrix = Matrix(vectors)\n matrix = matrix.transpose()\n return matrix\n elif isinstance(other, int) or isinstance(other, float): # Skalering af matrix\n for i in range(len(self.vectors)):\n self.vectors[i] *= other\n else:\n raise ValueError(\n \"Can only multiply Matrix with Matrix, Vector, Integer or Float\"\n )","def calculate_matmul(mat_a, mat_b):\n assert mat_a.shape[-2] == 1 and mat_b.shape[-1] == 1\n return tf.reduce_sum(tf.squeeze(mat_a, -2) * tf.squeeze(mat_b, -1), axis=2, keepdims=True)","def __mul__(self, other):\n return Matrix3(\n self.i * other,\n self.j * other,\n self.k * other,\n )","def _matmult(A, x):\n b = []\n for a in A:\n b.append(sum([ai * xi for ai, xi in zip(a, x)]))\n return b","def __mul__(self, otherMatrix):\n if not (len(self.array[0]) == len(otherMatrix.array)):\n raise ArithmeticError\n\n common = len(self.array[0])\n X = len(self.array)\n Y = len(otherMatrix.array[0])\n newArray = [[0 for x in range(X)] for x in range(Y)]\n\n for row in range(X):\n for col in range(Y):\n for elem in range(common):\n newArray[row][col] += self.array[row][elem] * otherMatrix.array[elem][col]\n\n\n return matrix(newArray)","def matrix_multiply(x, y):\r\n\r\n # handle the base case of receiving\r\n # two empty matrices\r\n if x == [] and y == []:\r\n return []\r\n\r\n # determine the number of rows and columns in the result matrix\r\n num_rows = len(x)\r\n num_cols = len(y[0])\r\n\r\n num_cross = len(x[0])\r\n\r\n # initialize the result matrix\r\n result_matrix = [[0] * num_cols for _ in xrange(num_rows)]\r\n\r\n # compute the values for each cell of the result\r\n # matrix\r\n for row_index in xrange(num_rows):\r\n for col_index in xrange(num_cols):\r\n\r\n # sum up the corresponding values from\r\n # x and y\r\n for multiplication_index in xrange(num_cross):\r\n\r\n x_value = x[row_index][multiplication_index]\r\n y_value = y[multiplication_index][col_index]\r\n\r\n result_matrix[row_index][col_index] += x_value * y_value\r\n\r\n return result_matrix","def __mul__(self, other):\n if isinstance(other, (int, float)):\n newmat = make_matrix(self.rows, self.cols)\n for i in range(newmat.rows):\n for j in range(newmat.cols):\n newmat[i, j] = self[i, j] * other\n elif isinstance(other, Matrix):\n if self.cols != other.rows:\n raise IndexError(\"Row/column mismatch: (%i, %i) x (%i, %i)\"%\n (self.rows, self.cols, other.rows, other.cols))\n\n newmat = make_matrix(self.rows, other.cols)\n\n for i in range(newmat.rows):\n for j in range(newmat.cols):\n for k in range(self.cols):\n newmat[i, j] += self[i, k] * other[k, j]\n return newmat","def multiplication(self):\n try:\n multiplication = self.matrix1 * self.matrix2\n except Exception as e:\n return \"Error: {}\".format(e)\n\n return multiplication","def matrix_dot(*args):\r\n rval = args[0]\r\n for a in args[1:]:\r\n rval = theano.tensor.dot(rval, a)\r\n return rval","def __matmul__(self, tensor):\n return self.matmul(tensor)","def multiply(A, B, *args, **kwargs):\n dim=A.__len__()\n assert(dim==B.__len__())\n C=[]\n for ii in range(dim):\n shape=(A[ii].shape[0]*B[ii].shape[0], A[ii].shape[1])\n val=np.empty(shape)\n for iimn, (mm, nn) in enumerate(itertools.product(list(range(A[ii].shape[0])), list(range(B[ii].shape[0])))):\n val[iimn] = A[ii][mm]*B[ii][nn]\n C.append(val)\n return C","def matrix_multiplication_loop(x_matrix, y_matrix):\n result = []\n for i, row in enumerate(x_matrix):\n row_vector = []\n for j in range(len(y_matrix[0])):\n product = 0\n for k in range(len(row)):\n product += x_matrix[i][k] * y_matrix[k][j]\n row_vector.append(product)\n result.append(row_vector)\n return result","def matr_prod(_A, _B):\r\n # Matrix multiplication\r\n B0 = _B[0]\r\n lenB = len(_B)\r\n lenA = len(_A)\r\n if(len(_A[0]) != lenB): # Check matrix dimensions \r\n Exception('Matrices have wrong dimensions')\r\n if(isinstance(B0, list) or isinstance(B0, array) or isinstance(B0, tuple)): #_B is matrix\r\n lenB0 = len(B0)\r\n C = [[0 for row in range(lenB0)] for col in range(lenA)]\r\n for i in range(lenA):\r\n for j in range(lenB0):\r\n for k in range(lenB):\r\n C[i][j] += _A[i][k]*_B[k][j]\r\n else: #_B is vector\r\n C = [0 for row in range(lenB)]\r\n for i in range(lenA):\r\n for k in range(lenB):\r\n C[i] += _A[i][k]*_B[k]\r\n return C","def __matmul__(self, csys):\n self._transform(csys)\n return self","def StrassenMatrixM(a, b):\r\n if len(a) != 2 or len(a[0]) != 2 or len(b) != 2 or len(b[0]) != 2:\r\n raise Exception('Matrices should be 2x2!')\r\n print(a[0][0] * b[0][1] + a[0][1] * b[1][1])\r\n matrix = [[a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],\r\n [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]]]\r\n\r\n return matrix","def transforms_multiply(t0s, t1s):\r\n \r\n return ut.matrix_multiply(t0s, t1s)","def __mul__(self, other):\n if not isinstance(other, Matrix):\n return NotImplemented\n\n if self.num_cols != other.num_rows:\n raise ValueError(\"self.num_cols (%d) != other.num_rows (%d)\" % (self.num_cols, other.num_cols))\n\n new_mat = Matrix(self.num_rows, other.num_cols)\n\n # iterate through rows of self\n for i in range(self.num_rows):\n # iterate through columns of other\n for j in range(other.num_cols):\n # iterate through rows of other\n for k in range(other.num_rows):\n new_mat[i, j] += self[i, k] * other[k, j]\n\n return new_mat","def __mul__(self, oth):\n\t\tif isinstance(oth, Matrix) or isiterable(oth):\n\t\t\t# matrix\n\t\t\toth_m = oth\n\t\t\tif not isinstance(oth_m, Matrix):\n\t\t\t\toth_m = Matrix(oth_m)\t\t\t\n\t\t\tres_m = self._mat_mul(oth_m)\n\t\t\tif isinstance(oth, Matrix):\n\t\t\t\treturn res_m\n\t\t\telse:\n\t\t\t\treturn type(oth)(res_m._unnest())\n\t\telse:\n\t\t\t# scalar\n\t\t\treturn Matrix._make_new(lambda i,j: self.data[i][j] * oth, self.rows, self.cols)","def naive_multiply(a, b):\n m = len(a) # Number of rows in first matrix\n k = len(b) # Number of rows in the second matrix\n res = []\n p = len(b[0])\n n = k\n for q in range(m):\n res.append([0])\n for q in range(m):\n for w in range(p - 1):\n res[q].append(0)\n for i in range(m):\n for j in range(p):\n for r in range(n):\n res[i][j] = a[i][r] * b[r][j] + res[i][j]\n return res","def mult_img_matrix(imgs, matrix):\n nimgs, ny, nx = imgs.shape\n\n vec = np.reshape(imgs, [nimgs, ny * nx])\n vec_out = matrix.dot(vec)\n imgs_out = np.reshape(vec_out, [nimgs, ny, nx])\n\n return imgs_out","def test_matmul_mm(self):\n self.check_dot_mm(matmul_usecase, None, \"'@'\")","def matmul(x, y):\n if len(list(y.size())) == 2:\n # if one of them is a vector (i.e. wanting to do MV mult)\n z = torch.zeros(2, x.size()[1], dtype=torch.double, device=x.device)\n z[0] = torch.mv(x[0], y[0]) - torch.mv(x[1], y[1])\n z[1] = torch.mv(x[0], y[1]) + torch.mv(x[1], y[0])\n\n if len(list(y.size())) == 3:\n z = torch.zeros(\n 2, x.size()[1], y.size()[2], dtype=torch.double, device=x.device\n )\n z[0] = torch.matmul(x[0], y[0]) - torch.matmul(x[1], y[1])\n z[1] = torch.matmul(x[0], y[1]) + torch.matmul(x[1], y[0])\n\n return z","def __matmul__(self, other):\n if isinstance(other, types.Vector):\n return self.apply(target=other)\n if isinstance(other, MatrixLieGroup):\n return self.multiply(other=other)\n else:\n assert False, \"Invalid argument\"","def __mul__(self, scalar):\n m, n = self.shape\n scalar = mpfr(scalar)\n data = dict()\n for i in range(m):\n for j in range(n):\n data[i, j] = self[i, j] * scalar\n return MPMatrix((m, n), data)","def matrix_mult(A,B,mod=10**9+7):\n C = [[1,1],[1,1]]\n C[0][0] = ((A[0][0]*B[0][0])%mod + (A[0][1]*B[1][0])%mod)%mod\n C[0][1] = ((A[0][0]*B[0][1])%mod + (A[0][1]*B[1][1])%mod)%mod\n C[1][0] = ((A[1][0]*B[0][0])%mod + (A[1][1]*B[1][0])%mod)%mod\n C[1][1] = ((A[1][0]*B[0][1])%mod + (A[1][1]*B[1][1])%mod)%mod\n return C","def python_nonsquare_matrix_mult(matrix):\n\n transposed_matrix = np.zeros([matrix.shape[1],matrix.shape[0]])\n start = time.time()\n # for i in range(matrix.shape[0]):\n # for j in range(matrix.shape[1]):\n # transposed_matrix[j,i] = matrix[i,j]\n\n transposed_matrix = np.transpose(matrix)\n product = matrix.dot(transposed_matrix)\n\n # transposed_matrix = np.transpose(matrix)\n end = time.time()-start\n\n # print(\"Python Golden Transpose: %s\" % product)\n # print('python transpose time: %.2E' % end)\n return [product, end]","def matrix_dot(*args):\n rval = args[0]\n for a in args[1:]:\n rval = tm.dot(rval, a)\n return rval","def multiply(self, b):\n assert(self.Dimension == b.Dimension)\n p = []\n for meb in b.Elements:\n for mea in self.Elements:\n if mea.j == meb.i:\n temp = mea.val * meb.val\n temp = MatrixElement(mea.i, meb.j, temp)\n p.append(temp)\n p = SparseMatrix(len(p), p)\n #print(p)\n return p","def combine_one_matrices(mul):\n factor, args = mul.as_coeff_matrices()\n new_args = [args[0]]\n\n for B in args[1:]:\n A = new_args[-1]\n if not isinstance(A, OneMatrix) or not isinstance(B, OneMatrix):\n new_args.append(B)\n continue\n new_args.pop()\n new_args.append(OneMatrix(A.shape[0], B.shape[1]))\n factor *= A.shape[1]\n\n return newmul(factor, *new_args)","def __mul__(self, other):\n if isinstance(other, (int, float)):\n return Matrix([[self.values[row][index] * other\n for index in range(len(self.values[0]))]\n for row in range(len(self.values))])\n\n elif isinstance(other, Vector):\n return Vector([other.dot(Vector(row)) for row in self.values])\n\n elif isinstance(other, Matrix):\n return Matrix([(other.transpose() * Vector(row)).values\n for row in self.values])","def __mul__(self,other):\n # \n # 注意矩阵的A的列 与 相乘矩阵B的行必须相等，才能进行运算\n height = 0\n width = 0\n if isinstance(other, list): # 判断other是否是矩阵，即list形式的矩阵\n height = len(other)\n width = len(other[0])\n else:\n # 如果是对象，则直接获取行列值\n height = other.h\n width = other.w\n\n\n my_mul = zeroes(self.h, self.w)\n if self.w == height: # 两个矩阵的行列值需要相等 才能相乘\n for i in range(self.h):\n for j in range(width):\n my_sum = 0\n for k in range(height):\n if isinstance(other, list):\n my_sum += self.g[i][k] * other[k][j]\n # 通过3个循环变量取所有矩阵的行列值\n else:\n my_sum += self.g[i][k] * other.g[k][j]\n my_mul[i][j] = my_sum\n return my_mul \n else:\n return NotImplementedError","def calculate_matmul_n_times(n_components, mat_a, mat_b):\n res = np.zeros(mat_a.shape)\n mat_a = tf.cast(mat_a, tf.double)\n mat_b = tf.cast(mat_b, tf.double)\n for i in range(n_components):\n mat_a_i = tf.squeeze(mat_a[:, i, :, :], -2)\n mat_b_i = tf.squeeze(mat_b[0, i, :, :])\n res[:, i, :, :] = tf.expand_dims(tf.matmul(mat_a_i, mat_b_i), 1)\n\n return tf.convert_to_tensor(res)","def matmul(A, B):\n # type: (Optional[Tensor], Tensor) -> Tensor\n if A is None:\n return B\n if is_sparse(A):\n return torch.sparse.mm(A, B)\n return torch.matmul(A, B)","def matrix_add():","def __mul__(left, right):\n \n if isinstance(left, Plucker) and isinstance(right, Plucker):\n # reciprocal product\n return np.dot(left.uw, right.v) + np.dot(right.uw, left.v)\n elif isinstance(left, Plucker) and arg.ismatrix(right, (4,None)):\n return left.skew @ right; # postmultiply by 4xN","def __mul__(self, other):\n N = self.matrix.shape[1]\n\n if isinstance(other, _PysparseMatrix):\n return _PysparseMatrix(matrix=spmatrix.matrixmultiply(self.matrix, other.matrix))\n else:\n shape = numerix.shape(other)\n if shape == ():\n L = spmatrix.ll_mat(N, N, N)\n L.put(other * numerix.ones(N, 'l'))\n return _PysparseMatrix(matrix=spmatrix.matrixmultiply(self.matrix, L))\n elif shape == (N,):\n y = numerix.empty((self.matrix.shape[0],))\n self.matrix.matvec(other, y)\n return y\n else:\n raise TypeError","def my_matmul(x, y):\n ##\n cmd = getattr(th, \"matmul\")\n x1, x2 = my_cut(x)\n y1, y2 = my_cut(y)\n x2y1 = cmd(x2, y1)\n x1y2 = cmd(x1, y2)\n x2y2 = cmd(x2, y2)\n ret = (x2y1 + x1y2) % int24field * int24field + x2y2\n ret = int48module(ret)\n return ret","def Mult(self, *args):\n return _hypre.HypreParMatrix_Mult(self, *args)","def add_matrices(m1, m2): \n output = []\n \n for index in range(len(m1)):\n row_1 = m1[index]\n row_2 = m2[index]\n new_row = []\n for index2 in range(len(row_1)):\n sum = row_1[index2] + row_2[index2]\n new_row.append(sum)\n output.append(new_row)\n return output","def __mul__(self, other):\n if hasattr(other, 'as_homogenous_transformation'):\n return basis(homogenous_transformation = self.as_homogenous_transformation() * other.as_homogenous_transformation())\n elif hasattr(other, 'n'):\n if other.n == (3,1):\n b = matrix.col((other[0], other[1], other[2], 1))\n elif other.n == (4,1):\n b = other\n else:\n raise TypeError(b, \"Incompatible matrices\")\n p = self.as_homogenous_transformation() * b\n if other.n == (3,1):\n return matrix.col(p[0:3])\n else:\n return p\n else:\n raise TypeError(b)","def chain_matmul_square(As):\n\n As_matmul = As\n while As_matmul.shape[0] > 1:\n if As_matmul.shape[0] % 2:\n A_last = As_matmul[-1:]\n else:\n A_last = None\n \n As_matmul = torch.matmul(As_matmul[0:-1:2], As_matmul[1::2])\n if A_last is not None:\n As_matmul = torch.cat([As_matmul, A_last], dim=0)\n \n return As_matmul.squeeze(0)"],"string":"[\n \"def matrix_mult(m1, m2):\\n pass\",\n \"def Multiply(M1,M2):\\r\\n M3=[]\\r\\n w=0\\r\\n while w<len(M2[0]):\\r\\n tap=[]\\r\\n t=0\\r\\n while t<len(M2):\\r\\n tap.append(M2[t][w])\\r\\n t=t+1\\r\\n M3.append(tap)\\r\\n w=w+1\\r\\n M=[]\\r\\n # Multiplying matrices\\r\\n k=0\\r\\n sums=0\\r\\n while k<len(M1):\\r\\n j=0\\r\\n mpy=[]\\r\\n while j<len(M3):\\r\\n p=0\\r\\n sums=0\\r\\n while p<len(M3[j]):\\r\\n temp = (M1[k][p])*(M3[j][p])\\r\\n sums=sums+temp\\r\\n p=p+1\\r\\n mpy.append(sums)\\r\\n j=j+1\\r\\n M.append(mpy)\\r\\n k=k+1\\r\\n return M\",\n \"def multiply_matrices(a, b):\\n try:\\n x = len(b[0])\\n except:\\n b = make_2D(b)\\n try:\\n x = len(a[0])\\n except:\\n a = make_2D(a)\\n if len(a[0]) != len(b):\\n print 'error: matrices cannot be multiplied'\\n return\\n out = np.zeros((len(a), len(b[0])))\\n for i in range(len(out)):\\n for j in range(len(out[0])):\\n sum = 0\\n for k in range(len(a[i])):\\n sum += a[i][k] * b[k][j]\\n out[i][j] = sum\\n return out\",\n \"def mul(self,mat1,mat2):\\n if(isinstance(mat2,int)==True):\\n result = [[mat1[i][j] * mat2 for j in range(len(mat1[0]))] for i in range(len(mat1))]\\n self.out = result\\n return self.out\\n elif(len(mat1[0])==len(mat2)):\\n result = [[sum(a*b for a,b in zip(i,j)) for j in zip(*mat2)] for i in mat1]\\n self.out = result\\n return self.out\",\n \"def mat_mul(mat1, mat2):\\n\\n if len(mat1[0]) == len(mat2):\\n\\n mat2 = matrix_transpose(mat2)\\n response = []\\n\\n for row in range(len(mat1)):\\n response.append(\\n [\\n sum(dot_product(mat1[row], mat2[column]))\\n for column in range(len(mat2))\\n ]\\n )\\n\\n return response\\n\\n else:\\n return None\",\n \"def matMul(a, b):\\n sa=matShape(a)\\n sb=matShape(b)\\n if sa[1]!=sb[0]: raise ValueError\\n ret=matZeros((sa[0],sb[1]))\\n for i in range(sa[0]):\\n for j in range(sb[1]):\\n val=0.0\\n for k in range(sa[1]):\\n val+=matGet(a,i,k)*matGet(b,k,j)\\n matSet(ret,i,j,val)\\n return ret\",\n \"def __mul__(self,m):\\n if type(m) != Matrix:\\n raise TypeError('The second argument is not a matrix lol')\\n if self.ncols != m.nrows:\\n raise ValueError('matrix dot argument has incorrect number of rows')\\n new = Matrix(self.nrows,m.ncols)\\n columns = m.getCols()\\n rowindex = 0\\n colindex = 0 \\n for row in self.matrix:\\n colindex = 0 \\n for col in columns:\\n summ = 0\\n for i,j in zip(row,col):\\n summ+= i*j \\n new.matrix[rowindex][colindex] = summ\\n print new.matrix\\n colindex += 1 \\n rowindex+=1\\n return new\",\n \"def matrix_mult_matrix(matrix_a, matrix_b):\\n m = len(matrix_a)\\n n = len(matrix_b)\\n result = []\\n matrix_b_t = transpose_matrix(matrix_b)\\n for i in xrange(m):\\n row = []\\n\\tfor j in xrange(m):\\n row.append(dot_product(matrix_a[i], matrix_b_t[j]))\\n\\tresult.append(row)\\n return result\",\n \"def matmul(a, b):\\n raise NotImplementedError\",\n \"def lazy_matrix_mul(m_a, m_b):\\n return np.dot(m_a, m_b)\",\n \"def multiply_matrices(list):\\n # Section 1: Start matrix product using 1st matrix in list\\n matrix_product = list[0]\\n\\n # Section 2: Loop thru list to create product\\n for matrix in list[1:]:\\n matrix_product = matrix_multiply(matrix_product, matrix)\\n\\n return matrix_product\",\n \"def __matmul__(self, q: np.ndarray) -> np.ndarray:\\n return self.product(q)\",\n \"def lazy_matrix_mul(m_a, m_b):\\n m_a = np.array(m_a)\\n m_b = np.array(m_b)\\n\\n return m_a.dot(m_b)\",\n \"def mat_mul(mat1, mat2):\\n\\n rows1 = len(mat1)\\n cols1 = len(mat1[0])\\n rows2 = len(mat2)\\n cols2 = len(mat2[0])\\n\\n if cols1 != rows2:\\n return None\\n else:\\n new_matrix = []\\n for x in range(rows1):\\n aux_row = []\\n for y in range(cols2):\\n aux_sum = []\\n for z in range(cols1):\\n aux_sum.append(mat1[x][z] * mat2[z][y])\\n aux_row.append(sum(aux_sum))\\n new_matrix.append(aux_row)\\n\\n return new_matrix\",\n \"def __mul__(self, other):\\n # \\n # TODO - your code here\\n #\\n \\n result = [];\\n row_result = [];\\n product = 0;\\n \\n if(self.w != other.h):\\n raise(ValueError, \\\"Matrices can not multiply for their dimesion doesn't match\\\"); \\n \\n for row in self.g:\\n row_result = [];\\n for j in range(other.w):\\n product = dot_product(row,other.get_column(j));\\n row_result.append(product);\\n result.append(row_result);\\n \\n return Matrix(result);\",\n \"def matrix_mult(m1, m2):\\n output = []\\n for rowIndex, row in enumerate(m1): #go through rows in m1\\n new_row = []\\n for columnIndex in range(len(m2[0])): #go through indices for each column of m2\\n sum = 0\\n for index3 in range(len(row)):\\n product = m1[rowIndex][index3] * m2[index3][columnIndex]\\n sum += product\\n new_row.append(sum)\\n output.append(new_row)\\n return output\\n \\n \\n #output = []\\n #first for loop corresponds to the rows of my output matrix and loops through the rows of m1 (enumerate)\\n #create an empty new row\\n # second for loop, loops through columns of m2\\n # create sum variable, initialize it with zero\\n # third for loop, multiplies the index of the row in m1 times the index of the column in m2\\n # add sum to product and assign this to the sum variable\\n # append sum to new row\\n # append new row to output\\n # return output\",\n \"def __mul__(self, other):\\n if self.n != other.m:\\n raise TypeError(\\\"Illegal dimensions for mul operator\\\")\\n tmp = [[0 for _ in xrange(self.n)] for _ in xrange(other.m)]\\n for i in xrange(self.n):\\n for j in xrange(other.m):\\n for k in xrange(other.n):\\n tmp[i][j] += self.values[i][k] * other.values[k][j]\\n res = []\\n for i in tmp:\\n res += i\\n return simplematrix(self.n, other.m, res)\",\n \"def matrix_mult(m1, m2):\\n\\ttemp = []\\n\\tfor i in range(len(m1)):\\n\\t\\te = []\\n\\t\\tfor j in range(len(m2[0])):\\n\\t\\t\\te.append(row_times_column(m1,i,m2,j))\\n\\t\\ttemp.append(e)\\n\\treturn temp\",\n \"def matrixMul(self, matrix, matrix2):\\n matrix0 = matrix[:]\\n matrix[0] = matrix0[0] * matrix2[0] + matrix0[2]*matrix2[1] # + matrix0[4]*0\\n matrix[1] = matrix0[1] * matrix2[0] + matrix0[3]*matrix2[1] # + matrix0[5]*0\\n matrix[2] = matrix0[0] * matrix2[2] + matrix0[2]*matrix2[3] # + matrix0[4]*0\\n matrix[3] = matrix0[1] * matrix2[2] + matrix0[3]*matrix2[3] # + matrix0[5]*0\\n matrix[4] = matrix0[0] * matrix2[4] + matrix0[2]*matrix2[5] + matrix0[4]\\n matrix[5] = matrix0[1] * matrix2[4] + matrix0[3]*matrix2[5] + matrix0[5]\",\n \"def lazy_matrix_mul(m_a, m_b):\\n return np.matmul(np.array(m_a), np.array(m_b))\",\n \"def multiM(*args):\\r\\n filas_1,filas_2 = len(args[0]),len(args[1])\\r\\n columnas_1,columnas_2 = len(args[0][0]),len(args[1][0])\\r\\n matriz_r = []\\r\\n for k in range(filas_1):\\r\\n matriz_r.append([0]*columnas_2)\\r\\n for i in range(columnas_2):\\r\\n matriz_r[k][i] = 0\\r\\n for i in range(filas_1):\\r\\n for j in range(columnas_1):\\r\\n for k in range(columnas_2):\\r\\n matriz_r[i][k] = matriz_r[i][k] + args[0][i][j] * args[1][j][k]\\r\\n return matriz_r\",\n \"def matrixMultiply(a, colsA, b, colsB):\\r\\n\\trowsA = len(a)\\r\\n\\trowsB = len(b)\\r\\n\\r\\n\\t# rowsA x colsA ... rowsB x colsB \\r\\n\\tassert rowsA == colsB, \\\"matrix dimensions not fit for multiplication\\\"\\r\\n\\r\\n\\t# result size: rowsA x colsB\\r\\n\\tr = rowsA * [None]\\r\\n\\tfor i in range(rowsA):\\r\\n\\t\\tr[i] = colsB * [None]\\r\\n\\t\\tfor j in range(colsB):\\r\\n\\t\\t\\t\\tr[i][j] = sum( a[i][k]* b[k][j] for k in range(colsA))\\r\\n\\treturn r\",\n \"def __mul__(self, other):\\n #\\n # TODO - your code here\\n #\\n final_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(other.w):\\n # take dot-product of row of\\n # matrix in 1st arg with col of\\n # matrix in 2nd arg\\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\\n final_matrix.append(temp_row)\\n return Matrix(final_matrix)\\n # TODO - your code here\",\n \"def matrix_mul(m_a, m_b):\\n rows_a = 0\\n cols_a = 0\\n rows_b = 0\\n cols_b = 0\\n if type(m_a) is not list:\\n raise TypeError(\\\"m_a must be a list\\\")\\n if type(m_b) is not list:\\n raise TypeError(\\\"m_b must be a list\\\")\\n length = []\\n for row in m_a:\\n if type(row) is not list:\\n raise TypeError(\\\"m_a must be a list of lists\\\")\\n for row in m_b:\\n if type(row) is not list:\\n raise TypeError(\\\"m_b must be a list of lists\\\")\\n if m_a == [] or m_a == [[]]:\\n raise ValueError(\\\"m_a can't be empty\\\")\\n if m_b == [] or m_b == [[]]:\\n raise ValueError(\\\"m_b can't be empty\\\")\\n for row in m_a:\\n cols_a = 0\\n for elem in row:\\n if type(elem) is not int and type(elem) is not float:\\n raise TypeError(\\\"m_a should contain only integers or floats\\\")\\n cols_a += 1\\n for row in m_b:\\n cols_b = 0\\n for elem in row:\\n if type(elem) is not int and type(elem) is not float:\\n raise TypeError(\\\"m_b should contain only integers or floats\\\")\\n cols_b += 1\\n for row in m_a:\\n length.append(len(row))\\n rows_a += 1\\n if not len(set(length)) <= 1:\\n raise TypeError(\\\"each row of m_a must be of the same size\\\")\\n length.clear()\\n for row in m_b:\\n length.append(len(row))\\n rows_b += 1\\n if not len(set(length)) <= 1:\\n raise TypeError(\\\"each row of m_b must be of the same size\\\")\\n if cols_a != rows_b:\\n raise ValueError(\\\"m_a and m_b can't be multiplied\\\")\\n new = [[0 for i in range(cols_b)] for j in range(rows_a)]\\n for new_rows in range(rows_a):\\n for new_cols in range(cols_b):\\n for i in range(cols_a):\\n new[new_rows][new_cols] += m_a[new_rows][i] * m_b[i][new_cols]\\n return new\",\n \"def mmultiply(self, matrix):\\n try:\\n result_matrix = [[0 for row in range(len(self.matrix))] for col in range(len(matrix[0]))]\\n for i in range(len(self.matrix)):\\n for j in range(len(matrix[0])):\\n for k in range(len(matrix)):\\n result_matrix[i][j] += self.matrix[i][k] * matrix[k][j]\\n self.matrix = result_matrix\\n except IndexError:\\n pass\\n pass\",\n \"def np_matmul(mat1, mat2):\\n return np.matmul(mat1, mat2)\",\n \"def matrix_multiply(m1, m2):\\n\\n\\tproduct = numpy.matmul(m1, m2)\\n\\tif type(product) == numpy.int64:\\n\\t\\treturn float(product)\\n\\telse:\\n\\t\\tresult = list(product)\\n\\t\\treturn result\",\n \"def matrix_mult(A,B):\\n\\n m = len(A)\\n p = len(B)\\n n = len(B[0])\\n AB = []\\n for i in range(m):\\n AB.append([])\\n for j in range(n):\\n total = 0\\n for k in range(p):\\n total += A[i][k] * B[k][j]\\n AB[i].append(total)\\n return AB\",\n \"def __matmul__(self, B):\\n m, n = self.shape\\n n_, r = B.shape\\n assert n == n_, (\\\"Cannot multiply shapes \\\"\\n \\\"({}, {}) and ({}, {})\\\".format(m, n, n_, r))\\n mul_ = dict()\\n # compute A_ik = sum_j A_ij*B_jk\\n for i in range(m):\\n for k in range(r):\\n prod = mpfr(0)\\n for j in range(n):\\n prod += self[i, j] * B[j, k]\\n mul_[i, k] = prod\\n return MPMatrix((m, r), mul_)\",\n \"def matrixMultiplication(firstMatrix, secondMatrix):\\n if len(firstMatrix[0]) == len(secondMatrix): # Checks whether the matrices can be multiplied or not or not\\n finalMatrix = []\\n for y in range(len(firstMatrix)): # 2\\n currentMatrix = []\\n for i in range(len(secondMatrix[0])):\\n currentSum = 0\\n for j in range(len(secondMatrix)):\\n currentSum += secondMatrix[j][i] * firstMatrix[y][j]\\n currentMatrix.append(currentSum)\\n print(\\\"This is my current matrix: \\\" + str(currentMatrix))\\n finalMatrix.append(currentMatrix)\\n print(\\\"This product of the two matrices is :) \\\" + str(finalMatrix))\\n else:\\n print(\\\"This operation cannot be done, make sure the rows of the first matrix is the same as the number of columns in the second matrix\\\")\",\n \"def matrix_multiply(self, Am, Bm):\\r\\n # Section 1: Ensure A & B dimensions are correct for multiplication\\r\\n rowsA = len(Am)\\r\\n colsA = len(Am[0])\\r\\n rowsB = len(Bm)\\r\\n colsB = len(Bm[0])\\r\\n if colsA != rowsB:\\r\\n raise ArithmeticError(\\r\\n 'Number of A columns must equal number of B rows.')\\r\\n \\r\\n # Section 2: Store matrix multiplication in a new matrix\\r\\n C = self.zeros_matrix(rowsA, colsB)\\r\\n for i in range(rowsA):\\r\\n for j in range(colsB):\\r\\n total = 0\\r\\n for ii in range(colsA):\\r\\n total += Am[i][ii] * Bm[ii][j]\\r\\n C[i][j] = total\\r\\n \\r\\n return C\",\n \"def matmul():\\n\\n if RESULT_IN_NVRAM:\\n matrix_c = ResultMatrixInDaos()\\n else:\\n matrix_c = ResultMatrixInMemory()\\n\\n # This could be trivially optimized by reordering indexes\\n # and caching either a_block or b_block (assuming C in-memory).\\n # *However* it would result in unfair comparisons with the \\n # previous implementation used elsewhere.\\n # Using the naive algorithm makes sense for a raw comparison.\\n for i in range(MATRIXSIZE):\\n for j in range(MATRIXSIZE):\\n partial_result_block = np.zeros((BLOCKSIZE, BLOCKSIZE))\\n\\n for k in range(MATRIXSIZE):\\n a_block = np.fromstring(\\n DAOS_KV[\\\"A%02d%02d\\\" % (i, k)],\\n dtype=NP_FROMSTRING_DTYPE\\n ).reshape((BLOCKSIZE, BLOCKSIZE))\\n\\n b_block = np.fromstring(\\n DAOS_KV[\\\"B%02d%02d\\\" % (k, j)],\\n dtype=NP_FROMSTRING_DTYPE\\n ).reshape((BLOCKSIZE, BLOCKSIZE))\\n\\n partial_result_block += a_block @ b_block\\n \\n matrix_c[i,j] = partial_result_block\\n\\n return matrix_c\",\n \"def matrix_multiply(A,B):\\n rowsA = len(A)\\n colsA = len(A[0])\\n\\n rowsB = len(B)\\n colsB = len(B[0])\\n\\n if colsA != rowsB:\\n raise ArithmeticError('Number of A columns must equal number of B rows.')\\n\\n C = zeros_matrix(rowsA, colsB)\\n\\n for i in range(rowsA):\\n for j in range(colsB):\\n total = 0\\n for ii in range(colsA):\\n total += A[i][ii] * B[ii][j]\\n C[i][j] = total\\n\\n return C\",\n \"def _mul(*args):\\n\\treturn functools.reduce(numpy.dot, args)\",\n \"def matrixMultiplication(self, n, id, context):\\n\\n print(\\\"id: {}\\\".format(id))\\n # Create one matrix\\n f = 1\\n m1 = []\\n for x in range(n):\\n row = []\\n for y in range(n):\\n row.append(f)\\n f = f + 1\\n m1.append(row)\\n # The second matrix is equal to the first matrix\\n m2 = m1\\n print(\\\"m2: {}\\\".format(m2))\\n\\n # Multiply matrices\\n m3 = []\\n for i in range(n):\\n row = []\\n for j in range(n):\\n sum = 0\\n for k in range(n):\\n sum = sum + m1[i][k] * m2[k][j]\\n row.append(sum)\\n m3.append(row)\\n\\n sum = 0\\n # add the entries\\n for i in range(n):\\n for j in range(n):\\n sum = sum + m3[i][j]\\n\\n print(\\\"Result of multiplication is {}\\\".format(sum))\\n return sum\",\n \"def matrix_mul(m_a, m_b):\\n if not isinstance(m_a, list):\\n raise TypeError(\\\"m_a must be a list\\\")\\n if not isinstance(m_b, list):\\n raise TypeError(\\\"m_b must be a list\\\")\\n if len(list(filter(lambda i: not isinstance(i, list), m_a))) > 0:\\n raise TypeError(\\\"m_a must be a list of lists\\\")\\n if len(list(filter(lambda i: not isinstance(i, list), m_b))) > 0:\\n raise TypeError(\\\"m_b must be a list of lists\\\")\\n if m_a is None or m_a == [] or m_a == [[]]:\\n raise ValueError(\\\"m_a can't be empty\\\")\\n if m_b is None or m_b == [] or m_b == [[]]:\\n raise ValueError(\\\"m_b can't be empty\\\")\\n for r in m_a:\\n for v in r:\\n if not isinstance(v, (int, float)):\\n raise ValueError(\\\"m_a should contain only integers or floats\\\")\\n for r in m_b:\\n for v in r:\\n if not isinstance(v, (int, float)):\\n raise ValueError(\\\"m_b should contain only integers or floats\\\")\\n if max(map(lambda i: len(i), m_a)) != min(map(lambda i: len(i), m_a)):\\n raise TypeError(\\\"each row of m_a must be of the same size\\\")\\n if max(map(lambda i: len(i), m_b)) != min(map(lambda i: len(i), m_b)):\\n raise TypeError(\\\"each row of m_b must be of the same size\\\")\\n try:\\n w = (len(m_a) + (0, 1)[len(m_a) == 1])\\n m_c = [(['x'] * w) for b in range(len(m_b[0]))]\\n for i in range(len(m_a)):\\n for j in range(len(m_b[0])):\\n s = 0\\n for k in range(len(m_a[0])):\\n s += (m_a[i][k] * m_b[k][j])\\n m_c[i][j] = s\\n return list(filter(lambda r: r != (['x'] * w), m_c))\\n except:\\n raise ValueError(\\\"m_a and m_b can't be multiplied\\\")\",\n \"def lazy_matrix_mul(m_a, m_b):\\n return (np.matmul(m_a, m_b))\",\n \"def matrixMult( self, matrix0, matrix1 ):\\r\\n result = {}\\r\\n keys = sorted( set( matrix0.keys() ) )\\r\\n count = range( len( matrix0.keys() ) )\\r\\n \\r\\n for key in keys:\\r\\n result[ key ] = []\\r\\n for i in count:\\r\\n sum = 0\\r\\n for j in count:\\r\\n sum += matrix0[ key ][j] * matrix1[ keys[j] ][i]\\r\\n result[ key ].insert( i, sum )\\r\\n \\r\\n return result\",\n \"def multiply(a, b):\\n columns_of_a = len(a[0])\\n lines_of_b = len(b)\\n if columns_of_a != lines_of_b:\\n # Check matrix dimensions\\n print \\\"Incompatible sizes!\\\"\\n else:\\n lines_of_a = len(a)\\n columns_of_b = len(b[0])\\n #C = []\\n #for i in range (lines_of_a):\\n # C.append(columns_of_b * [0])\\n c = [columns_of_b * [0] for i in range(lines_of_a)]\\n for i in range(lines_of_a):\\n for j in range(columns_of_b):\\n for k in range(lines_of_b):\\n c[i][j] += a[i][k] * b[k][j]\\n return c\",\n \"def matmul(xs: List[List[float]],\\n ys: List[List[float]]) -> List[List[float]]:\\n product = []\\n for x_row in range(len(xs)):\\n row = []\\n for y_col in range(len(ys[0])):\\n col = [ys[y_row][y_col] for y_row in range(len(ys))]\\n row.append(Math.dot(xs[x_row], col))\\n product.append(row)\\n return product\",\n \"def multiply_matrices(A, B):\\n # Section 1: Ensure A & B dimensions are correct for multiplication\\n rowsA = len(A)\\n colsA = len(A[0])\\n rowsB = len(B)\\n colsB = len(B[0])\\n if colsA != rowsB:\\n raise ArithmeticError(\\n 'Number of A columns must equal number of B rows.')\\n\\n # Section 2: Store matrix multiplication in a new matrix\\n C = zeros_matrix(rowsA, colsB)\\n for i in range(rowsA):\\n for j in range(colsB):\\n total = 0\\n for ii in range(colsA):\\n total += A[i][ii] * B[ii][j]\\n C[i][j] = total\\n\\n return C\",\n \"def matrix_mult(M, vector1, vector2):\\n out = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return out\",\n \"def matrix_mult(M, vector1, vector2):\\n out = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return out\",\n \"def matrix_mul(m_a, m_b):\\n if not isinstance(m_a, list):\\n raise TypeError(\\\"m_a must be a list\\\")\\n if not isinstance(m_b, list):\\n raise TypeError(\\\"m_b must be a list\\\")\\n if not all(isinstance(lst, list) for lst in m_a):\\n raise TypeError(\\\"m_a must be a list of lists\\\")\\n if not all(isinstance(lst, list) for lst in m_b):\\n raise TypeError(\\\"m_b must be a list of lists\\\")\\n if m_a in [[], [[]]]:\\n raise ValueError(\\\"m_a can't be empty\\\")\\n if m_b in [[], [[]]]:\\n raise ValueError(\\\"m_b can't be empty\\\")\\n if not all(all(isinstance(i, (int, float)) for i in lst) for lst in m_a):\\n raise TypeError(\\\"m_a should contain only integers or floats\\\")\\n if not all(all(isinstance(i, (int, float)) for i in lst) for lst in m_b):\\n raise TypeError(\\\"m_b should contain only integers or floats\\\")\\n if not all(len(i) == len(m_a[0]) for i in m_a):\\n raise TypeError(\\\"each row of m_a must be of the same size\\\")\\n if not all(len(i) == len(m_b[0]) for i in m_b):\\n raise TypeError(\\\"each row of m_b must be of the same size\\\")\\n if not len(m_a[0]) == len(m_b):\\n raise ValueError(\\\"m_a and m_b can't be multiplied\\\")\\n new_matrix = [[0 for i in m_b[0]] for j in m_a]\\n for i in range(len(m_a)):\\n for j in range(len(m_b[0])):\\n for k in range(len(m_b)):\\n new_matrix[i][j] += m_a[i][k] * m_b[k][j]\\n return new_matrix\",\n \"def np_matmul(mat1, mat2):\\n return mat1.dot(mat2)\",\n \"def matmul(x, y):\\n return np.matmul(x, y)\",\n \"def MultiplyMatrix(matrixA, matrixB):\\r\\n # result matrix initialized as singularity matrix\\r\\n result = [[0 for y in range(len(matrixB[0]))] for x in range(len(matrixA))]\\r\\n for i in range(len(matrixA)):\\r\\n # iterate through columns of Y\\r\\n for j in range(len(matrixB[0])):\\r\\n # iterate through rows of Y\\r\\n for k in range(len(matrixB)):\\r\\n result[i][j] += matrixA[i][k] * matrixB[k][j]\\r\\n return result\",\n \"def _multi_matmul(arrays, order, i, j, constant=False) -> Tensor:\\n if i == j:\\n return arrays[i]\\n else:\\n return matmul(\\n _multi_matmul(arrays, order, i, order[i, j], constant),\\n _multi_matmul(arrays, order, order[i, j] + 1, j, constant),\\n constant,\\n )\",\n \"def __mul__(self, other):\\r\\n T = type(other)\\r\\n # mat4*scalar\\r\\n if T==types.FloatType or T==types.IntType or T==types.LongType:\\r\\n return mat4(map(lambda x,other=other: x*other, self.mlist))\\r\\n # mat4*vec3\\r\\n if isinstance(other, _vec3):\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n w = float(m41*other.x + m42*other.y + m43*other.z + m44)\\r\\n return _vec3(m11*other.x + m12*other.y + m13*other.z + m14, \\r\\n m21*other.x + m22*other.y + m23*other.z + m24, \\r\\n m31*other.x + m32*other.y + m33*other.z + m34)/w\\r\\n # mat4*vec4\\r\\n if isinstance(other, _vec4):\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n return _vec4(m11*other.x + m12*other.y + m13*other.z + m14*other.w, \\r\\n m21*other.x + m22*other.y + m23*other.z + m24*other.w, \\r\\n m31*other.x + m32*other.y + m33*other.z + m34*other.w,\\r\\n m41*other.x + m42*other.y + m43*other.z + m44*other.w)\\r\\n # mat4*mat4\\r\\n if isinstance(other, mat4):\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n n11,n12,n13,n14,n21,n22,n23,n24,n31,n32,n33,n34,n41,n42,n43,n44 = other.mlist\\r\\n return mat4( m11*n11+m12*n21+m13*n31+m14*n41,\\r\\n m11*n12+m12*n22+m13*n32+m14*n42,\\r\\n m11*n13+m12*n23+m13*n33+m14*n43,\\r\\n m11*n14+m12*n24+m13*n34+m14*n44,\\r\\n\\r\\n m21*n11+m22*n21+m23*n31+m24*n41,\\r\\n m21*n12+m22*n22+m23*n32+m24*n42,\\r\\n m21*n13+m22*n23+m23*n33+m24*n43,\\r\\n m21*n14+m22*n24+m23*n34+m24*n44,\\r\\n\\r\\n m31*n11+m32*n21+m33*n31+m34*n41,\\r\\n m31*n12+m32*n22+m33*n32+m34*n42,\\r\\n m31*n13+m32*n23+m33*n33+m34*n43,\\r\\n m31*n14+m32*n24+m33*n34+m34*n44,\\r\\n\\r\\n m41*n11+m42*n21+m43*n31+m44*n41,\\r\\n m41*n12+m42*n22+m43*n32+m44*n42,\\r\\n m41*n13+m42*n23+m43*n33+m44*n43,\\r\\n m41*n14+m42*n24+m43*n34+m44*n44)\\r\\n # unsupported\\r\\n else:\\r\\n raise TypeError, \\\"unsupported operand type for *\\\"\",\n \"def Mult(A, B, C_, IM, M):\\n for i in range(M):\\n for j in range(M):\\n for k in range(M):\\n C_[i, j] = A[i, j] * B[i, j]\",\n \"def matmul(A, B):\\n\\n A._check('*', B, A.shape[1], B.shape[0])\\n return A.from_rep(A.rep.matmul(B.rep))\",\n \"def matrixMul(a, b):\\n # Initializing Empty Matrix\\n c = [[0, 0], [0, 0]]\\n # 2x2 matrix multiplication. Essentially O(1)\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n c[i][j] = (c[i][j] + (a[i][k] * b[k][j]))\\n\\n # Returning the products\\n return c\",\n \"def mult(m1, m2):\\n assert np.shape(m1) == (2, 3)\\n assert np.shape(m2) == (2, 3)\\n\\n m1_temp = np.vstack((m1, [0, 0, 1]))\\n m2_temp = np.vstack((m2, [0, 0, 1]))\\n result = m1_temp * m2_temp\\n\\n return result[:2, :]\",\n \"def recursive_multiply(a, b):\\n if len(a) == 2:\\n return naive_multiply(a, b)\\n\\n a11 = a[0:int(len(a) / 2)]\\n for index, row in enumerate(a11):\\n a11[index] = row[0:int(len(row) / 2)]\\n\\n a12 = a[0:int(len(a) / 2)]\\n for index, row in enumerate(a12):\\n a12[index] = row[int(len(a) / 2):len(a)]\\n\\n a21 = a[int(len(a) / 2):len(a)]\\n for index, row in enumerate(a21):\\n a21[index] = row[0:int(len(row) / 2)]\\n\\n a22 = a[int(len(a) / 2):len(a)]\\n for index, row in enumerate(a22):\\n a22[index] = row[int(len(a) / 2):len(a)]\\n\\n b11 = b[0:int(len(b) / 2)]\\n for index, row in enumerate(b11):\\n b11[index] = row[0:int(len(row) / 2)]\\n\\n b12 = b[0:int(len(b) / 2)]\\n for index, row in enumerate(b12):\\n b12[index] = row[int(len(b) / 2):len(b)]\\n\\n b21 = b[int(len(b) / 2):len(b)]\\n for index, row in enumerate(b21):\\n b21[index] = row[0:int(len(row) / 2)]\\n\\n b22 = b[int(len(b) / 2):len(b)]\\n for index, row in enumerate(b22):\\n b22[index] = row[int(len(b) / 2):len(b)]\\n\\n c11 = matrix_add(recursive_multiply(a11, b11), recursive_multiply(a12, b21)) # C11 = A11*B11 + A12*B21\\n c12 = matrix_add(recursive_multiply(a11, b12), recursive_multiply(a12, b22)) # C12 = A11*B12 + A12*B22\\n c21 = matrix_add(recursive_multiply(a21, b11), recursive_multiply(a22, b21)) # C21 = A21*B11 + A22*B21\\n c22 = matrix_add(recursive_multiply(a21, b12), recursive_multiply(a22, b22)) # C22 = A21*B12 + A22*B22\\n\\n # Append c12 to c11\\n for row_index, row in enumerate(c11):\\n for col_index, col in enumerate(c12):\\n row.append(c12[row_index][col_index])\\n\\n # Append c22 to c21\\n for row_index, row in enumerate(c21):\\n for col_index, col in enumerate(c12):\\n row.append(c22[row_index][col_index])\\n\\n # Append c21 to c11\\n for i in c21:\\n c11.append(i)\\n\\n return c11\",\n \"def matrix_multiply(A, B):\\n # Section 1: Ensure A & B dimensions are correct for multiplication\\n rowsA = len(A); colsA = len(A[0])\\n rowsB = len(B); colsB = len(B[0])\\n if colsA != rowsB:\\n raise ArithmeticError(\\n 'Number of A columns must equal number of B rows.')\\n\\n # Section 2: Store matrix multiplication in a new matrix\\n C = zeros_matrix(rowsA, colsB)\\n for i in range(rowsA):\\n for j in range(colsB):\\n total = 0\\n for ii in range(colsA):\\n total += A[i][ii] * B[ii][j]\\n C[i][j] = total\\n\\n return C\",\n \"def square_matrix_multiply(a, b):\\n n = len(a)\\n c = [[0]*n for _ in range(n)]\\n for i in range(n):\\n for j in range(n):\\n sm = 0\\n for k in range(n):\\n sm += (a[i][k] * b[k][j])\\n c[i][j] = sm\\n\\n return c\",\n \"def multiply(A, B):\\n\\n if len(A[0]) != len(B):\\n raise Exception(\\\"Matrix dimensions do not match for matrix multiplication: %d x %d and %d x %d\\\" % (len(A), len(A[0]), len(B), len(B[0])))\\n\\n result = [[0] * len(B[0]) for i in range(len(A))]\\n\\n for i in range(len(A)):\\n for j in range(len(B[0])):\\n\\n result[i][j] = LinAl.dot(A[i], LinAl.transpose(B)[j])\\n\\n return result\",\n \"def matrix_product(mat1: List[List[int]], mat2: List[List[int]]):\\n if len(mat1) == 0 or len(mat2) == 0:\\n raise ValueError(\\\"One of matrix is empty\\\")\\n n, k1 = len(mat1), len(mat1[0])\\n k2, m = len(mat2), len(mat2[0])\\n if k1 != k2:\\n raise ValueError(\\n f\\\"Can't multiply two matrices with shapes {n}x{k1} and {k2}x{m}\\\"\\n )\\n mat2_t = matrix_transpose(mat2)\\n return [[vec_product(vec1, vec2) for vec2 in mat2_t] for vec1 in mat1]\",\n \"def __mul__(self, other):\\n\\n # Scalar multiplication\\n if isinstance(other, (int, long, float, complex)):\\n return Matrix(self.rows, self.columns, [other * x for x in self.data])\\n\\n if not issubclass(type(other), Matrix):\\n raise TypeError(type(other))\\n\\n if self.columns != other.rows:\\n raise ValueError(\\\"Undefined multiplication for these matrices\\\")\\n\\n result = []\\n for i in range(1, self.rows + 1):\\n row = self.row(i)\\n result.extend([dot_product(row, other.column(j)) for j in range(1, other.columns + 1)])\\n\\n return Matrix(self.rows, other.columns, data = result)\",\n \"def __matmul__(self, other):\\n return F.MatMul.apply(self, other)\",\n \"def __mul__(self, other):\\n if isinstance(other, Vector):\\n # Matrix vector product\\n v = Vector(list())\\n for n in range(len(other.vectors)):\\n v += scale(other.vectors[n][n], self.vectors[n])\\n return v\\n elif isinstance(other, Matrix):\\n # Matrix matrix product\\n if self.n != other.m:\\n raise ValueError(\\\"Wrong fucking sizes, nøøb\\\")\\n\\n selfVectors = self.vectors\\n selfColVectors = self.transpose()\\n otherVectors = other.vectors\\n otherColVectors = other.transpose()\\n vectors = list()\\n for col in range(other.n):\\n cordinator = []\\n\\n for row in range(self.m):\\n coord = 0\\n\\n for k in range(other.m):\\n coord += (\\n selfVectors[row].coords[k]\\n * otherColVectors.vectors[col].coords[k]\\n )\\n\\n cordinator.append(coord)\\n\\n v = Vector(cordinator)\\n vectors.append(v)\\n matrix = Matrix(vectors)\\n matrix = matrix.transpose()\\n return matrix\\n elif isinstance(other, int) or isinstance(other, float): # Skalering af matrix\\n for i in range(len(self.vectors)):\\n self.vectors[i] *= other\\n else:\\n raise ValueError(\\n \\\"Can only multiply Matrix with Matrix, Vector, Integer or Float\\\"\\n )\",\n \"def calculate_matmul(mat_a, mat_b):\\n assert mat_a.shape[-2] == 1 and mat_b.shape[-1] == 1\\n return tf.reduce_sum(tf.squeeze(mat_a, -2) * tf.squeeze(mat_b, -1), axis=2, keepdims=True)\",\n \"def __mul__(self, other):\\n return Matrix3(\\n self.i * other,\\n self.j * other,\\n self.k * other,\\n )\",\n \"def _matmult(A, x):\\n b = []\\n for a in A:\\n b.append(sum([ai * xi for ai, xi in zip(a, x)]))\\n return b\",\n \"def __mul__(self, otherMatrix):\\n if not (len(self.array[0]) == len(otherMatrix.array)):\\n raise ArithmeticError\\n\\n common = len(self.array[0])\\n X = len(self.array)\\n Y = len(otherMatrix.array[0])\\n newArray = [[0 for x in range(X)] for x in range(Y)]\\n\\n for row in range(X):\\n for col in range(Y):\\n for elem in range(common):\\n newArray[row][col] += self.array[row][elem] * otherMatrix.array[elem][col]\\n\\n\\n return matrix(newArray)\",\n \"def matrix_multiply(x, y):\\r\\n\\r\\n # handle the base case of receiving\\r\\n # two empty matrices\\r\\n if x == [] and y == []:\\r\\n return []\\r\\n\\r\\n # determine the number of rows and columns in the result matrix\\r\\n num_rows = len(x)\\r\\n num_cols = len(y[0])\\r\\n\\r\\n num_cross = len(x[0])\\r\\n\\r\\n # initialize the result matrix\\r\\n result_matrix = [[0] * num_cols for _ in xrange(num_rows)]\\r\\n\\r\\n # compute the values for each cell of the result\\r\\n # matrix\\r\\n for row_index in xrange(num_rows):\\r\\n for col_index in xrange(num_cols):\\r\\n\\r\\n # sum up the corresponding values from\\r\\n # x and y\\r\\n for multiplication_index in xrange(num_cross):\\r\\n\\r\\n x_value = x[row_index][multiplication_index]\\r\\n y_value = y[multiplication_index][col_index]\\r\\n\\r\\n result_matrix[row_index][col_index] += x_value * y_value\\r\\n\\r\\n return result_matrix\",\n \"def __mul__(self, other):\\n if isinstance(other, (int, float)):\\n newmat = make_matrix(self.rows, self.cols)\\n for i in range(newmat.rows):\\n for j in range(newmat.cols):\\n newmat[i, j] = self[i, j] * other\\n elif isinstance(other, Matrix):\\n if self.cols != other.rows:\\n raise IndexError(\\\"Row/column mismatch: (%i, %i) x (%i, %i)\\\"%\\n (self.rows, self.cols, other.rows, other.cols))\\n\\n newmat = make_matrix(self.rows, other.cols)\\n\\n for i in range(newmat.rows):\\n for j in range(newmat.cols):\\n for k in range(self.cols):\\n newmat[i, j] += self[i, k] * other[k, j]\\n return newmat\",\n \"def multiplication(self):\\n try:\\n multiplication = self.matrix1 * self.matrix2\\n except Exception as e:\\n return \\\"Error: {}\\\".format(e)\\n\\n return multiplication\",\n \"def matrix_dot(*args):\\r\\n rval = args[0]\\r\\n for a in args[1:]:\\r\\n rval = theano.tensor.dot(rval, a)\\r\\n return rval\",\n \"def __matmul__(self, tensor):\\n return self.matmul(tensor)\",\n \"def multiply(A, B, *args, **kwargs):\\n dim=A.__len__()\\n assert(dim==B.__len__())\\n C=[]\\n for ii in range(dim):\\n shape=(A[ii].shape[0]*B[ii].shape[0], A[ii].shape[1])\\n val=np.empty(shape)\\n for iimn, (mm, nn) in enumerate(itertools.product(list(range(A[ii].shape[0])), list(range(B[ii].shape[0])))):\\n val[iimn] = A[ii][mm]*B[ii][nn]\\n C.append(val)\\n return C\",\n \"def matrix_multiplication_loop(x_matrix, y_matrix):\\n result = []\\n for i, row in enumerate(x_matrix):\\n row_vector = []\\n for j in range(len(y_matrix[0])):\\n product = 0\\n for k in range(len(row)):\\n product += x_matrix[i][k] * y_matrix[k][j]\\n row_vector.append(product)\\n result.append(row_vector)\\n return result\",\n \"def matr_prod(_A, _B):\\r\\n # Matrix multiplication\\r\\n B0 = _B[0]\\r\\n lenB = len(_B)\\r\\n lenA = len(_A)\\r\\n if(len(_A[0]) != lenB): # Check matrix dimensions \\r\\n Exception('Matrices have wrong dimensions')\\r\\n if(isinstance(B0, list) or isinstance(B0, array) or isinstance(B0, tuple)): #_B is matrix\\r\\n lenB0 = len(B0)\\r\\n C = [[0 for row in range(lenB0)] for col in range(lenA)]\\r\\n for i in range(lenA):\\r\\n for j in range(lenB0):\\r\\n for k in range(lenB):\\r\\n C[i][j] += _A[i][k]*_B[k][j]\\r\\n else: #_B is vector\\r\\n C = [0 for row in range(lenB)]\\r\\n for i in range(lenA):\\r\\n for k in range(lenB):\\r\\n C[i] += _A[i][k]*_B[k]\\r\\n return C\",\n \"def __matmul__(self, csys):\\n self._transform(csys)\\n return self\",\n \"def StrassenMatrixM(a, b):\\r\\n if len(a) != 2 or len(a[0]) != 2 or len(b) != 2 or len(b[0]) != 2:\\r\\n raise Exception('Matrices should be 2x2!')\\r\\n print(a[0][0] * b[0][1] + a[0][1] * b[1][1])\\r\\n matrix = [[a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],\\r\\n [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]]]\\r\\n\\r\\n return matrix\",\n \"def transforms_multiply(t0s, t1s):\\r\\n \\r\\n return ut.matrix_multiply(t0s, t1s)\",\n \"def __mul__(self, other):\\n if not isinstance(other, Matrix):\\n return NotImplemented\\n\\n if self.num_cols != other.num_rows:\\n raise ValueError(\\\"self.num_cols (%d) != other.num_rows (%d)\\\" % (self.num_cols, other.num_cols))\\n\\n new_mat = Matrix(self.num_rows, other.num_cols)\\n\\n # iterate through rows of self\\n for i in range(self.num_rows):\\n # iterate through columns of other\\n for j in range(other.num_cols):\\n # iterate through rows of other\\n for k in range(other.num_rows):\\n new_mat[i, j] += self[i, k] * other[k, j]\\n\\n return new_mat\",\n \"def __mul__(self, oth):\\n\\t\\tif isinstance(oth, Matrix) or isiterable(oth):\\n\\t\\t\\t# matrix\\n\\t\\t\\toth_m = oth\\n\\t\\t\\tif not isinstance(oth_m, Matrix):\\n\\t\\t\\t\\toth_m = Matrix(oth_m)\\t\\t\\t\\n\\t\\t\\tres_m = self._mat_mul(oth_m)\\n\\t\\t\\tif isinstance(oth, Matrix):\\n\\t\\t\\t\\treturn res_m\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn type(oth)(res_m._unnest())\\n\\t\\telse:\\n\\t\\t\\t# scalar\\n\\t\\t\\treturn Matrix._make_new(lambda i,j: self.data[i][j] * oth, self.rows, self.cols)\",\n \"def naive_multiply(a, b):\\n m = len(a) # Number of rows in first matrix\\n k = len(b) # Number of rows in the second matrix\\n res = []\\n p = len(b[0])\\n n = k\\n for q in range(m):\\n res.append([0])\\n for q in range(m):\\n for w in range(p - 1):\\n res[q].append(0)\\n for i in range(m):\\n for j in range(p):\\n for r in range(n):\\n res[i][j] = a[i][r] * b[r][j] + res[i][j]\\n return res\",\n \"def mult_img_matrix(imgs, matrix):\\n nimgs, ny, nx = imgs.shape\\n\\n vec = np.reshape(imgs, [nimgs, ny * nx])\\n vec_out = matrix.dot(vec)\\n imgs_out = np.reshape(vec_out, [nimgs, ny, nx])\\n\\n return imgs_out\",\n \"def test_matmul_mm(self):\\n self.check_dot_mm(matmul_usecase, None, \\\"'@'\\\")\",\n \"def matmul(x, y):\\n if len(list(y.size())) == 2:\\n # if one of them is a vector (i.e. wanting to do MV mult)\\n z = torch.zeros(2, x.size()[1], dtype=torch.double, device=x.device)\\n z[0] = torch.mv(x[0], y[0]) - torch.mv(x[1], y[1])\\n z[1] = torch.mv(x[0], y[1]) + torch.mv(x[1], y[0])\\n\\n if len(list(y.size())) == 3:\\n z = torch.zeros(\\n 2, x.size()[1], y.size()[2], dtype=torch.double, device=x.device\\n )\\n z[0] = torch.matmul(x[0], y[0]) - torch.matmul(x[1], y[1])\\n z[1] = torch.matmul(x[0], y[1]) + torch.matmul(x[1], y[0])\\n\\n return z\",\n \"def __matmul__(self, other):\\n if isinstance(other, types.Vector):\\n return self.apply(target=other)\\n if isinstance(other, MatrixLieGroup):\\n return self.multiply(other=other)\\n else:\\n assert False, \\\"Invalid argument\\\"\",\n \"def __mul__(self, scalar):\\n m, n = self.shape\\n scalar = mpfr(scalar)\\n data = dict()\\n for i in range(m):\\n for j in range(n):\\n data[i, j] = self[i, j] * scalar\\n return MPMatrix((m, n), data)\",\n \"def matrix_mult(A,B,mod=10**9+7):\\n C = [[1,1],[1,1]]\\n C[0][0] = ((A[0][0]*B[0][0])%mod + (A[0][1]*B[1][0])%mod)%mod\\n C[0][1] = ((A[0][0]*B[0][1])%mod + (A[0][1]*B[1][1])%mod)%mod\\n C[1][0] = ((A[1][0]*B[0][0])%mod + (A[1][1]*B[1][0])%mod)%mod\\n C[1][1] = ((A[1][0]*B[0][1])%mod + (A[1][1]*B[1][1])%mod)%mod\\n return C\",\n \"def python_nonsquare_matrix_mult(matrix):\\n\\n transposed_matrix = np.zeros([matrix.shape[1],matrix.shape[0]])\\n start = time.time()\\n # for i in range(matrix.shape[0]):\\n # for j in range(matrix.shape[1]):\\n # transposed_matrix[j,i] = matrix[i,j]\\n\\n transposed_matrix = np.transpose(matrix)\\n product = matrix.dot(transposed_matrix)\\n\\n # transposed_matrix = np.transpose(matrix)\\n end = time.time()-start\\n\\n # print(\\\"Python Golden Transpose: %s\\\" % product)\\n # print('python transpose time: %.2E' % end)\\n return [product, end]\",\n \"def matrix_dot(*args):\\n rval = args[0]\\n for a in args[1:]:\\n rval = tm.dot(rval, a)\\n return rval\",\n \"def multiply(self, b):\\n assert(self.Dimension == b.Dimension)\\n p = []\\n for meb in b.Elements:\\n for mea in self.Elements:\\n if mea.j == meb.i:\\n temp = mea.val * meb.val\\n temp = MatrixElement(mea.i, meb.j, temp)\\n p.append(temp)\\n p = SparseMatrix(len(p), p)\\n #print(p)\\n return p\",\n \"def combine_one_matrices(mul):\\n factor, args = mul.as_coeff_matrices()\\n new_args = [args[0]]\\n\\n for B in args[1:]:\\n A = new_args[-1]\\n if not isinstance(A, OneMatrix) or not isinstance(B, OneMatrix):\\n new_args.append(B)\\n continue\\n new_args.pop()\\n new_args.append(OneMatrix(A.shape[0], B.shape[1]))\\n factor *= A.shape[1]\\n\\n return newmul(factor, *new_args)\",\n \"def __mul__(self, other):\\n if isinstance(other, (int, float)):\\n return Matrix([[self.values[row][index] * other\\n for index in range(len(self.values[0]))]\\n for row in range(len(self.values))])\\n\\n elif isinstance(other, Vector):\\n return Vector([other.dot(Vector(row)) for row in self.values])\\n\\n elif isinstance(other, Matrix):\\n return Matrix([(other.transpose() * Vector(row)).values\\n for row in self.values])\",\n \"def __mul__(self,other):\\n # \\n # 注意矩阵的A的列 与 相乘矩阵B的行必须相等，才能进行运算\\n height = 0\\n width = 0\\n if isinstance(other, list): # 判断other是否是矩阵，即list形式的矩阵\\n height = len(other)\\n width = len(other[0])\\n else:\\n # 如果是对象，则直接获取行列值\\n height = other.h\\n width = other.w\\n\\n\\n my_mul = zeroes(self.h, self.w)\\n if self.w == height: # 两个矩阵的行列值需要相等 才能相乘\\n for i in range(self.h):\\n for j in range(width):\\n my_sum = 0\\n for k in range(height):\\n if isinstance(other, list):\\n my_sum += self.g[i][k] * other[k][j]\\n # 通过3个循环变量取所有矩阵的行列值\\n else:\\n my_sum += self.g[i][k] * other.g[k][j]\\n my_mul[i][j] = my_sum\\n return my_mul \\n else:\\n return NotImplementedError\",\n \"def calculate_matmul_n_times(n_components, mat_a, mat_b):\\n res = np.zeros(mat_a.shape)\\n mat_a = tf.cast(mat_a, tf.double)\\n mat_b = tf.cast(mat_b, tf.double)\\n for i in range(n_components):\\n mat_a_i = tf.squeeze(mat_a[:, i, :, :], -2)\\n mat_b_i = tf.squeeze(mat_b[0, i, :, :])\\n res[:, i, :, :] = tf.expand_dims(tf.matmul(mat_a_i, mat_b_i), 1)\\n\\n return tf.convert_to_tensor(res)\",\n \"def matmul(A, B):\\n # type: (Optional[Tensor], Tensor) -> Tensor\\n if A is None:\\n return B\\n if is_sparse(A):\\n return torch.sparse.mm(A, B)\\n return torch.matmul(A, B)\",\n \"def matrix_add():\",\n \"def __mul__(left, right):\\n \\n if isinstance(left, Plucker) and isinstance(right, Plucker):\\n # reciprocal product\\n return np.dot(left.uw, right.v) + np.dot(right.uw, left.v)\\n elif isinstance(left, Plucker) and arg.ismatrix(right, (4,None)):\\n return left.skew @ right; # postmultiply by 4xN\",\n \"def __mul__(self, other):\\n N = self.matrix.shape[1]\\n\\n if isinstance(other, _PysparseMatrix):\\n return _PysparseMatrix(matrix=spmatrix.matrixmultiply(self.matrix, other.matrix))\\n else:\\n shape = numerix.shape(other)\\n if shape == ():\\n L = spmatrix.ll_mat(N, N, N)\\n L.put(other * numerix.ones(N, 'l'))\\n return _PysparseMatrix(matrix=spmatrix.matrixmultiply(self.matrix, L))\\n elif shape == (N,):\\n y = numerix.empty((self.matrix.shape[0],))\\n self.matrix.matvec(other, y)\\n return y\\n else:\\n raise TypeError\",\n \"def my_matmul(x, y):\\n ##\\n cmd = getattr(th, \\\"matmul\\\")\\n x1, x2 = my_cut(x)\\n y1, y2 = my_cut(y)\\n x2y1 = cmd(x2, y1)\\n x1y2 = cmd(x1, y2)\\n x2y2 = cmd(x2, y2)\\n ret = (x2y1 + x1y2) % int24field * int24field + x2y2\\n ret = int48module(ret)\\n return ret\",\n \"def Mult(self, *args):\\n return _hypre.HypreParMatrix_Mult(self, *args)\",\n \"def add_matrices(m1, m2): \\n output = []\\n \\n for index in range(len(m1)):\\n row_1 = m1[index]\\n row_2 = m2[index]\\n new_row = []\\n for index2 in range(len(row_1)):\\n sum = row_1[index2] + row_2[index2]\\n new_row.append(sum)\\n output.append(new_row)\\n return output\",\n \"def __mul__(self, other):\\n if hasattr(other, 'as_homogenous_transformation'):\\n return basis(homogenous_transformation = self.as_homogenous_transformation() * other.as_homogenous_transformation())\\n elif hasattr(other, 'n'):\\n if other.n == (3,1):\\n b = matrix.col((other[0], other[1], other[2], 1))\\n elif other.n == (4,1):\\n b = other\\n else:\\n raise TypeError(b, \\\"Incompatible matrices\\\")\\n p = self.as_homogenous_transformation() * b\\n if other.n == (3,1):\\n return matrix.col(p[0:3])\\n else:\\n return p\\n else:\\n raise TypeError(b)\",\n \"def chain_matmul_square(As):\\n\\n As_matmul = As\\n while As_matmul.shape[0] > 1:\\n if As_matmul.shape[0] % 2:\\n A_last = As_matmul[-1:]\\n else:\\n A_last = None\\n \\n As_matmul = torch.matmul(As_matmul[0:-1:2], As_matmul[1::2])\\n if A_last is not None:\\n As_matmul = torch.cat([As_matmul, A_last], dim=0)\\n \\n return As_matmul.squeeze(0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.839403","0.77877283","0.7786913","0.76345795","0.7578386","0.752093","0.7499151","0.7495682","0.74534243","0.7433087","0.74056447","0.73597676","0.7326738","0.732322","0.7322675","0.731054","0.72843087","0.7257866","0.72538614","0.7223289","0.7222726","0.72109926","0.7210884","0.7193421","0.71875936","0.71751803","0.7163928","0.71602404","0.7155903","0.7155264","0.7137124","0.7122708","0.7121784","0.7111911","0.71113205","0.70916426","0.7086545","0.70816576","0.70795447","0.7077852","0.70775175","0.7033606","0.7033606","0.7029227","0.7028709","0.699483","0.69830054","0.69756466","0.69481534","0.6940633","0.6936434","0.69152826","0.6908271","0.68917704","0.6884037","0.6880783","0.6856087","0.6835476","0.6832661","0.68229556","0.6805816","0.68014777","0.67662555","0.67474926","0.674167","0.6732484","0.6722109","0.6704609","0.66893065","0.66819334","0.6656226","0.6628479","0.66209966","0.6617495","0.6610446","0.6609819","0.6606465","0.6603155","0.6601432","0.659203","0.6590573","0.6587667","0.65850896","0.65682054","0.6558304","0.6546407","0.65379286","0.652602","0.6522618","0.6500239","0.64959496","0.6460276","0.644583","0.6435343","0.6418276","0.64123225","0.64027333","0.6394951","0.63910294","0.6379685","0.6375029"],"string":"[\n \"0.839403\",\n \"0.77877283\",\n \"0.7786913\",\n \"0.76345795\",\n \"0.7578386\",\n \"0.752093\",\n \"0.7499151\",\n \"0.7495682\",\n \"0.74534243\",\n \"0.7433087\",\n \"0.74056447\",\n \"0.73597676\",\n \"0.7326738\",\n \"0.732322\",\n \"0.7322675\",\n \"0.731054\",\n \"0.72843087\",\n \"0.7257866\",\n \"0.72538614\",\n \"0.7223289\",\n \"0.7222726\",\n \"0.72109926\",\n \"0.7210884\",\n \"0.7193421\",\n \"0.71875936\",\n \"0.71751803\",\n \"0.7163928\",\n \"0.71602404\",\n \"0.7155903\",\n \"0.7155264\",\n \"0.7137124\",\n \"0.7122708\",\n \"0.7121784\",\n \"0.7111911\",\n \"0.71113205\",\n \"0.70916426\",\n \"0.7086545\",\n \"0.70816576\",\n \"0.70795447\",\n \"0.7077852\",\n \"0.70775175\",\n \"0.7033606\",\n \"0.7033606\",\n \"0.7029227\",\n \"0.7028709\",\n \"0.699483\",\n \"0.69830054\",\n \"0.69756466\",\n \"0.69481534\",\n \"0.6940633\",\n \"0.6936434\",\n \"0.69152826\",\n \"0.6908271\",\n \"0.68917704\",\n \"0.6884037\",\n \"0.6880783\",\n \"0.6856087\",\n \"0.6835476\",\n \"0.6832661\",\n \"0.68229556\",\n \"0.6805816\",\n \"0.68014777\",\n \"0.67662555\",\n \"0.67474926\",\n \"0.674167\",\n \"0.6732484\",\n \"0.6722109\",\n \"0.6704609\",\n \"0.66893065\",\n \"0.66819334\",\n \"0.6656226\",\n \"0.6628479\",\n \"0.66209966\",\n \"0.6617495\",\n \"0.6610446\",\n \"0.6609819\",\n \"0.6606465\",\n \"0.6603155\",\n \"0.6601432\",\n \"0.659203\",\n \"0.6590573\",\n \"0.6587667\",\n \"0.65850896\",\n \"0.65682054\",\n \"0.6558304\",\n \"0.6546407\",\n \"0.65379286\",\n \"0.652602\",\n \"0.6522618\",\n \"0.6500239\",\n \"0.64959496\",\n \"0.6460276\",\n \"0.644583\",\n \"0.6435343\",\n \"0.6418276\",\n \"0.64123225\",\n \"0.64027333\",\n \"0.6394951\",\n \"0.63910294\",\n \"0.6379685\",\n \"0.6375029\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6894,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the list of entries of this matrix."},"document":{"kind":"string","value":"def list(self):\n return [self[i,j] for i in range(self._d) for j in range(self._d)]"},"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 as_list(self):\n data = []\n for row in self._matrix_data:\n for column in row:\n data.append(column)\n return data","def rows(self):\n return list(self)","def as_list_of_lists(self):\n return self._matrix_data","def readentries(self):\n return list(x for x in self)","def entries(self):\n out = []\n for y,x in self.coords(False):\n out.append((y,x,self.retrieve(y,x)))\n return out","def rows(self):\n return self._row_list","def entries(self):\n return self._entries","def entries(self):\n return self._entries","def rows(self) -> List[List]:\n return self._rows","def get_entries(self) -> List[Entry]:\n return list(self.__entries)","def getEntries(self):\n return self.entries","def rows(self):\n return self.row","def getEntries(self):\n return self.__entries","def to_list_flat(self):\n return self.rep.entries()","def get_data(self) -> List[List[int]]:\n sudoku_array = []\n for row in self.entries:\n sudoku_array.append([0 if entry.text == '' else int(entry.text) for entry in row])\n return sudoku_array","def list(self):\n return self.cell.objects+self.cell.tempObjects","def values(self):\n return [row.values for row in self]","def At_list(self):\n return self.Atom_list","def to_list(self):\n return self.main_list[:self.num_elements]","def tolist (self) :\r\n if self.complex :\r\n result = []\r\n for x in xrange(0,len(self)) :\r\n result.append(self[x])\r\n return result\r\n else :\r\n return self.impl.tolist()","def entries():\n\n\treturn [entry.value for entry in db.session.query(Entry).all()]","def rows(self):\n return self.Rows(self)","def cols(self):\n\n return []","def get_entries(self):\n return self._netdis.loxone.entries","def get_rows(self):\n return utils.copy_matrix(self.board)","def entries(self) -> \"list[tuple[Codepoint, EffectiveWidth]]\":\n result = list(self.entry_set)\n result.sort()\n return result","def list(self):\n return self._get_list()","def to_list(self):\n return self._elements","def list_of_neighbors(self):\n return self.to_coo_matrix().tolil().rows.tolist()","def get_values(self):\n \n return []","def toList(self, rowmajor=0):\r\n if rowmajor:\r\n return copy.copy(self.mlist)\r\n else:\r\n return self.transpose().mlist","def get_list(self):\n return sorted(self.__entries.keys())","def values(self):\n self._values = [[cell for cell in row]\n for row in self.sheet._op.values]\n # self._values = [cell for row in self.sheet._op.values for cell in row]\n return self._values","def as_matrix(self):\n return self._data","def rows(self):\n # NOTE: To avoid duplicating large objects, this is just the\n # mutable private data.\n return self._rows","def values(self) -> list:\n return self.__values","def values(self):\n return [ self[x] for x in self ]","def entries(self):\n return [self._entries[key] for key in self._order]","def get_entries(\n self,\n entry\n ):\n\n try:\n return self._cache[self._alias[entry]]\n except:\n pass\n\n if entry in self._header:\n \n # get the index\n idx = self._header[entry]\n\n entries = []\n\n for row in self._array:\n tmp = [0 for i in row]\n for i,cell in enumerate(row):\n if cell != 0:\n tmp[i] = self[cell][idx]\n entries.append(tmp)\n\n # add entries to cache\n self._cache[self._alias[entry]] = entries\n\n return entries","def to_list(self):\n return self.rep.tolist()","def entries(self):\n if not self._lines:\n self._load_file()\n\n return tuple(self._lines)","def values(self):\n x = []\n for k in list(self.keys()):\n x.append(self[k])\n return x","def matrix(self):\n return np.matrix(list(self._columns.values()))","def all(self):\n self.scan()\n return self.entries","def values(self):\n values = []\n for key in self.keys():\n values.append(self[key])\n return values","def get_rows(self) -> List[List[str]]:\n return self.content","def rows(self):\r\n raise NotImplementedError","def values(self):\r\n return [self[k] for k in self]","def tolist(self):\n \n ret = []\n \n for e in self:\n ret.append(e)\n \n return ret","def matrix(self):\n return self._matrix","def matrix(self):\n return self._matrix","def data(self) -> List[List[Any]]:\n\n column_wise = [column.values for column in self.plaincolumns]\n row_wise = [list(row) for row in zip(*column_wise)]\n\n return row_wise","def cells_list(self):\n xx, yy = np.meshgrid(self.x_spacings, self.y_spacings)\n return np.vstack([yy.ravel(), xx.ravel()]).transpose()","def array(self):\n return list(self.sequence)","def getAll(self):\n return self.__lst","def getList(self):\n return self.position.exportToList()","def getContents(self):\r\n cont=[]\r\n for i in range (len(self._indices)):\r\n cont.append(self._dataset.getPoint(self._indices[i]))\r\n return cont","def columns(self) -> List[List]:\n return list(map(list, zip(*self.rows)))","def to_list(self):\n return list(self.data)","def values(self):\n\t\treturn self.myVals","def arr(self):\n return self._arr","def get_list(self):\r\n return self.numbers","def to_list(self) -> list:\n return self.A.tolist()","def lists(self):\n return dict.items(self)","def get_displayed_data(self):\n displayed_data = []\n disp_entry_positions = range(self.first_displayed_entry, self.last_displayed_entry+1)\n #print(\"Displayed entries: {}\".format(disp_entry_positions))\n for entry_num in disp_entry_positions:\n is_active = entry_num == self.pointer\n displayed_entry = self.render_displayed_entry(entry_num, active=is_active)\n displayed_data += displayed_entry\n #print(\"Displayed data: {}\".format(displayed_data))\n return displayed_data","def get_matrix(self):\n return self._matrix[:3, :]","def array(self):\n return array(self.get_values())","def cells(self) -> List[Tuple[int, int]]:\n return self._cells","def getitems(self):\n if self.onlydiag():\n return self.getdiag()\n else:\n return self.items()","def values(self) -> List:\n pass","def get_all(self):\n list = []\n line = self.get()\n while line:\n list.append(line)\n line = self.get()\n return list","def list(self) -> List:\n return list(self.values())","def values(self) -> ndarray:\n return self._vals","def matrix_features(self):\n return self._matrix_features","def get_entries(self) -> Generator[str, None, None]:\n return (entry for entry in self.entries)","def infolist(self):\r\n return list(self.infoiter())","def get_values(self) -> list:\r\n values = []\r\n for key, value in self._items:\r\n values.append(value)\r\n return values","def as_list(self):\n g = self.args[0]\n H = self.args[1]\n cst = []\n if str(self._dir) == '+':\n for h in H.elements:\n cst.append(h*g)\n else:\n for h in H.elements:\n cst.append(g*h)\n return cst","def ui_getrow(self):\n return [self.locked*'L',self.idx,self.guid,printsz(self.size),\n printsz(self.cachesize),self.vendor,self.model,\n len(self.paths),len(self.partitions),len(self.usedinluns)\n ]","def get_conn_matrix_vector(self):\n\n vect = []\n for line in sorted(self.connection_matrix):\n for item in self.connection_matrix[line]:\n vect.append(item)\n\n return vect","def rows(self):\r\n raise NotImplementedError()","def array(self):\n return self.get_array()","def list(self):\n return [self.x, self.y, self.z]","def rows(self) -> java.util.Collection:\n ...","def data(self) -> List[ndarray]:\n return self._data","def get_rows(self):\n rowlist = []\n if self.direction == \"horizontal\":\n rowlist.append(int(self.position[0][0]))\n return rowlist\n else:\n rowlist.append(int(self.position[0][0]))\n rowlist.append(int(self.position[1][0]))\n if self.size == 3:\n rowlist.append(int(self.position[2][0]))\n return rowlist","def values(self):\r\n return self.__values","def lines(self):\n return self.lines","def cells(self):\n return chain.from_iterable(self.cols)","def values(self):\n return [i.value for i in self.value]","def values(self):\n return [self[k] for k in self.keys()]","def values (self):\n return self._values","def values (self):\n return self._values","def vals(self) -> ndarray:\n return self._vals","def __iter__(self) -> Iterator[Tuple[K, List[V]]]:\n return (entry for entry in self._table.items())","def values(self):\n return self._values","def values(self):\n return self._values","def values(self):\n return self._values","def values(self):\n return self._values","def columns(self):\n return self.__column_list"],"string":"[\n \"def as_list(self):\\n data = []\\n for row in self._matrix_data:\\n for column in row:\\n data.append(column)\\n return data\",\n \"def rows(self):\\n return list(self)\",\n \"def as_list_of_lists(self):\\n return self._matrix_data\",\n \"def readentries(self):\\n return list(x for x in self)\",\n \"def entries(self):\\n out = []\\n for y,x in self.coords(False):\\n out.append((y,x,self.retrieve(y,x)))\\n return out\",\n \"def rows(self):\\n return self._row_list\",\n \"def entries(self):\\n return self._entries\",\n \"def entries(self):\\n return self._entries\",\n \"def rows(self) -> List[List]:\\n return self._rows\",\n \"def get_entries(self) -> List[Entry]:\\n return list(self.__entries)\",\n \"def getEntries(self):\\n return self.entries\",\n \"def rows(self):\\n return self.row\",\n \"def getEntries(self):\\n return self.__entries\",\n \"def to_list_flat(self):\\n return self.rep.entries()\",\n \"def get_data(self) -> List[List[int]]:\\n sudoku_array = []\\n for row in self.entries:\\n sudoku_array.append([0 if entry.text == '' else int(entry.text) for entry in row])\\n return sudoku_array\",\n \"def list(self):\\n return self.cell.objects+self.cell.tempObjects\",\n \"def values(self):\\n return [row.values for row in self]\",\n \"def At_list(self):\\n return self.Atom_list\",\n \"def to_list(self):\\n return self.main_list[:self.num_elements]\",\n \"def tolist (self) :\\r\\n if self.complex :\\r\\n result = []\\r\\n for x in xrange(0,len(self)) :\\r\\n result.append(self[x])\\r\\n return result\\r\\n else :\\r\\n return self.impl.tolist()\",\n \"def entries():\\n\\n\\treturn [entry.value for entry in db.session.query(Entry).all()]\",\n \"def rows(self):\\n return self.Rows(self)\",\n \"def cols(self):\\n\\n return []\",\n \"def get_entries(self):\\n return self._netdis.loxone.entries\",\n \"def get_rows(self):\\n return utils.copy_matrix(self.board)\",\n \"def entries(self) -> \\\"list[tuple[Codepoint, EffectiveWidth]]\\\":\\n result = list(self.entry_set)\\n result.sort()\\n return result\",\n \"def list(self):\\n return self._get_list()\",\n \"def to_list(self):\\n return self._elements\",\n \"def list_of_neighbors(self):\\n return self.to_coo_matrix().tolil().rows.tolist()\",\n \"def get_values(self):\\n \\n return []\",\n \"def toList(self, rowmajor=0):\\r\\n if rowmajor:\\r\\n return copy.copy(self.mlist)\\r\\n else:\\r\\n return self.transpose().mlist\",\n \"def get_list(self):\\n return sorted(self.__entries.keys())\",\n \"def values(self):\\n self._values = [[cell for cell in row]\\n for row in self.sheet._op.values]\\n # self._values = [cell for row in self.sheet._op.values for cell in row]\\n return self._values\",\n \"def as_matrix(self):\\n return self._data\",\n \"def rows(self):\\n # NOTE: To avoid duplicating large objects, this is just the\\n # mutable private data.\\n return self._rows\",\n \"def values(self) -> list:\\n return self.__values\",\n \"def values(self):\\n return [ self[x] for x in self ]\",\n \"def entries(self):\\n return [self._entries[key] for key in self._order]\",\n \"def get_entries(\\n self,\\n entry\\n ):\\n\\n try:\\n return self._cache[self._alias[entry]]\\n except:\\n pass\\n\\n if entry in self._header:\\n \\n # get the index\\n idx = self._header[entry]\\n\\n entries = []\\n\\n for row in self._array:\\n tmp = [0 for i in row]\\n for i,cell in enumerate(row):\\n if cell != 0:\\n tmp[i] = self[cell][idx]\\n entries.append(tmp)\\n\\n # add entries to cache\\n self._cache[self._alias[entry]] = entries\\n\\n return entries\",\n \"def to_list(self):\\n return self.rep.tolist()\",\n \"def entries(self):\\n if not self._lines:\\n self._load_file()\\n\\n return tuple(self._lines)\",\n \"def values(self):\\n x = []\\n for k in list(self.keys()):\\n x.append(self[k])\\n return x\",\n \"def matrix(self):\\n return np.matrix(list(self._columns.values()))\",\n \"def all(self):\\n self.scan()\\n return self.entries\",\n \"def values(self):\\n values = []\\n for key in self.keys():\\n values.append(self[key])\\n return values\",\n \"def get_rows(self) -> List[List[str]]:\\n return self.content\",\n \"def rows(self):\\r\\n raise NotImplementedError\",\n \"def values(self):\\r\\n return [self[k] for k in self]\",\n \"def tolist(self):\\n \\n ret = []\\n \\n for e in self:\\n ret.append(e)\\n \\n return ret\",\n \"def matrix(self):\\n return self._matrix\",\n \"def matrix(self):\\n return self._matrix\",\n \"def data(self) -> List[List[Any]]:\\n\\n column_wise = [column.values for column in self.plaincolumns]\\n row_wise = [list(row) for row in zip(*column_wise)]\\n\\n return row_wise\",\n \"def cells_list(self):\\n xx, yy = np.meshgrid(self.x_spacings, self.y_spacings)\\n return np.vstack([yy.ravel(), xx.ravel()]).transpose()\",\n \"def array(self):\\n return list(self.sequence)\",\n \"def getAll(self):\\n return self.__lst\",\n \"def getList(self):\\n return self.position.exportToList()\",\n \"def getContents(self):\\r\\n cont=[]\\r\\n for i in range (len(self._indices)):\\r\\n cont.append(self._dataset.getPoint(self._indices[i]))\\r\\n return cont\",\n \"def columns(self) -> List[List]:\\n return list(map(list, zip(*self.rows)))\",\n \"def to_list(self):\\n return list(self.data)\",\n \"def values(self):\\n\\t\\treturn self.myVals\",\n \"def arr(self):\\n return self._arr\",\n \"def get_list(self):\\r\\n return self.numbers\",\n \"def to_list(self) -> list:\\n return self.A.tolist()\",\n \"def lists(self):\\n return dict.items(self)\",\n \"def get_displayed_data(self):\\n displayed_data = []\\n disp_entry_positions = range(self.first_displayed_entry, self.last_displayed_entry+1)\\n #print(\\\"Displayed entries: {}\\\".format(disp_entry_positions))\\n for entry_num in disp_entry_positions:\\n is_active = entry_num == self.pointer\\n displayed_entry = self.render_displayed_entry(entry_num, active=is_active)\\n displayed_data += displayed_entry\\n #print(\\\"Displayed data: {}\\\".format(displayed_data))\\n return displayed_data\",\n \"def get_matrix(self):\\n return self._matrix[:3, :]\",\n \"def array(self):\\n return array(self.get_values())\",\n \"def cells(self) -> List[Tuple[int, int]]:\\n return self._cells\",\n \"def getitems(self):\\n if self.onlydiag():\\n return self.getdiag()\\n else:\\n return self.items()\",\n \"def values(self) -> List:\\n pass\",\n \"def get_all(self):\\n list = []\\n line = self.get()\\n while line:\\n list.append(line)\\n line = self.get()\\n return list\",\n \"def list(self) -> List:\\n return list(self.values())\",\n \"def values(self) -> ndarray:\\n return self._vals\",\n \"def matrix_features(self):\\n return self._matrix_features\",\n \"def get_entries(self) -> Generator[str, None, None]:\\n return (entry for entry in self.entries)\",\n \"def infolist(self):\\r\\n return list(self.infoiter())\",\n \"def get_values(self) -> list:\\r\\n values = []\\r\\n for key, value in self._items:\\r\\n values.append(value)\\r\\n return values\",\n \"def as_list(self):\\n g = self.args[0]\\n H = self.args[1]\\n cst = []\\n if str(self._dir) == '+':\\n for h in H.elements:\\n cst.append(h*g)\\n else:\\n for h in H.elements:\\n cst.append(g*h)\\n return cst\",\n \"def ui_getrow(self):\\n return [self.locked*'L',self.idx,self.guid,printsz(self.size),\\n printsz(self.cachesize),self.vendor,self.model,\\n len(self.paths),len(self.partitions),len(self.usedinluns)\\n ]\",\n \"def get_conn_matrix_vector(self):\\n\\n vect = []\\n for line in sorted(self.connection_matrix):\\n for item in self.connection_matrix[line]:\\n vect.append(item)\\n\\n return vect\",\n \"def rows(self):\\r\\n raise NotImplementedError()\",\n \"def array(self):\\n return self.get_array()\",\n \"def list(self):\\n return [self.x, self.y, self.z]\",\n \"def rows(self) -> java.util.Collection:\\n ...\",\n \"def data(self) -> List[ndarray]:\\n return self._data\",\n \"def get_rows(self):\\n rowlist = []\\n if self.direction == \\\"horizontal\\\":\\n rowlist.append(int(self.position[0][0]))\\n return rowlist\\n else:\\n rowlist.append(int(self.position[0][0]))\\n rowlist.append(int(self.position[1][0]))\\n if self.size == 3:\\n rowlist.append(int(self.position[2][0]))\\n return rowlist\",\n \"def values(self):\\r\\n return self.__values\",\n \"def lines(self):\\n return self.lines\",\n \"def cells(self):\\n return chain.from_iterable(self.cols)\",\n \"def values(self):\\n return [i.value for i in self.value]\",\n \"def values(self):\\n return [self[k] for k in self.keys()]\",\n \"def values (self):\\n return self._values\",\n \"def values (self):\\n return self._values\",\n \"def vals(self) -> ndarray:\\n return self._vals\",\n \"def __iter__(self) -> Iterator[Tuple[K, List[V]]]:\\n return (entry for entry in self._table.items())\",\n \"def values(self):\\n return self._values\",\n \"def values(self):\\n return self._values\",\n \"def values(self):\\n return self._values\",\n \"def values(self):\\n return self._values\",\n \"def columns(self):\\n return self.__column_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74211484","0.7351907","0.7139602","0.7107239","0.7102002","0.7040875","0.700234","0.700234","0.69514894","0.6915959","0.6805772","0.68021935","0.67886513","0.6775163","0.6770315","0.6736421","0.67067957","0.66475236","0.6628927","0.66164464","0.65946597","0.6570721","0.6539913","0.653377","0.65327","0.6511432","0.6499319","0.6491782","0.64409816","0.6394279","0.6361168","0.63452286","0.63422114","0.63421136","0.6338142","0.63303053","0.63302374","0.6320387","0.6305276","0.6293655","0.6290904","0.6276081","0.6273789","0.62736857","0.6239219","0.6236895","0.6233921","0.6232702","0.62302876","0.6221393","0.6221393","0.62197894","0.6206175","0.620273","0.6199111","0.6197966","0.6194342","0.61911935","0.6186292","0.6184974","0.6183829","0.61828524","0.61765933","0.61715543","0.61708647","0.6166792","0.61667436","0.61441207","0.613997","0.61338234","0.61179703","0.61110413","0.6110968","0.6110922","0.61051065","0.6104968","0.6102537","0.60994464","0.6090314","0.60887617","0.6076425","0.60702175","0.6069222","0.6068846","0.6060944","0.60536057","0.6046299","0.6045127","0.6043226","0.60410035","0.6037136","0.60338265","0.60338265","0.603062","0.6028495","0.6018327","0.6018327","0.6018327","0.6018327","0.60057735"],"string":"[\n \"0.74211484\",\n \"0.7351907\",\n \"0.7139602\",\n \"0.7107239\",\n \"0.7102002\",\n \"0.7040875\",\n \"0.700234\",\n \"0.700234\",\n \"0.69514894\",\n \"0.6915959\",\n \"0.6805772\",\n \"0.68021935\",\n \"0.67886513\",\n \"0.6775163\",\n \"0.6770315\",\n \"0.6736421\",\n \"0.67067957\",\n \"0.66475236\",\n \"0.6628927\",\n \"0.66164464\",\n \"0.65946597\",\n \"0.6570721\",\n \"0.6539913\",\n \"0.653377\",\n \"0.65327\",\n \"0.6511432\",\n \"0.6499319\",\n \"0.6491782\",\n \"0.64409816\",\n \"0.6394279\",\n \"0.6361168\",\n \"0.63452286\",\n \"0.63422114\",\n \"0.63421136\",\n \"0.6338142\",\n \"0.63303053\",\n \"0.63302374\",\n \"0.6320387\",\n \"0.6305276\",\n \"0.6293655\",\n \"0.6290904\",\n \"0.6276081\",\n \"0.6273789\",\n \"0.62736857\",\n \"0.6239219\",\n \"0.6236895\",\n \"0.6233921\",\n \"0.6232702\",\n \"0.62302876\",\n \"0.6221393\",\n \"0.6221393\",\n \"0.62197894\",\n \"0.6206175\",\n \"0.620273\",\n \"0.6199111\",\n \"0.6197966\",\n \"0.6194342\",\n \"0.61911935\",\n \"0.6186292\",\n \"0.6184974\",\n \"0.6183829\",\n \"0.61828524\",\n \"0.61765933\",\n \"0.61715543\",\n \"0.61708647\",\n \"0.6166792\",\n \"0.61667436\",\n \"0.61441207\",\n \"0.613997\",\n \"0.61338234\",\n \"0.61179703\",\n \"0.61110413\",\n \"0.6110968\",\n \"0.6110922\",\n \"0.61051065\",\n \"0.6104968\",\n \"0.6102537\",\n \"0.60994464\",\n \"0.6090314\",\n \"0.60887617\",\n \"0.6076425\",\n \"0.60702175\",\n \"0.6069222\",\n \"0.6068846\",\n \"0.6060944\",\n \"0.60536057\",\n \"0.6046299\",\n \"0.6045127\",\n \"0.6043226\",\n \"0.60410035\",\n \"0.6037136\",\n \"0.60338265\",\n \"0.60338265\",\n \"0.603062\",\n \"0.6028495\",\n \"0.6018327\",\n \"0.6018327\",\n \"0.6018327\",\n \"0.6018327\",\n \"0.60057735\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69504046"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":6895,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the list of equal coefficients between self and other."},"document":{"kind":"string","value":"def equal_coefficients(self, other):\n d = self._d\n return [(i,j) for i in range(d) for j in range(d) \\\n if self[i][j] == other[i][j]]"},"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 __xor__(self, other):\n\n sym_diff = [value for value in self if value not in other]\n sym_diff.extend([value for value in other if value not in self])\n\n return sym_diff","def GetEqualConstrains(self):\n return _gmat_py.Spacecraft_GetEqualConstrains(self)","def coefficients(self) :\n raise NotImplementedError","def coefficients(self) :\n return self.__coefficients","def __pow__(self, other):\n n = len(self)\n\n v = zeros_como(self)\n\n for i in range(n):\n v[i] = self[i]**other\n\n return v","def coefficients(self):\n return self._coefficients","def coefficients(self):\n return self._coefficients","def __sub__(self, other: 'ModelParameters') -> 'ModelParameters':\n return ModelParameters([self[idx] - other[idx] for idx in range(len(self))])","def coefficients(self) -> np.ndarray:\n return self._coefficients","def get_coefficients(self):\n return self.coefficients","def get_coefficients(self):\n return self.coefficients","def __xor__(self, other):\n a, b = Trits.match_length(self, other)\n return Trits([x ^ y for x, y in zip(a, b)])","def getEquates(self) -> Iterator[ghidra.program.model.symbol.Equate]:\n ...","def __isub__(self, other):\n self.components = [c1 - c2 for (c1, c2) in zip(self, other)]\n return self","def __sub__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self.coefficients, other.coefficients\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def pd(self, other):\n return Matriz([self]).T() * Matriz([other])","def find_coefficients(self):\n self.make_matrix()\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition","def __eq__(self, other):\n if self.coeff != other.coeff:\n return False\n \n if self.GetKeggID() != other.GetKeggID():\n return False\n \n if self.phase.Name() != other.phase.Name():\n return False\n \n return True","def test_coefficient_orders(self):\n for i in range(2, 5):\n spec = {2*j: 0 for j in range(i)}\n bcs_ref = BoundaryConditions(spec, 2*i-2)\n bcs_main = BoundaryConditions(spec, 2*i)\n\n coeffs_ref = get_ext_coeffs(bcs_ref)[i-1]\n coeffs_main = get_ext_coeffs(bcs_main)[i-1]\n\n assert coeffs_ref == coeffs_main","def enthalpy_equality_func(self):\n residual = []\n for i in range(self.num_i):\n residual += [self.inl[i].h.val_SI - self.outl[i].h.val_SI]\n return residual","def coefficients(self, force_characters = False) :\n raise NotImplementedError","def __xor__(self, other):\r\n return self + other - 2 * self * other","def IsEqualOrder(self,other):\n return self.InferPolynomialDegree() == other.InferPolynomialDegree()","def coefficients(self):\r\n return self.coef_['x']","def __isub__(self, other):\n self.components = [c1 - c2 for (c1, c2) in zip(self.components, other.components)]\n return self","def __sub__(self, other):\n # \n # TODO - your code here\n #\n result = [];\n for i in range(self.h):\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\n \n return Matrix(result);","def __and__(self, other):\n\n return [value for value in self if value in other]","def commutator(self, other) -> 'MultiVector':\n\n return ((self * other) - (other * self)) / 2","def commutes_with(self, other):\n if not isinstance(other, type(self)):\n raise TypeError(\n 'Can only test commutation with another MajoranaOperator.')\n\n if len(self.terms) == 1 and len(other.terms) == 1:\n return _majorana_terms_commute(\n list(self.terms.keys())[0],\n list(other.terms.keys())[0])\n return self * other == other * self","def __sub__(self, other):\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])","def a_coefficients(y1,y2):\n\tACoefficients = np.array([\ty1, \\\n\t\t\t\t\t\t\t\ty2 ]).astype(float)\n\treturn(ACoefficients)","def __xor__(self, other: t.Any) -> InspectableSet[_C]:\n return self._op_copy('__xor__', other)","def rhs_atoms(self):\n\n return itertools.chain(self.rhs_names, self.rhs_funcs)","def difference(self, other): # type: (Term) -> Term\n return self.intersect(other.inverse)","def getSmoothnessABC(self,other):\n\t\tif not self.sectors == other.sectors:\n\t\t\traise ValueError(\"Sectors do not match\")\n\t\ttotalNzero = self.nZero + other.nZero\n\n\t\tDself = np.zeros((2*self.totalBins))\n\t\tDother = np.zeros((2*other.totalBins))\n\t\tZself = np.zeros((2*totalNzero, 2*self.totalBins))\n\t\tZother = np.zeros((2*totalNzero, 2*other.totalBins))\n\t\tfor s in range(self.nSect):\n\t\t\tstartSelf = self.borders[s]\n\t\t\tstartOther = other.borders[s]\n\t\t\tnBins = min(self.borders[s+1] - self.borders[s], other.borders[s+1] - other.borders[s])\n\t\t\tfor i in range(nBins):\n\t\t\t\tdelRe = self.reals[startSelf+i] - other.reals[startOther+i]\n\t\t\t\tdelIm = self.imags[startSelf+i] - other.imags[startOther+i]\n\t\t\t\tDself[2*(startSelf + i) ] = delRe\n\t\t\t\tDself[2*(startSelf + i)+1] = delIm\n\t\t\t\tDother[2*(startOther + i) ] = delRe\n\t\t\t\tDother[2*(startOther + i)+1] = delIm\n\t\t\t\tfor z in range(self.nZero):\n\t\t\t\t\tzeroVal = self.zeroModes[z][startSelf+i]\n\t\t\t\t\tZself[2*z ,2*(startSelf + i) ] = zeroVal\n\t\t\t\t\tZself[2*z+1,2*(startSelf + i)+1 ] = zeroVal\n\t\t\t\t\tZother[2*z ,2*(startOther + i) ] = zeroVal\n\t\t\t\t\tZother[2*z+1,2*(startOther + i)+1] = zeroVal\n\t\t\t\tz0 = self.nZero\n\t\t\t\tfor z in range(other.nZero):\n\t\t\t\t\tzeroVal = -other.zeroModes[z][startOther+i]\n\t\t\t\t\tZself[2*(z+z0) , 2*(startSelf + i) ] = zeroVal\n\t\t\t\t\tZself[2*(z+z0)+1 , 2*(startSelf + i)+1] = zeroVal\n\t\t\t\t\tZother[2*(z+z0) , 2*(startOther+ i) ] = zeroVal\n\t\t\t\t\tZother[2*(z+z0)+1, 2*(startOther+ i)+1] = zeroVal\n\t\tDCself = np.dot(Dself, self.comaInv)\n\t\tDCother = np.dot(Dother, other.comaInv)\n\n\t\tCself = np.dot(Dself, DCself)\n\t\tCother = np.dot(Dother, DCother)\n\t\tBself = np.dot(Zself, DCself)\n\t\tBother = np.dot(Zother, DCother)\n\t\tAself = np.dot(Zself, np.transpose(np.dot(Zself, self.comaInv)))\n\t\tAother = np.dot(Zother, np.transpose(np.dot(Zother, other.comaInv)))\n\t\treturn Aself+Aother, 2*(Bself + Bother), Cself + Cother # A factor 2 was missing inB","def __xor__(self, other):\n\n if isinstance(other, Dyadic):\n return NotImplemented\n if isinstance(other, (int, type(Zero()))):\n if (other == 0):\n return self * 0\n self._check_vector(other)\n\n def _det(mat):\n \"\"\"This is needed as a little method for to find the determinant\n of a list in python; needs to work for a 3x3 list.\n SymPy's Matrix won't take in Vector, so need a custom function.\n You shouldn't be calling this.\n\n \"\"\"\n\n return (mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1])\n + mat[0][1] * (mat[1][2] * mat[2][0] - mat[1][0] *\n mat[2][2]) + mat[0][2] * (mat[1][0] * mat[2][1] -\n mat[1][1] * mat[2][0]))\n\n outvec = Vector([])\n ar = other.args # For brevity\n for i, v in enumerate(ar):\n tempx = v[1].x\n tempy = v[1].y\n tempz = v[1].z\n tempm = ([[tempx, tempy, tempz], [self & tempx, self & tempy,\n self & tempz], [Vector([ar[i]]) & tempx,\n Vector([ar[i]]) & tempy, Vector([ar[i]]) & tempz]])\n outvec += _det(tempm)\n return outvec","def smaller(self):\n return [x for x in TransitiveIdeal(attrcall('pred'), [self])]","def __eq__(self, other):\n\n equalCoordinates = self.getCoordinate() == other.getCoordinate()\n equalMasses = self.getMass() == other.getMass()\n equalVelocities = self.getVelocity() == other.getVelocity()\n equalAccelerations = self.getAcceleration() == other.getAcceleration()\n\n return equalCoordinates & equalMasses & equalVelocities & equalAccelerations","def __mul__(self, polynomial_2: Polynomial) -> Polynomial:\n coefficients: list[float] = [0] * (self.degree + polynomial_2.degree + 1)\n for i in range(self.degree + 1):\n for j in range(polynomial_2.degree + 1):\n coefficients[i + j] += (\n self.coefficients[i] * polynomial_2.coefficients[j]\n )\n\n return Polynomial(self.degree + polynomial_2.degree, coefficients)","def atoms(self):\n return itertools.chain(self.rhs_atoms, self.lhs_atoms)","def __pow__(self, other):\n if other == 2:\n # cartesian product\n new_set = Set()\n for s1 in self:\n for s2 in self:\n new_set += Set(List([[s1, s2]]))\n return new_set\n raise TypeError(\n f\"{other} must be 2 to compute cartesian product of a set with itself\")","def __add__(self, other):\n sum_ct = ContingencyTable(*(self.table + other.table).tolist())\n return sum_ct","def __eq__(self, rhs: Union[float, Simpy]) -> list[bool]:\n mask: list[bool] = []\n if isinstance(rhs, float):\n for item in self.values:\n mask.append(item == rhs)\n else:\n assert len(self.values) == len(rhs.values)\n for i in range(len(self.values)):\n mask.append(self.values[i] == rhs.values[i])\n return mask","def __add__(self, other: 'ModelParameters') -> 'ModelParameters':\n return ModelParameters([self[idx] + other[idx] for idx in range(len(self))])","def kspace_cholesky_solve_(self, other):\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\n self_k = transform(self, np.fft.fftn, n_points = n_points)\n other_k = transform(other, np.fft.fftn, n_points = n_points)\n\n ret = tmat()\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\n #ret = self_k*1.0\n ret.blocks*=0.0\n\n #ret.blocks[:-1] = np.einsum(\"ijk,ikl->ijl\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\n\n for i in np.arange(len(self_k.blocks)-1):\n \n #print(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i])))\n #assert(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i]))<1e-10), \"not symmetric\"\n #assert(np.linalg.norm(self_k.blocks[i].T-self_k.blocks[i])<1e-10), \"not symmetric\"\n Mk = np.linalg.cholesky(self_k.blocks[i])\n yk = np.linalg.solve(Mk, other_k.blocks[i])\n\n\n ret.blocks[i] = np.linalg.solve(Mk.conj().T, yk)\n\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\n return ret","def __xor__(self, other):\n if type(other) == Form:\n other = [other]\n return Form.union([other, self])","def xor(self, t1, t2):\n return [x ^ y for x, y in zip(t1, t2)]","def __xor__(self, other: Compound[Scalar]) -> Compound[Scalar]:\n return (self._pack_points(self._points_set ^ other._points_set)\n if isinstance(other, Multipoint)\n else NotImplemented)","def corr_with(self, other):\n return self.data.corrwith(other)","def __sub__(self, other):\n return Point([c1 - c2 for (c1, c2) in zip(self, other)])","def jaccard_similarity(iterable1, iterable2):\n t = ConfusionMatrix2.from_sets(iterable1, iterable2)\n return t.jaccard_coeff()","def coefficients(self):\n if self._coefficients is None:\n return np.hstack([c.coefficients for c in self._traces])\n return self._coefficients","def common_hypernyms(self, other):\n return set(self.all_hypernyms()).intersection(set(other.all_hypernyms()))","def __xor__(self, other):\n if not isinstance(other, UniSet):\n other = self.fam.c_uniset(other)\n return self.fam.c_xor(self, other)","def setdiff(self, other):\n\n return self.intersect(other, op=np.setdiff1d)","def test_coefficients_two_param_circuits(\n self, circuit, degree, expected_coeffs, use_broadcasting\n ):\n coeffs = coefficients(circuit, circuit.n_inputs, degree, use_broadcasting=use_broadcasting)\n assert np.allclose(coeffs, expected_coeffs)","def get_coeffs(self):\n\n return self._coeff_to_dict()","def __mod__(self, other):\n return (self - other) + (other - self)","def getEquates(self, instruction: ghidra.program.model.listing.Instruction, operandIndex: int) -> List[ghidra.program.model.symbol.Equate]:\n ...","def __add__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] += other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self, other\n if( len( self ) < len( other ) ) : c_l1, c_l2 = other, self\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def omega(self):\n return [coset for coset in range(len(self.p)) if self.p[coset] == coset]","def __xor__(self, other):\r\n if self.field.characteristic == 2:\r\n return runtime.xor(self, other)\r\n\r\n return super().__xor__(other)","def __listsubseteq(self, c1, c2):\n s2 = {}\n for delta in c2:\n s2[delta] = 1\n\n for delta in c1:\n if not s2.has_key(delta):\n return 0\n\n return 1","def all_coeffs(f):\n return dmp_all_coeffs(f.rep, f.lev, f.dom)","def __mul__ (self, other):\n return perm(*(self._getcycles() + other._getcycles()))","def _dot(self, other):\n if self.num_qubits != other.num_qubits:\n raise QiskitError(\"Multiplication on different number of qubits.\")\n result = CNOTDihedral(num_qubits=self.num_qubits)\n result.shift = [\n (x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(self.linear, other.shift), self.shift)\n ]\n result.linear = self._z2matmul(self.linear, other.linear)\n # Compute x' = B1*x + c1 using the p_j identity\n new_vars = []\n for i in range(self.num_qubits):\n support = np.arange(self.num_qubits)[np.nonzero(other.linear[i])]\n poly = SpecialPolynomial(self.num_qubits)\n poly.set_pj(support)\n if other.shift[i] == 1:\n poly = -1 * poly\n poly.weight_0 = (poly.weight_0 + 1) % 8\n new_vars.append(poly)\n # p' = p1 + p2(x')\n result.poly = other.poly + self.poly.evaluate(new_vars)\n return result","def __xor__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other, coerce=False)\n\n if mv:\n newValue = self.layout.omt_func(self.value, other.value)\n else:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return obj^other\n newValue = other*self.value\n\n return self._newMV(newValue)","def lowest_common_subsumer(self, other):\n lcs = set()\n if other == self:\n lcs.add(self)\n return lcs\n if other in self._direct_hypernyms or other.is_root():\n lcs.add(other)\n return lcs\n if self in other._direct_hypernyms or self.is_root():\n lcs.add(self)\n return lcs\n common_hypernyms = self.common_hypernyms(other)\n dist_dict1 = self.get_distances_hypernym_dic()\n dist_dict2 = other.get_distances_hypernym_dic()\n dist = math.inf\n for hypernym in common_hypernyms:\n dist1 = dist_dict1[hypernym]\n dist2 = dist_dict2[hypernym]\n if dist1 + dist2 < dist:\n lcs.clear()\n lcs.add(hypernym)\n dist = dist1 + dist2\n if dist1 + dist2 == dist:\n lcs.add(hypernym)\n return lcs","def similarity_scores(self, other):\n results = []\n\n words_score=compare_dictionaries(other.words, self.words)\n wordl_score=compare_dictionaries(other.word_lengths, self.word_lengths)\n stems_score=compare_dictionaries(other.stems, self.stems)\n sentl_score=compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\n endings_score=compare_dictionaries(other.endings, self.endings)\n results+= [words_score]\n results+= [wordl_score]\n results+= [stems_score]\n results+= [sentl_score]\n results+= [endings_score]\n return results","def __sub__(self, other):\n n = len(self)\n\n if n != len(other):\n raise(VetorError, \"Vetor dimensions are not equal\")\n\n v = zeros_como(self)\n\n for i in range(n):\n v[i] = self[i] - other[i]\n\n return v","def get_covariate_pairs(self):\n if self.covariate_field not in self.matrix.obs.columns:\n raise ValueError(\"Covariate value not available in dataset\")\n from itertools import product\n covariate = set(self.matrix.obs[self.covariate_field])\n return product(covariate, covariate)","def _compose(self, other):\n if self.num_qubits != other.num_qubits:\n raise QiskitError(\"Multiplication on different number of qubits.\")\n result = CNOTDihedral(num_qubits=self.num_qubits)\n result.shift = [\n (x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(other.linear, self.shift), other.shift)\n ]\n result.linear = self._z2matmul(other.linear, self.linear)\n # Compute x' = B1*x + c1 using the p_j identity\n new_vars = []\n for i in range(self.num_qubits):\n support = np.arange(other.num_qubits)[np.nonzero(self.linear[i])]\n poly = SpecialPolynomial(self.num_qubits)\n poly.set_pj(support)\n if self.shift[i] == 1:\n poly = -1 * poly\n poly.weight_0 = (poly.weight_0 + 1) % 8\n new_vars.append(poly)\n # p' = p1 + p2(x')\n result.poly = self.poly + other.poly.evaluate(new_vars)\n return result","def mix(self, other: \"DiscreteFactorTable\"):\n if (len(self.support) == 0):\n return other\n if (len(other.support) == 0):\n return self\n\n # NOTE: can this be relaxed?\n assert type(self.support[0]) == type(other.support[0])\n\n jsupport = []\n jlogits = []\n matchedrows = []\n unmatchedrows = []\n\n #check that all entries have same keys\n if isinstance(self.support[0], (dict, frozendict)):\n s_keys = tuple(self.support[0].keys())\n for si in self.support:\n assert tuple(si.keys()) == s_keys\n if isinstance(other.support[0], (dict, frozendict)):\n o_keys = tuple(other.support[0].keys())\n for oi in self.support:\n assert tuple(oi.keys()) == o_keys\n\n #first get inner join rows, tracking ones that don't match\n for si, oi in product(self.support, other.support):\n if isinstance(si, (dict, frozendict)) and isinstance(oi, (dict, frozendict)):\n if dict_match(si, oi): #not efficient if the cartesian product is large\n matchedrows.extend([si, oi])\n soi = dict_merge(si, oi)\n if soi in jsupport:\n continue\n jprob = np.exp(self.logit(si)) + np.exp(other.logit(oi))\n jlogit = np.log(jprob)\n\n if jlogit == -np.inf:\n continue\n jsupport.append(soi)\n jlogits.append(jlogit)\n else:\n unmatchedrows.extend([si, oi])\n else:\n soi = (si, oi)\n jprob = np.exp(self.logit(si)) + np.exp(other.logit(oi))\n jlogit = np.log(jprob)\n jsupport.append(soi)\n jlogits.append(jlogit)\n\n #add in the left and right outer join rows, ensuring that they were never matched\n for i in unmatchedrows:\n if (i in matchedrows) or (i in jsupport):\n continue\n logit = np.log(np.exp(self.logit(i)) + np.exp(other.logit(i)))\n if logit == -np.inf:\n continue\n jsupport.append(i)\n jlogits.append(logit)\n return DiscreteFactorTable(support=jsupport, logits=jlogits)","def __eq__(self, other):\r\n\t\treturn self._to_pylist() == other._to_pylist()","def difference(self, *other):\n \n new_ordered_set = OrderedSet()\n\n for element in self:\n for obj in other:\n if element in obj:\n break\n else:\n new_ordered_set.add(element)\n\n return new_ordered_set","def centralizer(self, other):\n if hasattr(other, 'generators'):\n if other.is_trivial or self.is_trivial:\n return self\n degree = self.degree\n identity = _af_new(list(range(degree)))\n orbits = other.orbits()\n num_orbits = len(orbits)\n orbits.sort(key=lambda x: -len(x))\n long_base = []\n orbit_reps = [None]*num_orbits\n orbit_reps_indices = [None]*num_orbits\n orbit_descr = [None]*degree\n for i in range(num_orbits):\n orbit = list(orbits[i])\n orbit_reps[i] = orbit[0]\n orbit_reps_indices[i] = len(long_base)\n for point in orbit:\n orbit_descr[point] = i\n long_base = long_base + orbit\n base, strong_gens = self.schreier_sims_incremental(base=long_base)\n strong_gens_distr = _distribute_gens_by_base(base, strong_gens)\n i = 0\n for i in range(len(base)):\n if strong_gens_distr[i] == [identity]:\n break\n base = base[:i]\n base_len = i\n for j in range(num_orbits):\n if base[base_len - 1] in orbits[j]:\n break\n rel_orbits = orbits[: j + 1]\n num_rel_orbits = len(rel_orbits)\n transversals = [None]*num_rel_orbits\n for j in range(num_rel_orbits):\n rep = orbit_reps[j]\n transversals[j] = dict(\n other.orbit_transversal(rep, pairs=True))\n trivial_test = lambda x: True\n tests = [None]*base_len\n for l in range(base_len):\n if base[l] in orbit_reps:\n tests[l] = trivial_test\n else:\n def test(computed_words, l=l):\n g = computed_words[l]\n rep_orb_index = orbit_descr[base[l]]\n rep = orbit_reps[rep_orb_index]\n im = g._array_form[base[l]]\n im_rep = g._array_form[rep]\n tr_el = transversals[rep_orb_index][base[l]]\n # using the definition of transversal,\n # base[l]^g = rep^(tr_el*g);\n # if g belongs to the centralizer, then\n # base[l]^g = (rep^g)^tr_el\n return im == tr_el._array_form[im_rep]\n tests[l] = test\n\n def prop(g):\n return [rmul(g, gen) for gen in other.generators] == \\\n [rmul(gen, g) for gen in other.generators]\n return self.subgroup_search(prop, base=base,\n strong_gens=strong_gens, tests=tests)\n elif hasattr(other, '__getitem__'):\n gens = list(other)\n return self.centralizer(PermutationGroup(gens))\n elif hasattr(other, 'array_form'):\n return self.centralizer(PermutationGroup([other]))","def __eq__(self, polynomial_2: object) -> bool:\n if not isinstance(polynomial_2, Polynomial):\n return False\n\n if self.degree != polynomial_2.degree:\n return False\n\n for i in range(self.degree + 1):\n if self.coefficients[i] != polynomial_2.coefficients[i]:\n return False\n\n return True","def __iadd__(self, other):\n self.components = [c1 + c2 for (c1, c2) in zip(self, other)]\n return self","def test_coefficients(self):\n\n coefs = self.cs.coefficients\n\n self.assertEqual(coefs, (1, 0, 1, 0, 0, -1))","def __add__(self, other):\n if (len(self.arg) < len(other.arg)):\n summ = Polynomial(other.arg)\n i = len(self.arg) - 1\n for x in self.arg:\n summ.arg[i] = self.arg[i] + summ.arg[i]\n i = i - 1\n else:\n summ = Polynomial(self.arg)\n i = len(other.arg) - 1\n for x in other.arg:\n summ.arg[i] = other.arg[i] + summ.arg[i]\n i = i - 1\n return summ","def dot(self, other: 'ModelParameters') -> float:\n param_products = []\n for idx in range(len(self.parameters)):\n param_products.append((self.parameters[idx] * other.parameters[idx]).sum().item())\n return sum(param_products)","def only_diff_elements(s1, s2):\n\n return set(s1 ^ s2)","def adjoint(self):\n return self.cofactorMatrix().transpose()","def symmetric_difference(self, other):\n return SymmetricDifference(self, other)","def __eq__(self, other):\n return LimitedGoniometer.__eq__(self,other) and \\\n (np.deg2rad(self.chi) == other.chi) and \\\n (np.deg2rad(self.omega) == other.omega)","def __eq__(self, other):\n return (self.real+(self.imag*1j)) == (other.real+(other.imag*1j))\n #return (Complex(self.real, self.imag) == Complex(other.real, other.imag))","def __cross(self,A, B):\n return [s+t for s in A for t in B]","def intersection(self, other):\n new_ieqs = []\n new_ieqs.extend(self.inequalities())\n new_ieqs.extend(other.inequalities())\n\n new_eqns = []\n new_eqns.extend(self.equations())\n new_eqns.extend(other.equations())\n\n return Polyhedron(ieqs = new_ieqs, eqns = new_eqns, \n field=self.coerce_field(other))","def combinations(self):\n return self._combinations","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def __eq__(self, other):\n if not isinstance(other, OneOfSolidNumericsSolver):\n return False\n\n return self.to_dict() == other.to_dict()","def __eq__(self, other):\n return (self.vertices == other.vertices and self.weight == other.weight)","def __and__(self, other):\n points = self.crossForm(other)\n points += [point for point in self.points if point in other]\n points += [point for point in other.points if point in self]\n if points: return Form(points)","def __eq__(self, other):\n return np.allclose(self.P, other.P)","def All(self):\n return Constrains._constrains.copy()","def __eq__(self, other):\n\n if hasattr(other, 'vector'):\n return self.vector == other.vector","def get_base_coefs(mv):\n\trs = []\n\tfor bs in bases:\n\t\tt = []\n\t\tfor b in bs:\n\t\t\tt.append(mv.coef(b))\n\t\t\t\t\t\n\t\trs.append(t)\t\t\n\treturn rs","def union(self, other):\n return PermClass([S_1 + S_2 for S_1, S_2 in zip(self, other)])","def equivalencies(self):\n if hasattr(self, '_equivalencies'):\n return self._equivalencies\n else:\n return self._default_equivalencies"],"string":"[\n \"def __xor__(self, other):\\n\\n sym_diff = [value for value in self if value not in other]\\n sym_diff.extend([value for value in other if value not in self])\\n\\n return sym_diff\",\n \"def GetEqualConstrains(self):\\n return _gmat_py.Spacecraft_GetEqualConstrains(self)\",\n \"def coefficients(self) :\\n raise NotImplementedError\",\n \"def coefficients(self) :\\n return self.__coefficients\",\n \"def __pow__(self, other):\\n n = len(self)\\n\\n v = zeros_como(self)\\n\\n for i in range(n):\\n v[i] = self[i]**other\\n\\n return v\",\n \"def coefficients(self):\\n return self._coefficients\",\n \"def coefficients(self):\\n return self._coefficients\",\n \"def __sub__(self, other: 'ModelParameters') -> 'ModelParameters':\\n return ModelParameters([self[idx] - other[idx] for idx in range(len(self))])\",\n \"def coefficients(self) -> np.ndarray:\\n return self._coefficients\",\n \"def get_coefficients(self):\\n return self.coefficients\",\n \"def get_coefficients(self):\\n return self.coefficients\",\n \"def __xor__(self, other):\\n a, b = Trits.match_length(self, other)\\n return Trits([x ^ y for x, y in zip(a, b)])\",\n \"def getEquates(self) -> Iterator[ghidra.program.model.symbol.Equate]:\\n ...\",\n \"def __isub__(self, other):\\n self.components = [c1 - c2 for (c1, c2) in zip(self, other)]\\n return self\",\n \"def __sub__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] -= other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self.coefficients, other.coefficients\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = c_l2, c_l1\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def pd(self, other):\\n return Matriz([self]).T() * Matriz([other])\",\n \"def find_coefficients(self):\\n self.make_matrix()\\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition\",\n \"def __eq__(self, other):\\n if self.coeff != other.coeff:\\n return False\\n \\n if self.GetKeggID() != other.GetKeggID():\\n return False\\n \\n if self.phase.Name() != other.phase.Name():\\n return False\\n \\n return True\",\n \"def test_coefficient_orders(self):\\n for i in range(2, 5):\\n spec = {2*j: 0 for j in range(i)}\\n bcs_ref = BoundaryConditions(spec, 2*i-2)\\n bcs_main = BoundaryConditions(spec, 2*i)\\n\\n coeffs_ref = get_ext_coeffs(bcs_ref)[i-1]\\n coeffs_main = get_ext_coeffs(bcs_main)[i-1]\\n\\n assert coeffs_ref == coeffs_main\",\n \"def enthalpy_equality_func(self):\\n residual = []\\n for i in range(self.num_i):\\n residual += [self.inl[i].h.val_SI - self.outl[i].h.val_SI]\\n return residual\",\n \"def coefficients(self, force_characters = False) :\\n raise NotImplementedError\",\n \"def __xor__(self, other):\\r\\n return self + other - 2 * self * other\",\n \"def IsEqualOrder(self,other):\\n return self.InferPolynomialDegree() == other.InferPolynomialDegree()\",\n \"def coefficients(self):\\r\\n return self.coef_['x']\",\n \"def __isub__(self, other):\\n self.components = [c1 - c2 for (c1, c2) in zip(self.components, other.components)]\\n return self\",\n \"def __sub__(self, other):\\n # \\n # TODO - your code here\\n #\\n result = [];\\n for i in range(self.h):\\n result.append([a-b for a,b in zip(self.g[i],other.g[i])]);\\n \\n return Matrix(result);\",\n \"def __and__(self, other):\\n\\n return [value for value in self if value in other]\",\n \"def commutator(self, other) -> 'MultiVector':\\n\\n return ((self * other) - (other * self)) / 2\",\n \"def commutes_with(self, other):\\n if not isinstance(other, type(self)):\\n raise TypeError(\\n 'Can only test commutation with another MajoranaOperator.')\\n\\n if len(self.terms) == 1 and len(other.terms) == 1:\\n return _majorana_terms_commute(\\n list(self.terms.keys())[0],\\n list(other.terms.keys())[0])\\n return self * other == other * self\",\n \"def __sub__(self, other):\\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])\",\n \"def a_coefficients(y1,y2):\\n\\tACoefficients = np.array([\\ty1, \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\ty2 ]).astype(float)\\n\\treturn(ACoefficients)\",\n \"def __xor__(self, other: t.Any) -> InspectableSet[_C]:\\n return self._op_copy('__xor__', other)\",\n \"def rhs_atoms(self):\\n\\n return itertools.chain(self.rhs_names, self.rhs_funcs)\",\n \"def difference(self, other): # type: (Term) -> Term\\n return self.intersect(other.inverse)\",\n \"def getSmoothnessABC(self,other):\\n\\t\\tif not self.sectors == other.sectors:\\n\\t\\t\\traise ValueError(\\\"Sectors do not match\\\")\\n\\t\\ttotalNzero = self.nZero + other.nZero\\n\\n\\t\\tDself = np.zeros((2*self.totalBins))\\n\\t\\tDother = np.zeros((2*other.totalBins))\\n\\t\\tZself = np.zeros((2*totalNzero, 2*self.totalBins))\\n\\t\\tZother = np.zeros((2*totalNzero, 2*other.totalBins))\\n\\t\\tfor s in range(self.nSect):\\n\\t\\t\\tstartSelf = self.borders[s]\\n\\t\\t\\tstartOther = other.borders[s]\\n\\t\\t\\tnBins = min(self.borders[s+1] - self.borders[s], other.borders[s+1] - other.borders[s])\\n\\t\\t\\tfor i in range(nBins):\\n\\t\\t\\t\\tdelRe = self.reals[startSelf+i] - other.reals[startOther+i]\\n\\t\\t\\t\\tdelIm = self.imags[startSelf+i] - other.imags[startOther+i]\\n\\t\\t\\t\\tDself[2*(startSelf + i) ] = delRe\\n\\t\\t\\t\\tDself[2*(startSelf + i)+1] = delIm\\n\\t\\t\\t\\tDother[2*(startOther + i) ] = delRe\\n\\t\\t\\t\\tDother[2*(startOther + i)+1] = delIm\\n\\t\\t\\t\\tfor z in range(self.nZero):\\n\\t\\t\\t\\t\\tzeroVal = self.zeroModes[z][startSelf+i]\\n\\t\\t\\t\\t\\tZself[2*z ,2*(startSelf + i) ] = zeroVal\\n\\t\\t\\t\\t\\tZself[2*z+1,2*(startSelf + i)+1 ] = zeroVal\\n\\t\\t\\t\\t\\tZother[2*z ,2*(startOther + i) ] = zeroVal\\n\\t\\t\\t\\t\\tZother[2*z+1,2*(startOther + i)+1] = zeroVal\\n\\t\\t\\t\\tz0 = self.nZero\\n\\t\\t\\t\\tfor z in range(other.nZero):\\n\\t\\t\\t\\t\\tzeroVal = -other.zeroModes[z][startOther+i]\\n\\t\\t\\t\\t\\tZself[2*(z+z0) , 2*(startSelf + i) ] = zeroVal\\n\\t\\t\\t\\t\\tZself[2*(z+z0)+1 , 2*(startSelf + i)+1] = zeroVal\\n\\t\\t\\t\\t\\tZother[2*(z+z0) , 2*(startOther+ i) ] = zeroVal\\n\\t\\t\\t\\t\\tZother[2*(z+z0)+1, 2*(startOther+ i)+1] = zeroVal\\n\\t\\tDCself = np.dot(Dself, self.comaInv)\\n\\t\\tDCother = np.dot(Dother, other.comaInv)\\n\\n\\t\\tCself = np.dot(Dself, DCself)\\n\\t\\tCother = np.dot(Dother, DCother)\\n\\t\\tBself = np.dot(Zself, DCself)\\n\\t\\tBother = np.dot(Zother, DCother)\\n\\t\\tAself = np.dot(Zself, np.transpose(np.dot(Zself, self.comaInv)))\\n\\t\\tAother = np.dot(Zother, np.transpose(np.dot(Zother, other.comaInv)))\\n\\t\\treturn Aself+Aother, 2*(Bself + Bother), Cself + Cother # A factor 2 was missing inB\",\n \"def __xor__(self, other):\\n\\n if isinstance(other, Dyadic):\\n return NotImplemented\\n if isinstance(other, (int, type(Zero()))):\\n if (other == 0):\\n return self * 0\\n self._check_vector(other)\\n\\n def _det(mat):\\n \\\"\\\"\\\"This is needed as a little method for to find the determinant\\n of a list in python; needs to work for a 3x3 list.\\n SymPy's Matrix won't take in Vector, so need a custom function.\\n You shouldn't be calling this.\\n\\n \\\"\\\"\\\"\\n\\n return (mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1])\\n + mat[0][1] * (mat[1][2] * mat[2][0] - mat[1][0] *\\n mat[2][2]) + mat[0][2] * (mat[1][0] * mat[2][1] -\\n mat[1][1] * mat[2][0]))\\n\\n outvec = Vector([])\\n ar = other.args # For brevity\\n for i, v in enumerate(ar):\\n tempx = v[1].x\\n tempy = v[1].y\\n tempz = v[1].z\\n tempm = ([[tempx, tempy, tempz], [self & tempx, self & tempy,\\n self & tempz], [Vector([ar[i]]) & tempx,\\n Vector([ar[i]]) & tempy, Vector([ar[i]]) & tempz]])\\n outvec += _det(tempm)\\n return outvec\",\n \"def smaller(self):\\n return [x for x in TransitiveIdeal(attrcall('pred'), [self])]\",\n \"def __eq__(self, other):\\n\\n equalCoordinates = self.getCoordinate() == other.getCoordinate()\\n equalMasses = self.getMass() == other.getMass()\\n equalVelocities = self.getVelocity() == other.getVelocity()\\n equalAccelerations = self.getAcceleration() == other.getAcceleration()\\n\\n return equalCoordinates & equalMasses & equalVelocities & equalAccelerations\",\n \"def __mul__(self, polynomial_2: Polynomial) -> Polynomial:\\n coefficients: list[float] = [0] * (self.degree + polynomial_2.degree + 1)\\n for i in range(self.degree + 1):\\n for j in range(polynomial_2.degree + 1):\\n coefficients[i + j] += (\\n self.coefficients[i] * polynomial_2.coefficients[j]\\n )\\n\\n return Polynomial(self.degree + polynomial_2.degree, coefficients)\",\n \"def atoms(self):\\n return itertools.chain(self.rhs_atoms, self.lhs_atoms)\",\n \"def __pow__(self, other):\\n if other == 2:\\n # cartesian product\\n new_set = Set()\\n for s1 in self:\\n for s2 in self:\\n new_set += Set(List([[s1, s2]]))\\n return new_set\\n raise TypeError(\\n f\\\"{other} must be 2 to compute cartesian product of a set with itself\\\")\",\n \"def __add__(self, other):\\n sum_ct = ContingencyTable(*(self.table + other.table).tolist())\\n return sum_ct\",\n \"def __eq__(self, rhs: Union[float, Simpy]) -> list[bool]:\\n mask: list[bool] = []\\n if isinstance(rhs, float):\\n for item in self.values:\\n mask.append(item == rhs)\\n else:\\n assert len(self.values) == len(rhs.values)\\n for i in range(len(self.values)):\\n mask.append(self.values[i] == rhs.values[i])\\n return mask\",\n \"def __add__(self, other: 'ModelParameters') -> 'ModelParameters':\\n return ModelParameters([self[idx] + other[idx] for idx in range(len(self))])\",\n \"def kspace_cholesky_solve_(self, other):\\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\\n self_k = transform(self, np.fft.fftn, n_points = n_points)\\n other_k = transform(other, np.fft.fftn, n_points = n_points)\\n\\n ret = tmat()\\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\\n #ret = self_k*1.0\\n ret.blocks*=0.0\\n\\n #ret.blocks[:-1] = np.einsum(\\\"ijk,ikl->ijl\\\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\\n\\n for i in np.arange(len(self_k.blocks)-1):\\n \\n #print(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i])))\\n #assert(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i]))<1e-10), \\\"not symmetric\\\"\\n #assert(np.linalg.norm(self_k.blocks[i].T-self_k.blocks[i])<1e-10), \\\"not symmetric\\\"\\n Mk = np.linalg.cholesky(self_k.blocks[i])\\n yk = np.linalg.solve(Mk, other_k.blocks[i])\\n\\n\\n ret.blocks[i] = np.linalg.solve(Mk.conj().T, yk)\\n\\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\\n return ret\",\n \"def __xor__(self, other):\\n if type(other) == Form:\\n other = [other]\\n return Form.union([other, self])\",\n \"def xor(self, t1, t2):\\n return [x ^ y for x, y in zip(t1, t2)]\",\n \"def __xor__(self, other: Compound[Scalar]) -> Compound[Scalar]:\\n return (self._pack_points(self._points_set ^ other._points_set)\\n if isinstance(other, Multipoint)\\n else NotImplemented)\",\n \"def corr_with(self, other):\\n return self.data.corrwith(other)\",\n \"def __sub__(self, other):\\n return Point([c1 - c2 for (c1, c2) in zip(self, other)])\",\n \"def jaccard_similarity(iterable1, iterable2):\\n t = ConfusionMatrix2.from_sets(iterable1, iterable2)\\n return t.jaccard_coeff()\",\n \"def coefficients(self):\\n if self._coefficients is None:\\n return np.hstack([c.coefficients for c in self._traces])\\n return self._coefficients\",\n \"def common_hypernyms(self, other):\\n return set(self.all_hypernyms()).intersection(set(other.all_hypernyms()))\",\n \"def __xor__(self, other):\\n if not isinstance(other, UniSet):\\n other = self.fam.c_uniset(other)\\n return self.fam.c_xor(self, other)\",\n \"def setdiff(self, other):\\n\\n return self.intersect(other, op=np.setdiff1d)\",\n \"def test_coefficients_two_param_circuits(\\n self, circuit, degree, expected_coeffs, use_broadcasting\\n ):\\n coeffs = coefficients(circuit, circuit.n_inputs, degree, use_broadcasting=use_broadcasting)\\n assert np.allclose(coeffs, expected_coeffs)\",\n \"def get_coeffs(self):\\n\\n return self._coeff_to_dict()\",\n \"def __mod__(self, other):\\n return (self - other) + (other - self)\",\n \"def getEquates(self, instruction: ghidra.program.model.listing.Instruction, operandIndex: int) -> List[ghidra.program.model.symbol.Equate]:\\n ...\",\n \"def __add__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] += other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self, other\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = other, self\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def omega(self):\\n return [coset for coset in range(len(self.p)) if self.p[coset] == coset]\",\n \"def __xor__(self, other):\\r\\n if self.field.characteristic == 2:\\r\\n return runtime.xor(self, other)\\r\\n\\r\\n return super().__xor__(other)\",\n \"def __listsubseteq(self, c1, c2):\\n s2 = {}\\n for delta in c2:\\n s2[delta] = 1\\n\\n for delta in c1:\\n if not s2.has_key(delta):\\n return 0\\n\\n return 1\",\n \"def all_coeffs(f):\\n return dmp_all_coeffs(f.rep, f.lev, f.dom)\",\n \"def __mul__ (self, other):\\n return perm(*(self._getcycles() + other._getcycles()))\",\n \"def _dot(self, other):\\n if self.num_qubits != other.num_qubits:\\n raise QiskitError(\\\"Multiplication on different number of qubits.\\\")\\n result = CNOTDihedral(num_qubits=self.num_qubits)\\n result.shift = [\\n (x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(self.linear, other.shift), self.shift)\\n ]\\n result.linear = self._z2matmul(self.linear, other.linear)\\n # Compute x' = B1*x + c1 using the p_j identity\\n new_vars = []\\n for i in range(self.num_qubits):\\n support = np.arange(self.num_qubits)[np.nonzero(other.linear[i])]\\n poly = SpecialPolynomial(self.num_qubits)\\n poly.set_pj(support)\\n if other.shift[i] == 1:\\n poly = -1 * poly\\n poly.weight_0 = (poly.weight_0 + 1) % 8\\n new_vars.append(poly)\\n # p' = p1 + p2(x')\\n result.poly = other.poly + self.poly.evaluate(new_vars)\\n return result\",\n \"def __xor__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other, coerce=False)\\n\\n if mv:\\n newValue = self.layout.omt_func(self.value, other.value)\\n else:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return obj^other\\n newValue = other*self.value\\n\\n return self._newMV(newValue)\",\n \"def lowest_common_subsumer(self, other):\\n lcs = set()\\n if other == self:\\n lcs.add(self)\\n return lcs\\n if other in self._direct_hypernyms or other.is_root():\\n lcs.add(other)\\n return lcs\\n if self in other._direct_hypernyms or self.is_root():\\n lcs.add(self)\\n return lcs\\n common_hypernyms = self.common_hypernyms(other)\\n dist_dict1 = self.get_distances_hypernym_dic()\\n dist_dict2 = other.get_distances_hypernym_dic()\\n dist = math.inf\\n for hypernym in common_hypernyms:\\n dist1 = dist_dict1[hypernym]\\n dist2 = dist_dict2[hypernym]\\n if dist1 + dist2 < dist:\\n lcs.clear()\\n lcs.add(hypernym)\\n dist = dist1 + dist2\\n if dist1 + dist2 == dist:\\n lcs.add(hypernym)\\n return lcs\",\n \"def similarity_scores(self, other):\\n results = []\\n\\n words_score=compare_dictionaries(other.words, self.words)\\n wordl_score=compare_dictionaries(other.word_lengths, self.word_lengths)\\n stems_score=compare_dictionaries(other.stems, self.stems)\\n sentl_score=compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\\n endings_score=compare_dictionaries(other.endings, self.endings)\\n results+= [words_score]\\n results+= [wordl_score]\\n results+= [stems_score]\\n results+= [sentl_score]\\n results+= [endings_score]\\n return results\",\n \"def __sub__(self, other):\\n n = len(self)\\n\\n if n != len(other):\\n raise(VetorError, \\\"Vetor dimensions are not equal\\\")\\n\\n v = zeros_como(self)\\n\\n for i in range(n):\\n v[i] = self[i] - other[i]\\n\\n return v\",\n \"def get_covariate_pairs(self):\\n if self.covariate_field not in self.matrix.obs.columns:\\n raise ValueError(\\\"Covariate value not available in dataset\\\")\\n from itertools import product\\n covariate = set(self.matrix.obs[self.covariate_field])\\n return product(covariate, covariate)\",\n \"def _compose(self, other):\\n if self.num_qubits != other.num_qubits:\\n raise QiskitError(\\\"Multiplication on different number of qubits.\\\")\\n result = CNOTDihedral(num_qubits=self.num_qubits)\\n result.shift = [\\n (x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(other.linear, self.shift), other.shift)\\n ]\\n result.linear = self._z2matmul(other.linear, self.linear)\\n # Compute x' = B1*x + c1 using the p_j identity\\n new_vars = []\\n for i in range(self.num_qubits):\\n support = np.arange(other.num_qubits)[np.nonzero(self.linear[i])]\\n poly = SpecialPolynomial(self.num_qubits)\\n poly.set_pj(support)\\n if self.shift[i] == 1:\\n poly = -1 * poly\\n poly.weight_0 = (poly.weight_0 + 1) % 8\\n new_vars.append(poly)\\n # p' = p1 + p2(x')\\n result.poly = self.poly + other.poly.evaluate(new_vars)\\n return result\",\n \"def mix(self, other: \\\"DiscreteFactorTable\\\"):\\n if (len(self.support) == 0):\\n return other\\n if (len(other.support) == 0):\\n return self\\n\\n # NOTE: can this be relaxed?\\n assert type(self.support[0]) == type(other.support[0])\\n\\n jsupport = []\\n jlogits = []\\n matchedrows = []\\n unmatchedrows = []\\n\\n #check that all entries have same keys\\n if isinstance(self.support[0], (dict, frozendict)):\\n s_keys = tuple(self.support[0].keys())\\n for si in self.support:\\n assert tuple(si.keys()) == s_keys\\n if isinstance(other.support[0], (dict, frozendict)):\\n o_keys = tuple(other.support[0].keys())\\n for oi in self.support:\\n assert tuple(oi.keys()) == o_keys\\n\\n #first get inner join rows, tracking ones that don't match\\n for si, oi in product(self.support, other.support):\\n if isinstance(si, (dict, frozendict)) and isinstance(oi, (dict, frozendict)):\\n if dict_match(si, oi): #not efficient if the cartesian product is large\\n matchedrows.extend([si, oi])\\n soi = dict_merge(si, oi)\\n if soi in jsupport:\\n continue\\n jprob = np.exp(self.logit(si)) + np.exp(other.logit(oi))\\n jlogit = np.log(jprob)\\n\\n if jlogit == -np.inf:\\n continue\\n jsupport.append(soi)\\n jlogits.append(jlogit)\\n else:\\n unmatchedrows.extend([si, oi])\\n else:\\n soi = (si, oi)\\n jprob = np.exp(self.logit(si)) + np.exp(other.logit(oi))\\n jlogit = np.log(jprob)\\n jsupport.append(soi)\\n jlogits.append(jlogit)\\n\\n #add in the left and right outer join rows, ensuring that they were never matched\\n for i in unmatchedrows:\\n if (i in matchedrows) or (i in jsupport):\\n continue\\n logit = np.log(np.exp(self.logit(i)) + np.exp(other.logit(i)))\\n if logit == -np.inf:\\n continue\\n jsupport.append(i)\\n jlogits.append(logit)\\n return DiscreteFactorTable(support=jsupport, logits=jlogits)\",\n \"def __eq__(self, other):\\r\\n\\t\\treturn self._to_pylist() == other._to_pylist()\",\n \"def difference(self, *other):\\n \\n new_ordered_set = OrderedSet()\\n\\n for element in self:\\n for obj in other:\\n if element in obj:\\n break\\n else:\\n new_ordered_set.add(element)\\n\\n return new_ordered_set\",\n \"def centralizer(self, other):\\n if hasattr(other, 'generators'):\\n if other.is_trivial or self.is_trivial:\\n return self\\n degree = self.degree\\n identity = _af_new(list(range(degree)))\\n orbits = other.orbits()\\n num_orbits = len(orbits)\\n orbits.sort(key=lambda x: -len(x))\\n long_base = []\\n orbit_reps = [None]*num_orbits\\n orbit_reps_indices = [None]*num_orbits\\n orbit_descr = [None]*degree\\n for i in range(num_orbits):\\n orbit = list(orbits[i])\\n orbit_reps[i] = orbit[0]\\n orbit_reps_indices[i] = len(long_base)\\n for point in orbit:\\n orbit_descr[point] = i\\n long_base = long_base + orbit\\n base, strong_gens = self.schreier_sims_incremental(base=long_base)\\n strong_gens_distr = _distribute_gens_by_base(base, strong_gens)\\n i = 0\\n for i in range(len(base)):\\n if strong_gens_distr[i] == [identity]:\\n break\\n base = base[:i]\\n base_len = i\\n for j in range(num_orbits):\\n if base[base_len - 1] in orbits[j]:\\n break\\n rel_orbits = orbits[: j + 1]\\n num_rel_orbits = len(rel_orbits)\\n transversals = [None]*num_rel_orbits\\n for j in range(num_rel_orbits):\\n rep = orbit_reps[j]\\n transversals[j] = dict(\\n other.orbit_transversal(rep, pairs=True))\\n trivial_test = lambda x: True\\n tests = [None]*base_len\\n for l in range(base_len):\\n if base[l] in orbit_reps:\\n tests[l] = trivial_test\\n else:\\n def test(computed_words, l=l):\\n g = computed_words[l]\\n rep_orb_index = orbit_descr[base[l]]\\n rep = orbit_reps[rep_orb_index]\\n im = g._array_form[base[l]]\\n im_rep = g._array_form[rep]\\n tr_el = transversals[rep_orb_index][base[l]]\\n # using the definition of transversal,\\n # base[l]^g = rep^(tr_el*g);\\n # if g belongs to the centralizer, then\\n # base[l]^g = (rep^g)^tr_el\\n return im == tr_el._array_form[im_rep]\\n tests[l] = test\\n\\n def prop(g):\\n return [rmul(g, gen) for gen in other.generators] == \\\\\\n [rmul(gen, g) for gen in other.generators]\\n return self.subgroup_search(prop, base=base,\\n strong_gens=strong_gens, tests=tests)\\n elif hasattr(other, '__getitem__'):\\n gens = list(other)\\n return self.centralizer(PermutationGroup(gens))\\n elif hasattr(other, 'array_form'):\\n return self.centralizer(PermutationGroup([other]))\",\n \"def __eq__(self, polynomial_2: object) -> bool:\\n if not isinstance(polynomial_2, Polynomial):\\n return False\\n\\n if self.degree != polynomial_2.degree:\\n return False\\n\\n for i in range(self.degree + 1):\\n if self.coefficients[i] != polynomial_2.coefficients[i]:\\n return False\\n\\n return True\",\n \"def __iadd__(self, other):\\n self.components = [c1 + c2 for (c1, c2) in zip(self, other)]\\n return self\",\n \"def test_coefficients(self):\\n\\n coefs = self.cs.coefficients\\n\\n self.assertEqual(coefs, (1, 0, 1, 0, 0, -1))\",\n \"def __add__(self, other):\\n if (len(self.arg) < len(other.arg)):\\n summ = Polynomial(other.arg)\\n i = len(self.arg) - 1\\n for x in self.arg:\\n summ.arg[i] = self.arg[i] + summ.arg[i]\\n i = i - 1\\n else:\\n summ = Polynomial(self.arg)\\n i = len(other.arg) - 1\\n for x in other.arg:\\n summ.arg[i] = other.arg[i] + summ.arg[i]\\n i = i - 1\\n return summ\",\n \"def dot(self, other: 'ModelParameters') -> float:\\n param_products = []\\n for idx in range(len(self.parameters)):\\n param_products.append((self.parameters[idx] * other.parameters[idx]).sum().item())\\n return sum(param_products)\",\n \"def only_diff_elements(s1, s2):\\n\\n return set(s1 ^ s2)\",\n \"def adjoint(self):\\n return self.cofactorMatrix().transpose()\",\n \"def symmetric_difference(self, other):\\n return SymmetricDifference(self, other)\",\n \"def __eq__(self, other):\\n return LimitedGoniometer.__eq__(self,other) and \\\\\\n (np.deg2rad(self.chi) == other.chi) and \\\\\\n (np.deg2rad(self.omega) == other.omega)\",\n \"def __eq__(self, other):\\n return (self.real+(self.imag*1j)) == (other.real+(other.imag*1j))\\n #return (Complex(self.real, self.imag) == Complex(other.real, other.imag))\",\n \"def __cross(self,A, B):\\n return [s+t for s in A for t in B]\",\n \"def intersection(self, other):\\n new_ieqs = []\\n new_ieqs.extend(self.inequalities())\\n new_ieqs.extend(other.inequalities())\\n\\n new_eqns = []\\n new_eqns.extend(self.equations())\\n new_eqns.extend(other.equations())\\n\\n return Polyhedron(ieqs = new_ieqs, eqns = new_eqns, \\n field=self.coerce_field(other))\",\n \"def combinations(self):\\n return self._combinations\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def __eq__(self, other):\\n if not isinstance(other, OneOfSolidNumericsSolver):\\n return False\\n\\n return self.to_dict() == other.to_dict()\",\n \"def __eq__(self, other):\\n return (self.vertices == other.vertices and self.weight == other.weight)\",\n \"def __and__(self, other):\\n points = self.crossForm(other)\\n points += [point for point in self.points if point in other]\\n points += [point for point in other.points if point in self]\\n if points: return Form(points)\",\n \"def __eq__(self, other):\\n return np.allclose(self.P, other.P)\",\n \"def All(self):\\n return Constrains._constrains.copy()\",\n \"def __eq__(self, other):\\n\\n if hasattr(other, 'vector'):\\n return self.vector == other.vector\",\n \"def get_base_coefs(mv):\\n\\trs = []\\n\\tfor bs in bases:\\n\\t\\tt = []\\n\\t\\tfor b in bs:\\n\\t\\t\\tt.append(mv.coef(b))\\n\\t\\t\\t\\t\\t\\n\\t\\trs.append(t)\\t\\t\\n\\treturn rs\",\n \"def union(self, other):\\n return PermClass([S_1 + S_2 for S_1, S_2 in zip(self, other)])\",\n \"def equivalencies(self):\\n if hasattr(self, '_equivalencies'):\\n return self._equivalencies\\n else:\\n return self._default_equivalencies\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66310555","0.6198817","0.61889756","0.5865301","0.5818835","0.5683608","0.5683608","0.56740135","0.5648324","0.56273437","0.56273437","0.5593266","0.55242145","0.5514569","0.546532","0.5455155","0.5414487","0.5409538","0.5363544","0.53480685","0.5334692","0.53232247","0.53002703","0.5292918","0.52882516","0.52718186","0.5233594","0.5221504","0.5219258","0.5215172","0.51632375","0.515847","0.5152764","0.51506984","0.5141174","0.5139557","0.5118783","0.51012415","0.50980574","0.5096633","0.5063115","0.5062866","0.50571597","0.5043687","0.5042229","0.5040098","0.50396025","0.5026579","0.501017","0.50096226","0.50094974","0.5008803","0.4993444","0.4991799","0.49832505","0.49819326","0.49696428","0.49661624","0.49544895","0.49509567","0.49439642","0.49437022","0.4937551","0.49374145","0.49257195","0.49219087","0.4918385","0.49071503","0.4906507","0.49015427","0.48845962","0.48816976","0.4880299","0.4878021","0.487765","0.4876724","0.48762232","0.48742834","0.4869939","0.48668262","0.48641574","0.48594037","0.48576808","0.4856895","0.48525363","0.48458672","0.4843521","0.48420364","0.48408514","0.48391318","0.48391318","0.48374033","0.4830426","0.48208165","0.4820636","0.48106027","0.4808377","0.4800521","0.47976816","0.47932193"],"string":"[\n \"0.66310555\",\n \"0.6198817\",\n \"0.61889756\",\n \"0.5865301\",\n \"0.5818835\",\n \"0.5683608\",\n \"0.5683608\",\n \"0.56740135\",\n \"0.5648324\",\n \"0.56273437\",\n \"0.56273437\",\n \"0.5593266\",\n \"0.55242145\",\n \"0.5514569\",\n \"0.546532\",\n \"0.5455155\",\n \"0.5414487\",\n \"0.5409538\",\n \"0.5363544\",\n \"0.53480685\",\n \"0.5334692\",\n \"0.53232247\",\n \"0.53002703\",\n \"0.5292918\",\n \"0.52882516\",\n \"0.52718186\",\n \"0.5233594\",\n \"0.5221504\",\n \"0.5219258\",\n \"0.5215172\",\n \"0.51632375\",\n \"0.515847\",\n \"0.5152764\",\n \"0.51506984\",\n \"0.5141174\",\n \"0.5139557\",\n \"0.5118783\",\n \"0.51012415\",\n \"0.50980574\",\n \"0.5096633\",\n \"0.5063115\",\n \"0.5062866\",\n \"0.50571597\",\n \"0.5043687\",\n \"0.5042229\",\n \"0.5040098\",\n \"0.50396025\",\n \"0.5026579\",\n \"0.501017\",\n \"0.50096226\",\n \"0.50094974\",\n \"0.5008803\",\n \"0.4993444\",\n \"0.4991799\",\n \"0.49832505\",\n \"0.49819326\",\n \"0.49696428\",\n \"0.49661624\",\n \"0.49544895\",\n \"0.49509567\",\n \"0.49439642\",\n \"0.49437022\",\n \"0.4937551\",\n \"0.49374145\",\n \"0.49257195\",\n \"0.49219087\",\n \"0.4918385\",\n \"0.49071503\",\n \"0.4906507\",\n \"0.49015427\",\n \"0.48845962\",\n \"0.48816976\",\n \"0.4880299\",\n \"0.4878021\",\n \"0.487765\",\n \"0.4876724\",\n \"0.48762232\",\n \"0.48742834\",\n \"0.4869939\",\n \"0.48668262\",\n \"0.48641574\",\n \"0.48594037\",\n \"0.48576808\",\n \"0.4856895\",\n \"0.48525363\",\n \"0.48458672\",\n \"0.4843521\",\n \"0.48420364\",\n \"0.48408514\",\n \"0.48391318\",\n \"0.48391318\",\n \"0.48374033\",\n \"0.4830426\",\n \"0.48208165\",\n \"0.4820636\",\n \"0.48106027\",\n \"0.4808377\",\n \"0.4800521\",\n \"0.47976816\",\n \"0.47932193\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78071773"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6896,"cells":{"query":{"kind":"string","value":"r\"\"\" String when the object is printed"},"document":{"kind":"string","value":"def _repr_(self):\n return 'A {}x{} symbolic max plus matrix on {} variables'.format(\n self.dim(), self.dim(), self.num_vars())"},"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 __str__(self):\n return self.printable()","def __str__(self):\r\n return repr(self)","def __str__(self):\n return repr(self)","def __str__(self):\n return \"<%s: %s>\" % (self.__class__, self.describe())","def __str__(self):\n return_string = self.name + \"\\n\" + str(self.traits)\n\n return return_string","def __str__(self):\n # print(self.get_string())\n return self.get_string()","def __str__(self):\n # print(self.get_string())\n return self.get_string()","def _printable(self):\n pass","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self):\n return self.__class__.__name__ + '\\n' + self.__class__.__doc__","def __str__(self):\n debug_str = \"%s ::=\" % str(self.head)\n for symbol in self.body:\n debug_str += \" %s\" % str(symbol)\n return debug_str","def __str__(self): # pragma: no cover\n return self.display()","def __repr__(self) -> str:\n\t\treturn \"- {}\\n{}\\n\".format(self.name, self.__str__())","def __repr__(self) -> str:\n\t\treturn \"\"","def __str__(self):\r\n to_print = (\"Name: \" + self.name + \", Age: \" +\r\n str(self.age) + \", Hobbys: \" + str(self.hobbys))\r\n return to_print","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __repr__(self):\n str(self)","def print(self):\n # Your implementation here","def __str__(self):\n return str(self.__dict__['_obj'])","def print_me(self):\n return \"ID: %s Title: %s\" % (self.ID, self.title)","def __str__(self):\r\n return self.__repr__()","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self):\r\n return str(self)","def display(self):\n print(str(self))","def __repr__(self):\r\n\t\treturn str(self)","def __str__(self):\n\n # Print the class and address.\n msg = \"{0} at {1}\\n\".format(str(self.__class__), str(hex(id(self))))\n\n # Print some other basic information.\n msg = \"{0} line name: ({1})\\n\".format(msg, self.name)\n msg = \"{0} ping_time: ({1})\\n\".format(\n msg,\n self.ping_time.shape[0])\n msg = \"{0} data: ({1})\\n\".format(\n msg,\n self.data.shape[0])\n msg = \"{0} start time: {1}\\n\".format(msg,\n self.ping_time[0])\n msg = \"{0} end time: {1}\\n\" .format(msg,\n self.ping_time[-1])\n\n return msg","def __str__(self):\n print_info = f\"\\nStudent ID: {self._id}, Name: {self._name}, \" \\\n f\"Year: {self._year} \\nPhone: {str(self._phone)}, \" \\\n f\"Address: {str(self._address)} \" \\\n f\"\\nClasses: {str(self._classes)}\" \\\n f\"\\nBirth Date: {self._date}\"\n return print_info","def __str__(self):\n str = \"[{}] ({}) {}\"\n return (str.format(self.__class__.__name__, self.id, self.__dict__))","def _print_custom(self):\n pass","def __str__(self):\n return \"{}\".format(super().__str__())","def __str__(self):\n string = super().__str__()\n string += \"\\n\" + str(self.get_dict())\n return string","def toString(self, indent=\"\"):\n return indent + self.__class__.__name__ + \": { }\"","def __str__(self):\n if self.__description:\n return self.__description\n return repr(self)","def __str__(self):\n return self.format()","def __str__(self):\n return str(self.__s)","def __str__(self) -> str:\n\t\treturn \"{}{}; {}\".format(TAB, self.get_typestring(force_regen=True), self.get_description())","def __repr__(self):\n\t\treturn str(self)","def __repr__(self):\n\t\treturn str(self)","def __pout__(self):\n return self.__str__()","def __str__(self):\n\n return '__str__ for Object'","def toString():","def __repr__(self):\r\n return self.__str__()","def __str__(self):\n print_string = 'key: {} | value: {}'.format(\n str(self.key), str(self.value)\n )\n return print_string","def debug_string(self):\n\n raise NotImplementedError","def __str__(self):\r\n return Assert(self.obj.__str__())","def __str__(self):\n return str(self.obj)","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def repr_(object_):\n return repr(object_)","def __str__(self):\n to_print = '{} : {}\\n'.format('Name'.ljust(34),self.name)\n to_print = to_print + '{} : {}\\n'.format('Name'.ljust(34),self.pathloss.name)\n to_print = to_print + '{} : {}\\n'.format('Number of samples'.ljust(34),self.nsamples)\n to_print = to_print + '{} : {}\\n'.format('Sensor model'.ljust(34),self.sensor_model.name)\n to_print = to_print + '{} : {}\\n'.format('Motion model'.ljust(34),self.motion_model.name)\n return to_print","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __str__(self):\n\n\t\toutput = MyUtilities.common.Container.__str__(self)\n\t\tif (self.thing is not None):\n\t\t\toutput += f\"-- Title: {self.title}\\n\"\n\t\treturn output","def __str__(self):\n return f\"<{full_class_name(self)} {self.name!r} @{'%x' % id(self)}>\"","def display(self):\n print(self)","def __str__(self):\n return '{}({})'.format(type(self).__name__, self.__name)","def __str__(self):\n return str(self.__dict__)","def __str__(self):\n return str(self.__dict__)","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()","def __repr__(self):\n return self.__str__()"],"string":"[\n \"def __str__(self):\\n return self.printable()\",\n \"def __str__(self):\\r\\n return repr(self)\",\n \"def __str__(self):\\n return repr(self)\",\n \"def __str__(self):\\n return \\\"<%s: %s>\\\" % (self.__class__, self.describe())\",\n \"def __str__(self):\\n return_string = self.name + \\\"\\\\n\\\" + str(self.traits)\\n\\n return return_string\",\n \"def __str__(self):\\n # print(self.get_string())\\n return self.get_string()\",\n \"def __str__(self):\\n # print(self.get_string())\\n return self.get_string()\",\n \"def _printable(self):\\n pass\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self):\\n return self.__class__.__name__ + '\\\\n' + self.__class__.__doc__\",\n \"def __str__(self):\\n debug_str = \\\"%s ::=\\\" % str(self.head)\\n for symbol in self.body:\\n debug_str += \\\" %s\\\" % str(symbol)\\n return debug_str\",\n \"def __str__(self): # pragma: no cover\\n return self.display()\",\n \"def __repr__(self) -> str:\\n\\t\\treturn \\\"- {}\\\\n{}\\\\n\\\".format(self.name, self.__str__())\",\n \"def __repr__(self) -> str:\\n\\t\\treturn \\\"\\\"\",\n \"def __str__(self):\\r\\n to_print = (\\\"Name: \\\" + self.name + \\\", Age: \\\" +\\r\\n str(self.age) + \\\", Hobbys: \\\" + str(self.hobbys))\\r\\n return to_print\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __repr__(self):\\n str(self)\",\n \"def print(self):\\n # Your implementation here\",\n \"def __str__(self):\\n return str(self.__dict__['_obj'])\",\n \"def print_me(self):\\n return \\\"ID: %s Title: %s\\\" % (self.ID, self.title)\",\n \"def __str__(self):\\r\\n return self.__repr__()\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self):\\r\\n return str(self)\",\n \"def display(self):\\n print(str(self))\",\n \"def __repr__(self):\\r\\n\\t\\treturn str(self)\",\n \"def __str__(self):\\n\\n # Print the class and address.\\n msg = \\\"{0} at {1}\\\\n\\\".format(str(self.__class__), str(hex(id(self))))\\n\\n # Print some other basic information.\\n msg = \\\"{0} line name: ({1})\\\\n\\\".format(msg, self.name)\\n msg = \\\"{0} ping_time: ({1})\\\\n\\\".format(\\n msg,\\n self.ping_time.shape[0])\\n msg = \\\"{0} data: ({1})\\\\n\\\".format(\\n msg,\\n self.data.shape[0])\\n msg = \\\"{0} start time: {1}\\\\n\\\".format(msg,\\n self.ping_time[0])\\n msg = \\\"{0} end time: {1}\\\\n\\\" .format(msg,\\n self.ping_time[-1])\\n\\n return msg\",\n \"def __str__(self):\\n print_info = f\\\"\\\\nStudent ID: {self._id}, Name: {self._name}, \\\" \\\\\\n f\\\"Year: {self._year} \\\\nPhone: {str(self._phone)}, \\\" \\\\\\n f\\\"Address: {str(self._address)} \\\" \\\\\\n f\\\"\\\\nClasses: {str(self._classes)}\\\" \\\\\\n f\\\"\\\\nBirth Date: {self._date}\\\"\\n return print_info\",\n \"def __str__(self):\\n str = \\\"[{}] ({}) {}\\\"\\n return (str.format(self.__class__.__name__, self.id, self.__dict__))\",\n \"def _print_custom(self):\\n pass\",\n \"def __str__(self):\\n return \\\"{}\\\".format(super().__str__())\",\n \"def __str__(self):\\n string = super().__str__()\\n string += \\\"\\\\n\\\" + str(self.get_dict())\\n return string\",\n \"def toString(self, indent=\\\"\\\"):\\n return indent + self.__class__.__name__ + \\\": { }\\\"\",\n \"def __str__(self):\\n if self.__description:\\n return self.__description\\n return repr(self)\",\n \"def __str__(self):\\n return self.format()\",\n \"def __str__(self):\\n return str(self.__s)\",\n \"def __str__(self) -> str:\\n\\t\\treturn \\\"{}{}; {}\\\".format(TAB, self.get_typestring(force_regen=True), self.get_description())\",\n \"def __repr__(self):\\n\\t\\treturn str(self)\",\n \"def __repr__(self):\\n\\t\\treturn str(self)\",\n \"def __pout__(self):\\n return self.__str__()\",\n \"def __str__(self):\\n\\n return '__str__ for Object'\",\n \"def toString():\",\n \"def __repr__(self):\\r\\n return self.__str__()\",\n \"def __str__(self):\\n print_string = 'key: {} | value: {}'.format(\\n str(self.key), str(self.value)\\n )\\n return print_string\",\n \"def debug_string(self):\\n\\n raise NotImplementedError\",\n \"def __str__(self):\\r\\n return Assert(self.obj.__str__())\",\n \"def __str__(self):\\n return str(self.obj)\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def repr_(object_):\\n return repr(object_)\",\n \"def __str__(self):\\n to_print = '{} : {}\\\\n'.format('Name'.ljust(34),self.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Name'.ljust(34),self.pathloss.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Number of samples'.ljust(34),self.nsamples)\\n to_print = to_print + '{} : {}\\\\n'.format('Sensor model'.ljust(34),self.sensor_model.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Motion model'.ljust(34),self.motion_model.name)\\n return to_print\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __str__(self):\\n\\n\\t\\toutput = MyUtilities.common.Container.__str__(self)\\n\\t\\tif (self.thing is not None):\\n\\t\\t\\toutput += f\\\"-- Title: {self.title}\\\\n\\\"\\n\\t\\treturn output\",\n \"def __str__(self):\\n return f\\\"<{full_class_name(self)} {self.name!r} @{'%x' % id(self)}>\\\"\",\n \"def display(self):\\n print(self)\",\n \"def __str__(self):\\n return '{}({})'.format(type(self).__name__, self.__name)\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\",\n \"def __repr__(self):\\n return self.__str__()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8097469","0.78782415","0.77841264","0.7769064","0.7669302","0.76466906","0.76466906","0.7623327","0.75980204","0.75980204","0.75980204","0.75980204","0.7578883","0.7571893","0.75686365","0.75658494","0.7563032","0.7543171","0.7536491","0.7536491","0.7536491","0.75335777","0.7533551","0.75238943","0.7519295","0.75015163","0.74921685","0.74921685","0.74921685","0.74921685","0.74921685","0.7491741","0.74778247","0.74673915","0.74646866","0.746028","0.7448336","0.74404454","0.7432172","0.74287134","0.74286175","0.7415816","0.7414046","0.74117905","0.7407612","0.740644","0.740644","0.74050784","0.73949355","0.73907","0.73903054","0.7385912","0.73768544","0.737641","0.737323","0.7372543","0.7372543","0.7372543","0.7372543","0.7372543","0.7372","0.7372","0.7372","0.7372","0.7357865","0.7352673","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.734744","0.7347109","0.73441124","0.73388463","0.73385465","0.7324787","0.7324787","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329","0.731329"],"string":"[\n \"0.8097469\",\n \"0.78782415\",\n \"0.77841264\",\n \"0.7769064\",\n \"0.7669302\",\n \"0.76466906\",\n \"0.76466906\",\n \"0.7623327\",\n \"0.75980204\",\n \"0.75980204\",\n \"0.75980204\",\n \"0.75980204\",\n \"0.7578883\",\n \"0.7571893\",\n \"0.75686365\",\n \"0.75658494\",\n \"0.7563032\",\n \"0.7543171\",\n \"0.7536491\",\n \"0.7536491\",\n \"0.7536491\",\n \"0.75335777\",\n \"0.7533551\",\n \"0.75238943\",\n \"0.7519295\",\n \"0.75015163\",\n \"0.74921685\",\n \"0.74921685\",\n \"0.74921685\",\n \"0.74921685\",\n \"0.74921685\",\n \"0.7491741\",\n \"0.74778247\",\n \"0.74673915\",\n \"0.74646866\",\n \"0.746028\",\n \"0.7448336\",\n \"0.74404454\",\n \"0.7432172\",\n \"0.74287134\",\n \"0.74286175\",\n \"0.7415816\",\n \"0.7414046\",\n \"0.74117905\",\n \"0.7407612\",\n \"0.740644\",\n \"0.740644\",\n \"0.74050784\",\n \"0.73949355\",\n \"0.73907\",\n \"0.73903054\",\n \"0.7385912\",\n \"0.73768544\",\n \"0.737641\",\n \"0.737323\",\n \"0.7372543\",\n \"0.7372543\",\n \"0.7372543\",\n \"0.7372543\",\n \"0.7372543\",\n \"0.7372\",\n \"0.7372\",\n \"0.7372\",\n \"0.7372\",\n \"0.7357865\",\n \"0.7352673\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.734744\",\n \"0.7347109\",\n \"0.73441124\",\n \"0.73388463\",\n \"0.73385465\",\n \"0.7324787\",\n \"0.7324787\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\",\n \"0.731329\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6897,"cells":{"query":{"kind":"string","value":"r\"\"\" Evaluates this symbolic matrix at the integer point ``p``."},"document":{"kind":"string","value":"def eval(self, p):\n from max_plus.max_plus_int import minus_infinity, IntegerMaxPlusMatrix\n F = FreeModule(ZZ, self._nvars)\n p = F(p)\n mat = []\n d = self.dim()\n for i in range(d):\n row = []\n for j in range(d):\n pts = self[i,j]\n row.append(minus_infinity() if not pts else max(p.dot_product(v) for v in pts))\n mat.append(row)\n return IntegerMaxPlusMatrix(self._d, self._d, mat)"},"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 evaluate(self,p):\n if not self.initialized: self.__initialize__()\n if self.vp0: p_ = 1-p\n else: p_ = p\n if self.ids_to_consider is None:\n #sum on all parametrized cell\n cf = np.sum(self.V[self.p_ids-1]*p_)/self.V_tot - self.max_v_frac\n else:\n cf = np.sum((self.V[self.ids_to_consider-1]*p_))/self.V_tot - self.max_v_frac\n return cf","def eval_poly(self, p):\n A = self\n m, n = A.shape\n\n if m != n:\n raise DMNonSquareMatrixError(\"Matrix must be square\")\n\n if not p:\n return self.zeros(self.shape, self.domain)\n elif len(p) == 1:\n return p[0] * self.eye(self.shape, self.domain)\n\n # Evaluate p(A) using Horner's method:\n # XXX: Use Paterson-Stockmeyer method?\n I = A.eye(A.shape, A.domain)\n p_A = p[0] * I\n for pi in p[1:]:\n p_A = A*p_A + pi*I\n\n return p_A","def matrix_simmetric_representate(self, p):\r\n if (p >0 and (p <= self.dimension()) ):\r\n v = self.basis_group_oriented_p_chains(p)\r\n p = p - 1\r\n ve = self.basis_group_oriented_p_chains(p)\r\n M = csr_matrix((len(ve.dic), len(v.dic)), dtype=np.int8).toarray()\r\n j = 0\r\n for u1 in list(v.dic.keys()):\r\n d = P_chains([u1],[v.dic[u1]])\r\n l = boundary_op_n(d).dic\r\n for u2 in list(l.keys()):\r\n i = 0\r\n for w in list(ve.dic.keys()):\r\n if (w == u2):\r\n M[i,j] = int((l)[u2])\r\n i = i + 1\r\n j = j + 1\r\n return M \r\n else:\r\n if (p == 0):\r\n return np.identity(len(list(self.basis_group_oriented_p_chains(0).dic.keys())))\r\n else:\r\n return False","def update_p(self, p: float):\n self.p = p\n for k, sequential in self.m_ops.items():\n if sequential[0].is_identity_op():\n sequential[-1].p = p","def EvaluateLocation(self, p_int, , p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def _eval_coeff(self, pt):\n val = 1\n for a in self.args:\n val *= a.coeff(pt)\n return val","def regular(P):\n try:\n cols = P.shape[0]\n ans = np.ones((1, cols))\n # eq = np.matmul(ans, P)\n # s = np.array(np.arange(1, cols + 1))\n eq = np.vstack([P.T - np.identity(cols), ans])\n # va, vec = np.linalg .eig(P)\n results = np.zeros((cols, 1))\n results = np.vstack([results, np.array([1])])\n statetionary = np.linalg.solve(eq.T.dot(eq), eq.T.dot(results)).T\n # print(statetionary)\n # print(np.argwhere(statetionary < 0))\n if len(np.argwhere(statetionary < 0)) > 0:\n return None\n return statetionary\n except Exception as e:\n return None","def evalComponent(self, x, p):\n if p > 0 and p <= self.n:\n p = str(p)\n y = self[\"off\"] + self[\"lin\"] * x\n self._v1d.assignValues(\n {\"A\": self[\"A\" + p], \"al\": self[\"al\" + p], \"ad\": self[\"ad\" + p], \"mu\": self[\"mu\" + p]})\n y += self._v1d.evaluate(x)\n return y\n else:\n raise(PE.PyAValError(\"No such component (no. \" + str(p) + \")\", where=\"MultiVoigt1d::evalComponent\",\n solution=\"Use value between 1 and \" + str(self.n)))","def resolves_matrix(self):\n self.P = np.linalg.solve(self.M, self.f)","def cost_function(H, n_qubits, p, params):\n ini_state=plus_state(n_qubits)\n for i in range(p):\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state","def ap(self, P):\n if P.divides(self.conductor()):\n if (P*P).divides(self.conductor()):\n # It is 0, because the reduction is additive.\n return ZZ(0)\n else:\n # TODO: It is +1 or -1, but I do not yet know how to\n # compute which without using the L-function.\n return '?'\n else:\n return self._S.hecke_matrix(P)[0,0]","def evaluate_rijP(self, q):\n rP_i = self._parent._parent.bodies[self.body_id_i].evaluate_r(q, element_id=self.element_id, ksi=self.element_ksi)\n\n self.r_P_list[0] = rP_i\n\n # distance vector\n r_ij_P = rP_i - self.rP_j\n\n return r_ij_P","def evaluate(self) -> int:","def power(self,p):\r\n\t\t\r\n\t\t# raise to power\r\n\t\tr,o = Li._expand(self,p)\r\n\t\t\r\n\t\treturn Li(r)","def __evaluate(self, point):\n assert len(point) == len(self.weight)-1\n result = self.weight[0]\n for i in range(0,len(point)):\n result += self.weight[i+1] * point[i]\n return result","def _eval_coeff(self, pt):\n return sum(a.coeff(pt) for a in self.args)","def _compute_pTable(self, expand=False, factor=False,\n simplify=False):\n if self._has(\"p\"):\n return\n if not self._has(\"k\"):\n self.kTable(expand=expand, factor=factor, simplify=simplify)\n if not self._has(\"m\"):\n self.multiplicities(expand=expand, factor=factor,\n simplify=simplify)\n p = Array3D(self._.d + 1)\n self._compute_parameters(p, self._.P, self._.m, integral=True,\n name=PARAMETER, sym=SYMBOL)\n self._.p = p\n self.check_handshake()","def __imul__(self, s):\n val = _hypre.HypreParMatrix___imul__(self, s)\n\n # val.thisown = 0\n return self\n\n\n return val","def _precompute_xl(self, p: int) -> List[int]:\n res = [1]\n val = 1\n for _ in range(len(self._s)):\n val = (val * self.X) % p\n res.append(val)\n return res","def regular(P):\n try:\n dim = P.shape[0]\n q = (P - np.eye(dim))\n ones = np.ones(dim)\n q = np.c_[q, ones]\n QTQ = np.dot(q, q.T)\n bQT = np.ones(dim)\n answer = np.linalg.solve(QTQ, bQT)\n if np.all(answer > 0):\n return answer\n else:\n return None\n except Exception as e:\n return None","def evaluate(self, point):\n result = self.__evaluate(point)\n return -1 if result < 0 else 1","def _compute_parameters(self, p, P, m, integral=False, name=None,\n sym=None):\n for h in range(self._.d + 1):\n for i in range(self._.d + 1):\n for j in range(self._.d + 1):\n p[h, i, j] = full_simplify(\n sum(m[t] * P[t, h] * P[t, i] * P[t, j]\n for t in range(self._.d + 1))\n / (self._.n * P[0, h]))\n self._check_parameter(h, i, j, p[h, i, j],\n integral=integral,\n name=name, sym=sym)\n self._check_consistency(p, P[0], name=name, sym=sym)","def EvaluatePosition(self, , p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def solve_ilp(self):\n\n ilp_solution = pylp.Solution()\n self.ilp_solver.set_constraints(self.constraints)\n message = self.ilp_solver.solve(ilp_solution)\n print(\"ILP solved with minimal value \" + str(ilp_solution.get_value()) + \" and status \" + message)\n\n solution = lil_matrix(self.graph.shape)\n for i in range(self.num_variables):\n print(\"value of var \" + str(i) + \" is \" + str(ilp_solution.get_vector()[i]))\n if ilp_solution.get_vector()[i] < 0.5:\n continue\n (u,v) = self.var_to_edge[i]\n solution[u,v] = self.graph[u,v] - self.min_cost + 1\n\n return solution","def Eval(self, r, ppar, pperp, v, gamma=None, p2=None, p=None, xi=None):\n while False:\n yield None","def a_ij(s, p, i=1, j=1): # (Validated)\n from math import sqrt\n if i == j:\n return s.c[i]['a'] # Return pure paramater\n else: # find mixture aij i =/= j\n return (1 - p.m['k'][i][j]) * sqrt(s.c[i]['a'] * s.c[j]['a'])","def I(x, y, l, p):\n \n return 0.5 / (mu * c) * A0**2 * ( u(x, y, l, p) )**2","def success_p(self, input_p = None):\r\n if input_p is None:\r\n input_p = uniform_p(self.n_inputs())\r\n return np.trace(np.dot(np.diag(input_p), self.matrix))","def compute_demand(self, p):\n \n G, h = spdiag([-1.0]*self.n), matrix(0.0, (self.n, 1))\n \n if self.type == 'quad':\n Q, r = self.data\n return solvers.qp(-Q, p-r, G, h)['x']\n\n if self.type == 'sqrt':\n def F(x=None, z=None):\n if x is None: return 0, matrix(1.0, (self.n, 1))\n u, Du, H = self.utility(x)\n f, Df = p.T*x - u, p.T - Du\n if z is None: return f, Df\n return f, Df, -z[0]*H\n return solvers.cp(F, G, h)['x']","def mod_inv(a,p):\r\n\r\n for i in range(1,p):\r\n if (i*a)%p==1: return i\r\n raise ValueError(str(a)+\" has no inverse mod \"+str(p))","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def compute_PSSM_self_information(p):\n return -sp.sum(p*sp.log(p))","def _model(x, p):\n y_hat = 0\n for i, pi in enumerate(reversed(p)):\n y_hat += x**i * pi\n return y_hat","def ij(ij, pol, ant) :\n s.ij(pol, ij, ant)","def laplacian(self, p):\n wf = self._wf(p)\n return - G * self.d * wf.sum()","def eval_function_modlin(point, level_vector, index_vector):\n\n product = 1\n for (l, i, x) in izip(level_vector, index_vector, point):\n if l == 1 and i == 1:\n val = 1\n elif l > 1 and i == 1:\n if x >= 0 and x <= 2 ** (1 - l):\n val = 2 - 2 ** l * x\n else:\n val = 0\n elif l > 1 and i == 2 ** l - 1:\n if x >= 1 - 2 ** (1 - l) and x <= 1:\n val = 2 ** l * x + 1 - i\n else:\n val = 0\n else:\n val = __phi(x * 2 ** l - i)\n product *= val\n if product == 0:\n break\n return product","def expression(self, p):\n num_type, first, second = get_type_first_second_of_binary_operation(p.expression, p.term)\n\n opcode_type = I_for_int_R_for_float(num_type)\n opcode_action = \"ADD\" if p.ADDOP == \"+\" else \"SUB\"\n opcode = opcode_type + opcode_action\n\n temp = next(g_generate_temp_variable_name)\n temp_variables_values_dict[temp] = temp\n\n qaud_code(f\"{opcode} {temp} {first} {second}\")\n return Expression(num_type, temp)","def m_p(Z0, P0, P):\n return m(Z0) * P/P0","def eval(f, a, j=0):\n return f.per(dmp_eval_in(f.rep, f.dom.convert(a), j, f.lev, f.dom), lower=True)","def p(self):\n self.pTable()","def algorithm_1_2(p, c, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (1 - x) * q[j] + x * q[j + 1]\n return q[0]","def _evaluate_recur(self, p):\n if self.is_leaf(p):\n return float(p.element()) # we assume element is numeric\n else:\n op = p.element()\n left_val = self._evaluate_recur(self.left(p))\n right_val = self._evaluate_recur(self.right(p))\n if op == '+':\n return left_val + right_val\n elif op == '-':\n return left_val - right_val\n elif op == '/':\n return left_val / right_val\n else:\n return left_val * right_val # treat 'x' or '*' as multiplication","def _evaluate(self, x):\n raise NotImplementedError()","def perplexity(self):\n raise NotImplementedError(\"To be implemented\")","def _pfunc(i,j,perm):\n if perm[i-1] == j:\n return 1\n else:\n return 0","def P(self):\n self.eigenmatrix()","def return_policy_evaluation(self, p, u, r, T, gamma):\n for s in range(0, self.env.observation_space.n):\n if not np.isnan(p[s]):\n v = np.zeros((1, self.env.observation_space.n), dtype=float)\n v[0, s] = 1.0\n action = int(p[s])\n u[s] = r[s] + gamma * np.sum(np.multiply(u, np.dot(v, T[:, :, action])))\n return u","def polyeval(self, x):\n return NotImplemented","def _evaluate_recur(self, p):\n if self.is_leaf(p):\n return float(p.element()) # we assume element is numeric\n else:\n op = p.element()\n left_val = self._evaluate_recur(self.left(p))\n right_val = self._evaluate_recur(self.right(p))\n if op == '+':\n return left_val + right_val\n elif op == '-':\n return left_val - right_val\n elif op == '/':\n return left_val / right_val\n else: # treat 'x' or '*' as multiplication\n return left_val * right_val","def apply(self, point):\r\n return self*point","def evaluate(self, p: Posting) -> Union[str, None]:\n return self.eval_fn(p)","def _get_Pij(self): \n \n with tf.name_scope(\"getting_Pij\"):\n \n n_splits = int(self.dim_input / self.per_split_feats)\n n_divisible = n_splits * self.per_split_feats\n X_split = tf.split(self.X_transformed[:,0:n_divisible], n_splits, axis=1)\n X_split.append(self.X_transformed[:,n_divisible:])\n \n # get norm along first feature set\n normAX = X_split[0][None, :, :] - X_split[0][:, None, :]\n normAX = tf.reduce_sum(normAX ** 2, axis=2)\n \n for split in range(1, len(X_split)): \n \n # Expand dims of AX to [n_samples, n_samples, n_features], where\n # each \"channel\" in the third dimension is the difference between\n # one sample and all other samples along one feature\n norm_thisFeatureSet = X_split[split][None, :, :] - \\\n X_split[split][:, None, :]\n \n norm_thisFeatureSet = tf.reduce_sum(norm_thisFeatureSet ** 2, axis=2)\n \n # add to existing cumulative sum \n normAX = normAX + norm_thisFeatureSet\n \n # Calculate Pij, the probability that j will be chosen \n # as i's neighbor, for all i's. Pij has shape\n # [n_samples, n_samples] and ** is NOT symmetrical **.\n # Because the data is normalized using softmax, values\n # add to 1 in rows, that is i (central patients) are\n # represented in rows\n denomSum = tf.reduce_sum(tf.exp(-normAX), axis=0)\n epsilon = 1e-50\n denomSum = denomSum + epsilon \n \n self.Pij = tf.exp(-normAX) / denomSum[:, None]","def p0(self, p0):\n u = self.p0 - self.p1\n v = p0 - self.p1\n scale, rM = self.scale_rot_matrix(u, v)\n self.c = self.p1 + rM @ (self.c - self.p1)\n self.r *= scale\n self.r2 = self.r * self.r\n dp = p0 - self.c\n self.a0 = atan2(dp.y, dp.x)","def _re(self, p):\n return self.edges[:, 0, :] - p # 0 is arbitrary - the other end also works","def evaluate_cost(\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\n ) -> CasADiArrayType:\n x = self.opt.decision_variables.dict2vec(x)\n p = self.opt.parameters.dict2vec(p)\n return self.opt.f(x, p)","def pe_solver(Aij, Bij, pi):\n # =========================================================================\n # Calculating the pressure at row i + 1\n # =========================================================================\n return np.dot(np.linalg.inv(Aij), np.dot(Bij, pi))","def flipy(self, p):\n return int(p.x), int(-p.y+self.h)","def inv(P):\n L = cho_factor(P)\n return cho_solve(L, np.eye(P.shape[0]))","def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\n ...","def evaluate(self, state):\n abstract","def f(t,x,p,q):\n return p[1] + q[0]*x","def __call__(self, xi, p=None):\n\n # print('basis function is called {0}, {1}'.format(xi, p))\n\n return self.__basis(xi, self.p if p is None else p)","def __pow__(self, power):\n if type(power) is not int:\n return NotImplemented\n if not self.isSquare():\n raise ValueError(\"Power invalid for non-square matrices\")\n if power > 0:\n p = power\n returnvalue = Matrix(self)\n elif power < 0:\n p = -power\n returnvalue = self.inverse()\n elif power == 0:\n return NotImplemented\n for i in range(p - 1):\n returnvalue *= returnvalue\n return returnvalue","def mat24_perm_to_int(p):\n oct = sum(1 << x for x in p[:8])\n res = gc.vect_to_octad(oct) \n #print(\"p2i oct\", hex(oct))\n res -= STD_OCTAD\n res += (res >> 12) & 759 \n #print(\"p2i\", res)\n p1 = [24]*32\n oct, j = 8 * oct, 0x00 \n for i in range(24):\n o = oct & 8\n p1[i] = (j >> o) & 0x1f\n j += 1 << o\n oct >>= 1\n q, q_inv = [None]*8, [None]*8\n for i in range(8):\n j = p1[p[i] & 0x1f] & 7\n q[j] = i\n q_inv[i] = j\n for i in range(6):\n # exchange place i with place q_inv[i]\n j = q_inv[i]\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\n #q[i], q[j] = q[j], q[i]\n #assert q[:i] == q_inv[:i] == lrange(i)\n q_inv[q[i]] = q_inv[q[j]]\n q[j] = q[i]\n #print(\"p2i%d\" % i, j-i) \n res = res * (8 - i) + j - i\n #print(\"p2ifinal\", p1[p[8] & 0x1f]) \n return 16 * res + p1[p[8] & 0x1f]","def computeSPPMI_matrix(P, shifted_k: int, check_sym = True):\n a, b = P.shape\n # print P.shape, type(P)\n P = np.asarray(P)\n # print 'Shape of P: ', P.shape\n assert a == b\n D = np.sum(P)\n cols = np.sum(P, axis = 0) # sum the columns (b,)\n rows = np.sum(P, axis = 1, keepdims=True) # sum the row (a,1)\n P = P / (cols + 1e-10)\n P = P / (rows + 1e-10)\n P = P * D\n PMI = np.log(P + 1e-10)\n S = PMI - np.log(shifted_k)\n mask = S > 0\n SPPMI = np.multiply(S, mask)\n assert np.min(SPPMI) == 0\n if check_sym: np.fill_diagonal(SPPMI, 0) # in-place operation\n assert torch_utils.check_symmetric(SPPMI) == True\n return SPPMI","def p2f (p):\n #return 11000**((p+1)/2)\n #return (p+1)*11000\n return (p+1)*5500","def __init__ (self, p, q):\n self.n = p * q\n self.n_sq = self.n * self.n\n self.g = self.n + 1","def evaluate( self, x ) :\n\n P = 0.\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\n return( P )","def apply_pt(self, x_pt, y_pt):\n return ( self.matrix[0][0]*x_pt + self.matrix[0][1]*y_pt + self.vector[0],\n self.matrix[1][0]*x_pt + self.matrix[1][1]*y_pt + self.vector[1] )","def normIP(p):\n z = normIQ(1.0 - p)\n return z + (p - normP(z)) / normZ(z)","def evaluationFunction(self, currentGameState, action):\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n return scoreEvaluationFunction(successorGameState)","def test_indexed_increment(self, expr, result):\n j, l = dimify('j l')\n a = symbol(name='a', dimensions=(j, l), value=2., mode='indexed').base\n fa = a.function\n fa.data[1:, 1:] = 0\n\n eqn = eval(expr)\n Operator(eqn)(fa)\n assert np.allclose(fa.data, result, rtol=1e-12)","def _P(m):\n P = np.zeros((m**2,m**2), dtype=np.int64)\n for i in range(1, m**2 + 1):\n j = 1 + m*((i - 1) % m) + (i - 1)//m\n P[i-1, j-1] = 1\n return P","def __call__(self, t=1 / 2):\n return (t * self.vector)(self.p1)","def _phi_int(self, x, d, p):\n ks = np.arange(self.p + 1)\n ks = ks[np.where(2 * (self.p - ks) - d >= 0)][:, np.newaxis]\n return np.sum(\n binom(self.p, ks)\n * (-1) ** ks\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d + 1)\n * perm(2 * (self.p - ks), d)\n / (2 * (self.p - ks) - d + 1),\n axis=0,\n )","def _query(self, p, k):\n if isinstance(p, int):\n if k >= len(self._table[p]):\n return None\n return self._table[p][k]\n\n # if k > self._tree.depth(p):\n if k >= len(self._table[p.index()]):\n return None\n return self._table[p.index()][k]","def _pij(i: int, j: int):\n ia = i * 2 + 0\n ib = i * 2 + 1\n ja = j * 2 + 0\n jb = j * 2 + 1\n term1 = FermionOperator(((ja, 0), (ib, 0)), 1.0)\n term2 = FermionOperator(((ia, 0), (jb, 0)), 1.0)\n return numpy.sqrt(0.5) * (term1 + term2)","def moment(self, p, q):\n\n def combin(n, r):\n # compute number of combinations of size r from set n\n def prod(values):\n try:\n return reduce(lambda x, y: x * y, values)\n except TypeError:\n return 1\n\n return prod(range(n - r + 1, n + 1)) / prod(range(1, r + 1))\n\n vertices = self.vertices(closed=True)\n x = vertices[0, :]\n y = vertices[1, :]\n\n m = 0.0\n n = len(x)\n for l in range(n):\n l1 = (l - 1) % n\n dxl = x[l] - x[l1]\n dyl = y[l] - y[l1]\n Al = x[l] * dyl - y[l] * dxl\n \n s = 0.0\n for i in range(p + 1):\n for j in range(q + 1):\n s += (-1)**(i + j) \\\n * combin(p, i) \\\n * combin(q, j) / ( i+ j + 1) \\\n * x[l]**(p - i) * y[l]**(q - j) \\\n * dxl**i * dyl**j\n m += Al * s\n\n return m / (p + q + 2)","def _renorm_p(self, p):\n return np.sign(p)*np.sqrt(np.sqrt(np.abs(p)))","def optimizer_array(self, p):\n f = None\n if self.has_parent() and self.constraints[__fixed__].size != 0:\n f = np.ones(self.size).astype(bool)\n f[self.constraints[__fixed__]] = FIXED\n elif self._has_fixes():\n f = self._fixes_\n if f is None:\n self.param_array.flat = p\n [np.put(self.param_array, ind, c.f(self.param_array.flat[ind]))\n #py3 fix\n #for c, ind in self.constraints.iteritems() if c != __fixed__]\n for c, ind in self.constraints.items() if c != __fixed__]\n else:\n self.param_array.flat[f] = p\n [np.put(self.param_array, ind[f[ind]], c.f(self.param_array.flat[ind[f[ind]]]))\n #py3 fix\n #for c, ind in self.constraints.iteritems() if c != __fixed__]\n for c, ind in self.constraints.items() if c != __fixed__]\n #self._highest_parent_.tie.propagate_val()\n\n self._optimizer_copy_transformed = False\n self.trigger_update()","def gini_scorer(a,p):\n\n return gini_normalized(a,p[:,1])","def square_func(i, T, amp, p = 10000):\n if (i//p)%2 == 0:\n return T + amp\n else:\n return T - amp","def polyval(p, x):\r\n val = 0\r\n ii = len(p) - 1\r\n for i in range(len(p) - 1):\r\n val += p[i] * (x ** ii)\r\n ii -= 1\r\n return val + p[-1]","def fun_lorentzian(p,r):\n return p[1] / ((r/p[0])**2 + 1)","def pvector_pp(i, q):\n\tc0 = coords_cut[i]\n\tra, dec = c0.ra.value, c0.dec.value\n\tr = hp.rotator.Rotator([ra, dec, 0])\n\tsT = np.matmul(r.mat, np.matmul(s_tensor_cut[:,:,i], r.mat.transpose()))\n\tevals, evecs = np.linalg.eigh(sT[1:,1:])\n\tevecA, evecB = evecs[:,0], evecs[:,1]\n\tif evecB[0] < 0:\n\t\tevecB = -evecB\n\ttheta = np.arctan2(evecB[1], evecB[0])\n\tres = 180*theta.item()/np.pi, i\n\tq.put(res)\n\treturn res","def _xphi_int(self, x, d, p):\n ks = np.arange(self.p + 1)\n ks = ks[np.where(2 * (self.p - ks) - d >= 0)][:, np.newaxis]\n return np.sum(\n binom(self.p, ks)\n * (-1) ** ks\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d + 2)\n * perm(2 * (self.p - ks), d)\n / (2 * (self.p - ks) - d + 2),\n axis=0,\n )","def p_m(pmx_c,px):\n pm = np.zeros(pmx_c.shape[0])\n for mi in range(pm.size):\n for xi in range(px.size):\n pm[mi] += pmx_c[mi,xi]*px[xi]\n return pm","def solution(n,p):\n \n a=pow(n, (p - 1) // 2, p)\n if(a==1):\n return True\n else :\n return False","def p1(self, p1):\n p0 = self.p0\n u = self.p1 - p0\n v = p1 - p0\n\n scale, rM = self.scale_rot_matrix(u, v)\n self.c = p0 + rM @ (self.c - p0)\n self.r *= scale\n self.r2 = self.r * self.r\n dp = p0 - self.c\n self.a0 = atan2(dp.y, dp.x)","def prim_method(self):","def prim_method(self):","def _init_eigenmatrix(self, P):\n self._.d = nrows(P) - 1\n assert all(len(r) == self._.d + 1 for r in P), \\\n \"parameter length mismatch\"\n P = Matrix(SR, P)\n for i, x in enumerate(P[0]):\n P[0, i] = integralize(x)\n self._.n = sum(P[0])\n return P","def get_abscissa(self, p):\n return np.dot(p - self.zero, self.direction)","def P_i(self, alpha, Q, X_data):\n X_lin_comb = np.dot(alpha, X_data)\n Pi = Q * np.exp(X_lin_comb - X_lin_comb.max(initial=0))\n Pi = Pi / Pi.sum()\n return Pi","def evaluatePolicy_SolvingSystemOfLinearEqs(self, policy):\n\n V = np.zeros(self.nStates)\n # loop\n for state in range(self.nStates):\n # value to 0\n v = 0\n action = np.argmax(policy[:, state])\n for next_state, prob in enumerate(self.T[action][state]):\n v += prob * (self.R[action][state] + self.discount * V[next_state])\n V[state] = v\n return V","def eval_prior(self, state, action):\n\n return np.dot(state, self.a.T) + np.dot(action, self.b.T)","def _evaluate(self, x, return_indices=False):\n return self._evalOrDer(x, True, False)[0]","def _evaluate(self, index):\n raise NotImplementedError","def set_expansion_steps(self, p):\n p = int(p)\n if p <= 0:\n raise ValueError(\n 'Integer must be greater than zero (to limit the interval size'\n ' to (2 ** integer) * width).')\n self._p = p","def algorithm_1_1(p, c, t, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\n t[j + k] - t[j]) * q[j + 1]\n return q[0]"],"string":"[\n \"def evaluate(self,p):\\n if not self.initialized: self.__initialize__()\\n if self.vp0: p_ = 1-p\\n else: p_ = p\\n if self.ids_to_consider is None:\\n #sum on all parametrized cell\\n cf = np.sum(self.V[self.p_ids-1]*p_)/self.V_tot - self.max_v_frac\\n else:\\n cf = np.sum((self.V[self.ids_to_consider-1]*p_))/self.V_tot - self.max_v_frac\\n return cf\",\n \"def eval_poly(self, p):\\n A = self\\n m, n = A.shape\\n\\n if m != n:\\n raise DMNonSquareMatrixError(\\\"Matrix must be square\\\")\\n\\n if not p:\\n return self.zeros(self.shape, self.domain)\\n elif len(p) == 1:\\n return p[0] * self.eye(self.shape, self.domain)\\n\\n # Evaluate p(A) using Horner's method:\\n # XXX: Use Paterson-Stockmeyer method?\\n I = A.eye(A.shape, A.domain)\\n p_A = p[0] * I\\n for pi in p[1:]:\\n p_A = A*p_A + pi*I\\n\\n return p_A\",\n \"def matrix_simmetric_representate(self, p):\\r\\n if (p >0 and (p <= self.dimension()) ):\\r\\n v = self.basis_group_oriented_p_chains(p)\\r\\n p = p - 1\\r\\n ve = self.basis_group_oriented_p_chains(p)\\r\\n M = csr_matrix((len(ve.dic), len(v.dic)), dtype=np.int8).toarray()\\r\\n j = 0\\r\\n for u1 in list(v.dic.keys()):\\r\\n d = P_chains([u1],[v.dic[u1]])\\r\\n l = boundary_op_n(d).dic\\r\\n for u2 in list(l.keys()):\\r\\n i = 0\\r\\n for w in list(ve.dic.keys()):\\r\\n if (w == u2):\\r\\n M[i,j] = int((l)[u2])\\r\\n i = i + 1\\r\\n j = j + 1\\r\\n return M \\r\\n else:\\r\\n if (p == 0):\\r\\n return np.identity(len(list(self.basis_group_oriented_p_chains(0).dic.keys())))\\r\\n else:\\r\\n return False\",\n \"def update_p(self, p: float):\\n self.p = p\\n for k, sequential in self.m_ops.items():\\n if sequential[0].is_identity_op():\\n sequential[-1].p = p\",\n \"def EvaluateLocation(self, p_int, , p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def _eval_coeff(self, pt):\\n val = 1\\n for a in self.args:\\n val *= a.coeff(pt)\\n return val\",\n \"def regular(P):\\n try:\\n cols = P.shape[0]\\n ans = np.ones((1, cols))\\n # eq = np.matmul(ans, P)\\n # s = np.array(np.arange(1, cols + 1))\\n eq = np.vstack([P.T - np.identity(cols), ans])\\n # va, vec = np.linalg .eig(P)\\n results = np.zeros((cols, 1))\\n results = np.vstack([results, np.array([1])])\\n statetionary = np.linalg.solve(eq.T.dot(eq), eq.T.dot(results)).T\\n # print(statetionary)\\n # print(np.argwhere(statetionary < 0))\\n if len(np.argwhere(statetionary < 0)) > 0:\\n return None\\n return statetionary\\n except Exception as e:\\n return None\",\n \"def evalComponent(self, x, p):\\n if p > 0 and p <= self.n:\\n p = str(p)\\n y = self[\\\"off\\\"] + self[\\\"lin\\\"] * x\\n self._v1d.assignValues(\\n {\\\"A\\\": self[\\\"A\\\" + p], \\\"al\\\": self[\\\"al\\\" + p], \\\"ad\\\": self[\\\"ad\\\" + p], \\\"mu\\\": self[\\\"mu\\\" + p]})\\n y += self._v1d.evaluate(x)\\n return y\\n else:\\n raise(PE.PyAValError(\\\"No such component (no. \\\" + str(p) + \\\")\\\", where=\\\"MultiVoigt1d::evalComponent\\\",\\n solution=\\\"Use value between 1 and \\\" + str(self.n)))\",\n \"def resolves_matrix(self):\\n self.P = np.linalg.solve(self.M, self.f)\",\n \"def cost_function(H, n_qubits, p, params):\\n ini_state=plus_state(n_qubits)\\n for i in range(p):\\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state\",\n \"def ap(self, P):\\n if P.divides(self.conductor()):\\n if (P*P).divides(self.conductor()):\\n # It is 0, because the reduction is additive.\\n return ZZ(0)\\n else:\\n # TODO: It is +1 or -1, but I do not yet know how to\\n # compute which without using the L-function.\\n return '?'\\n else:\\n return self._S.hecke_matrix(P)[0,0]\",\n \"def evaluate_rijP(self, q):\\n rP_i = self._parent._parent.bodies[self.body_id_i].evaluate_r(q, element_id=self.element_id, ksi=self.element_ksi)\\n\\n self.r_P_list[0] = rP_i\\n\\n # distance vector\\n r_ij_P = rP_i - self.rP_j\\n\\n return r_ij_P\",\n \"def evaluate(self) -> int:\",\n \"def power(self,p):\\r\\n\\t\\t\\r\\n\\t\\t# raise to power\\r\\n\\t\\tr,o = Li._expand(self,p)\\r\\n\\t\\t\\r\\n\\t\\treturn Li(r)\",\n \"def __evaluate(self, point):\\n assert len(point) == len(self.weight)-1\\n result = self.weight[0]\\n for i in range(0,len(point)):\\n result += self.weight[i+1] * point[i]\\n return result\",\n \"def _eval_coeff(self, pt):\\n return sum(a.coeff(pt) for a in self.args)\",\n \"def _compute_pTable(self, expand=False, factor=False,\\n simplify=False):\\n if self._has(\\\"p\\\"):\\n return\\n if not self._has(\\\"k\\\"):\\n self.kTable(expand=expand, factor=factor, simplify=simplify)\\n if not self._has(\\\"m\\\"):\\n self.multiplicities(expand=expand, factor=factor,\\n simplify=simplify)\\n p = Array3D(self._.d + 1)\\n self._compute_parameters(p, self._.P, self._.m, integral=True,\\n name=PARAMETER, sym=SYMBOL)\\n self._.p = p\\n self.check_handshake()\",\n \"def __imul__(self, s):\\n val = _hypre.HypreParMatrix___imul__(self, s)\\n\\n # val.thisown = 0\\n return self\\n\\n\\n return val\",\n \"def _precompute_xl(self, p: int) -> List[int]:\\n res = [1]\\n val = 1\\n for _ in range(len(self._s)):\\n val = (val * self.X) % p\\n res.append(val)\\n return res\",\n \"def regular(P):\\n try:\\n dim = P.shape[0]\\n q = (P - np.eye(dim))\\n ones = np.ones(dim)\\n q = np.c_[q, ones]\\n QTQ = np.dot(q, q.T)\\n bQT = np.ones(dim)\\n answer = np.linalg.solve(QTQ, bQT)\\n if np.all(answer > 0):\\n return answer\\n else:\\n return None\\n except Exception as e:\\n return None\",\n \"def evaluate(self, point):\\n result = self.__evaluate(point)\\n return -1 if result < 0 else 1\",\n \"def _compute_parameters(self, p, P, m, integral=False, name=None,\\n sym=None):\\n for h in range(self._.d + 1):\\n for i in range(self._.d + 1):\\n for j in range(self._.d + 1):\\n p[h, i, j] = full_simplify(\\n sum(m[t] * P[t, h] * P[t, i] * P[t, j]\\n for t in range(self._.d + 1))\\n / (self._.n * P[0, h]))\\n self._check_parameter(h, i, j, p[h, i, j],\\n integral=integral,\\n name=name, sym=sym)\\n self._check_consistency(p, P[0], name=name, sym=sym)\",\n \"def EvaluatePosition(self, , p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def solve_ilp(self):\\n\\n ilp_solution = pylp.Solution()\\n self.ilp_solver.set_constraints(self.constraints)\\n message = self.ilp_solver.solve(ilp_solution)\\n print(\\\"ILP solved with minimal value \\\" + str(ilp_solution.get_value()) + \\\" and status \\\" + message)\\n\\n solution = lil_matrix(self.graph.shape)\\n for i in range(self.num_variables):\\n print(\\\"value of var \\\" + str(i) + \\\" is \\\" + str(ilp_solution.get_vector()[i]))\\n if ilp_solution.get_vector()[i] < 0.5:\\n continue\\n (u,v) = self.var_to_edge[i]\\n solution[u,v] = self.graph[u,v] - self.min_cost + 1\\n\\n return solution\",\n \"def Eval(self, r, ppar, pperp, v, gamma=None, p2=None, p=None, xi=None):\\n while False:\\n yield None\",\n \"def a_ij(s, p, i=1, j=1): # (Validated)\\n from math import sqrt\\n if i == j:\\n return s.c[i]['a'] # Return pure paramater\\n else: # find mixture aij i =/= j\\n return (1 - p.m['k'][i][j]) * sqrt(s.c[i]['a'] * s.c[j]['a'])\",\n \"def I(x, y, l, p):\\n \\n return 0.5 / (mu * c) * A0**2 * ( u(x, y, l, p) )**2\",\n \"def success_p(self, input_p = None):\\r\\n if input_p is None:\\r\\n input_p = uniform_p(self.n_inputs())\\r\\n return np.trace(np.dot(np.diag(input_p), self.matrix))\",\n \"def compute_demand(self, p):\\n \\n G, h = spdiag([-1.0]*self.n), matrix(0.0, (self.n, 1))\\n \\n if self.type == 'quad':\\n Q, r = self.data\\n return solvers.qp(-Q, p-r, G, h)['x']\\n\\n if self.type == 'sqrt':\\n def F(x=None, z=None):\\n if x is None: return 0, matrix(1.0, (self.n, 1))\\n u, Du, H = self.utility(x)\\n f, Df = p.T*x - u, p.T - Du\\n if z is None: return f, Df\\n return f, Df, -z[0]*H\\n return solvers.cp(F, G, h)['x']\",\n \"def mod_inv(a,p):\\r\\n\\r\\n for i in range(1,p):\\r\\n if (i*a)%p==1: return i\\r\\n raise ValueError(str(a)+\\\" has no inverse mod \\\"+str(p))\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def compute_PSSM_self_information(p):\\n return -sp.sum(p*sp.log(p))\",\n \"def _model(x, p):\\n y_hat = 0\\n for i, pi in enumerate(reversed(p)):\\n y_hat += x**i * pi\\n return y_hat\",\n \"def ij(ij, pol, ant) :\\n s.ij(pol, ij, ant)\",\n \"def laplacian(self, p):\\n wf = self._wf(p)\\n return - G * self.d * wf.sum()\",\n \"def eval_function_modlin(point, level_vector, index_vector):\\n\\n product = 1\\n for (l, i, x) in izip(level_vector, index_vector, point):\\n if l == 1 and i == 1:\\n val = 1\\n elif l > 1 and i == 1:\\n if x >= 0 and x <= 2 ** (1 - l):\\n val = 2 - 2 ** l * x\\n else:\\n val = 0\\n elif l > 1 and i == 2 ** l - 1:\\n if x >= 1 - 2 ** (1 - l) and x <= 1:\\n val = 2 ** l * x + 1 - i\\n else:\\n val = 0\\n else:\\n val = __phi(x * 2 ** l - i)\\n product *= val\\n if product == 0:\\n break\\n return product\",\n \"def expression(self, p):\\n num_type, first, second = get_type_first_second_of_binary_operation(p.expression, p.term)\\n\\n opcode_type = I_for_int_R_for_float(num_type)\\n opcode_action = \\\"ADD\\\" if p.ADDOP == \\\"+\\\" else \\\"SUB\\\"\\n opcode = opcode_type + opcode_action\\n\\n temp = next(g_generate_temp_variable_name)\\n temp_variables_values_dict[temp] = temp\\n\\n qaud_code(f\\\"{opcode} {temp} {first} {second}\\\")\\n return Expression(num_type, temp)\",\n \"def m_p(Z0, P0, P):\\n return m(Z0) * P/P0\",\n \"def eval(f, a, j=0):\\n return f.per(dmp_eval_in(f.rep, f.dom.convert(a), j, f.lev, f.dom), lower=True)\",\n \"def p(self):\\n self.pTable()\",\n \"def algorithm_1_2(p, c, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (1 - x) * q[j] + x * q[j + 1]\\n return q[0]\",\n \"def _evaluate_recur(self, p):\\n if self.is_leaf(p):\\n return float(p.element()) # we assume element is numeric\\n else:\\n op = p.element()\\n left_val = self._evaluate_recur(self.left(p))\\n right_val = self._evaluate_recur(self.right(p))\\n if op == '+':\\n return left_val + right_val\\n elif op == '-':\\n return left_val - right_val\\n elif op == '/':\\n return left_val / right_val\\n else:\\n return left_val * right_val # treat 'x' or '*' as multiplication\",\n \"def _evaluate(self, x):\\n raise NotImplementedError()\",\n \"def perplexity(self):\\n raise NotImplementedError(\\\"To be implemented\\\")\",\n \"def _pfunc(i,j,perm):\\n if perm[i-1] == j:\\n return 1\\n else:\\n return 0\",\n \"def P(self):\\n self.eigenmatrix()\",\n \"def return_policy_evaluation(self, p, u, r, T, gamma):\\n for s in range(0, self.env.observation_space.n):\\n if not np.isnan(p[s]):\\n v = np.zeros((1, self.env.observation_space.n), dtype=float)\\n v[0, s] = 1.0\\n action = int(p[s])\\n u[s] = r[s] + gamma * np.sum(np.multiply(u, np.dot(v, T[:, :, action])))\\n return u\",\n \"def polyeval(self, x):\\n return NotImplemented\",\n \"def _evaluate_recur(self, p):\\n if self.is_leaf(p):\\n return float(p.element()) # we assume element is numeric\\n else:\\n op = p.element()\\n left_val = self._evaluate_recur(self.left(p))\\n right_val = self._evaluate_recur(self.right(p))\\n if op == '+':\\n return left_val + right_val\\n elif op == '-':\\n return left_val - right_val\\n elif op == '/':\\n return left_val / right_val\\n else: # treat 'x' or '*' as multiplication\\n return left_val * right_val\",\n \"def apply(self, point):\\r\\n return self*point\",\n \"def evaluate(self, p: Posting) -> Union[str, None]:\\n return self.eval_fn(p)\",\n \"def _get_Pij(self): \\n \\n with tf.name_scope(\\\"getting_Pij\\\"):\\n \\n n_splits = int(self.dim_input / self.per_split_feats)\\n n_divisible = n_splits * self.per_split_feats\\n X_split = tf.split(self.X_transformed[:,0:n_divisible], n_splits, axis=1)\\n X_split.append(self.X_transformed[:,n_divisible:])\\n \\n # get norm along first feature set\\n normAX = X_split[0][None, :, :] - X_split[0][:, None, :]\\n normAX = tf.reduce_sum(normAX ** 2, axis=2)\\n \\n for split in range(1, len(X_split)): \\n \\n # Expand dims of AX to [n_samples, n_samples, n_features], where\\n # each \\\"channel\\\" in the third dimension is the difference between\\n # one sample and all other samples along one feature\\n norm_thisFeatureSet = X_split[split][None, :, :] - \\\\\\n X_split[split][:, None, :]\\n \\n norm_thisFeatureSet = tf.reduce_sum(norm_thisFeatureSet ** 2, axis=2)\\n \\n # add to existing cumulative sum \\n normAX = normAX + norm_thisFeatureSet\\n \\n # Calculate Pij, the probability that j will be chosen \\n # as i's neighbor, for all i's. Pij has shape\\n # [n_samples, n_samples] and ** is NOT symmetrical **.\\n # Because the data is normalized using softmax, values\\n # add to 1 in rows, that is i (central patients) are\\n # represented in rows\\n denomSum = tf.reduce_sum(tf.exp(-normAX), axis=0)\\n epsilon = 1e-50\\n denomSum = denomSum + epsilon \\n \\n self.Pij = tf.exp(-normAX) / denomSum[:, None]\",\n \"def p0(self, p0):\\n u = self.p0 - self.p1\\n v = p0 - self.p1\\n scale, rM = self.scale_rot_matrix(u, v)\\n self.c = self.p1 + rM @ (self.c - self.p1)\\n self.r *= scale\\n self.r2 = self.r * self.r\\n dp = p0 - self.c\\n self.a0 = atan2(dp.y, dp.x)\",\n \"def _re(self, p):\\n return self.edges[:, 0, :] - p # 0 is arbitrary - the other end also works\",\n \"def evaluate_cost(\\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\\n ) -> CasADiArrayType:\\n x = self.opt.decision_variables.dict2vec(x)\\n p = self.opt.parameters.dict2vec(p)\\n return self.opt.f(x, p)\",\n \"def pe_solver(Aij, Bij, pi):\\n # =========================================================================\\n # Calculating the pressure at row i + 1\\n # =========================================================================\\n return np.dot(np.linalg.inv(Aij), np.dot(Bij, pi))\",\n \"def flipy(self, p):\\n return int(p.x), int(-p.y+self.h)\",\n \"def inv(P):\\n L = cho_factor(P)\\n return cho_solve(L, np.eye(P.shape[0]))\",\n \"def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def evaluate(self, state):\\n abstract\",\n \"def f(t,x,p,q):\\n return p[1] + q[0]*x\",\n \"def __call__(self, xi, p=None):\\n\\n # print('basis function is called {0}, {1}'.format(xi, p))\\n\\n return self.__basis(xi, self.p if p is None else p)\",\n \"def __pow__(self, power):\\n if type(power) is not int:\\n return NotImplemented\\n if not self.isSquare():\\n raise ValueError(\\\"Power invalid for non-square matrices\\\")\\n if power > 0:\\n p = power\\n returnvalue = Matrix(self)\\n elif power < 0:\\n p = -power\\n returnvalue = self.inverse()\\n elif power == 0:\\n return NotImplemented\\n for i in range(p - 1):\\n returnvalue *= returnvalue\\n return returnvalue\",\n \"def mat24_perm_to_int(p):\\n oct = sum(1 << x for x in p[:8])\\n res = gc.vect_to_octad(oct) \\n #print(\\\"p2i oct\\\", hex(oct))\\n res -= STD_OCTAD\\n res += (res >> 12) & 759 \\n #print(\\\"p2i\\\", res)\\n p1 = [24]*32\\n oct, j = 8 * oct, 0x00 \\n for i in range(24):\\n o = oct & 8\\n p1[i] = (j >> o) & 0x1f\\n j += 1 << o\\n oct >>= 1\\n q, q_inv = [None]*8, [None]*8\\n for i in range(8):\\n j = p1[p[i] & 0x1f] & 7\\n q[j] = i\\n q_inv[i] = j\\n for i in range(6):\\n # exchange place i with place q_inv[i]\\n j = q_inv[i]\\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\\n #q[i], q[j] = q[j], q[i]\\n #assert q[:i] == q_inv[:i] == lrange(i)\\n q_inv[q[i]] = q_inv[q[j]]\\n q[j] = q[i]\\n #print(\\\"p2i%d\\\" % i, j-i) \\n res = res * (8 - i) + j - i\\n #print(\\\"p2ifinal\\\", p1[p[8] & 0x1f]) \\n return 16 * res + p1[p[8] & 0x1f]\",\n \"def computeSPPMI_matrix(P, shifted_k: int, check_sym = True):\\n a, b = P.shape\\n # print P.shape, type(P)\\n P = np.asarray(P)\\n # print 'Shape of P: ', P.shape\\n assert a == b\\n D = np.sum(P)\\n cols = np.sum(P, axis = 0) # sum the columns (b,)\\n rows = np.sum(P, axis = 1, keepdims=True) # sum the row (a,1)\\n P = P / (cols + 1e-10)\\n P = P / (rows + 1e-10)\\n P = P * D\\n PMI = np.log(P + 1e-10)\\n S = PMI - np.log(shifted_k)\\n mask = S > 0\\n SPPMI = np.multiply(S, mask)\\n assert np.min(SPPMI) == 0\\n if check_sym: np.fill_diagonal(SPPMI, 0) # in-place operation\\n assert torch_utils.check_symmetric(SPPMI) == True\\n return SPPMI\",\n \"def p2f (p):\\n #return 11000**((p+1)/2)\\n #return (p+1)*11000\\n return (p+1)*5500\",\n \"def __init__ (self, p, q):\\n self.n = p * q\\n self.n_sq = self.n * self.n\\n self.g = self.n + 1\",\n \"def evaluate( self, x ) :\\n\\n P = 0.\\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\\n return( P )\",\n \"def apply_pt(self, x_pt, y_pt):\\n return ( self.matrix[0][0]*x_pt + self.matrix[0][1]*y_pt + self.vector[0],\\n self.matrix[1][0]*x_pt + self.matrix[1][1]*y_pt + self.vector[1] )\",\n \"def normIP(p):\\n z = normIQ(1.0 - p)\\n return z + (p - normP(z)) / normZ(z)\",\n \"def evaluationFunction(self, currentGameState, action):\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n return scoreEvaluationFunction(successorGameState)\",\n \"def test_indexed_increment(self, expr, result):\\n j, l = dimify('j l')\\n a = symbol(name='a', dimensions=(j, l), value=2., mode='indexed').base\\n fa = a.function\\n fa.data[1:, 1:] = 0\\n\\n eqn = eval(expr)\\n Operator(eqn)(fa)\\n assert np.allclose(fa.data, result, rtol=1e-12)\",\n \"def _P(m):\\n P = np.zeros((m**2,m**2), dtype=np.int64)\\n for i in range(1, m**2 + 1):\\n j = 1 + m*((i - 1) % m) + (i - 1)//m\\n P[i-1, j-1] = 1\\n return P\",\n \"def __call__(self, t=1 / 2):\\n return (t * self.vector)(self.p1)\",\n \"def _phi_int(self, x, d, p):\\n ks = np.arange(self.p + 1)\\n ks = ks[np.where(2 * (self.p - ks) - d >= 0)][:, np.newaxis]\\n return np.sum(\\n binom(self.p, ks)\\n * (-1) ** ks\\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d + 1)\\n * perm(2 * (self.p - ks), d)\\n / (2 * (self.p - ks) - d + 1),\\n axis=0,\\n )\",\n \"def _query(self, p, k):\\n if isinstance(p, int):\\n if k >= len(self._table[p]):\\n return None\\n return self._table[p][k]\\n\\n # if k > self._tree.depth(p):\\n if k >= len(self._table[p.index()]):\\n return None\\n return self._table[p.index()][k]\",\n \"def _pij(i: int, j: int):\\n ia = i * 2 + 0\\n ib = i * 2 + 1\\n ja = j * 2 + 0\\n jb = j * 2 + 1\\n term1 = FermionOperator(((ja, 0), (ib, 0)), 1.0)\\n term2 = FermionOperator(((ia, 0), (jb, 0)), 1.0)\\n return numpy.sqrt(0.5) * (term1 + term2)\",\n \"def moment(self, p, q):\\n\\n def combin(n, r):\\n # compute number of combinations of size r from set n\\n def prod(values):\\n try:\\n return reduce(lambda x, y: x * y, values)\\n except TypeError:\\n return 1\\n\\n return prod(range(n - r + 1, n + 1)) / prod(range(1, r + 1))\\n\\n vertices = self.vertices(closed=True)\\n x = vertices[0, :]\\n y = vertices[1, :]\\n\\n m = 0.0\\n n = len(x)\\n for l in range(n):\\n l1 = (l - 1) % n\\n dxl = x[l] - x[l1]\\n dyl = y[l] - y[l1]\\n Al = x[l] * dyl - y[l] * dxl\\n \\n s = 0.0\\n for i in range(p + 1):\\n for j in range(q + 1):\\n s += (-1)**(i + j) \\\\\\n * combin(p, i) \\\\\\n * combin(q, j) / ( i+ j + 1) \\\\\\n * x[l]**(p - i) * y[l]**(q - j) \\\\\\n * dxl**i * dyl**j\\n m += Al * s\\n\\n return m / (p + q + 2)\",\n \"def _renorm_p(self, p):\\n return np.sign(p)*np.sqrt(np.sqrt(np.abs(p)))\",\n \"def optimizer_array(self, p):\\n f = None\\n if self.has_parent() and self.constraints[__fixed__].size != 0:\\n f = np.ones(self.size).astype(bool)\\n f[self.constraints[__fixed__]] = FIXED\\n elif self._has_fixes():\\n f = self._fixes_\\n if f is None:\\n self.param_array.flat = p\\n [np.put(self.param_array, ind, c.f(self.param_array.flat[ind]))\\n #py3 fix\\n #for c, ind in self.constraints.iteritems() if c != __fixed__]\\n for c, ind in self.constraints.items() if c != __fixed__]\\n else:\\n self.param_array.flat[f] = p\\n [np.put(self.param_array, ind[f[ind]], c.f(self.param_array.flat[ind[f[ind]]]))\\n #py3 fix\\n #for c, ind in self.constraints.iteritems() if c != __fixed__]\\n for c, ind in self.constraints.items() if c != __fixed__]\\n #self._highest_parent_.tie.propagate_val()\\n\\n self._optimizer_copy_transformed = False\\n self.trigger_update()\",\n \"def gini_scorer(a,p):\\n\\n return gini_normalized(a,p[:,1])\",\n \"def square_func(i, T, amp, p = 10000):\\n if (i//p)%2 == 0:\\n return T + amp\\n else:\\n return T - amp\",\n \"def polyval(p, x):\\r\\n val = 0\\r\\n ii = len(p) - 1\\r\\n for i in range(len(p) - 1):\\r\\n val += p[i] * (x ** ii)\\r\\n ii -= 1\\r\\n return val + p[-1]\",\n \"def fun_lorentzian(p,r):\\n return p[1] / ((r/p[0])**2 + 1)\",\n \"def pvector_pp(i, q):\\n\\tc0 = coords_cut[i]\\n\\tra, dec = c0.ra.value, c0.dec.value\\n\\tr = hp.rotator.Rotator([ra, dec, 0])\\n\\tsT = np.matmul(r.mat, np.matmul(s_tensor_cut[:,:,i], r.mat.transpose()))\\n\\tevals, evecs = np.linalg.eigh(sT[1:,1:])\\n\\tevecA, evecB = evecs[:,0], evecs[:,1]\\n\\tif evecB[0] < 0:\\n\\t\\tevecB = -evecB\\n\\ttheta = np.arctan2(evecB[1], evecB[0])\\n\\tres = 180*theta.item()/np.pi, i\\n\\tq.put(res)\\n\\treturn res\",\n \"def _xphi_int(self, x, d, p):\\n ks = np.arange(self.p + 1)\\n ks = ks[np.where(2 * (self.p - ks) - d >= 0)][:, np.newaxis]\\n return np.sum(\\n binom(self.p, ks)\\n * (-1) ** ks\\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d + 2)\\n * perm(2 * (self.p - ks), d)\\n / (2 * (self.p - ks) - d + 2),\\n axis=0,\\n )\",\n \"def p_m(pmx_c,px):\\n pm = np.zeros(pmx_c.shape[0])\\n for mi in range(pm.size):\\n for xi in range(px.size):\\n pm[mi] += pmx_c[mi,xi]*px[xi]\\n return pm\",\n \"def solution(n,p):\\n \\n a=pow(n, (p - 1) // 2, p)\\n if(a==1):\\n return True\\n else :\\n return False\",\n \"def p1(self, p1):\\n p0 = self.p0\\n u = self.p1 - p0\\n v = p1 - p0\\n\\n scale, rM = self.scale_rot_matrix(u, v)\\n self.c = p0 + rM @ (self.c - p0)\\n self.r *= scale\\n self.r2 = self.r * self.r\\n dp = p0 - self.c\\n self.a0 = atan2(dp.y, dp.x)\",\n \"def prim_method(self):\",\n \"def prim_method(self):\",\n \"def _init_eigenmatrix(self, P):\\n self._.d = nrows(P) - 1\\n assert all(len(r) == self._.d + 1 for r in P), \\\\\\n \\\"parameter length mismatch\\\"\\n P = Matrix(SR, P)\\n for i, x in enumerate(P[0]):\\n P[0, i] = integralize(x)\\n self._.n = sum(P[0])\\n return P\",\n \"def get_abscissa(self, p):\\n return np.dot(p - self.zero, self.direction)\",\n \"def P_i(self, alpha, Q, X_data):\\n X_lin_comb = np.dot(alpha, X_data)\\n Pi = Q * np.exp(X_lin_comb - X_lin_comb.max(initial=0))\\n Pi = Pi / Pi.sum()\\n return Pi\",\n \"def evaluatePolicy_SolvingSystemOfLinearEqs(self, policy):\\n\\n V = np.zeros(self.nStates)\\n # loop\\n for state in range(self.nStates):\\n # value to 0\\n v = 0\\n action = np.argmax(policy[:, state])\\n for next_state, prob in enumerate(self.T[action][state]):\\n v += prob * (self.R[action][state] + self.discount * V[next_state])\\n V[state] = v\\n return V\",\n \"def eval_prior(self, state, action):\\n\\n return np.dot(state, self.a.T) + np.dot(action, self.b.T)\",\n \"def _evaluate(self, x, return_indices=False):\\n return self._evalOrDer(x, True, False)[0]\",\n \"def _evaluate(self, index):\\n raise NotImplementedError\",\n \"def set_expansion_steps(self, p):\\n p = int(p)\\n if p <= 0:\\n raise ValueError(\\n 'Integer must be greater than zero (to limit the interval size'\\n ' to (2 ** integer) * width).')\\n self._p = p\",\n \"def algorithm_1_1(p, c, t, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\\n t[j + k] - t[j]) * q[j + 1]\\n return q[0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6590414","0.64902985","0.5803352","0.576456","0.56841123","0.56735307","0.5545928","0.54923505","0.54681116","0.5413606","0.5399578","0.5339681","0.5316676","0.53084254","0.5288867","0.525981","0.52447516","0.5244498","0.5217221","0.521235","0.5206362","0.5195178","0.51789606","0.51632947","0.5100213","0.5087714","0.5081258","0.5078931","0.5053198","0.5036393","0.5028569","0.5026325","0.5006044","0.50043327","0.50035065","0.49929","0.4988843","0.49867758","0.4965937","0.4960121","0.49469024","0.49428186","0.49421504","0.49393705","0.49109876","0.49095565","0.49022937","0.48998582","0.48952553","0.48780093","0.48776975","0.48700348","0.48700204","0.486586","0.48640615","0.48609558","0.48577482","0.48563483","0.48547348","0.48444352","0.48281825","0.48280936","0.48252603","0.48018655","0.47849703","0.47845882","0.4782678","0.47798303","0.4769205","0.47675377","0.4761075","0.47494498","0.47493553","0.4743193","0.47419637","0.47397158","0.47369513","0.47263083","0.47255614","0.4724568","0.47204784","0.47195882","0.47183186","0.47121957","0.47072968","0.47068492","0.47050366","0.47007012","0.46976492","0.4692514","0.4692514","0.46919358","0.4689712","0.46852478","0.46752906","0.4671883","0.46674138","0.4664621","0.46615413","0.46550694"],"string":"[\n \"0.6590414\",\n \"0.64902985\",\n \"0.5803352\",\n \"0.576456\",\n \"0.56841123\",\n \"0.56735307\",\n \"0.5545928\",\n \"0.54923505\",\n \"0.54681116\",\n \"0.5413606\",\n \"0.5399578\",\n \"0.5339681\",\n \"0.5316676\",\n \"0.53084254\",\n \"0.5288867\",\n \"0.525981\",\n \"0.52447516\",\n \"0.5244498\",\n \"0.5217221\",\n \"0.521235\",\n \"0.5206362\",\n \"0.5195178\",\n \"0.51789606\",\n \"0.51632947\",\n \"0.5100213\",\n \"0.5087714\",\n \"0.5081258\",\n \"0.5078931\",\n \"0.5053198\",\n \"0.5036393\",\n \"0.5028569\",\n \"0.5026325\",\n \"0.5006044\",\n \"0.50043327\",\n \"0.50035065\",\n \"0.49929\",\n \"0.4988843\",\n \"0.49867758\",\n \"0.4965937\",\n \"0.4960121\",\n \"0.49469024\",\n \"0.49428186\",\n \"0.49421504\",\n \"0.49393705\",\n \"0.49109876\",\n \"0.49095565\",\n \"0.49022937\",\n \"0.48998582\",\n \"0.48952553\",\n \"0.48780093\",\n \"0.48776975\",\n \"0.48700348\",\n \"0.48700204\",\n \"0.486586\",\n \"0.48640615\",\n \"0.48609558\",\n \"0.48577482\",\n \"0.48563483\",\n \"0.48547348\",\n \"0.48444352\",\n \"0.48281825\",\n \"0.48280936\",\n \"0.48252603\",\n \"0.48018655\",\n \"0.47849703\",\n \"0.47845882\",\n \"0.4782678\",\n \"0.47798303\",\n \"0.4769205\",\n \"0.47675377\",\n \"0.4761075\",\n \"0.47494498\",\n \"0.47493553\",\n \"0.4743193\",\n \"0.47419637\",\n \"0.47397158\",\n \"0.47369513\",\n \"0.47263083\",\n \"0.47255614\",\n \"0.4724568\",\n \"0.47204784\",\n \"0.47195882\",\n \"0.47183186\",\n \"0.47121957\",\n \"0.47072968\",\n \"0.47068492\",\n \"0.47050366\",\n \"0.47007012\",\n \"0.46976492\",\n \"0.4692514\",\n \"0.4692514\",\n \"0.46919358\",\n \"0.4689712\",\n \"0.46852478\",\n \"0.46752906\",\n \"0.4671883\",\n \"0.46674138\",\n \"0.4664621\",\n \"0.46615413\",\n \"0.46550694\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6615458"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6898,"cells":{"query":{"kind":"string","value":"r\"\"\" Return the dimension of the affine space spanned generated by each Newton polytopes. for triangular matrices, seems to stay 0 on the diagonal."},"document":{"kind":"string","value":"def get_vector_span(self, i, j):\n from sage.rings.infinity import Infinity\n from sage.matrix.constructor import matrix\n data = self[i,j]\n if not data:\n return None\n elif len(data) == 1:\n return FreeModule(ZZ, self._nvars).submodule([])\n else:\n return matrix([x-data[0] for x in data]).row_space()"},"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 dim(self) -> int:","def getlen(self):\n if self.onlydiag():\n return self.lendiag()\n else:\n return len(self)","def dimension(self):\n return 3*self.genus - 3 + self.n","def dim(self) -> int:\n return self.atoms.shape[:-1]","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def diagonal_size(self):\n b = self.GetBounds()\n return np.sqrt((b[1] - b[0]) ** 2 + (b[3] - b[2]) ** 2)","def n_dim(self):\n return self._n_dim","def shape(self) -> (int,int):\n return (len(self.mat), len(self.mat[0]))","def matrix_dim(CT):\r\n if CT[0]==0 and CT[-1]==0:\r\n return 2\r\n elif CT[0]!=0 and CT[-1]!=0:\r\n return 4","def __len__(self):\n return np.size(self.A,0)","def Nx(self):\n return self.shape[-1]","def dim(self) -> int:\n pass","def __len__(self):\n return self.N.shape[0]","def dimensionality(self):\n return int(self.nDims)","def nplex(self):\n return self.shape[1]","def dim(self):\n return self.m, self.n","def my_dimension(self) -> Nat:\n my_part = self.my_diagram.as_list()\n sum_phat_sq = sum((z*(2*i+1) for (i, z) in enumerate(my_part)))\n dimension = 0\n num_odd_parts = sum((z % 2 for z in my_part))\n if self.my_type is LieType.A:\n dimension = (self.lie_rank+1)**2 - sum_phat_sq\n elif self.my_type is LieType.D:\n dimension = 2*(self.lie_rank**2) - self.lie_rank - \\\n sum_phat_sq//2 + num_odd_parts//2\n elif self.my_type is LieType.B:\n dimension = 2*(self.lie_rank**2) + self.lie_rank - \\\n sum_phat_sq//2 + num_odd_parts//2\n elif self.my_type is LieType.C:\n dimension = 2*(self.lie_rank**2) + self.lie_rank - \\\n sum_phat_sq//2 - num_odd_parts//2\n else:\n raise ValueError(\n \"Lie type must be one of the 4 classical families\")\n return dimension","def size(adj_mat):\n return adj_mat.shape[0]","def n_thres(self):\n return np.size(self.thres)","def number_of_basis(self):\n return self._pre_kernel.shape[0]","def get_zdim(self):\n return self.decoder.get_input_info_dict()['latent_vector'].get_shape()[1]","def nNx(self):\n return self.nCx + 1","def InferSpatialDimension(self):\n\n assert self.points is not None\n # if self.points.shape[1] == 3:\n # if self.element_type == \"tri\" or self.element_type == \"quad\":\n # print(\"3D surface mesh of \", self.element_type)\n\n return self.points.shape[1]","def size(self)->int:\n\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])","def dimensionality(self):\n if self.vector.shape is ():\n return 0\n if len(self.vector.shape) is 1:\n return 1\n _, dim = self.vector.shape\n return dim","def dim(self):\n return len(self.shape)","def dim(self):\n return len(self.shape)","def nspatials(self):\n return int(len(self)/2)","def numel(self):\n return self.t.size","def dims(x):\n return len(x.shape)","def element_size(self):\n vecs = (\n self.nodes[self.elements[:, :4], :][:, 1:, :]\n - self.nodes[self.elements[:, :4], :][:, 0, None, :]\n )\n return np.abs(np.linalg.det(vecs)) / 6","def dim(self):\n return len(self._n)","def flat_dim(self):\n return np.sum([c.flat_dim for c in self.spaces])","def nNy(self):\n if self.dim < 2:\n return None\n return self.nCy + 1","def ndims(x):\n return len(x.get_shape())","def dim(self) -> int:\n return self._n_dim","def size(self):\n return int(misc.intprod(self.shape))","def dim(self):\n return self.ambient_dim() - self.n_equations()","def getdim(self):\n return round(self.w() / self.c)","def columns(self) -> int:\n return self.__squares[0].__len__()","def n_dims(self):\n return self.pdm.n_dims","def dimension(self):\n return self.__N","def __len__(self):\n return self.n_node.shape[0]","def __len__(self) -> int:\n\n return self.layout.gaDims","def getNpol(self):\n return self.shape(squeeze=False)[1]","def calculate_dimensions(self):\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\n self.nr_nodes_x = self.nr_elements_x + 1\n self.nr_elements_z = self.nr_nodes_z - 1","def get_grid_width(puzzle: str) -> int:\r\n return int(len(puzzle) ** (1 / 2))","def get_in_dim(self) -> int:\n return self.in_dim","def dim(self):\n if '_dim' in self.__dict__:\n return self._dim\n\n if len(self._Vrepresentation)==0:\n self._dim = -1\n return self._dim\n\n origin = vector(self._Vrepresentation[0])\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\n self._dim = matrix(v_list).rank()\n return self._dim","def dim(self) -> tuple:\n if self.has_tensor(): return self.as_tensor().dim()\n else:\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]","def get_dims(self):\n row_lbl, col_lbl = self.get_idxvals()\n return len(row_lbl), len(col_lbl)","def size(self):\r\n # Anthony stage 2\r\n return number_size(self.n) - 1","def n_dims(self):\n return len(self.dimensions)","def __len__(self):\n return self.flatten_dim(self.shape[0])","def size(self):\n\t\treturn self.dims","def nvar(self):\n return self.h.shape[0]","def nD(self):\n return self.locations[0].shape[0]","def __len__(self):\n return self.xyz.shape[0]","def __len__(self):\n return self.xyz.shape[0]","def N(self):\n return _hypre.HypreParMatrix_N(self)","def xdim(self):\n return len(self._x)","def nNz(self):\n if self.dim < 3:\n return None\n return self.nCz + 1","def dimensions():","def width(self):\n return self.board.shape[1]","def outdim(self):\n return len(self.getSensors())","def width(self) -> int:\n return self._obj[self.x_dim].size","def dim(self) -> Tuple[Tuple[int, int], Tuple[int, int]]:","def _get_parameter_count(self):\n parameters_d = 5;\n size_h = self.model.size_h\n return (size_h - 1) + size_h * (\n (size_h - 1) + parameters_d + (self.model.size_aa - 1) + \n (self.model.size_ss - 1) + (self.model.size_cis - 1)\n )","def __len__(self) -> int:\n\n return self.shape.shape[1]","def inertia(mus):\n pos, negs, zeros = cluster_eignvalues(mus)\n\n return len(zeros) + min(len(pos), len(negs))","def dim_M(self):\n assert 'M' in self.dp\n return np.sqrt(self.f1*self.f2*self.f3**3)*self.dT**2*self.dp.M","def n_dims(self):\n return self.model.template_instance.n_dims","def dimension(self):","def numpoints(self):\n return len(self.pars) + 1 # so dof is 1","def nD(self):\n return self.locations.shape[0]","def dim(self) -> tuple:\n if self.expr_list: return (self.expr_list[0].size()[0], len(self.expr_list)) + self.expr_list[0].size()[1:]\n elif self.expr_tensor is not None: return self.expr_tensor.size()\n elif self.expr_transposed_tensor is not None:\n return (self.expr_transposed_tensor.size()[1], self.expr_transposed_tensor.size()[0]) + self.expr_transposed_tensor.size()[2:]\n else:\n raise NotImplementedError()","def dim_calculator():\r\n probe_set = np.arange(1, 101)\r\n X = -36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def size(self) -> int:\n return int(np.multiply(*self.shape))","def size(self):\n if type(self._shape).__name__ == 'tuple':\n return self._shape[-1]\n else:\n return self._shape","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def dim(self):\n return (self.n, )","def __len__(self):\n # type: () -> int\n return self.shape[0]","def ncells(self):\n return self.izone.size","def nD(self):\n return self.locations.shape[0] * len(self.components)","def getDim(self):\n return \"%dx%d\" % (self.rows, self.cols)","def matShape(mat):\n return (len(mat),len(mat[0]))","def ndim(self) -> int:\r\n return len(self.plates)","def get_dof(self):\n return len(self.a_n)","def dim(self):\n\t\treturn self.D","def __len__(self):\r\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))","def nx(self):\n return self.__nx-2*self.pml_length","def get_grid_width(self):\n # replace with your code\n return 0","def num_quadrature_points(self) -> int:","def rows(self) -> int:\n return self.__squares.__len__()","def get_input_dim(self) -> int:\n raise NotImplementedError","def num_cells(self):\n if hasattr(self, '__num_cells__'):\n return self.__num_cells__\n if self.x is not None:\n return self.x.size(self.__cat_dim__('x', self.x))\n if self.boundary_index is not None:\n return int(self.boundary_index[1,:].max()) + 1\n assert self.upper_index is None and self.lower_index is None\n return None","def dim(self,mat):\n result = np.shape(mat)\n self.dimensions = result\n return self.dimensions","def get_dimension_length(self):\n pass","def nsites(self) -> int:\n return len(self.A)","def num_parameters(self) -> int:\n return len(self.w) + prod(self.v.shape) - len(self.v)","def width(self):\n return self.i_node.distance(self.j_node)"],"string":"[\n \"def dim(self) -> int:\",\n \"def getlen(self):\\n if self.onlydiag():\\n return self.lendiag()\\n else:\\n return len(self)\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def dim(self) -> int:\\n return self.atoms.shape[:-1]\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def diagonal_size(self):\\n b = self.GetBounds()\\n return np.sqrt((b[1] - b[0]) ** 2 + (b[3] - b[2]) ** 2)\",\n \"def n_dim(self):\\n return self._n_dim\",\n \"def shape(self) -> (int,int):\\n return (len(self.mat), len(self.mat[0]))\",\n \"def matrix_dim(CT):\\r\\n if CT[0]==0 and CT[-1]==0:\\r\\n return 2\\r\\n elif CT[0]!=0 and CT[-1]!=0:\\r\\n return 4\",\n \"def __len__(self):\\n return np.size(self.A,0)\",\n \"def Nx(self):\\n return self.shape[-1]\",\n \"def dim(self) -> int:\\n pass\",\n \"def __len__(self):\\n return self.N.shape[0]\",\n \"def dimensionality(self):\\n return int(self.nDims)\",\n \"def nplex(self):\\n return self.shape[1]\",\n \"def dim(self):\\n return self.m, self.n\",\n \"def my_dimension(self) -> Nat:\\n my_part = self.my_diagram.as_list()\\n sum_phat_sq = sum((z*(2*i+1) for (i, z) in enumerate(my_part)))\\n dimension = 0\\n num_odd_parts = sum((z % 2 for z in my_part))\\n if self.my_type is LieType.A:\\n dimension = (self.lie_rank+1)**2 - sum_phat_sq\\n elif self.my_type is LieType.D:\\n dimension = 2*(self.lie_rank**2) - self.lie_rank - \\\\\\n sum_phat_sq//2 + num_odd_parts//2\\n elif self.my_type is LieType.B:\\n dimension = 2*(self.lie_rank**2) + self.lie_rank - \\\\\\n sum_phat_sq//2 + num_odd_parts//2\\n elif self.my_type is LieType.C:\\n dimension = 2*(self.lie_rank**2) + self.lie_rank - \\\\\\n sum_phat_sq//2 - num_odd_parts//2\\n else:\\n raise ValueError(\\n \\\"Lie type must be one of the 4 classical families\\\")\\n return dimension\",\n \"def size(adj_mat):\\n return adj_mat.shape[0]\",\n \"def n_thres(self):\\n return np.size(self.thres)\",\n \"def number_of_basis(self):\\n return self._pre_kernel.shape[0]\",\n \"def get_zdim(self):\\n return self.decoder.get_input_info_dict()['latent_vector'].get_shape()[1]\",\n \"def nNx(self):\\n return self.nCx + 1\",\n \"def InferSpatialDimension(self):\\n\\n assert self.points is not None\\n # if self.points.shape[1] == 3:\\n # if self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n # print(\\\"3D surface mesh of \\\", self.element_type)\\n\\n return self.points.shape[1]\",\n \"def size(self)->int:\\n\\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])\",\n \"def dimensionality(self):\\n if self.vector.shape is ():\\n return 0\\n if len(self.vector.shape) is 1:\\n return 1\\n _, dim = self.vector.shape\\n return dim\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def nspatials(self):\\n return int(len(self)/2)\",\n \"def numel(self):\\n return self.t.size\",\n \"def dims(x):\\n return len(x.shape)\",\n \"def element_size(self):\\n vecs = (\\n self.nodes[self.elements[:, :4], :][:, 1:, :]\\n - self.nodes[self.elements[:, :4], :][:, 0, None, :]\\n )\\n return np.abs(np.linalg.det(vecs)) / 6\",\n \"def dim(self):\\n return len(self._n)\",\n \"def flat_dim(self):\\n return np.sum([c.flat_dim for c in self.spaces])\",\n \"def nNy(self):\\n if self.dim < 2:\\n return None\\n return self.nCy + 1\",\n \"def ndims(x):\\n return len(x.get_shape())\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def size(self):\\n return int(misc.intprod(self.shape))\",\n \"def dim(self):\\n return self.ambient_dim() - self.n_equations()\",\n \"def getdim(self):\\n return round(self.w() / self.c)\",\n \"def columns(self) -> int:\\n return self.__squares[0].__len__()\",\n \"def n_dims(self):\\n return self.pdm.n_dims\",\n \"def dimension(self):\\n return self.__N\",\n \"def __len__(self):\\n return self.n_node.shape[0]\",\n \"def __len__(self) -> int:\\n\\n return self.layout.gaDims\",\n \"def getNpol(self):\\n return self.shape(squeeze=False)[1]\",\n \"def calculate_dimensions(self):\\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\\n self.nr_nodes_x = self.nr_elements_x + 1\\n self.nr_elements_z = self.nr_nodes_z - 1\",\n \"def get_grid_width(puzzle: str) -> int:\\r\\n return int(len(puzzle) ** (1 / 2))\",\n \"def get_in_dim(self) -> int:\\n return self.in_dim\",\n \"def dim(self):\\n if '_dim' in self.__dict__:\\n return self._dim\\n\\n if len(self._Vrepresentation)==0:\\n self._dim = -1\\n return self._dim\\n\\n origin = vector(self._Vrepresentation[0])\\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\\n self._dim = matrix(v_list).rank()\\n return self._dim\",\n \"def dim(self) -> tuple:\\n if self.has_tensor(): return self.as_tensor().dim()\\n else:\\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]\",\n \"def get_dims(self):\\n row_lbl, col_lbl = self.get_idxvals()\\n return len(row_lbl), len(col_lbl)\",\n \"def size(self):\\r\\n # Anthony stage 2\\r\\n return number_size(self.n) - 1\",\n \"def n_dims(self):\\n return len(self.dimensions)\",\n \"def __len__(self):\\n return self.flatten_dim(self.shape[0])\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def nD(self):\\n return self.locations[0].shape[0]\",\n \"def __len__(self):\\n return self.xyz.shape[0]\",\n \"def __len__(self):\\n return self.xyz.shape[0]\",\n \"def N(self):\\n return _hypre.HypreParMatrix_N(self)\",\n \"def xdim(self):\\n return len(self._x)\",\n \"def nNz(self):\\n if self.dim < 3:\\n return None\\n return self.nCz + 1\",\n \"def dimensions():\",\n \"def width(self):\\n return self.board.shape[1]\",\n \"def outdim(self):\\n return len(self.getSensors())\",\n \"def width(self) -> int:\\n return self._obj[self.x_dim].size\",\n \"def dim(self) -> Tuple[Tuple[int, int], Tuple[int, int]]:\",\n \"def _get_parameter_count(self):\\n parameters_d = 5;\\n size_h = self.model.size_h\\n return (size_h - 1) + size_h * (\\n (size_h - 1) + parameters_d + (self.model.size_aa - 1) + \\n (self.model.size_ss - 1) + (self.model.size_cis - 1)\\n )\",\n \"def __len__(self) -> int:\\n\\n return self.shape.shape[1]\",\n \"def inertia(mus):\\n pos, negs, zeros = cluster_eignvalues(mus)\\n\\n return len(zeros) + min(len(pos), len(negs))\",\n \"def dim_M(self):\\n assert 'M' in self.dp\\n return np.sqrt(self.f1*self.f2*self.f3**3)*self.dT**2*self.dp.M\",\n \"def n_dims(self):\\n return self.model.template_instance.n_dims\",\n \"def dimension(self):\",\n \"def numpoints(self):\\n return len(self.pars) + 1 # so dof is 1\",\n \"def nD(self):\\n return self.locations.shape[0]\",\n \"def dim(self) -> tuple:\\n if self.expr_list: return (self.expr_list[0].size()[0], len(self.expr_list)) + self.expr_list[0].size()[1:]\\n elif self.expr_tensor is not None: return self.expr_tensor.size()\\n elif self.expr_transposed_tensor is not None:\\n return (self.expr_transposed_tensor.size()[1], self.expr_transposed_tensor.size()[0]) + self.expr_transposed_tensor.size()[2:]\\n else:\\n raise NotImplementedError()\",\n \"def dim_calculator():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = -36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def size(self) -> int:\\n return int(np.multiply(*self.shape))\",\n \"def size(self):\\n if type(self._shape).__name__ == 'tuple':\\n return self._shape[-1]\\n else:\\n return self._shape\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def dim(self):\\n return (self.n, )\",\n \"def __len__(self):\\n # type: () -> int\\n return self.shape[0]\",\n \"def ncells(self):\\n return self.izone.size\",\n \"def nD(self):\\n return self.locations.shape[0] * len(self.components)\",\n \"def getDim(self):\\n return \\\"%dx%d\\\" % (self.rows, self.cols)\",\n \"def matShape(mat):\\n return (len(mat),len(mat[0]))\",\n \"def ndim(self) -> int:\\r\\n return len(self.plates)\",\n \"def get_dof(self):\\n return len(self.a_n)\",\n \"def dim(self):\\n\\t\\treturn self.D\",\n \"def __len__(self):\\r\\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))\",\n \"def nx(self):\\n return self.__nx-2*self.pml_length\",\n \"def get_grid_width(self):\\n # replace with your code\\n return 0\",\n \"def num_quadrature_points(self) -> int:\",\n \"def rows(self) -> int:\\n return self.__squares.__len__()\",\n \"def get_input_dim(self) -> int:\\n raise NotImplementedError\",\n \"def num_cells(self):\\n if hasattr(self, '__num_cells__'):\\n return self.__num_cells__\\n if self.x is not None:\\n return self.x.size(self.__cat_dim__('x', self.x))\\n if self.boundary_index is not None:\\n return int(self.boundary_index[1,:].max()) + 1\\n assert self.upper_index is None and self.lower_index is None\\n return None\",\n \"def dim(self,mat):\\n result = np.shape(mat)\\n self.dimensions = result\\n return self.dimensions\",\n \"def get_dimension_length(self):\\n pass\",\n \"def nsites(self) -> int:\\n return len(self.A)\",\n \"def num_parameters(self) -> int:\\n return len(self.w) + prod(self.v.shape) - len(self.v)\",\n \"def width(self):\\n return self.i_node.distance(self.j_node)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67515165","0.67112654","0.6535919","0.653394","0.64353853","0.6379742","0.63764715","0.63629043","0.63574785","0.63428813","0.62986326","0.6278618","0.62567246","0.62425613","0.6237966","0.6212587","0.6183233","0.61782753","0.61762774","0.61756885","0.6173078","0.6171133","0.61695725","0.61553955","0.6145848","0.6143558","0.6143558","0.61384237","0.6121866","0.61109114","0.61099464","0.6102169","0.6100881","0.60988355","0.60914415","0.60912895","0.60797006","0.60751504","0.6073545","0.60726696","0.60682726","0.6066201","0.6063794","0.60608405","0.60524803","0.60439014","0.6034139","0.60324085","0.6028394","0.6027569","0.6025686","0.6020437","0.6018058","0.60153395","0.60114664","0.6006208","0.59950763","0.5992419","0.5992419","0.59921795","0.5989881","0.5983861","0.5976259","0.5972445","0.59680414","0.5966377","0.5965046","0.5964087","0.5961787","0.5957779","0.59314173","0.59222436","0.5918292","0.59114695","0.590334","0.5899204","0.5881982","0.5875742","0.58710384","0.58633184","0.5856082","0.58543617","0.5853011","0.5848631","0.5846997","0.5846564","0.5841678","0.58262444","0.58250344","0.5819995","0.5819645","0.5818771","0.58114475","0.581131","0.5804395","0.5800937","0.5800435","0.5798782","0.5794297","0.5786859","0.5782895"],"string":"[\n \"0.67515165\",\n \"0.67112654\",\n \"0.6535919\",\n \"0.653394\",\n \"0.64353853\",\n \"0.6379742\",\n \"0.63764715\",\n \"0.63629043\",\n \"0.63574785\",\n \"0.63428813\",\n \"0.62986326\",\n \"0.6278618\",\n \"0.62567246\",\n \"0.62425613\",\n \"0.6237966\",\n \"0.6212587\",\n \"0.6183233\",\n \"0.61782753\",\n \"0.61762774\",\n \"0.61756885\",\n \"0.6173078\",\n \"0.6171133\",\n \"0.61695725\",\n \"0.61553955\",\n \"0.6145848\",\n \"0.6143558\",\n \"0.6143558\",\n \"0.61384237\",\n \"0.6121866\",\n \"0.61109114\",\n \"0.61099464\",\n \"0.6102169\",\n \"0.6100881\",\n \"0.60988355\",\n \"0.60914415\",\n \"0.60912895\",\n \"0.60797006\",\n \"0.60751504\",\n \"0.6073545\",\n \"0.60726696\",\n \"0.60682726\",\n \"0.6066201\",\n \"0.6063794\",\n \"0.60608405\",\n \"0.60524803\",\n \"0.60439014\",\n \"0.6034139\",\n \"0.60324085\",\n \"0.6028394\",\n \"0.6027569\",\n \"0.6025686\",\n \"0.6020437\",\n \"0.6018058\",\n \"0.60153395\",\n \"0.60114664\",\n \"0.6006208\",\n \"0.59950763\",\n \"0.5992419\",\n \"0.5992419\",\n \"0.59921795\",\n \"0.5989881\",\n \"0.5983861\",\n \"0.5976259\",\n \"0.5972445\",\n \"0.59680414\",\n \"0.5966377\",\n \"0.5965046\",\n \"0.5964087\",\n \"0.5961787\",\n \"0.5957779\",\n \"0.59314173\",\n \"0.59222436\",\n \"0.5918292\",\n \"0.59114695\",\n \"0.590334\",\n \"0.5899204\",\n \"0.5881982\",\n \"0.5875742\",\n \"0.58710384\",\n \"0.58633184\",\n \"0.5856082\",\n \"0.58543617\",\n \"0.5853011\",\n \"0.5848631\",\n \"0.5846997\",\n \"0.5846564\",\n \"0.5841678\",\n \"0.58262444\",\n \"0.58250344\",\n \"0.5819995\",\n \"0.5819645\",\n \"0.5818771\",\n \"0.58114475\",\n \"0.581131\",\n \"0.5804395\",\n \"0.5800937\",\n \"0.5800435\",\n \"0.5798782\",\n \"0.5794297\",\n \"0.5786859\",\n \"0.5782895\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6899,"cells":{"query":{"kind":"string","value":"r\"\"\" Permutations (i1,j1) > (i2,j2) Make an exchange of rows/columns in matrix data. This is used in multiplication of full symbolic matrices."},"document":{"kind":"string","value":"def vertex_swap(d, n, l, i1, i2, j1, j2):\n if i1 == i2 and j1 == j2:\n return l\n if i1 == j1:\n # (i1,i1) -> (i2,i2)\n assert i2 == j2\n def swap(v):\n swap2(d, n, v, i1, i2)\n elif i1 == i2:\n # (i,j1) -> (i,j2)\n def swap(v):\n swap2(d, n, v, j1, j2)\n elif j1 == j2:\n # (i1,j) -> (i2,j)\n def swap(v):\n swap2(d, n, v, i1, i2)\n elif i1 == j2 and i2 == j1:\n # (i1,j1) -> (j1,i1)\n def swap(v):\n swap2(d, n, v, i1, j1)\n elif i1 == j2:\n # (i1,j1) -> (i2,i1)\n def swap(v):\n swap3(d, n, v, j1, i1, i2)\n elif i2 == j1:\n # (i1,j1) -> (j1,j2)\n def swap(v):\n swap3(d, n, v, i1, j1, j2)\n else:\n # (i1,j1) -> (i2,j2)\n def swap(v):\n swap2(d, n, v, i1, i2)\n swap2(d, n, v, j1, j2)\n ll = []\n for v in l:\n v = v.__copy__()\n swap(v)\n v.set_immutable()\n ll.append(v)\n ll.sort()\n return tuple(ll)"},"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 swap_columns(i, j, *args):\n output = list()\n for M in args:\n output.append(_cswap(i, j, M))\n return output","def swap_rows(i, j, *args):\n output = list()\n for M in args:\n output.append(_rswap(i, j, M))\n return output","def return_swaps( # pylint: disable=too-many-locals,too-many-branches,too-many-statements\n self, old_mapping, new_mapping, permutation=None\n ):\n if permutation is None:\n permutation = list(range(self.num_rows))\n swap_operations = []\n\n class Position: # pylint: disable=too-few-public-methods\n \"\"\"Custom Container.\"\"\"\n\n def __init__( # pylint: disable=too-many-arguments\n self,\n current_row,\n current_column,\n final_row,\n final_column,\n row_after_step_1=None,\n ):\n self.current_row = current_row\n self.current_column = current_column\n self.final_row = final_row\n self.final_column = final_column\n self.row_after_step_1 = row_after_step_1\n\n # final_positions contains info containers\n # final_position[i][j] contains info container with\n # current_row == i and current_column == j\n final_positions = [[None for i in range(self.num_columns)] for j in range(self.num_rows)]\n # move qubits which are in both mappings\n used_mapped_ids = set()\n for logical_id in old_mapping:\n if logical_id in new_mapping:\n used_mapped_ids.add(new_mapping[logical_id])\n old_column = old_mapping[logical_id] % self.num_columns\n old_row = old_mapping[logical_id] // self.num_columns\n new_column = new_mapping[logical_id] % self.num_columns\n new_row = new_mapping[logical_id] // self.num_columns\n info_container = Position(\n current_row=old_row,\n current_column=old_column,\n final_row=new_row,\n final_column=new_column,\n )\n final_positions[old_row][old_column] = info_container\n # exchange all remaining None with the not yet used mapped ids\n all_ids = set(range(self.num_qubits))\n not_used_mapped_ids = list(all_ids.difference(used_mapped_ids))\n not_used_mapped_ids = sorted(not_used_mapped_ids, reverse=True)\n for row in range(self.num_rows):\n for column in range(self.num_columns):\n if final_positions[row][column] is None:\n mapped_id = not_used_mapped_ids.pop()\n new_column = mapped_id % self.num_columns\n new_row = mapped_id // self.num_columns\n info_container = Position(\n current_row=row,\n current_column=column,\n final_row=new_row,\n final_column=new_column,\n )\n final_positions[row][column] = info_container\n if len(not_used_mapped_ids) > 0: # pragma: no cover\n raise RuntimeError('Internal compiler error: len(not_used_mapped_ids) > 0')\n # 1. Assign column_after_step_1 for each element\n # Matching contains the num_columns matchings\n matchings = [None for i in range(self.num_rows)]\n # Build bipartite graph. Nodes are the current columns numbered (0, 1, ...) and the destination columns\n # numbered with an offset of self.num_columns (0 + offset, 1+offset, ...)\n graph = nx.Graph()\n offset = self.num_columns\n graph.add_nodes_from(range(self.num_columns), bipartite=0)\n graph.add_nodes_from(range(offset, offset + self.num_columns), bipartite=1)\n # Add an edge to the graph from (i, j+offset) for every element currently in column i which should go to\n # column j for the new mapping\n for row in range(self.num_rows):\n for column in range(self.num_columns):\n destination_column = final_positions[row][column].final_column\n if not graph.has_edge(column, destination_column + offset):\n graph.add_edge(column, destination_column + offset)\n # Keep manual track of multiple edges between nodes\n graph[column][destination_column + offset]['num'] = 1\n else:\n graph[column][destination_column + offset]['num'] += 1\n # Find perfect matching, remove those edges from the graph and do it again:\n for i in range(self.num_rows):\n top_nodes = range(self.num_columns)\n matching = nx.bipartite.maximum_matching(graph, top_nodes)\n matchings[i] = matching\n # Remove all edges of the current perfect matching\n for node in range(self.num_columns):\n if graph[node][matching[node]]['num'] == 1:\n graph.remove_edge(node, matching[node])\n else:\n graph[node][matching[node]]['num'] -= 1\n # permute the matchings:\n tmp = deepcopy(matchings)\n for i in range(self.num_rows):\n matchings[i] = tmp[permutation[i]]\n # Assign row_after_step_1\n for column in range(self.num_columns):\n for row_after_step_1 in range(self.num_rows):\n dest_column = matchings[row_after_step_1][column] - offset\n best_element = None\n for row in range(self.num_rows):\n element = final_positions[row][column]\n if element.row_after_step_1 is not None:\n continue\n if element.final_column == dest_column:\n if best_element is None:\n best_element = element\n elif best_element.final_row > element.final_row:\n best_element = element\n best_element.row_after_step_1 = row_after_step_1\n # 2. Sort inside all the rows\n swaps = self._sort_within_columns(final_positions=final_positions, key=lambda x: x.row_after_step_1)\n swap_operations += swaps\n # 3. Sort inside all the columns\n swaps = self._sort_within_rows(final_positions=final_positions, key=lambda x: x.final_column)\n swap_operations += swaps\n # 4. Sort inside all the rows\n swaps = self._sort_within_columns(final_positions=final_positions, key=lambda x: x.final_row)\n swap_operations += swaps\n return swap_operations","def permutation_matrix(order):\n matrix = np.zeros([order,order])\n matrix[-1,0] = 1\n matrix[0:-1,1::] = np.identity(order-1)\n return matrix","def xor(m, i, j):\n for e in range(len(m[0])):\n m[j][e] ^= m[i][e]\n return m","def transpose(m):\n\n pass","def reverse_matrix(self):\n return SWAP.matrix @ self.matrix @ SWAP.matrix","def perform_gauss_jordan_elimination(m, show):\n if show:\n print(\"Initial State\")\n print_matrix(m)\n\n r, c = 0, 0\n rows = len(m)\n cols = len(m[0])\n\n if show:\n print(\"rows: %s cols: %s\"%(rows, cols))\n\n while True:\n _swap = False\n\n if show:\n print(\"r %s c %s\"%(r, c))\n\n ## Check Pivot\n if m[r][c] == 0:\n ## Swap\n for i in range(rows):\n if r != i and i > r: ## Avoid comparing the same row and do not swap to upper rows\n if m[i][c] == 1 and not _swap: ## Check if a swap is not performed before in the same column\n if show:\n print(\"Swapping %s %s and %s %s\"%(r, m[r], i, m[i]))\n #m = swap(m,r,i)\n temp = m[r]\n m[r] = m[i]\n m[i] = temp\n _swap = True\n if show:\n print_matrix(m)\n if not _swap: ## If not swap, means there is no 1 to swap, so go to the next column\n c+=1\n\n if m[r][c] == 1:\n ## XOR\n for i in range(rows):\n if r != i: ## Avoid comparing the same row\n if m[i][c] == 1:\n if show:\n print(\"XOR Row %s: %s into Row %s: %s\"%(r, m[r], i, m[i]))\n for e in range(len(m[0])):\n m[i][e] ^= m[r][e]\n if show:\n print_matrix(m)\n\n ## Increase row and column\n r+=1\n c+=1\n\n ## break condition if all rows or all columns (except the augmented column are treated)\n if r == rows or c >= cols-1:\n break\n \n return m","def jmatswap(ind: int):\n return _jmswap[ind - 1]","def _swap_permutation(i, j, permutation_vector):\n permutation_vector[i], permutation_vector[j] = permutation_vector[j], permutation_vector[i]","def transpose(self):\n order = list(self.order)\n order[-2], order[-1] = order[-1], order[-2]\n self.order = order","def perm2(a,ix):\n if ix==len(a):\n print(a)\n else:\n for j in range(ix+1):\n swap(a,j,ix)\n perm2(a,ix+1)\n swap(a,j,ix)","def swap(permutation, transposition, remaining=[]):\n i, j = transposition\n nb_positions = len(permutation)\n res = np.array(permutation)\n\n if j < nb_positions:\n res[i], res[j] = res[j], res[i]\n else:\n res[i] = remaining[j-nb_positions]\n\n return tuple(res)","def _swap(self, i, j, k):\n\t\tif self.verbose:\n\t\t\tprint(i, k)\n\t\t\tprint(i, j)\n\t\t\tprint(j, k)\n\t\tself.arrangement[i],self.arrangement[k] = self.arrangement[k],self.arrangement[i]\n\t\tself.arrangement[i],self.arrangement[j] = self.arrangement[j],self.arrangement[i]\n\t\tself.arrangement[j],self.arrangement[k] = self.arrangement[k],self.arrangement[j]","def _multi_matmul_chain_order(arrays):\n n = len(arrays)\n # p stores the dimensions of the matrices\n # Example for p: A_{10x100}, B_{100x5}, C_{5x50} --> p = [10, 100, 5, 50]\n # Using -2 to generalize for shapes that are more than 2 dimmensions\n p = [a.shape[-2] for a in arrays] + [arrays[-1].shape[-1]]\n # m is a matrix of costs of the subproblems\n # m[i,j]: min number of scalar multiplications needed to compute A_{i..j}\n m = np.zeros((n, n), dtype=np.double)\n # s is the actual ordering\n # s[i, j] is the value of k at which we split the product A_i..A_j\n s = np.empty((n, n), dtype=np.intp)\n\n for l in range(1, n):\n for i in range(n - l):\n j = i + l\n m[i, j] = np.inf\n for k in range(i, j):\n q = m[i, k] + m[k + 1, j] + p[i] * p[k + 1] * p[j + 1]\n if q < m[i, j]:\n m[i, j] = q\n s[i, j] = k # Note that Cormen uses 1-based index\n return s","def rotate(self, matrix: List[List[int]]) -> None:\r\n n = len(matrix)\r\n for j in range((n+1)//2):\r\n for i in range(n-2*j-1):\r\n matrix[j][j+i], matrix[j+i][n-1-j], matrix[n-1-j][n-1-j-i], matrix[n-1-j-i][j] = matrix[n-1-j-i][j], matrix[j][j+i], matrix[j+i][n-1-j], matrix[n-1-j][n-1-j-i]","def rotate(self, matrix: List[List[int]]) -> None:\n # note: coded up logic after looking at discussion board\n\n # 1 - swap symmetrically across diagonal so that 123 becomes the first column\n # leftIndent = 0\n n = len(matrix)\n # for i in range(len(matrix)):\n for i in range(n):\n # indent (to only iterate top side of diagonal) adds 1 per line, so same as i\n # for j in range(i, len(matrix[i])):\n for j in range(i, n):\n # print(matrix[i][j], matrix[j][i])\n # print()\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\n\n # print(matrix)\n # 2 - swap elements in individual rows to swap order of columns (since 123 should be last column)\n # for i in range(len(matrix)):\n for i in range(n):\n # for j in range(len(matrix)):\n # print(\"new row: \", matrix[i])\n left = 0\n right = len(matrix[i]) - 1\n while (left <= right):\n # print(\"left: \", left, \" right: \", right, matrix[i][left], matrix[i][right])\n matrix[i][left], matrix[i][right] = matrix[i][right], matrix[i][left]\n left += 1\n right -= 1\n # print(matrix)\n # print()","def swapColumns(self, i, j):\n if not (type(i) in MATRIX_VALID_INTS and type(\n j) in MATRIX_VALID_INTS): # this should be fixed to accomodate 'long' types\n raise TypeError(\"Row indices must be of type 'int'\")\n columnA = self.deleteColumn(max(i, j))\n columnB = self.deleteColumn(min(i, j))\n self.insertColumn(min(i, j), *columnA)\n self.insertColumn(max(i, j), *columnB)","def derMatrix(Bulk_Operators, Bdy_Operators, Bulk_second, s=1):\n\t\tMatrix = []\n\t\tfor i in range(1, M_max + 1):\n\t\t\t\trow = []\n\t\t\t\tfor Bulk_Op in Bulk_Operators:\n\t\t\t\t\t\ttable_call = N*table1.table[0, i].subs({\"Delta\":Bulk_Op, \"Delta_12\":delta_12, \"Xi\":1.00})\n\t\t\t\t\t\trow.append(table_call)\n\t\t\t\tfor index in range(len(Bulk_second)):\n\t\t\t\t\t\trow.append(0*table1.table[0,0])\n\t\t\t\tfor Bdy_Op in Bdy_Operators:\n\t\t\t\t\tif Bdy_Op == 2.0:\n\t\t\t\t\t\t\tprint(\"here\")\n\t\t\t\t\t\t\ttable_call = (N-1)*table1.table[1, i].subs({\"Delta\":Bdy_Op, \"Xi\":1.00})\n\t\t\t\t\telse:\n\t\t\t\t\t\ttable_call = table1.table[1, i].subs({\"Delta\":Bdy_Op, \"Xi\":1.00})\n\t\t\t\t\trow.append(table_call)\n\t\t\t\tXi = symbols('Xi')\n\t\t\t\tif s == 1:\n\t\t\t\t\t\tlast_expr = Xi**((delta_1 + delta_2)/2)\n\t\t\t\t\t\tlast_elem = diff(last_expr, Xi, i).subs({\"Xi\":1.00}).evalf()\n\t\t\t\t\t\trow.append(last_elem)\n\t\t\t\tMatrix.append(row)\n\t\t\t\trow2 = []\n\t\t\t\tfor index in range(len(Bulk_Operators)):\n\t\t\t\t\t\trow2.append(0*table1.table[0,0])\n\t\t\t\tfor Bulk_Op in Bulk_second:\n\t\t\t\t\t\ttable_call = table1.table[0, i].subs({\"Delta\":Bulk_Op, \"Delta_12\":delta_12, \"Xi\":1.00})\n\t\t\t\t\t\trow2.append(table_call)\n\t\t\t\tfor Bdy_Op in Bdy_Operators:\n\t\t\t\t\t\tif Bdy_Op == 2.0:\n\t\t\t\t\t\t\tprint(\"here\")\n\t\t\t\t\t\t\ttable_call = -1*table1.table[1, i].subs({\"Delta\":Bdy_Op, \"Xi\":1.00})\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\ttable_call = table1.table[1, i].subs({\"Delta\":Bdy_Op, \"Xi\":1.00})\n\t\t\t\t\t\trow2.append(table_call)\n\t\t\t\tXi = symbols('Xi')\n\t\t\t\tif s == 1:\n\t\t\t\t\t\tlast_expr = Xi**((delta_1 + delta_2)/2)\n\t\t\t\t\t\tlast_elem = diff(last_expr, Xi, i).subs({\"Xi\":1.00}).evalf()\n\t\t\t\t\t\trow2.append(last_elem)\n\t\t\t\tMatrix.append(row2)\t\t\n\t\treturn np.array(Matrix)","def transpose():","def test_distance_matrix_permutation_test_symmetric(self):\r\n def make_result_list(*args, **kwargs):\r\n return (\r\n [distance_matrix_permutation_test(*args)[2] for i in range(10)]\r\n )\r\n\r\n m = array([[0, 1, 3], [1, 2, 4], [3, 4, 5]])\r\n # looks at each possible permutation n times --\r\n # compare first row to rest\r\n n = 100\r\n\r\n # looks at each possible permutation n times --\r\n # compare first row to rest\r\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n)\r\n self.assertSimilarMeans(r, 0. / 6.)\r\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n, tails='high')\r\n self.assertSimilarMeans(r, 0.77281447417149496, 0)\r\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n, tails='low')\r\n self.assertSimilarMeans(r, 4. / 6.)\r\n\r\n # The following lines are not part of the test code, but are useful in\r\n # figuring out what t-scores all of the permutations will yield.\r\n # permutes = [[0, 1, 2], [0, 2, 1], [1, 0, 2],\\\r\n # [1, 2, 0], [2, 0, 1], [2, 1, 0]]\r\n #results = []\r\n # for p in permutes:\r\n # p_m = permute_2d(m,p)\r\n # results.append(t_two_sample(\\\r\n # [p_m[0,1],p_m[0,2]],[p_m[2,1]],tails='high'))\r\n # print results\r","def rotate1(self, matrix: List[List[int]]) -> None:\n matrixLen = len(matrix)\n\n for i in range(matrixLen):\n for j in range(i, matrixLen):\n print(i, j)\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\n\n for i in range(matrixLen):\n for j in range(matrixLen // 2):\n matrix[i][j], matrix[i][matrixLen - 1 - j] = matrix[i][matrixLen - 1 - j], matrix[i][j]","def test_dim2(self):\r\n # Each row of p is a different permutation to inverse\r\n p = imatrix()\r\n inv = inverse_permutation(p)\r\n f_inverse = function([p], inv)\r\n\r\n rng = numpy.random.RandomState(utt.fetch_seed())\r\n # Generate 10 random permutations\r\n p_val = numpy.asarray([rng.permutation(10) for i in range(7)],\r\n dtype='int32')\r\n inv_val = f_inverse(p_val)\r\n\r\n # Check that the inverse of the inverse is the original permutation list\r\n assert numpy.all(f_inverse(inv_val) == p_val)\r\n # Check that, for each permutation,\r\n # permutation(inverse) == inverse(permutation) = identity\r\n for p_row, i_row in zip(p_val, inv_val):\r\n assert numpy.all(p_row[i_row] == numpy.arange(10))\r\n assert numpy.all(i_row[p_row] == numpy.arange(10))","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n for dig in range(n):\n row = dig\n for col in range(dig+1, n):\n matrix[row][col] , matrix[col][row] = matrix[col][row], matrix[row][col]\n print(matrix)\n left = 0\n right = n-1\n while left < right:\n for row in range(n):\n matrix[row][left], matrix[row][right] = matrix[row][right], matrix[row][left]\n left+=1\n right-=1","def perform_gauss_jordan_elimination_(m, show):\n if show:\n print(\"Initial State\")\n print_matrix(m)\n \n r = 0\n c = 0\n rows, cols = len(m), len(m[0])\n\n if show:\n print(\"rows: %s cols: %s\"%(rows, cols))\n\n while True:\n if show:\n print(\"r %s c %s\"%(r, c))\n\n ## Check Pivot\n _swap = False\n if m[r,c] == 0:\n for i in range(r+1,rows):\n if m[i,c] == 1:# If new pivot found... swap\n if show:\n print(\"Swapping %s %s and %s %s\"%(r, m[r], i, m[i]))\n m[[i,r]] = m[[r,i]] ## Swap\n _swap = True\n if show:\n print_matrix(m)\n break # No more swapping in this column\n if not _swap: ## No swap, move to the next column, same row\n c+=1\n\n if m[r,c] == 1:\n ## XOR\n for i in range(rows):\n indexes = np.setdiff1d(np.where(m[:,c] == 1),r) # Get all the ones to XOR in the same column\n for i in indexes:\n m[i] = np.bitwise_xor(m[i],m[r]) # Bitwise XOR\n if show:\n print(\"XOR Row %s: %s into Row %s: %s\"%(r, m[r], i, m[i]))\n if show:\n print_matrix(m)\n\n ## Increase row and column\n r+=1\n c+=1\n\n ## break condition if all rows or all columns (except the augmented column) are treated\n if r == rows or c >= cols-1:\n break\n\n if show:\n print(\"Final State\")\n print_matrix(m)\n \n return m","def _clifford_swap(cls, slot_i, slot_j) -> Tensor:\n\n return Tensor(\n {\n Tensor._merge_keys((slot_j,), (slot_i,)): -1,\n Tensor._merge_keys(): 2 * cls.symmetric_bilinear_form(slot_i, slot_j),\n }\n )","def rotate2D(self, matrix) -> None:\n N = len(matrix)\n\n # In case of N is odd, the innermost square belt is just one cell, no need of rotating.\n for i in range(0,int(N/2)): # outer loop for each square belt\t\t\t\n for j in range(i,N-i-1): # N-i group in the i-th square belt\n #print(i,j)\n tmp = matrix[i][j]\n matrix[i][j] = matrix[N-j-1][i]\n matrix[N-j-1][i] = matrix[N-i-1][N-j-1]\n matrix[N-i-1][N-j-1] = matrix[j][N-i-1]\n matrix[j][N-i-1] = tmp\n #print(matrix)","def rotate(self, m):\n n = len(m)\n for i in range(n//2):\n for j in range(i,n-i-1):\n m[j][~i],m[~i][~j],m[~j][i],m[i][j] = \\\n m[i][j],m[j][~i],m[~i][~j],m[~j][i]","def T(self):\n # TODO - your code here\n transpose = []\n for col in range(self.w):\n new_row = []\n for row in range(self.h):\n new_row.append(self.g[row][col])\n transpose.append(new_row)\n return Matrix(transpose)\n # TODO - your code here","def _cswap(i, j, S):\n N = _rswap(i, j, S.transpose()).transpose()\n return N","def transp(self, x1, x2, d):\n raise NotImplementedError","def transpose(self):\n pass","def commute_matrix(A):\n R = resistance_matrix(A)\n E = A.sum() / 2 # number of edges in graph\n C = 2 * E * R\n return C","def test_distance_matrix_permutation_test_non_symmetric(self):\r\n def make_result_list(*args, **kwargs):\r\n return [distance_matrix_permutation_test(*args, **kwargs)[2]\r\n for i in range(10)]\r\n\r\n m = arange(9).reshape((3, 3))\r\n n = 100\r\n # looks at each possible permutation n times --\r\n # compare first row to rest\r\n r = make_result_list(\r\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False)\r\n self.assertSimilarMeans(r, 0. / 6.)\r\n r = make_result_list(\r\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False,\r\n tails='high')\r\n self.assertSimilarMeans(r, 4. / 6.)\r\n r = make_result_list(\r\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False,\r\n tails='low')\r\n self.assertSimilarMeans(r, 0. / 6.)\r\n\r\n # looks at each possible permutation n times --\r\n # compare last row to rest\r\n r = make_result_list(\r\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False)\r\n self.assertSimilarMeans(r, 0. / 6.)\r\n r = make_result_list(\r\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False,\r\n tails='high')\r\n self.assertSimilarMeans(r, 0. / 6.)\r\n r = make_result_list(\r\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False,\r\n tails='low')\r\n self.assertSimilarMeans(r, 4. / 6.)","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix[0])\n for i in range(n // 2 + n % 2):\n for j in range(n // 2):\n tmp = matrix[n - 1 - j][i]\n matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1]\n matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 -i]\n matrix[j][n - 1 - i] = matrix[i][j]\n matrix[i][j] = tmp","def transpose(self):\n return self.conjugate()","def swap_cells(state, i1, j1, i2, j2):\n value1 = state[i1][j1]\n value2 = state[i2][j2]\n \n new_state = []\n for row in range(len(state)): \n new_row = []\n for column in range(len(state[row])): \n if row == i1 and column == j1: \n new_row.append(value2)\n elif row == i2 and column == j2:\n new_row.append(value1)\n else: \n new_row.append(state[row][column])\n new_state.append(tuple(new_row))\n return tuple(new_state)","def transpose(self) -> None:\n ...","def matrix_mult(m1, m2):\n\ttemp = []\n\tfor i in range(len(m1)):\n\t\te = []\n\t\tfor j in range(len(m2[0])):\n\t\t\te.append(row_times_column(m1,i,m2,j))\n\t\ttemp.append(e)\n\treturn temp","def transpositions(self):\n a = self.cyclic_form\n res = []\n for x in a:\n nx = len(x)\n if nx == 2:\n res.append(tuple(x))\n elif nx > 2:\n first = x[0]\n for y in x[nx-1:0:-1]:\n res.append((first,y))\n return res","def test_permute_2d(self):\r\n a = reshape(arange(9), (3, 3))\r\n self.assertEqual(permute_2d(a, [0, 1, 2]), a)\r\n self.assertEqual(permute_2d(a, [2, 1, 0]),\r\n array([[8, 7, 6], [5, 4, 3], [2, 1, 0]]))\r\n self.assertEqual(permute_2d(a, [1, 2, 0]),\r\n array([[4, 5, 3], [7, 8, 6], [1, 2, 0]]))","def commutes_with(self, other):\n a = self.array_form\n b = other.array_form\n if len(a) != len(b):\n raise ValueError(\"The number of elements in the permutations \\\ndon\\'t match.\")\n for i in range(len(a)-1):\n if a[b[i]] != b[a[i]]:\n return False\n return True","def _rswap(i, j, S):\n N = copy.deepcopy(S)\n row = copy.deepcopy(N[i])\n N[i] = copy.deepcopy(N[j])\n N[j] = row\n return N","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n for i in range(n):\n for j in range(i+1):\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\n for i in range(n//2):\n for j in range(n):\n matrix[j][i], matrix[j][n-i-1] = matrix[j][n-i-1], matrix[j][i]\n return matrix","def _flip_vectors(jn_matrix, m_matrix):\r\n m_matrix_trans = m_matrix.transpose()\r\n jn_matrix_trans = jn_matrix.transpose()\r\n new_matrix = zeros(jn_matrix_trans.shape, float)\r\n for i, m_vector in enumerate(m_matrix_trans):\r\n jn_vector = jn_matrix_trans[i]\r\n disT = list(m_vector - jn_vector)\r\n disT = sum(map(abs, disT))\r\n jn_flip = jn_vector * [-1]\r\n disF = list(m_vector - jn_flip)\r\n disF = sum(map(abs, disF))\r\n if disT > disF:\r\n new_matrix[i] = jn_flip\r\n else:\r\n new_matrix[i] = jn_vector\r\n return new_matrix.transpose()","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n for i in range(n - 1):\n for j in range(n - 1 - i):\n matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]\n for i in range(n):\n for j in range(n // 2):\n matrix[j][i], matrix[n-1-j][i] = matrix[n-1-j][i], matrix[j][i]","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n for l in range(n // 2):\n r = n - 1 - l\n for p in range(l, r):\n q = n - 1 - p\n cache = matrix[l][p]\n matrix[l][p] = matrix[q][l]\n matrix[q][l] = matrix[r][q]\n matrix[r][q] = matrix[p][r]\n matrix[p][r] = cache","def rotateMatrixAttempt(matrix):\n for idxring in range(len(matrix) / 2):\n swap = []\n ringgen = ringCoords(len(matrix), idxring)\n for x, y in ringgen:\n swap.append(matrix[y][x])\n ringgen = ringCoords(len(matrix), idxring)\n start_idx = len(matrix) - 1 - idxring\n for swapidx in range(-1 * start_idx, len(swap) - start_idx):\n x, y = ringgen.next()\n matrix[y][x] = swap[swapidx]","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n if n <= 1:\n return\n\n for i in range((n + 1)//2):\n for j in range(i, n - 1 - i):\n tmp = matrix[i][j]\n matrix[i][j] = matrix[n - 1 - j][i]\n matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]\n matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]\n matrix[j][n - 1 - i] = tmp","def build_symmetry_operations(symmetry: List[Any]) -> None:\n dim = len(symmetry[0][0])\n unit = numpy.identity(dim, dtype=int)\n for permutation in symmetry:\n perm = unit[:, numpy.argsort(permutation[0])]\n permutation[0] = perm","def mat24_perm_to_int(p):\n oct = sum(1 << x for x in p[:8])\n res = gc.vect_to_octad(oct) \n #print(\"p2i oct\", hex(oct))\n res -= STD_OCTAD\n res += (res >> 12) & 759 \n #print(\"p2i\", res)\n p1 = [24]*32\n oct, j = 8 * oct, 0x00 \n for i in range(24):\n o = oct & 8\n p1[i] = (j >> o) & 0x1f\n j += 1 << o\n oct >>= 1\n q, q_inv = [None]*8, [None]*8\n for i in range(8):\n j = p1[p[i] & 0x1f] & 7\n q[j] = i\n q_inv[i] = j\n for i in range(6):\n # exchange place i with place q_inv[i]\n j = q_inv[i]\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\n #q[i], q[j] = q[j], q[i]\n #assert q[:i] == q_inv[:i] == lrange(i)\n q_inv[q[i]] = q_inv[q[j]]\n q[j] = q[i]\n #print(\"p2i%d\" % i, j-i) \n res = res * (8 - i) + j - i\n #print(\"p2ifinal\", p1[p[8] & 0x1f]) \n return 16 * res + p1[p[8] & 0x1f]","def Jac(M):\n x = [sy.Dummy() for _ in range(nargs(M))]\n y = M(*x)\n J = [sy.diff(yi, xi) for yi in y for xi in x]\n return sy.lambdify(x, J, 'sympy')","def apply_columns_recursive_inplace(self, mat1: 'Nparray',\n mat2: 'Nparray') -> None:\n trans = FqeData(self.nbeta(),\n self.nalpha(),\n self.norb(),\n self._core.alpha_beta_transpose(),\n dtype=self.coeff.dtype)\n buf = trans.coeff.reshape(self.lena(), self.lenb())\n self._apply_columns_recursive_alpha(mat1, buf)\n\n if fqe.settings.use_accelerated_code:\n _transpose(trans.coeff, self.coeff)\n else:\n trans.coeff[:, :] = self.coeff.T[:, :]\n buf = self.coeff.reshape(self.lenb(), self.lena())\n trans._apply_columns_recursive_alpha(mat2, buf)\n\n if fqe.settings.use_accelerated_code:\n _transpose(self.coeff, trans.coeff)\n else:\n self.coeff[:, :] = trans.coeff.T[:, :]","def swap2(d, n, v, i, j):\n for a in range(n):\n for k in range(d):\n if k == i or k == j:\n continue\n x = a*d*d + d*i + k\n y = a*d*d + d*j + k\n v[x], v[y] = v[y], v[x]\n\n x = a*d*d + d*k + i\n y = a*d*d + d*k + j\n v[x], v[y] = v[y], v[x]\n\n x = a*d*d + d*i + i\n y = a*d*d + d*j + j\n v[x], v[y] = v[y], v[x]\n\n x = a*d*d + d*j + i\n y = a*d*d + d*i + j\n v[x], v[y] = v[y], v[x]","def rotate(self, matrix: List[List[int]]) -> None:\n # transpose\n N = len(matrix)\n for i in range(N):\n for j in range(0, i):\n matrix[i][j] = matrix[i][j] ^ matrix[j][i]\n matrix[j][i] = matrix[i][j] ^ matrix[j][i]\n matrix[i][j] = matrix[i][j] ^ matrix[j][i]\n \n # print(matrix)\n # 左右互换\n for i in range(N):\n for j in range(N // 2):\n matrix[i][j] = matrix[i][j] ^ matrix[i][N - j - 1]\n matrix[i][N - j - 1] = matrix[i][j] ^ matrix[i][N - j - 1]\n matrix[i][j] = matrix[i][j] ^ matrix[i][N - j - 1]\n # print(matrix)","def rotate(self, matrix: List[List[int]]) -> None:\n length = len(matrix)\n for row in range(length//2):\n for col in range(row, length-row-1):\n # matrix[row][col], matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row]\n matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row], matrix[row][col] = matrix[row][col], matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row]\n return","def z_operator_matrix(self):\n n, r_1, r_2, k = self.n, self.r_1, self.r_2, self.k\n\n # Use the row vector [ A2^T 0 I ], which commutes with the check matrix.\n check_mat = np.zeros((k, n), dtype='int')\n check_mat[:, 0:r_1] = np.transpose(self.parity_check_c1[:, (r_1 + r_2):n])\n check_mat[:, (r_1 + r_2):n] = np.identity(k)\n return check_mat","def rotate(self, matrix: list) -> None:\n for i in range(len(matrix)):\n for j in range(i):\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\n # matrix[i].reverse()\n print(matrix)\n for i in range(len(matrix)):\n matrix[i].reverse()\n print(matrix)","def __mul__(self, other):\n #\n # TODO - your code here\n #\n final_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(other.w):\n # take dot-product of row of\n # matrix in 1st arg with col of\n # matrix in 2nd arg\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\n final_matrix.append(temp_row)\n return Matrix(final_matrix)\n # TODO - your code here","def rotate_2d_matrix(matrix):\n\n L = len(matrix)\n for i in range(L // 2):\n for j in range(i, L - i - 1):\n temp = matrix[i][j]\n matrix[i][j] = matrix[L - 1 - j][i]\n matrix[L - 1 - j][i] = matrix[L - 1 - i][L - 1 - j]\n matrix[L - 1 - i][L - 1 - j] = matrix[j][L - 1 - i]\n matrix[j][L - 1 - i] = temp","def trans_o(self):\n temp_array = []\n for j in range(self.O.shape[1]):\n for i in range(self.V.shape[1]):\n if self.V[0, i] == self.O[0, j]:\n temp_array.append(i)\n self.O = mat(temp_array)","def mirror(self, p1=(0, 1), p2=(0, 0)) -> \"Group\":\n for e in self.elements:\n e.mirror(p1=p1, p2=p2)\n return self","def _permute_generetably(elements: List[T], i: int):\n if i == 1:\n yield elements\n else:\n for j in range(i - 1):\n for permutation in _permute_generetably(elements, i - 1):\n yield permutation\n\n k = 0 if i % 2 == 1 else j\n\n elements[k], elements[i - 1] = elements[i - 1], elements[k]\n\n for permutation in _permute_generetably(elements, i - 1):\n yield permutation","def rotate(self, matrix: List[List[int]]) -> None:\n if(matrix == None or len(matrix) == 1): return\n n = len(matrix)\n for i in range(0, n//2 + 1):\n for j in range(i, n-1-i):\n tmp = matrix[i][j]\n matrix[i][j] = matrix[n-1-j][i]\n matrix[n-1-j][i] = matrix[n-1-i][n-1-j]\n matrix[n-1-i][n-1-j] = matrix[j][n-1-i]\n matrix[j][n-1-i] = tmp\n \n return","def rotate(self, matrix: List[List[int]]) -> None:\n n = len(matrix)\n for i in range(n):\n for j in range(n // 2):\n matrix[i][j], matrix[i][n-1-j] = matrix[i][n-1-j], matrix[i][j]\n for i in range(n):\n for j in range(n-i):\n matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]","def swap(self,i,j):\r\n self._data[i], self._data[j] = self._data[j], self._data[i]","def mirror(self):\n for l in range(self.numRows):\n mirrorGrid = []\n for l in range(self.numCols):\n row = self.grid[l][::-1]\n mirrorGrid.append(row)\n return mirrorGrid","def _swap(self, i, j):\n self._data[i], self._data[j] = self._data[j], self._data[i]","def _swap(self, i, j):\n self._data[i], self._data[j] = self._data[j], self._data[i]","def swapRows(self, i, j):\n if not (type(i) in MATRIX_VALID_INTS and type(\n j) in MATRIX_VALID_INTS): # this should be fixed to accomodate 'long' types\n raise TypeError(\"Row indices must be of type 'int'\")\n rowA = self.deleteRow(max(i, j))\n rowB = self.deleteRow(min(i, j))\n self.insertRow(min(i, j), *rowA)\n self.insertRow(max(i, j), *rowB)","def reverse_cuthill_mckee(self, permutation: bool = True) -> [np.ndarray, np.ndarray]:\n # 1. get the connectivity matrix\n nodeids, C = self.node_connectivity_matrix()\n\n # 2. compute the new node order\n perm = scipy.sparse.csgraph.reverse_cuthill_mckee(C, False)\n\n # 3. create a dictionary with new node order\n nodeids = {nid: perm[i] for nid, i in nodeids.items()}\n\n if permutation:\n # 4. create the permutation matrix for node order if requested\n P = C[np._ix(perm, perm)]\n return nodeids, P\n else:\n # 4. or return just the new node order\n return nodeids","def _swap2(self, cids, iids):\n # The coupling indexes of the two legs to swap\n c1, c2 = cids\n # The index of the two legs to swap within the given coupling\n i1, i2 = iids\n assert c1 != c2\n\n # Get the connecting coupling between the two couplings\n cnx = self.get_couplingnetwork().to_undirected(as_view=True)\n ci = set(nx.common_neighbors(cnx, *[self.coupling[ii] for ii in cids]))\n if len(ci) != 1:\n raise ValueError(f'cids: {cids} have {len(ci)} common neighbors')\n ci = self.coupling.index(ci.pop())\n\n # internal legs\n l1 = cnx.edges[self.coupling[c1], self.coupling[ci], 0]['leg']\n l2 = cnx.edges[self.coupling[c2], self.coupling[ci], 0]['leg']\n\n # index of the internal leg in c1 and c2\n legs = self.get_legs()\n il1, il2 = [[legs[x].index(ll) for x in (y, ci)]\n for y, ll in zip(cids, (l1, l2))]\n\n assert il1[0] != i1 and il2[0] != i2\n assert il1[1] != il2[1]\n # Check that the flow is consistent along the internal bond\n assert self.coupling[c1][il1[0]][1] is not self.coupling[ci][il1[1]][1]\n assert self.coupling[c2][il2[0]][1] is not self.coupling[ci][il2[1]][1]\n\n def permute_key(key):\n copy = list(list(k) for k in key)\n copy[c1][i1], copy[c2][i2] = copy[c2][i2], copy[c1][i1]\n return copy\n f1, f2, fi = ([x[1] for x in self.coupling[c]] for c in (c1, c2, ci))\n self._coupling = tuple(tuple(c) for c in permute_key(self.coupling))\n\n # All good interal symmetry sectors in for the swapped 1st coupling\n nkeys = set(tuple(tuple(e) for e in permute_key(k)) for k in self)\n c1set = {}\n r11, r12 = set(range(3)).difference([il1[0]])\n for k in set(key[c1] for key in nkeys):\n kn = (k[r11], k[r12])\n if kn not in c1set:\n c1set[kn] = set(\n sls.allowed_couplings(k, f1, il1[0], self.symmetries))\n c2set = {}\n r21, r22 = set(range(3)).difference([il2[0]])\n for k in set(key[c2] for key in nkeys):\n kn = (k[r21], k[r22])\n if kn not in c2set:\n c2set[kn] = set(\n sls.allowed_couplings(k, f2, il2[0], self.symmetries))\n\n vac = sls.vacuumIrrep(self.symmetries)\n Z1 = set().union(*c1set.values())\n Z2 = set().union(*c2set.values())\n rf = set(range(3)).difference([il1[1], il2[1]]).pop()\n fit = [fi[rf], fi[il1[1]], fi[il2[1]]]\n oks = {(k1, k2): set(sls.allowed_couplings((vac, k1, k2),\n fit, 0, self.symmetries))\n for k1, k2 in itertools.product(Z1, Z2)}\n\n def mappingf(okey):\n nk = permute_key(okey)\n set1 = c1set[(nk[c1][r11], nk[c1][r12])]\n set2 = c2set[(nk[c2][r21], nk[c2][r22])]\n for kk1 in set1:\n for kk2 in set2:\n if nk[ci][rf] not in oks[(kk1, kk2)]:\n continue\n\n # Assign the key of the internal leg\n nk[c1][il1[0]], nk[ci][il1[1]] = kk1, kk1\n nk[c2][il2[0]], nk[ci][il2[1]] = kk2, kk2\n yield tuple(tuple(e) for e in nk)\n\n prefdict = sls._prefswap2(iids, il1, il2, f1, f2, fi)\n\n def prefactorf(okey, nkey):\n flokey = [list(x) for x in\n zip(*[el for j in (c1, c2, ci) for el in okey[j]])]\n flnkey = [list(x) for x in\n zip(*[el for j in (c1, c2, ci) for el in nkey[j]])]\n return np.prod([prefdict.get(ss, lambda x, y: 1.)(o, n) for\n o, n, ss in zip(flokey, flnkey, self.symmetries)])\n\n self._manipulate_coupling(mappingf, prefactorf)\n return self","def perm_2_let():\r\n return {''.join(i) for i in permutations('abcdefghijklmnopqrstuvwxyz', 2)}\r\n # print(comb_2_let, sep='')\r","def transferMatrix(self, i1=0, i2=-1, plane=\"x\"):\n B2 = self.normMat(i2, plane=plane)\n B1 = self.normMat(i1, plane=plane)\n psi = 2 * np.pi * (self[\"mu\" + plane][i2] - self[\"mu\" + plane][i1])\n R = np.array([[np.cos(psi), np.sin(psi)], [-np.sin(psi), np.cos(psi)]])\n return np.dot(np.dot(B2, R), np.linang.inv(B1))","def permutations(cube):\r\n yield from rotations24(cube)\r\n yield from rotations24(np.flip(cube, 0))\r\n yield from rotations24(np.flip(cube, 1))\r\n yield from rotations24(np.flip(cube, 2))","def _swap(self, x1, y1, x2, y2):\n puzzle_copy = [list(row) for row in self.position] # copy the puzzle\n puzzle_copy[x1][y1], puzzle_copy[x2][y2] = puzzle_copy[x2][y2], puzzle_copy[x1][y1]\n\n return puzzle_copy","def swap_full(permutation, transposition,nb_position):\n i, j = transposition\n res = np.array(permutation)\n res[i], res[j] = res[j], res[i]\n return tuple(res[:nb_position])","def symmetrize(n):\n times = lambda x: jnp.concatenate((jnp.flipud(x), x))\n trans = lambda x: x[n:] + x[n-1::-1]\n return Operator(times=times, trans=trans, shape=(2*n,n))","def rotate_matrix(self, mat):\r\n N=3\r\n for x in range(0, int(N / 2)):\r\n for y in range(x, N-x-1):\r\n temp = mat[x][y]\r\n mat[x][y] = mat[y][N-1-x]\r\n mat[y][N-1-x] = mat[N-1-x][N-1-y]\r\n mat[N-1-x][N-1-y] = mat[N-1-y][x]\r\n mat[N-1-y][x] = temp\r\n return mat","def test_matrix(self, tol):\n\n res_static = qml.QFT.compute_matrix(2)\n res_dynamic = qml.QFT(wires=[0, 1]).matrix()\n res_reordered = qml.QFT(wires=[0, 1]).matrix([1, 0])\n\n expected = np.array(\n [\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\n [0.5 + 0.0j, 0.0 + 0.5j, -0.5 + 0.0j, -0.0 - 0.5j],\n [0.5 + 0.0j, -0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j],\n [0.5 + 0.0j, -0.0 - 0.5j, -0.5 + 0.0j, 0.0 + 0.5j],\n ]\n )\n\n assert np.allclose(res_static, expected, atol=tol, rtol=0)\n assert np.allclose(res_dynamic, expected, atol=tol, rtol=0)\n\n expected_permuted = [\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\n [0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j, -0.5 + 0.0j],\n [0.5 + 0.0j, -0.5 + 0.0j, 0.0 + 0.5j, -0.0 - 0.5j],\n [0.5 + 0.0j, -0.5 + 0.0j, -0.0 - 0.5j, 0.0 + 0.5j],\n ]\n assert np.allclose(res_reordered, expected_permuted, atol=tol, rtol=0)","def rotate(self, matrix: list[list[int]]) -> None:","def transpose(self):\n for i in range(self.columns): # This for loop makes the rows we need in our transposed matrix\n matrix = [] # List that will contain the rows of the transpose matrix\n for j in range(self.rows): # This for loop makes the columns we need in our transposed matrix\n matrix.append(self.Matrix[j][i]) \n self.Transpose.append(matrix) # Appending the rows into the bigger list we created\n print(\"This is your transposed matrix: \", self.Transpose)","def rotate(self, matrix: List[List[int]]) -> None:\n height=len(matrix)\n for h in range(math.ceil(height/2)):\n for i in range(h,height-h-1):\n # print((h,i), (height-i-1,h))\n temp=matrix[h][i]\n matrix[h][i] = matrix[height-i-1][h]\n matrix[height-i-1][h] = matrix[height-h-1][height-i-1]\n matrix[height-h-1][height-i-1] = matrix[i][height-h-1]\n matrix[i][height-h-1] = temp","def part_2():\n return itertools.permutations(range(5, 10))","def test_two_qubit_weyl_decomposition_swap(self):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(np.pi / 4, np.pi / 4, np.pi / 4)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def swap(self, adjacent_transposition):\n\n result = Tensor()\n for key_self in self.keys():\n # ensure that the swap can be made with the available slots\n if max(adjacent_transposition) < len(key_self):\n prefix = Tensor({Tensor._merge_keys(*key_self[0 : min(adjacent_transposition)]): self[key_self]})\n root = type(self)._clifford_swap(\n *key_self[min(adjacent_transposition) : max(adjacent_transposition) + 1]\n )\n postfix = Tensor({Tensor._merge_keys(*key_self[max(adjacent_transposition) + 1 :]): 1})\n result = result + prefix * root * postfix\n else:\n result = result + Tensor({key_self: self[key_self]})\n self.clear()\n self.update(result)\n return self","def swap(self, i: int, j: int) -> None:\n self.data[i], self.data[j] = self.data[j], self.data[i]","def MatMulOrder(D):\r\n\tnum = len(D)-1 # number of matrix in the chain\r\n\tprint(f\"There are {num} matrix to multiply\")\r\n\tM = [[0 for _ in range(num)] for _ in range(num)]\r\n\tP = [[0 for _ in range(num)] for _ in range(num)]\r\n\r\n\t# i要从大到小\r\n\t# i == j时, M[i][j]=0,所以不用更新\r\n\t# i-th矩阵到j-th矩阵的乘的最优值初始化为inf\r\n\tfor i in range(num-2, -1, -1):\r\n\t\tfor j in range(i+1, num):\r\n\t\t\tM[i][j] = 100000000\r\n\t\t\tfor k in range(i, j):\r\n\t\t\t\tnew = M[i][k] + M[k+1][j] + D[i]*D[k+1]*D[j+1]\r\n\t\t\t\tif new < M[i][j]:\r\n\t\t\t\t\tM[i][j] = new \r\n\t\t\t\t\tP[i][j] = k\r\n\treturn M, P","def contract(tensor):\n temp = np.einsum('ikma, jlan', tensor, tensor)\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\n return M","def test_flip_vectors(self):\r\n m_matrix = array([[1.0, 0.0, 1.0], [2.0, 4.0, 4.0]])\r\n jn_matrix = array([[1.2, 0.1, -1.2], [2.5, 4.0, -4.5]])\r\n new_matrix = _flip_vectors(jn_matrix, m_matrix)\r\n assert_almost_equal(new_matrix, array([[1.2, 0.1, 1.2], [2.5, 4.0, 4.5]]))","def test_flip_vectors(self):\n m_matrix = array([[1.0, 0.0, 1.0], [2.0, 4.0, 4.0]])\n jn_matrix = array([[1.2, 0.1, -1.2], [2.5, 4.0, -4.5]])\n new_matrix = _flip_vectors(jn_matrix, m_matrix)\n assert_almost_equal(new_matrix, array([[1.2, 0.1, 1.2], [2.5, 4.0, 4.5]]))","def swapCouplingTuples(self, permutation):\n from collections import Counter\n\n if Counter(permutation) != Counter(range(len(self.coupling))):\n raise ValueError(f'Permutation {permutation} is not valid')\n\n def permute_key(key):\n return tuple(key[p] for p in permutation)\n\n self._coupling = permute_key(self.coupling)\n\n def mappingf(okey):\n yield permute_key(okey)\n\n self._manipulate_coupling(mappingf, lambda x, y: 1)\n return self","def check_perm(tri1,tri2):\n for t1 in tri1:\n for t2 in tri2:\n if t1 == t2:\n return False\n return True","def matrix_chain_dynamic(dimensions, n):\n\n m = [[-1 for _ in range(n)] for _ in range(n)]\n s = [[0 for _ in range(n)] for _ in range(n)]\n\n # multiplying matrix by itself\n for i in range(1, n):\n m[i][i] = 0\n\n for length in range(2, n):\n for i in range(1, n - length + 1):\n j = i + length - 1\n for k in range(i, j):\n cost = m[i][k] + m[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j]\n if cost > m[i][j]:\n m[i][j] = cost\n # index if splitting\n s[i][j] = k\n return m, s","def products(q_1: Qs, q_2: Qs, kind: str = \"\", reverse: bool = False) -> Qs:\n\n q_1_copy = deepcopy(q_1)\n q_2_copy = deepcopy(q_2)\n qs_left, qs_right = Qs(), Qs()\n\n # Diagonalize if need be.\n if ((q_1.rows == q_2.rows) and (q_1.columns == q_2.columns)) or (\n \"scalar_q\" in [q_1.qs_type, q_2.qs_type]\n ):\n\n if q_1.columns == 1:\n qs_right = q_2_copy\n qs_left = diagonal(q_1_copy, qs_right.rows)\n\n elif q_2.rows == 1:\n qs_left = q_1_copy\n qs_right = diagonal(q_2_copy, qs_left.columns)\n\n else:\n qs_left = q_1_copy\n qs_right = q_2_copy\n\n # Typical matrix multiplication criteria.\n elif q_1.columns == q_2.rows:\n qs_left = q_1_copy\n qs_right = q_2_copy\n\n else:\n print(\n \"Oops, cannot multiply series with row/column dimensions of {}/{} to {}/{}\".format(\n q_1.rows, q_1.columns, q_2.rows, q_2.columns\n )\n )\n\n # Operator products need to be transposed.\n operator_flag = False\n if qs_left in [\"op\", \"operator\"] and qs_right in [\"op\", \"operator\"]:\n operator_flag = True\n\n outer_row_max = qs_left.rows\n outer_column_max = qs_right.columns\n shared_inner_max = qs_left.columns\n projector_flag = (\n (shared_inner_max == 1) and (outer_row_max > 1) and (outer_column_max > 1)\n )\n\n result = [\n [q0(q_type=\"\") for _i in range(outer_column_max)]\n for _j in range(outer_row_max)\n ]\n\n for outer_row in range(outer_row_max):\n for outer_column in range(outer_column_max):\n for shared_inner in range(shared_inner_max):\n\n # For projection operators.\n left_index = outer_row\n right_index = outer_column\n\n if outer_row_max >= 1 and shared_inner_max > 1:\n left_index = outer_row + shared_inner * outer_row_max\n\n if outer_column_max >= 1 and shared_inner_max > 1:\n right_index = shared_inner + outer_column * shared_inner_max\n\n result[outer_row][outer_column] = add(result[outer_row][outer_column],\n product(qs_left.qs[left_index],\n qs_right.qs[right_index], kind=kind, reverse=reverse\n )\n )\n\n # Flatten the list.\n new_qs = [item for sublist in result for item in sublist]\n new_states = Qs(new_qs, rows=outer_row_max, columns=outer_column_max)\n\n if projector_flag or operator_flag:\n return transpose(new_states)\n\n else:\n return new_states","def symmetry_duplication(\n bijection: BijectionType,\n ) -> Iterator[BijectionType]:\n return (\n bij\n for rotated in (\n {k.rotate(angle): v.rotate(angle) for k, v in bijection.items()}\n for angle in range(4)\n )\n for bij in (rotated, {k.inverse(): v.inverse() for k, v in rotated.items()})\n )","def transposed(self) -> 'MatrixBoolean':\n\t\tmatrix = MatrixBoolean(empty=(self.dimN, self.dimM))\n\t\tfor m in range(self.dimM):\n\t\t\tfor n in range(self.dimN):\n\t\t\t\tmatrix.matrix[n][m] = self.matrix[m][n]\n\t\treturn matrix","def _swap_energies(i, j, energies):\n energies[:, [i, j]] = energies[:, [j, i]]","def test_two_qubit_weyl_decomposition_iswap(self):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(np.pi / 4, np.pi / 4, 0)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def pd(self, other):\n return Matriz([self]).T() * Matriz([other])","def sort(self):\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[0][j] < self.genepool[0][j-1]:\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\n else:\n break\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[1][j] < self.genepool[1][j-1]:\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\n else:\n break"],"string":"[\n \"def swap_columns(i, j, *args):\\n output = list()\\n for M in args:\\n output.append(_cswap(i, j, M))\\n return output\",\n \"def swap_rows(i, j, *args):\\n output = list()\\n for M in args:\\n output.append(_rswap(i, j, M))\\n return output\",\n \"def return_swaps( # pylint: disable=too-many-locals,too-many-branches,too-many-statements\\n self, old_mapping, new_mapping, permutation=None\\n ):\\n if permutation is None:\\n permutation = list(range(self.num_rows))\\n swap_operations = []\\n\\n class Position: # pylint: disable=too-few-public-methods\\n \\\"\\\"\\\"Custom Container.\\\"\\\"\\\"\\n\\n def __init__( # pylint: disable=too-many-arguments\\n self,\\n current_row,\\n current_column,\\n final_row,\\n final_column,\\n row_after_step_1=None,\\n ):\\n self.current_row = current_row\\n self.current_column = current_column\\n self.final_row = final_row\\n self.final_column = final_column\\n self.row_after_step_1 = row_after_step_1\\n\\n # final_positions contains info containers\\n # final_position[i][j] contains info container with\\n # current_row == i and current_column == j\\n final_positions = [[None for i in range(self.num_columns)] for j in range(self.num_rows)]\\n # move qubits which are in both mappings\\n used_mapped_ids = set()\\n for logical_id in old_mapping:\\n if logical_id in new_mapping:\\n used_mapped_ids.add(new_mapping[logical_id])\\n old_column = old_mapping[logical_id] % self.num_columns\\n old_row = old_mapping[logical_id] // self.num_columns\\n new_column = new_mapping[logical_id] % self.num_columns\\n new_row = new_mapping[logical_id] // self.num_columns\\n info_container = Position(\\n current_row=old_row,\\n current_column=old_column,\\n final_row=new_row,\\n final_column=new_column,\\n )\\n final_positions[old_row][old_column] = info_container\\n # exchange all remaining None with the not yet used mapped ids\\n all_ids = set(range(self.num_qubits))\\n not_used_mapped_ids = list(all_ids.difference(used_mapped_ids))\\n not_used_mapped_ids = sorted(not_used_mapped_ids, reverse=True)\\n for row in range(self.num_rows):\\n for column in range(self.num_columns):\\n if final_positions[row][column] is None:\\n mapped_id = not_used_mapped_ids.pop()\\n new_column = mapped_id % self.num_columns\\n new_row = mapped_id // self.num_columns\\n info_container = Position(\\n current_row=row,\\n current_column=column,\\n final_row=new_row,\\n final_column=new_column,\\n )\\n final_positions[row][column] = info_container\\n if len(not_used_mapped_ids) > 0: # pragma: no cover\\n raise RuntimeError('Internal compiler error: len(not_used_mapped_ids) > 0')\\n # 1. Assign column_after_step_1 for each element\\n # Matching contains the num_columns matchings\\n matchings = [None for i in range(self.num_rows)]\\n # Build bipartite graph. Nodes are the current columns numbered (0, 1, ...) and the destination columns\\n # numbered with an offset of self.num_columns (0 + offset, 1+offset, ...)\\n graph = nx.Graph()\\n offset = self.num_columns\\n graph.add_nodes_from(range(self.num_columns), bipartite=0)\\n graph.add_nodes_from(range(offset, offset + self.num_columns), bipartite=1)\\n # Add an edge to the graph from (i, j+offset) for every element currently in column i which should go to\\n # column j for the new mapping\\n for row in range(self.num_rows):\\n for column in range(self.num_columns):\\n destination_column = final_positions[row][column].final_column\\n if not graph.has_edge(column, destination_column + offset):\\n graph.add_edge(column, destination_column + offset)\\n # Keep manual track of multiple edges between nodes\\n graph[column][destination_column + offset]['num'] = 1\\n else:\\n graph[column][destination_column + offset]['num'] += 1\\n # Find perfect matching, remove those edges from the graph and do it again:\\n for i in range(self.num_rows):\\n top_nodes = range(self.num_columns)\\n matching = nx.bipartite.maximum_matching(graph, top_nodes)\\n matchings[i] = matching\\n # Remove all edges of the current perfect matching\\n for node in range(self.num_columns):\\n if graph[node][matching[node]]['num'] == 1:\\n graph.remove_edge(node, matching[node])\\n else:\\n graph[node][matching[node]]['num'] -= 1\\n # permute the matchings:\\n tmp = deepcopy(matchings)\\n for i in range(self.num_rows):\\n matchings[i] = tmp[permutation[i]]\\n # Assign row_after_step_1\\n for column in range(self.num_columns):\\n for row_after_step_1 in range(self.num_rows):\\n dest_column = matchings[row_after_step_1][column] - offset\\n best_element = None\\n for row in range(self.num_rows):\\n element = final_positions[row][column]\\n if element.row_after_step_1 is not None:\\n continue\\n if element.final_column == dest_column:\\n if best_element is None:\\n best_element = element\\n elif best_element.final_row > element.final_row:\\n best_element = element\\n best_element.row_after_step_1 = row_after_step_1\\n # 2. Sort inside all the rows\\n swaps = self._sort_within_columns(final_positions=final_positions, key=lambda x: x.row_after_step_1)\\n swap_operations += swaps\\n # 3. Sort inside all the columns\\n swaps = self._sort_within_rows(final_positions=final_positions, key=lambda x: x.final_column)\\n swap_operations += swaps\\n # 4. Sort inside all the rows\\n swaps = self._sort_within_columns(final_positions=final_positions, key=lambda x: x.final_row)\\n swap_operations += swaps\\n return swap_operations\",\n \"def permutation_matrix(order):\\n matrix = np.zeros([order,order])\\n matrix[-1,0] = 1\\n matrix[0:-1,1::] = np.identity(order-1)\\n return matrix\",\n \"def xor(m, i, j):\\n for e in range(len(m[0])):\\n m[j][e] ^= m[i][e]\\n return m\",\n \"def transpose(m):\\n\\n pass\",\n \"def reverse_matrix(self):\\n return SWAP.matrix @ self.matrix @ SWAP.matrix\",\n \"def perform_gauss_jordan_elimination(m, show):\\n if show:\\n print(\\\"Initial State\\\")\\n print_matrix(m)\\n\\n r, c = 0, 0\\n rows = len(m)\\n cols = len(m[0])\\n\\n if show:\\n print(\\\"rows: %s cols: %s\\\"%(rows, cols))\\n\\n while True:\\n _swap = False\\n\\n if show:\\n print(\\\"r %s c %s\\\"%(r, c))\\n\\n ## Check Pivot\\n if m[r][c] == 0:\\n ## Swap\\n for i in range(rows):\\n if r != i and i > r: ## Avoid comparing the same row and do not swap to upper rows\\n if m[i][c] == 1 and not _swap: ## Check if a swap is not performed before in the same column\\n if show:\\n print(\\\"Swapping %s %s and %s %s\\\"%(r, m[r], i, m[i]))\\n #m = swap(m,r,i)\\n temp = m[r]\\n m[r] = m[i]\\n m[i] = temp\\n _swap = True\\n if show:\\n print_matrix(m)\\n if not _swap: ## If not swap, means there is no 1 to swap, so go to the next column\\n c+=1\\n\\n if m[r][c] == 1:\\n ## XOR\\n for i in range(rows):\\n if r != i: ## Avoid comparing the same row\\n if m[i][c] == 1:\\n if show:\\n print(\\\"XOR Row %s: %s into Row %s: %s\\\"%(r, m[r], i, m[i]))\\n for e in range(len(m[0])):\\n m[i][e] ^= m[r][e]\\n if show:\\n print_matrix(m)\\n\\n ## Increase row and column\\n r+=1\\n c+=1\\n\\n ## break condition if all rows or all columns (except the augmented column are treated)\\n if r == rows or c >= cols-1:\\n break\\n \\n return m\",\n \"def jmatswap(ind: int):\\n return _jmswap[ind - 1]\",\n \"def _swap_permutation(i, j, permutation_vector):\\n permutation_vector[i], permutation_vector[j] = permutation_vector[j], permutation_vector[i]\",\n \"def transpose(self):\\n order = list(self.order)\\n order[-2], order[-1] = order[-1], order[-2]\\n self.order = order\",\n \"def perm2(a,ix):\\n if ix==len(a):\\n print(a)\\n else:\\n for j in range(ix+1):\\n swap(a,j,ix)\\n perm2(a,ix+1)\\n swap(a,j,ix)\",\n \"def swap(permutation, transposition, remaining=[]):\\n i, j = transposition\\n nb_positions = len(permutation)\\n res = np.array(permutation)\\n\\n if j < nb_positions:\\n res[i], res[j] = res[j], res[i]\\n else:\\n res[i] = remaining[j-nb_positions]\\n\\n return tuple(res)\",\n \"def _swap(self, i, j, k):\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint(i, k)\\n\\t\\t\\tprint(i, j)\\n\\t\\t\\tprint(j, k)\\n\\t\\tself.arrangement[i],self.arrangement[k] = self.arrangement[k],self.arrangement[i]\\n\\t\\tself.arrangement[i],self.arrangement[j] = self.arrangement[j],self.arrangement[i]\\n\\t\\tself.arrangement[j],self.arrangement[k] = self.arrangement[k],self.arrangement[j]\",\n \"def _multi_matmul_chain_order(arrays):\\n n = len(arrays)\\n # p stores the dimensions of the matrices\\n # Example for p: A_{10x100}, B_{100x5}, C_{5x50} --> p = [10, 100, 5, 50]\\n # Using -2 to generalize for shapes that are more than 2 dimmensions\\n p = [a.shape[-2] for a in arrays] + [arrays[-1].shape[-1]]\\n # m is a matrix of costs of the subproblems\\n # m[i,j]: min number of scalar multiplications needed to compute A_{i..j}\\n m = np.zeros((n, n), dtype=np.double)\\n # s is the actual ordering\\n # s[i, j] is the value of k at which we split the product A_i..A_j\\n s = np.empty((n, n), dtype=np.intp)\\n\\n for l in range(1, n):\\n for i in range(n - l):\\n j = i + l\\n m[i, j] = np.inf\\n for k in range(i, j):\\n q = m[i, k] + m[k + 1, j] + p[i] * p[k + 1] * p[j + 1]\\n if q < m[i, j]:\\n m[i, j] = q\\n s[i, j] = k # Note that Cormen uses 1-based index\\n return s\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\r\\n n = len(matrix)\\r\\n for j in range((n+1)//2):\\r\\n for i in range(n-2*j-1):\\r\\n matrix[j][j+i], matrix[j+i][n-1-j], matrix[n-1-j][n-1-j-i], matrix[n-1-j-i][j] = matrix[n-1-j-i][j], matrix[j][j+i], matrix[j+i][n-1-j], matrix[n-1-j][n-1-j-i]\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n # note: coded up logic after looking at discussion board\\n\\n # 1 - swap symmetrically across diagonal so that 123 becomes the first column\\n # leftIndent = 0\\n n = len(matrix)\\n # for i in range(len(matrix)):\\n for i in range(n):\\n # indent (to only iterate top side of diagonal) adds 1 per line, so same as i\\n # for j in range(i, len(matrix[i])):\\n for j in range(i, n):\\n # print(matrix[i][j], matrix[j][i])\\n # print()\\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\\n\\n # print(matrix)\\n # 2 - swap elements in individual rows to swap order of columns (since 123 should be last column)\\n # for i in range(len(matrix)):\\n for i in range(n):\\n # for j in range(len(matrix)):\\n # print(\\\"new row: \\\", matrix[i])\\n left = 0\\n right = len(matrix[i]) - 1\\n while (left <= right):\\n # print(\\\"left: \\\", left, \\\" right: \\\", right, matrix[i][left], matrix[i][right])\\n matrix[i][left], matrix[i][right] = matrix[i][right], matrix[i][left]\\n left += 1\\n right -= 1\\n # print(matrix)\\n # print()\",\n \"def swapColumns(self, i, j):\\n if not (type(i) in MATRIX_VALID_INTS and type(\\n j) in MATRIX_VALID_INTS): # this should be fixed to accomodate 'long' types\\n raise TypeError(\\\"Row indices must be of type 'int'\\\")\\n columnA = self.deleteColumn(max(i, j))\\n columnB = self.deleteColumn(min(i, j))\\n self.insertColumn(min(i, j), *columnA)\\n self.insertColumn(max(i, j), *columnB)\",\n \"def derMatrix(Bulk_Operators, Bdy_Operators, Bulk_second, s=1):\\n\\t\\tMatrix = []\\n\\t\\tfor i in range(1, M_max + 1):\\n\\t\\t\\t\\trow = []\\n\\t\\t\\t\\tfor Bulk_Op in Bulk_Operators:\\n\\t\\t\\t\\t\\t\\ttable_call = N*table1.table[0, i].subs({\\\"Delta\\\":Bulk_Op, \\\"Delta_12\\\":delta_12, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\t\\trow.append(table_call)\\n\\t\\t\\t\\tfor index in range(len(Bulk_second)):\\n\\t\\t\\t\\t\\t\\trow.append(0*table1.table[0,0])\\n\\t\\t\\t\\tfor Bdy_Op in Bdy_Operators:\\n\\t\\t\\t\\t\\tif Bdy_Op == 2.0:\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"here\\\")\\n\\t\\t\\t\\t\\t\\t\\ttable_call = (N-1)*table1.table[1, i].subs({\\\"Delta\\\":Bdy_Op, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\ttable_call = table1.table[1, i].subs({\\\"Delta\\\":Bdy_Op, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\trow.append(table_call)\\n\\t\\t\\t\\tXi = symbols('Xi')\\n\\t\\t\\t\\tif s == 1:\\n\\t\\t\\t\\t\\t\\tlast_expr = Xi**((delta_1 + delta_2)/2)\\n\\t\\t\\t\\t\\t\\tlast_elem = diff(last_expr, Xi, i).subs({\\\"Xi\\\":1.00}).evalf()\\n\\t\\t\\t\\t\\t\\trow.append(last_elem)\\n\\t\\t\\t\\tMatrix.append(row)\\n\\t\\t\\t\\trow2 = []\\n\\t\\t\\t\\tfor index in range(len(Bulk_Operators)):\\n\\t\\t\\t\\t\\t\\trow2.append(0*table1.table[0,0])\\n\\t\\t\\t\\tfor Bulk_Op in Bulk_second:\\n\\t\\t\\t\\t\\t\\ttable_call = table1.table[0, i].subs({\\\"Delta\\\":Bulk_Op, \\\"Delta_12\\\":delta_12, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\t\\trow2.append(table_call)\\n\\t\\t\\t\\tfor Bdy_Op in Bdy_Operators:\\n\\t\\t\\t\\t\\t\\tif Bdy_Op == 2.0:\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"here\\\")\\n\\t\\t\\t\\t\\t\\t\\ttable_call = -1*table1.table[1, i].subs({\\\"Delta\\\":Bdy_Op, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\ttable_call = table1.table[1, i].subs({\\\"Delta\\\":Bdy_Op, \\\"Xi\\\":1.00})\\n\\t\\t\\t\\t\\t\\trow2.append(table_call)\\n\\t\\t\\t\\tXi = symbols('Xi')\\n\\t\\t\\t\\tif s == 1:\\n\\t\\t\\t\\t\\t\\tlast_expr = Xi**((delta_1 + delta_2)/2)\\n\\t\\t\\t\\t\\t\\tlast_elem = diff(last_expr, Xi, i).subs({\\\"Xi\\\":1.00}).evalf()\\n\\t\\t\\t\\t\\t\\trow2.append(last_elem)\\n\\t\\t\\t\\tMatrix.append(row2)\\t\\t\\n\\t\\treturn np.array(Matrix)\",\n \"def transpose():\",\n \"def test_distance_matrix_permutation_test_symmetric(self):\\r\\n def make_result_list(*args, **kwargs):\\r\\n return (\\r\\n [distance_matrix_permutation_test(*args)[2] for i in range(10)]\\r\\n )\\r\\n\\r\\n m = array([[0, 1, 3], [1, 2, 4], [3, 4, 5]])\\r\\n # looks at each possible permutation n times --\\r\\n # compare first row to rest\\r\\n n = 100\\r\\n\\r\\n # looks at each possible permutation n times --\\r\\n # compare first row to rest\\r\\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n)\\r\\n self.assertSimilarMeans(r, 0. / 6.)\\r\\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n, tails='high')\\r\\n self.assertSimilarMeans(r, 0.77281447417149496, 0)\\r\\n r = make_result_list(m, [(0, 0), (0, 1), (0, 2)], n=n, tails='low')\\r\\n self.assertSimilarMeans(r, 4. / 6.)\\r\\n\\r\\n # The following lines are not part of the test code, but are useful in\\r\\n # figuring out what t-scores all of the permutations will yield.\\r\\n # permutes = [[0, 1, 2], [0, 2, 1], [1, 0, 2],\\\\\\r\\n # [1, 2, 0], [2, 0, 1], [2, 1, 0]]\\r\\n #results = []\\r\\n # for p in permutes:\\r\\n # p_m = permute_2d(m,p)\\r\\n # results.append(t_two_sample(\\\\\\r\\n # [p_m[0,1],p_m[0,2]],[p_m[2,1]],tails='high'))\\r\\n # print results\\r\",\n \"def rotate1(self, matrix: List[List[int]]) -> None:\\n matrixLen = len(matrix)\\n\\n for i in range(matrixLen):\\n for j in range(i, matrixLen):\\n print(i, j)\\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\\n\\n for i in range(matrixLen):\\n for j in range(matrixLen // 2):\\n matrix[i][j], matrix[i][matrixLen - 1 - j] = matrix[i][matrixLen - 1 - j], matrix[i][j]\",\n \"def test_dim2(self):\\r\\n # Each row of p is a different permutation to inverse\\r\\n p = imatrix()\\r\\n inv = inverse_permutation(p)\\r\\n f_inverse = function([p], inv)\\r\\n\\r\\n rng = numpy.random.RandomState(utt.fetch_seed())\\r\\n # Generate 10 random permutations\\r\\n p_val = numpy.asarray([rng.permutation(10) for i in range(7)],\\r\\n dtype='int32')\\r\\n inv_val = f_inverse(p_val)\\r\\n\\r\\n # Check that the inverse of the inverse is the original permutation list\\r\\n assert numpy.all(f_inverse(inv_val) == p_val)\\r\\n # Check that, for each permutation,\\r\\n # permutation(inverse) == inverse(permutation) = identity\\r\\n for p_row, i_row in zip(p_val, inv_val):\\r\\n assert numpy.all(p_row[i_row] == numpy.arange(10))\\r\\n assert numpy.all(i_row[p_row] == numpy.arange(10))\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n for dig in range(n):\\n row = dig\\n for col in range(dig+1, n):\\n matrix[row][col] , matrix[col][row] = matrix[col][row], matrix[row][col]\\n print(matrix)\\n left = 0\\n right = n-1\\n while left < right:\\n for row in range(n):\\n matrix[row][left], matrix[row][right] = matrix[row][right], matrix[row][left]\\n left+=1\\n right-=1\",\n \"def perform_gauss_jordan_elimination_(m, show):\\n if show:\\n print(\\\"Initial State\\\")\\n print_matrix(m)\\n \\n r = 0\\n c = 0\\n rows, cols = len(m), len(m[0])\\n\\n if show:\\n print(\\\"rows: %s cols: %s\\\"%(rows, cols))\\n\\n while True:\\n if show:\\n print(\\\"r %s c %s\\\"%(r, c))\\n\\n ## Check Pivot\\n _swap = False\\n if m[r,c] == 0:\\n for i in range(r+1,rows):\\n if m[i,c] == 1:# If new pivot found... swap\\n if show:\\n print(\\\"Swapping %s %s and %s %s\\\"%(r, m[r], i, m[i]))\\n m[[i,r]] = m[[r,i]] ## Swap\\n _swap = True\\n if show:\\n print_matrix(m)\\n break # No more swapping in this column\\n if not _swap: ## No swap, move to the next column, same row\\n c+=1\\n\\n if m[r,c] == 1:\\n ## XOR\\n for i in range(rows):\\n indexes = np.setdiff1d(np.where(m[:,c] == 1),r) # Get all the ones to XOR in the same column\\n for i in indexes:\\n m[i] = np.bitwise_xor(m[i],m[r]) # Bitwise XOR\\n if show:\\n print(\\\"XOR Row %s: %s into Row %s: %s\\\"%(r, m[r], i, m[i]))\\n if show:\\n print_matrix(m)\\n\\n ## Increase row and column\\n r+=1\\n c+=1\\n\\n ## break condition if all rows or all columns (except the augmented column) are treated\\n if r == rows or c >= cols-1:\\n break\\n\\n if show:\\n print(\\\"Final State\\\")\\n print_matrix(m)\\n \\n return m\",\n \"def _clifford_swap(cls, slot_i, slot_j) -> Tensor:\\n\\n return Tensor(\\n {\\n Tensor._merge_keys((slot_j,), (slot_i,)): -1,\\n Tensor._merge_keys(): 2 * cls.symmetric_bilinear_form(slot_i, slot_j),\\n }\\n )\",\n \"def rotate2D(self, matrix) -> None:\\n N = len(matrix)\\n\\n # In case of N is odd, the innermost square belt is just one cell, no need of rotating.\\n for i in range(0,int(N/2)): # outer loop for each square belt\\t\\t\\t\\n for j in range(i,N-i-1): # N-i group in the i-th square belt\\n #print(i,j)\\n tmp = matrix[i][j]\\n matrix[i][j] = matrix[N-j-1][i]\\n matrix[N-j-1][i] = matrix[N-i-1][N-j-1]\\n matrix[N-i-1][N-j-1] = matrix[j][N-i-1]\\n matrix[j][N-i-1] = tmp\\n #print(matrix)\",\n \"def rotate(self, m):\\n n = len(m)\\n for i in range(n//2):\\n for j in range(i,n-i-1):\\n m[j][~i],m[~i][~j],m[~j][i],m[i][j] = \\\\\\n m[i][j],m[j][~i],m[~i][~j],m[~j][i]\",\n \"def T(self):\\n # TODO - your code here\\n transpose = []\\n for col in range(self.w):\\n new_row = []\\n for row in range(self.h):\\n new_row.append(self.g[row][col])\\n transpose.append(new_row)\\n return Matrix(transpose)\\n # TODO - your code here\",\n \"def _cswap(i, j, S):\\n N = _rswap(i, j, S.transpose()).transpose()\\n return N\",\n \"def transp(self, x1, x2, d):\\n raise NotImplementedError\",\n \"def transpose(self):\\n pass\",\n \"def commute_matrix(A):\\n R = resistance_matrix(A)\\n E = A.sum() / 2 # number of edges in graph\\n C = 2 * E * R\\n return C\",\n \"def test_distance_matrix_permutation_test_non_symmetric(self):\\r\\n def make_result_list(*args, **kwargs):\\r\\n return [distance_matrix_permutation_test(*args, **kwargs)[2]\\r\\n for i in range(10)]\\r\\n\\r\\n m = arange(9).reshape((3, 3))\\r\\n n = 100\\r\\n # looks at each possible permutation n times --\\r\\n # compare first row to rest\\r\\n r = make_result_list(\\r\\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False)\\r\\n self.assertSimilarMeans(r, 0. / 6.)\\r\\n r = make_result_list(\\r\\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False,\\r\\n tails='high')\\r\\n self.assertSimilarMeans(r, 4. / 6.)\\r\\n r = make_result_list(\\r\\n m, [(0, 0), (0, 1), (0, 2)], n=n, is_symmetric=False,\\r\\n tails='low')\\r\\n self.assertSimilarMeans(r, 0. / 6.)\\r\\n\\r\\n # looks at each possible permutation n times --\\r\\n # compare last row to rest\\r\\n r = make_result_list(\\r\\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False)\\r\\n self.assertSimilarMeans(r, 0. / 6.)\\r\\n r = make_result_list(\\r\\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False,\\r\\n tails='high')\\r\\n self.assertSimilarMeans(r, 0. / 6.)\\r\\n r = make_result_list(\\r\\n m, [(2, 0), (2, 1), (2, 2)], n=n, is_symmetric=False,\\r\\n tails='low')\\r\\n self.assertSimilarMeans(r, 4. / 6.)\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix[0])\\n for i in range(n // 2 + n % 2):\\n for j in range(n // 2):\\n tmp = matrix[n - 1 - j][i]\\n matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1]\\n matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 -i]\\n matrix[j][n - 1 - i] = matrix[i][j]\\n matrix[i][j] = tmp\",\n \"def transpose(self):\\n return self.conjugate()\",\n \"def swap_cells(state, i1, j1, i2, j2):\\n value1 = state[i1][j1]\\n value2 = state[i2][j2]\\n \\n new_state = []\\n for row in range(len(state)): \\n new_row = []\\n for column in range(len(state[row])): \\n if row == i1 and column == j1: \\n new_row.append(value2)\\n elif row == i2 and column == j2:\\n new_row.append(value1)\\n else: \\n new_row.append(state[row][column])\\n new_state.append(tuple(new_row))\\n return tuple(new_state)\",\n \"def transpose(self) -> None:\\n ...\",\n \"def matrix_mult(m1, m2):\\n\\ttemp = []\\n\\tfor i in range(len(m1)):\\n\\t\\te = []\\n\\t\\tfor j in range(len(m2[0])):\\n\\t\\t\\te.append(row_times_column(m1,i,m2,j))\\n\\t\\ttemp.append(e)\\n\\treturn temp\",\n \"def transpositions(self):\\n a = self.cyclic_form\\n res = []\\n for x in a:\\n nx = len(x)\\n if nx == 2:\\n res.append(tuple(x))\\n elif nx > 2:\\n first = x[0]\\n for y in x[nx-1:0:-1]:\\n res.append((first,y))\\n return res\",\n \"def test_permute_2d(self):\\r\\n a = reshape(arange(9), (3, 3))\\r\\n self.assertEqual(permute_2d(a, [0, 1, 2]), a)\\r\\n self.assertEqual(permute_2d(a, [2, 1, 0]),\\r\\n array([[8, 7, 6], [5, 4, 3], [2, 1, 0]]))\\r\\n self.assertEqual(permute_2d(a, [1, 2, 0]),\\r\\n array([[4, 5, 3], [7, 8, 6], [1, 2, 0]]))\",\n \"def commutes_with(self, other):\\n a = self.array_form\\n b = other.array_form\\n if len(a) != len(b):\\n raise ValueError(\\\"The number of elements in the permutations \\\\\\ndon\\\\'t match.\\\")\\n for i in range(len(a)-1):\\n if a[b[i]] != b[a[i]]:\\n return False\\n return True\",\n \"def _rswap(i, j, S):\\n N = copy.deepcopy(S)\\n row = copy.deepcopy(N[i])\\n N[i] = copy.deepcopy(N[j])\\n N[j] = row\\n return N\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n for i in range(n):\\n for j in range(i+1):\\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\\n for i in range(n//2):\\n for j in range(n):\\n matrix[j][i], matrix[j][n-i-1] = matrix[j][n-i-1], matrix[j][i]\\n return matrix\",\n \"def _flip_vectors(jn_matrix, m_matrix):\\r\\n m_matrix_trans = m_matrix.transpose()\\r\\n jn_matrix_trans = jn_matrix.transpose()\\r\\n new_matrix = zeros(jn_matrix_trans.shape, float)\\r\\n for i, m_vector in enumerate(m_matrix_trans):\\r\\n jn_vector = jn_matrix_trans[i]\\r\\n disT = list(m_vector - jn_vector)\\r\\n disT = sum(map(abs, disT))\\r\\n jn_flip = jn_vector * [-1]\\r\\n disF = list(m_vector - jn_flip)\\r\\n disF = sum(map(abs, disF))\\r\\n if disT > disF:\\r\\n new_matrix[i] = jn_flip\\r\\n else:\\r\\n new_matrix[i] = jn_vector\\r\\n return new_matrix.transpose()\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n for i in range(n - 1):\\n for j in range(n - 1 - i):\\n matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]\\n for i in range(n):\\n for j in range(n // 2):\\n matrix[j][i], matrix[n-1-j][i] = matrix[n-1-j][i], matrix[j][i]\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n for l in range(n // 2):\\n r = n - 1 - l\\n for p in range(l, r):\\n q = n - 1 - p\\n cache = matrix[l][p]\\n matrix[l][p] = matrix[q][l]\\n matrix[q][l] = matrix[r][q]\\n matrix[r][q] = matrix[p][r]\\n matrix[p][r] = cache\",\n \"def rotateMatrixAttempt(matrix):\\n for idxring in range(len(matrix) / 2):\\n swap = []\\n ringgen = ringCoords(len(matrix), idxring)\\n for x, y in ringgen:\\n swap.append(matrix[y][x])\\n ringgen = ringCoords(len(matrix), idxring)\\n start_idx = len(matrix) - 1 - idxring\\n for swapidx in range(-1 * start_idx, len(swap) - start_idx):\\n x, y = ringgen.next()\\n matrix[y][x] = swap[swapidx]\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n if n <= 1:\\n return\\n\\n for i in range((n + 1)//2):\\n for j in range(i, n - 1 - i):\\n tmp = matrix[i][j]\\n matrix[i][j] = matrix[n - 1 - j][i]\\n matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]\\n matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]\\n matrix[j][n - 1 - i] = tmp\",\n \"def build_symmetry_operations(symmetry: List[Any]) -> None:\\n dim = len(symmetry[0][0])\\n unit = numpy.identity(dim, dtype=int)\\n for permutation in symmetry:\\n perm = unit[:, numpy.argsort(permutation[0])]\\n permutation[0] = perm\",\n \"def mat24_perm_to_int(p):\\n oct = sum(1 << x for x in p[:8])\\n res = gc.vect_to_octad(oct) \\n #print(\\\"p2i oct\\\", hex(oct))\\n res -= STD_OCTAD\\n res += (res >> 12) & 759 \\n #print(\\\"p2i\\\", res)\\n p1 = [24]*32\\n oct, j = 8 * oct, 0x00 \\n for i in range(24):\\n o = oct & 8\\n p1[i] = (j >> o) & 0x1f\\n j += 1 << o\\n oct >>= 1\\n q, q_inv = [None]*8, [None]*8\\n for i in range(8):\\n j = p1[p[i] & 0x1f] & 7\\n q[j] = i\\n q_inv[i] = j\\n for i in range(6):\\n # exchange place i with place q_inv[i]\\n j = q_inv[i]\\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\\n #q[i], q[j] = q[j], q[i]\\n #assert q[:i] == q_inv[:i] == lrange(i)\\n q_inv[q[i]] = q_inv[q[j]]\\n q[j] = q[i]\\n #print(\\\"p2i%d\\\" % i, j-i) \\n res = res * (8 - i) + j - i\\n #print(\\\"p2ifinal\\\", p1[p[8] & 0x1f]) \\n return 16 * res + p1[p[8] & 0x1f]\",\n \"def Jac(M):\\n x = [sy.Dummy() for _ in range(nargs(M))]\\n y = M(*x)\\n J = [sy.diff(yi, xi) for yi in y for xi in x]\\n return sy.lambdify(x, J, 'sympy')\",\n \"def apply_columns_recursive_inplace(self, mat1: 'Nparray',\\n mat2: 'Nparray') -> None:\\n trans = FqeData(self.nbeta(),\\n self.nalpha(),\\n self.norb(),\\n self._core.alpha_beta_transpose(),\\n dtype=self.coeff.dtype)\\n buf = trans.coeff.reshape(self.lena(), self.lenb())\\n self._apply_columns_recursive_alpha(mat1, buf)\\n\\n if fqe.settings.use_accelerated_code:\\n _transpose(trans.coeff, self.coeff)\\n else:\\n trans.coeff[:, :] = self.coeff.T[:, :]\\n buf = self.coeff.reshape(self.lenb(), self.lena())\\n trans._apply_columns_recursive_alpha(mat2, buf)\\n\\n if fqe.settings.use_accelerated_code:\\n _transpose(self.coeff, trans.coeff)\\n else:\\n self.coeff[:, :] = trans.coeff.T[:, :]\",\n \"def swap2(d, n, v, i, j):\\n for a in range(n):\\n for k in range(d):\\n if k == i or k == j:\\n continue\\n x = a*d*d + d*i + k\\n y = a*d*d + d*j + k\\n v[x], v[y] = v[y], v[x]\\n\\n x = a*d*d + d*k + i\\n y = a*d*d + d*k + j\\n v[x], v[y] = v[y], v[x]\\n\\n x = a*d*d + d*i + i\\n y = a*d*d + d*j + j\\n v[x], v[y] = v[y], v[x]\\n\\n x = a*d*d + d*j + i\\n y = a*d*d + d*i + j\\n v[x], v[y] = v[y], v[x]\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n # transpose\\n N = len(matrix)\\n for i in range(N):\\n for j in range(0, i):\\n matrix[i][j] = matrix[i][j] ^ matrix[j][i]\\n matrix[j][i] = matrix[i][j] ^ matrix[j][i]\\n matrix[i][j] = matrix[i][j] ^ matrix[j][i]\\n \\n # print(matrix)\\n # 左右互换\\n for i in range(N):\\n for j in range(N // 2):\\n matrix[i][j] = matrix[i][j] ^ matrix[i][N - j - 1]\\n matrix[i][N - j - 1] = matrix[i][j] ^ matrix[i][N - j - 1]\\n matrix[i][j] = matrix[i][j] ^ matrix[i][N - j - 1]\\n # print(matrix)\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n length = len(matrix)\\n for row in range(length//2):\\n for col in range(row, length-row-1):\\n # matrix[row][col], matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row]\\n matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row], matrix[row][col] = matrix[row][col], matrix[col][length-1-row], matrix[length-1-row][length-1-col], matrix[length-1-col][row]\\n return\",\n \"def z_operator_matrix(self):\\n n, r_1, r_2, k = self.n, self.r_1, self.r_2, self.k\\n\\n # Use the row vector [ A2^T 0 I ], which commutes with the check matrix.\\n check_mat = np.zeros((k, n), dtype='int')\\n check_mat[:, 0:r_1] = np.transpose(self.parity_check_c1[:, (r_1 + r_2):n])\\n check_mat[:, (r_1 + r_2):n] = np.identity(k)\\n return check_mat\",\n \"def rotate(self, matrix: list) -> None:\\n for i in range(len(matrix)):\\n for j in range(i):\\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\\n # matrix[i].reverse()\\n print(matrix)\\n for i in range(len(matrix)):\\n matrix[i].reverse()\\n print(matrix)\",\n \"def __mul__(self, other):\\n #\\n # TODO - your code here\\n #\\n final_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(other.w):\\n # take dot-product of row of\\n # matrix in 1st arg with col of\\n # matrix in 2nd arg\\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\\n final_matrix.append(temp_row)\\n return Matrix(final_matrix)\\n # TODO - your code here\",\n \"def rotate_2d_matrix(matrix):\\n\\n L = len(matrix)\\n for i in range(L // 2):\\n for j in range(i, L - i - 1):\\n temp = matrix[i][j]\\n matrix[i][j] = matrix[L - 1 - j][i]\\n matrix[L - 1 - j][i] = matrix[L - 1 - i][L - 1 - j]\\n matrix[L - 1 - i][L - 1 - j] = matrix[j][L - 1 - i]\\n matrix[j][L - 1 - i] = temp\",\n \"def trans_o(self):\\n temp_array = []\\n for j in range(self.O.shape[1]):\\n for i in range(self.V.shape[1]):\\n if self.V[0, i] == self.O[0, j]:\\n temp_array.append(i)\\n self.O = mat(temp_array)\",\n \"def mirror(self, p1=(0, 1), p2=(0, 0)) -> \\\"Group\\\":\\n for e in self.elements:\\n e.mirror(p1=p1, p2=p2)\\n return self\",\n \"def _permute_generetably(elements: List[T], i: int):\\n if i == 1:\\n yield elements\\n else:\\n for j in range(i - 1):\\n for permutation in _permute_generetably(elements, i - 1):\\n yield permutation\\n\\n k = 0 if i % 2 == 1 else j\\n\\n elements[k], elements[i - 1] = elements[i - 1], elements[k]\\n\\n for permutation in _permute_generetably(elements, i - 1):\\n yield permutation\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n if(matrix == None or len(matrix) == 1): return\\n n = len(matrix)\\n for i in range(0, n//2 + 1):\\n for j in range(i, n-1-i):\\n tmp = matrix[i][j]\\n matrix[i][j] = matrix[n-1-j][i]\\n matrix[n-1-j][i] = matrix[n-1-i][n-1-j]\\n matrix[n-1-i][n-1-j] = matrix[j][n-1-i]\\n matrix[j][n-1-i] = tmp\\n \\n return\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n n = len(matrix)\\n for i in range(n):\\n for j in range(n // 2):\\n matrix[i][j], matrix[i][n-1-j] = matrix[i][n-1-j], matrix[i][j]\\n for i in range(n):\\n for j in range(n-i):\\n matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]\",\n \"def swap(self,i,j):\\r\\n self._data[i], self._data[j] = self._data[j], self._data[i]\",\n \"def mirror(self):\\n for l in range(self.numRows):\\n mirrorGrid = []\\n for l in range(self.numCols):\\n row = self.grid[l][::-1]\\n mirrorGrid.append(row)\\n return mirrorGrid\",\n \"def _swap(self, i, j):\\n self._data[i], self._data[j] = self._data[j], self._data[i]\",\n \"def _swap(self, i, j):\\n self._data[i], self._data[j] = self._data[j], self._data[i]\",\n \"def swapRows(self, i, j):\\n if not (type(i) in MATRIX_VALID_INTS and type(\\n j) in MATRIX_VALID_INTS): # this should be fixed to accomodate 'long' types\\n raise TypeError(\\\"Row indices must be of type 'int'\\\")\\n rowA = self.deleteRow(max(i, j))\\n rowB = self.deleteRow(min(i, j))\\n self.insertRow(min(i, j), *rowA)\\n self.insertRow(max(i, j), *rowB)\",\n \"def reverse_cuthill_mckee(self, permutation: bool = True) -> [np.ndarray, np.ndarray]:\\n # 1. get the connectivity matrix\\n nodeids, C = self.node_connectivity_matrix()\\n\\n # 2. compute the new node order\\n perm = scipy.sparse.csgraph.reverse_cuthill_mckee(C, False)\\n\\n # 3. create a dictionary with new node order\\n nodeids = {nid: perm[i] for nid, i in nodeids.items()}\\n\\n if permutation:\\n # 4. create the permutation matrix for node order if requested\\n P = C[np._ix(perm, perm)]\\n return nodeids, P\\n else:\\n # 4. or return just the new node order\\n return nodeids\",\n \"def _swap2(self, cids, iids):\\n # The coupling indexes of the two legs to swap\\n c1, c2 = cids\\n # The index of the two legs to swap within the given coupling\\n i1, i2 = iids\\n assert c1 != c2\\n\\n # Get the connecting coupling between the two couplings\\n cnx = self.get_couplingnetwork().to_undirected(as_view=True)\\n ci = set(nx.common_neighbors(cnx, *[self.coupling[ii] for ii in cids]))\\n if len(ci) != 1:\\n raise ValueError(f'cids: {cids} have {len(ci)} common neighbors')\\n ci = self.coupling.index(ci.pop())\\n\\n # internal legs\\n l1 = cnx.edges[self.coupling[c1], self.coupling[ci], 0]['leg']\\n l2 = cnx.edges[self.coupling[c2], self.coupling[ci], 0]['leg']\\n\\n # index of the internal leg in c1 and c2\\n legs = self.get_legs()\\n il1, il2 = [[legs[x].index(ll) for x in (y, ci)]\\n for y, ll in zip(cids, (l1, l2))]\\n\\n assert il1[0] != i1 and il2[0] != i2\\n assert il1[1] != il2[1]\\n # Check that the flow is consistent along the internal bond\\n assert self.coupling[c1][il1[0]][1] is not self.coupling[ci][il1[1]][1]\\n assert self.coupling[c2][il2[0]][1] is not self.coupling[ci][il2[1]][1]\\n\\n def permute_key(key):\\n copy = list(list(k) for k in key)\\n copy[c1][i1], copy[c2][i2] = copy[c2][i2], copy[c1][i1]\\n return copy\\n f1, f2, fi = ([x[1] for x in self.coupling[c]] for c in (c1, c2, ci))\\n self._coupling = tuple(tuple(c) for c in permute_key(self.coupling))\\n\\n # All good interal symmetry sectors in for the swapped 1st coupling\\n nkeys = set(tuple(tuple(e) for e in permute_key(k)) for k in self)\\n c1set = {}\\n r11, r12 = set(range(3)).difference([il1[0]])\\n for k in set(key[c1] for key in nkeys):\\n kn = (k[r11], k[r12])\\n if kn not in c1set:\\n c1set[kn] = set(\\n sls.allowed_couplings(k, f1, il1[0], self.symmetries))\\n c2set = {}\\n r21, r22 = set(range(3)).difference([il2[0]])\\n for k in set(key[c2] for key in nkeys):\\n kn = (k[r21], k[r22])\\n if kn not in c2set:\\n c2set[kn] = set(\\n sls.allowed_couplings(k, f2, il2[0], self.symmetries))\\n\\n vac = sls.vacuumIrrep(self.symmetries)\\n Z1 = set().union(*c1set.values())\\n Z2 = set().union(*c2set.values())\\n rf = set(range(3)).difference([il1[1], il2[1]]).pop()\\n fit = [fi[rf], fi[il1[1]], fi[il2[1]]]\\n oks = {(k1, k2): set(sls.allowed_couplings((vac, k1, k2),\\n fit, 0, self.symmetries))\\n for k1, k2 in itertools.product(Z1, Z2)}\\n\\n def mappingf(okey):\\n nk = permute_key(okey)\\n set1 = c1set[(nk[c1][r11], nk[c1][r12])]\\n set2 = c2set[(nk[c2][r21], nk[c2][r22])]\\n for kk1 in set1:\\n for kk2 in set2:\\n if nk[ci][rf] not in oks[(kk1, kk2)]:\\n continue\\n\\n # Assign the key of the internal leg\\n nk[c1][il1[0]], nk[ci][il1[1]] = kk1, kk1\\n nk[c2][il2[0]], nk[ci][il2[1]] = kk2, kk2\\n yield tuple(tuple(e) for e in nk)\\n\\n prefdict = sls._prefswap2(iids, il1, il2, f1, f2, fi)\\n\\n def prefactorf(okey, nkey):\\n flokey = [list(x) for x in\\n zip(*[el for j in (c1, c2, ci) for el in okey[j]])]\\n flnkey = [list(x) for x in\\n zip(*[el for j in (c1, c2, ci) for el in nkey[j]])]\\n return np.prod([prefdict.get(ss, lambda x, y: 1.)(o, n) for\\n o, n, ss in zip(flokey, flnkey, self.symmetries)])\\n\\n self._manipulate_coupling(mappingf, prefactorf)\\n return self\",\n \"def perm_2_let():\\r\\n return {''.join(i) for i in permutations('abcdefghijklmnopqrstuvwxyz', 2)}\\r\\n # print(comb_2_let, sep='')\\r\",\n \"def transferMatrix(self, i1=0, i2=-1, plane=\\\"x\\\"):\\n B2 = self.normMat(i2, plane=plane)\\n B1 = self.normMat(i1, plane=plane)\\n psi = 2 * np.pi * (self[\\\"mu\\\" + plane][i2] - self[\\\"mu\\\" + plane][i1])\\n R = np.array([[np.cos(psi), np.sin(psi)], [-np.sin(psi), np.cos(psi)]])\\n return np.dot(np.dot(B2, R), np.linang.inv(B1))\",\n \"def permutations(cube):\\r\\n yield from rotations24(cube)\\r\\n yield from rotations24(np.flip(cube, 0))\\r\\n yield from rotations24(np.flip(cube, 1))\\r\\n yield from rotations24(np.flip(cube, 2))\",\n \"def _swap(self, x1, y1, x2, y2):\\n puzzle_copy = [list(row) for row in self.position] # copy the puzzle\\n puzzle_copy[x1][y1], puzzle_copy[x2][y2] = puzzle_copy[x2][y2], puzzle_copy[x1][y1]\\n\\n return puzzle_copy\",\n \"def swap_full(permutation, transposition,nb_position):\\n i, j = transposition\\n res = np.array(permutation)\\n res[i], res[j] = res[j], res[i]\\n return tuple(res[:nb_position])\",\n \"def symmetrize(n):\\n times = lambda x: jnp.concatenate((jnp.flipud(x), x))\\n trans = lambda x: x[n:] + x[n-1::-1]\\n return Operator(times=times, trans=trans, shape=(2*n,n))\",\n \"def rotate_matrix(self, mat):\\r\\n N=3\\r\\n for x in range(0, int(N / 2)):\\r\\n for y in range(x, N-x-1):\\r\\n temp = mat[x][y]\\r\\n mat[x][y] = mat[y][N-1-x]\\r\\n mat[y][N-1-x] = mat[N-1-x][N-1-y]\\r\\n mat[N-1-x][N-1-y] = mat[N-1-y][x]\\r\\n mat[N-1-y][x] = temp\\r\\n return mat\",\n \"def test_matrix(self, tol):\\n\\n res_static = qml.QFT.compute_matrix(2)\\n res_dynamic = qml.QFT(wires=[0, 1]).matrix()\\n res_reordered = qml.QFT(wires=[0, 1]).matrix([1, 0])\\n\\n expected = np.array(\\n [\\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\\n [0.5 + 0.0j, 0.0 + 0.5j, -0.5 + 0.0j, -0.0 - 0.5j],\\n [0.5 + 0.0j, -0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j],\\n [0.5 + 0.0j, -0.0 - 0.5j, -0.5 + 0.0j, 0.0 + 0.5j],\\n ]\\n )\\n\\n assert np.allclose(res_static, expected, atol=tol, rtol=0)\\n assert np.allclose(res_dynamic, expected, atol=tol, rtol=0)\\n\\n expected_permuted = [\\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\\n [0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j, -0.5 + 0.0j],\\n [0.5 + 0.0j, -0.5 + 0.0j, 0.0 + 0.5j, -0.0 - 0.5j],\\n [0.5 + 0.0j, -0.5 + 0.0j, -0.0 - 0.5j, 0.0 + 0.5j],\\n ]\\n assert np.allclose(res_reordered, expected_permuted, atol=tol, rtol=0)\",\n \"def rotate(self, matrix: list[list[int]]) -> None:\",\n \"def transpose(self):\\n for i in range(self.columns): # This for loop makes the rows we need in our transposed matrix\\n matrix = [] # List that will contain the rows of the transpose matrix\\n for j in range(self.rows): # This for loop makes the columns we need in our transposed matrix\\n matrix.append(self.Matrix[j][i]) \\n self.Transpose.append(matrix) # Appending the rows into the bigger list we created\\n print(\\\"This is your transposed matrix: \\\", self.Transpose)\",\n \"def rotate(self, matrix: List[List[int]]) -> None:\\n height=len(matrix)\\n for h in range(math.ceil(height/2)):\\n for i in range(h,height-h-1):\\n # print((h,i), (height-i-1,h))\\n temp=matrix[h][i]\\n matrix[h][i] = matrix[height-i-1][h]\\n matrix[height-i-1][h] = matrix[height-h-1][height-i-1]\\n matrix[height-h-1][height-i-1] = matrix[i][height-h-1]\\n matrix[i][height-h-1] = temp\",\n \"def part_2():\\n return itertools.permutations(range(5, 10))\",\n \"def test_two_qubit_weyl_decomposition_swap(self):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(np.pi / 4, np.pi / 4, np.pi / 4)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def swap(self, adjacent_transposition):\\n\\n result = Tensor()\\n for key_self in self.keys():\\n # ensure that the swap can be made with the available slots\\n if max(adjacent_transposition) < len(key_self):\\n prefix = Tensor({Tensor._merge_keys(*key_self[0 : min(adjacent_transposition)]): self[key_self]})\\n root = type(self)._clifford_swap(\\n *key_self[min(adjacent_transposition) : max(adjacent_transposition) + 1]\\n )\\n postfix = Tensor({Tensor._merge_keys(*key_self[max(adjacent_transposition) + 1 :]): 1})\\n result = result + prefix * root * postfix\\n else:\\n result = result + Tensor({key_self: self[key_self]})\\n self.clear()\\n self.update(result)\\n return self\",\n \"def swap(self, i: int, j: int) -> None:\\n self.data[i], self.data[j] = self.data[j], self.data[i]\",\n \"def MatMulOrder(D):\\r\\n\\tnum = len(D)-1 # number of matrix in the chain\\r\\n\\tprint(f\\\"There are {num} matrix to multiply\\\")\\r\\n\\tM = [[0 for _ in range(num)] for _ in range(num)]\\r\\n\\tP = [[0 for _ in range(num)] for _ in range(num)]\\r\\n\\r\\n\\t# i要从大到小\\r\\n\\t# i == j时, M[i][j]=0,所以不用更新\\r\\n\\t# i-th矩阵到j-th矩阵的乘的最优值初始化为inf\\r\\n\\tfor i in range(num-2, -1, -1):\\r\\n\\t\\tfor j in range(i+1, num):\\r\\n\\t\\t\\tM[i][j] = 100000000\\r\\n\\t\\t\\tfor k in range(i, j):\\r\\n\\t\\t\\t\\tnew = M[i][k] + M[k+1][j] + D[i]*D[k+1]*D[j+1]\\r\\n\\t\\t\\t\\tif new < M[i][j]:\\r\\n\\t\\t\\t\\t\\tM[i][j] = new \\r\\n\\t\\t\\t\\t\\tP[i][j] = k\\r\\n\\treturn M, P\",\n \"def contract(tensor):\\n temp = np.einsum('ikma, jlan', tensor, tensor)\\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\\n return M\",\n \"def test_flip_vectors(self):\\r\\n m_matrix = array([[1.0, 0.0, 1.0], [2.0, 4.0, 4.0]])\\r\\n jn_matrix = array([[1.2, 0.1, -1.2], [2.5, 4.0, -4.5]])\\r\\n new_matrix = _flip_vectors(jn_matrix, m_matrix)\\r\\n assert_almost_equal(new_matrix, array([[1.2, 0.1, 1.2], [2.5, 4.0, 4.5]]))\",\n \"def test_flip_vectors(self):\\n m_matrix = array([[1.0, 0.0, 1.0], [2.0, 4.0, 4.0]])\\n jn_matrix = array([[1.2, 0.1, -1.2], [2.5, 4.0, -4.5]])\\n new_matrix = _flip_vectors(jn_matrix, m_matrix)\\n assert_almost_equal(new_matrix, array([[1.2, 0.1, 1.2], [2.5, 4.0, 4.5]]))\",\n \"def swapCouplingTuples(self, permutation):\\n from collections import Counter\\n\\n if Counter(permutation) != Counter(range(len(self.coupling))):\\n raise ValueError(f'Permutation {permutation} is not valid')\\n\\n def permute_key(key):\\n return tuple(key[p] for p in permutation)\\n\\n self._coupling = permute_key(self.coupling)\\n\\n def mappingf(okey):\\n yield permute_key(okey)\\n\\n self._manipulate_coupling(mappingf, lambda x, y: 1)\\n return self\",\n \"def check_perm(tri1,tri2):\\n for t1 in tri1:\\n for t2 in tri2:\\n if t1 == t2:\\n return False\\n return True\",\n \"def matrix_chain_dynamic(dimensions, n):\\n\\n m = [[-1 for _ in range(n)] for _ in range(n)]\\n s = [[0 for _ in range(n)] for _ in range(n)]\\n\\n # multiplying matrix by itself\\n for i in range(1, n):\\n m[i][i] = 0\\n\\n for length in range(2, n):\\n for i in range(1, n - length + 1):\\n j = i + length - 1\\n for k in range(i, j):\\n cost = m[i][k] + m[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j]\\n if cost > m[i][j]:\\n m[i][j] = cost\\n # index if splitting\\n s[i][j] = k\\n return m, s\",\n \"def products(q_1: Qs, q_2: Qs, kind: str = \\\"\\\", reverse: bool = False) -> Qs:\\n\\n q_1_copy = deepcopy(q_1)\\n q_2_copy = deepcopy(q_2)\\n qs_left, qs_right = Qs(), Qs()\\n\\n # Diagonalize if need be.\\n if ((q_1.rows == q_2.rows) and (q_1.columns == q_2.columns)) or (\\n \\\"scalar_q\\\" in [q_1.qs_type, q_2.qs_type]\\n ):\\n\\n if q_1.columns == 1:\\n qs_right = q_2_copy\\n qs_left = diagonal(q_1_copy, qs_right.rows)\\n\\n elif q_2.rows == 1:\\n qs_left = q_1_copy\\n qs_right = diagonal(q_2_copy, qs_left.columns)\\n\\n else:\\n qs_left = q_1_copy\\n qs_right = q_2_copy\\n\\n # Typical matrix multiplication criteria.\\n elif q_1.columns == q_2.rows:\\n qs_left = q_1_copy\\n qs_right = q_2_copy\\n\\n else:\\n print(\\n \\\"Oops, cannot multiply series with row/column dimensions of {}/{} to {}/{}\\\".format(\\n q_1.rows, q_1.columns, q_2.rows, q_2.columns\\n )\\n )\\n\\n # Operator products need to be transposed.\\n operator_flag = False\\n if qs_left in [\\\"op\\\", \\\"operator\\\"] and qs_right in [\\\"op\\\", \\\"operator\\\"]:\\n operator_flag = True\\n\\n outer_row_max = qs_left.rows\\n outer_column_max = qs_right.columns\\n shared_inner_max = qs_left.columns\\n projector_flag = (\\n (shared_inner_max == 1) and (outer_row_max > 1) and (outer_column_max > 1)\\n )\\n\\n result = [\\n [q0(q_type=\\\"\\\") for _i in range(outer_column_max)]\\n for _j in range(outer_row_max)\\n ]\\n\\n for outer_row in range(outer_row_max):\\n for outer_column in range(outer_column_max):\\n for shared_inner in range(shared_inner_max):\\n\\n # For projection operators.\\n left_index = outer_row\\n right_index = outer_column\\n\\n if outer_row_max >= 1 and shared_inner_max > 1:\\n left_index = outer_row + shared_inner * outer_row_max\\n\\n if outer_column_max >= 1 and shared_inner_max > 1:\\n right_index = shared_inner + outer_column * shared_inner_max\\n\\n result[outer_row][outer_column] = add(result[outer_row][outer_column],\\n product(qs_left.qs[left_index],\\n qs_right.qs[right_index], kind=kind, reverse=reverse\\n )\\n )\\n\\n # Flatten the list.\\n new_qs = [item for sublist in result for item in sublist]\\n new_states = Qs(new_qs, rows=outer_row_max, columns=outer_column_max)\\n\\n if projector_flag or operator_flag:\\n return transpose(new_states)\\n\\n else:\\n return new_states\",\n \"def symmetry_duplication(\\n bijection: BijectionType,\\n ) -> Iterator[BijectionType]:\\n return (\\n bij\\n for rotated in (\\n {k.rotate(angle): v.rotate(angle) for k, v in bijection.items()}\\n for angle in range(4)\\n )\\n for bij in (rotated, {k.inverse(): v.inverse() for k, v in rotated.items()})\\n )\",\n \"def transposed(self) -> 'MatrixBoolean':\\n\\t\\tmatrix = MatrixBoolean(empty=(self.dimN, self.dimM))\\n\\t\\tfor m in range(self.dimM):\\n\\t\\t\\tfor n in range(self.dimN):\\n\\t\\t\\t\\tmatrix.matrix[n][m] = self.matrix[m][n]\\n\\t\\treturn matrix\",\n \"def _swap_energies(i, j, energies):\\n energies[:, [i, j]] = energies[:, [j, i]]\",\n \"def test_two_qubit_weyl_decomposition_iswap(self):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(np.pi / 4, np.pi / 4, 0)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def pd(self, other):\\n return Matriz([self]).T() * Matriz([other])\",\n \"def sort(self):\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[0][j] < self.genepool[0][j-1]:\\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\\n else:\\n break\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[1][j] < self.genepool[1][j-1]:\\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\\n else:\\n break\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6260572","0.61407316","0.60737467","0.58037573","0.5779625","0.5728096","0.56909776","0.5626455","0.5626066","0.55842173","0.5571164","0.5571073","0.5566883","0.55655205","0.55617666","0.5537897","0.55265135","0.5522779","0.55212414","0.5504172","0.5502277","0.5499689","0.5494559","0.54692745","0.5448146","0.54468817","0.54391587","0.5429634","0.5419231","0.54069114","0.53999865","0.5399903","0.5388735","0.5387693","0.5350425","0.53328","0.5332238","0.533077","0.5323849","0.5318166","0.53097653","0.5303948","0.529397","0.5292545","0.52909434","0.52904165","0.5283748","0.5261649","0.5255824","0.52543145","0.5245406","0.52424765","0.52421993","0.52369875","0.5233853","0.5228763","0.5226109","0.52213526","0.5217493","0.5204849","0.520208","0.5195528","0.5190807","0.5190738","0.51806414","0.5172804","0.51701295","0.51699954","0.51699954","0.51694405","0.51596904","0.51573694","0.5154442","0.51522404","0.5142365","0.5139053","0.5130099","0.5129072","0.5119029","0.5113565","0.51092374","0.51089793","0.5106363","0.51026005","0.5097424","0.5090588","0.50893134","0.50871736","0.5085991","0.50849617","0.5084761","0.5073242","0.5065707","0.50647956","0.50643754","0.50617826","0.50549674","0.5050744","0.50503874","0.5049664","0.5049319"],"string":"[\n \"0.6260572\",\n \"0.61407316\",\n \"0.60737467\",\n \"0.58037573\",\n \"0.5779625\",\n \"0.5728096\",\n \"0.56909776\",\n \"0.5626455\",\n \"0.5626066\",\n \"0.55842173\",\n \"0.5571164\",\n \"0.5571073\",\n \"0.5566883\",\n \"0.55655205\",\n \"0.55617666\",\n \"0.5537897\",\n \"0.55265135\",\n \"0.5522779\",\n \"0.55212414\",\n \"0.5504172\",\n \"0.5502277\",\n \"0.5499689\",\n \"0.5494559\",\n \"0.54692745\",\n \"0.5448146\",\n \"0.54468817\",\n \"0.54391587\",\n \"0.5429634\",\n \"0.5419231\",\n \"0.54069114\",\n \"0.53999865\",\n \"0.5399903\",\n \"0.5388735\",\n \"0.5387693\",\n \"0.5350425\",\n \"0.53328\",\n \"0.5332238\",\n \"0.533077\",\n \"0.5323849\",\n \"0.5318166\",\n \"0.53097653\",\n \"0.5303948\",\n \"0.529397\",\n \"0.5292545\",\n \"0.52909434\",\n \"0.52904165\",\n \"0.5283748\",\n \"0.5261649\",\n \"0.5255824\",\n \"0.52543145\",\n \"0.5245406\",\n \"0.52424765\",\n \"0.52421993\",\n \"0.52369875\",\n \"0.5233853\",\n \"0.5228763\",\n \"0.5226109\",\n \"0.52213526\",\n \"0.5217493\",\n \"0.5204849\",\n \"0.520208\",\n \"0.5195528\",\n \"0.5190807\",\n \"0.5190738\",\n \"0.51806414\",\n \"0.5172804\",\n \"0.51701295\",\n \"0.51699954\",\n \"0.51699954\",\n \"0.51694405\",\n \"0.51596904\",\n \"0.51573694\",\n \"0.5154442\",\n \"0.51522404\",\n \"0.5142365\",\n \"0.5139053\",\n \"0.5130099\",\n \"0.5129072\",\n \"0.5119029\",\n \"0.5113565\",\n \"0.51092374\",\n \"0.51089793\",\n \"0.5106363\",\n \"0.51026005\",\n \"0.5097424\",\n \"0.5090588\",\n \"0.50893134\",\n \"0.50871736\",\n \"0.5085991\",\n \"0.50849617\",\n \"0.5084761\",\n \"0.5073242\",\n \"0.5065707\",\n \"0.50647956\",\n \"0.50643754\",\n \"0.50617826\",\n \"0.50549674\",\n \"0.5050744\",\n \"0.50503874\",\n \"0.5049664\",\n \"0.5049319\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":68,"numItemsPerPage":100,"numTotalItems":95772,"offset":6800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MjY3NjgzOSwianRpIjoiMTc5MjBiNWUtNDNlMC00MThkLWE1ODctODQwNDcwNGZjODFjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODI2ODA0MzksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.TlesT7ls2rhKgWvVC4ocSU2PakcoxZ349Gca0Gi5fyYufITSD0K--rmgjKB8O962oR3ODGol4ErYEInfNwDPBA","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 |
|---|---|---|---|---|---|---|
Create an IK attribute on the given ctrl, connect IK handles to ik switch. Also connect fk ctrls and ik ctrls visibility to switch. This will create an 'IK' attr on the switch ctrl | def create_fk_ik_switch(switch_ctrl, ik_handles, fk_ctrls, ik_ctrls, vis_ctrl=None, switch_attr_name='IK', vis_attr_name='fkIkCtrlVis'):
fk_ctrls = mc.ls(fk_ctrls)
ik_ctrls = mc.ls(ik_ctrls)
ik_handles = mc.ls(ik_handles)
if not vis_ctrl:
vis_ctrl = switch_ctrl
# Create attributes
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_soft_ik(ik_ctrl, ik_joints, ik_handle):\n\n # get name and constant variables\n name = ik_handle+'Soft'\n parent = utils.get_parent(ik_joints[0])\n ik_handle_parent = utils.get_parent(ik_handle)\n\n # get total length of joint chain\n chain_length = 0\n for jnt in ik_joints[1:]:\n ... | [
"0.6865341",
"0.670034",
"0.6326762",
"0.61733705",
"0.6086193",
"0.59026164",
"0.57446015",
"0.55481964",
"0.540773",
"0.5367092",
"0.53659767",
"0.51581305",
"0.5066359",
"0.493914",
"0.48905978",
"0.48687443",
"0.48397043",
"0.48023486",
"0.47860128",
"0.47808054",
"0.4765... | 0.7807563 | 0 |
Create soft ik constraint on ikHandle. | def create_soft_ik(ik_ctrl, ik_joints, ik_handle):
# get name and constant variables
name = ik_handle+'Soft'
parent = utils.get_parent(ik_joints[0])
ik_handle_parent = utils.get_parent(ik_handle)
# get total length of joint chain
chain_length = 0
for jnt in ik_joints[1:]:
chain_len... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_keep_in_constraint(self,der=2,limit=1e1,weight=1e5):\n print(\"Creating Keep in constraint\")\n constr = dict()\n constr['constraint_type'] = \"ellipsoid\"\n constr['weight'] = self.accel_weight\n constr['keep_out'] = False\n constr['der'] = der\n constr[... | [
"0.5469389",
"0.531737",
"0.52888745",
"0.51781154",
"0.50092465",
"0.49953595",
"0.49701515",
"0.4952075",
"0.49448365",
"0.49093467",
"0.49027547",
"0.4884955",
"0.4834274",
"0.47601178",
"0.47214177",
"0.46724012",
"0.4648716",
"0.46426857",
"0.4633451",
"0.46300042",
"0.4... | 0.7518777 | 0 |
Quaterion / matrix based twist for upper arms and legs. | def upper_twist(shoulder_jnt, up_arm_ik_jnt, lo_arm_ik_jnt, up_arm_jnt, lo_arm_jnt, up_arm_twist_jnts):
# Create a group that does not rotate and parent under the ik arm parent (shoulder)
stable_reader_grp = utils.create_node('transform', n=up_arm_ik_jnt+'_stable_reader', p=up_arm_ik_jnt)
# Create a grp t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lower_twist(lo_arm_ik_jnt, wrist_ik_jnt, lo_arm_jnt, lo_arm_twist_jnts, wrist_jnt=None):\n\n # Create a group that does not rotate and parent under the ik arm parent (shoulder)\n stable_reader_grp = utils.create_node('transform', n=lo_arm_ik_jnt+'_stable_reader', p=lo_arm_ik_jnt)\n\n # Create a grp th... | [
"0.5514963",
"0.52410305",
"0.5185732",
"0.51259094",
"0.5053267",
"0.5020422",
"0.49390778",
"0.4879556",
"0.48793352",
"0.4878152",
"0.4855",
"0.4854443",
"0.48542276",
"0.48520848",
"0.48423955",
"0.4821107",
"0.4791083",
"0.47887972",
"0.47870728",
"0.47847036",
"0.478411... | 0.56926125 | 0 |
Quaterion / matrix based stretch for forearms and lower legs | def lower_twist(lo_arm_ik_jnt, wrist_ik_jnt, lo_arm_jnt, lo_arm_twist_jnts, wrist_jnt=None):
# Create a group that does not rotate and parent under the ik arm parent (shoulder)
stable_reader_grp = utils.create_node('transform', n=lo_arm_ik_jnt+'_stable_reader', p=lo_arm_ik_jnt)
# Create a grp that will ro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ar_addStretchSquash():\n setupName = 'Nose'\n sel = cmds.ls(sl=True)\n chain = cmds.ls(sel[0], dag=True, typ='joint')\n IKSpine = cmds.ikHandle(sj=chain[0], ee=chain[len(chain) - 1], sol='ikSplineSolver')\n # rename\n cmds.rename(IKSpine[0], 'IKSplineHandle_' + setupName)\n cmds.rename(IKS... | [
"0.5521156",
"0.52241683",
"0.52145356",
"0.51717967",
"0.5153184",
"0.5151809",
"0.5132688",
"0.5117285",
"0.5094757",
"0.50800526",
"0.5053586",
"0.5023979",
"0.5008975",
"0.50081855",
"0.50077236",
"0.5004814",
"0.49971503",
"0.49883208",
"0.49845037",
"0.49832925",
"0.497... | 0.0 | -1 |
Stretch setup for biped (2 joint chain) arms and legs | def biped_stretch(ik_ctrl,
ik_last_node,
pv_ctrl,
switch_ctrl,
up_arm_fk_ctrl,
lo_arm_fk_ctrl,
wrist_fk_ctrl,
up_arm_ik_jnt,
lo_arm_ik_jnt,
wrist_ik_jnt,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multi_joint_stretch(ik_ctrl, ik_last_node, switch_ctrl, fk_ctrls, jnts, ik_handle):\n\n root_grp = utils.get_parent(jnts[0])\n stretch_jnts = jnts[1:]\n stretch_fk_ctrls = fk_ctrls[1:]\n\n # create attrs\n attrs = ['upStretch','loStretch']\n for i in reversed(range(len(stretch_jnts)-2)):\n ... | [
"0.6122613",
"0.60881704",
"0.5706191",
"0.5586057",
"0.554519",
"0.55225635",
"0.55225635",
"0.54242057",
"0.54017335",
"0.5394755",
"0.5353252",
"0.52999943",
"0.52834505",
"0.52750146",
"0.524787",
"0.5220676",
"0.5217967",
"0.51952493",
"0.51629597",
"0.5109538",
"0.51004... | 0.66334 | 0 |
Create IK FK Streatch for limbs with more than two bines | def multi_joint_stretch(ik_ctrl, ik_last_node, switch_ctrl, fk_ctrls, jnts, ik_handle):
root_grp = utils.get_parent(jnts[0])
stretch_jnts = jnts[1:]
stretch_fk_ctrls = fk_ctrls[1:]
# create attrs
attrs = ['upStretch','loStretch']
for i in reversed(range(len(stretch_jnts)-2)):
ltr = ''
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def boundary(self):\n answer = self.zero()\n for k, v in self.items():\n for idx, cube in enumerate(k):\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\n for i in range(cube.dimension):\n for epsilon in (0, 1):\n ... | [
"0.5314263",
"0.5311153",
"0.5255831",
"0.5082965",
"0.50570154",
"0.4981262",
"0.49758726",
"0.4932032",
"0.49083376",
"0.49006724",
"0.48869604",
"0.4875669",
"0.4868179",
"0.48634484",
"0.48508698",
"0.48497802",
"0.48386258",
"0.4834771",
"0.48233885",
"0.48123473",
"0.48... | 0.0 | -1 |
Create stratch point constraints on a chain of stretch joints. | def stretch_twist_jnts(start_jnt, end_jnt, twist_jnts):
div = 1.0 / (len(twist_jnts)+1)
for i, joint in enumerate(twist_jnts):
weight = div*(i+1)
mc.pointConstraint(start_jnt, joint, weight=1.0-weight)
mc.pointConstraint(end_jnt, joint, weight=weight) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multi_joint_stretch(ik_ctrl, ik_last_node, switch_ctrl, fk_ctrls, jnts, ik_handle):\n\n root_grp = utils.get_parent(jnts[0])\n stretch_jnts = jnts[1:]\n stretch_fk_ctrls = fk_ctrls[1:]\n\n # create attrs\n attrs = ['upStretch','loStretch']\n for i in reversed(range(len(stretch_jnts)-2)):\n ... | [
"0.60946095",
"0.5763195",
"0.5703657",
"0.5553354",
"0.5487165",
"0.5435914",
"0.53954494",
"0.51878697",
"0.51259",
"0.51116204",
"0.5077191",
"0.5054225",
"0.4999024",
"0.49555075",
"0.49334964",
"0.4926704",
"0.4873679",
"0.48712805",
"0.48634586",
"0.48509604",
"0.484819... | 0.66719025 | 0 |
Duplicate a joint chain. | def duplicate_chain(chain, search='', replace='', suffix=''):
if suffix:
suffix = '_'+suffix
new_jnts = []
for joint in chain:
new_name = joint.replace(search, replace, 1)+suffix
new_jnt = mc.duplicate(joint, po=1, n=new_name)[0]
if new_jnts:
mc.parent(new_jnt,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def skeleton_buildDuplicateChain(self,sourceJoints = None, modifier = 'rig', connectToModule = False, connectAs = 'rigJoints', connectToSource = None, singleMode = False, cgmType = None, indices = [],blockNames=False):\n _str_func = 'skeleton_buildDuplicateChain'\n \n \n if indices:\n log.debug... | [
"0.63030636",
"0.6269034",
"0.60625374",
"0.58090156",
"0.5777003",
"0.57204974",
"0.56585926",
"0.55766195",
"0.5560866",
"0.55120313",
"0.5510162",
"0.54400694",
"0.5433781",
"0.54283494",
"0.5389344",
"0.5383912",
"0.53801215",
"0.53679395",
"0.5365678",
"0.5365056",
"0.53... | 0.6813391 | 0 |
Extract the images into a 4D uint8 numpy array [index, y, x, depth]. | def extract_images(filename,lx):
print('Extracting', filename,'aaaaaa')
data=numpy.loadtxt(filename,dtype='int64')
dim=data.shape[0]
data=data.reshape(dim, lx, lx, 1)
# Convert shape from [num examples, rows, columns, depth]
# to [num examples, rows*columns] (assuming depth == 1)
data ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _images(path):\r\n with gzip.open(path) as f:\r\n # First 16 bytes are magic_number, n_imgs, n_rows, n_cols\r\n pixels = np.frombuffer(f.read(), 'B', offset=16)\r\n return pixels.reshape(-1, 784).astype('float32') / 255",
"def extract_data(filename, num_images):\n print('... | [
"0.6674317",
"0.6536259",
"0.651069",
"0.63781893",
"0.63752973",
"0.63359886",
"0.6284267",
"0.6278434",
"0.6248823",
"0.623316",
"0.6226097",
"0.62114894",
"0.6170373",
"0.61536634",
"0.61412567",
"0.61320215",
"0.61277705",
"0.6126708",
"0.6115631",
"0.61038214",
"0.604964... | 0.6521254 | 2 |
Convert class labels from scalars to onehot vectors. | def dense_to_one_hot(labels_dense, num_classes=10):
num_labels = labels_dense.shape[0]
index_offset = numpy.arange(num_labels) * num_classes
labels_one_hot = numpy.zeros((num_labels, num_classes))
labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
return labels_one_hot | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def one_hot(labels, classes=None):\n return K.utils.to_categorical(labels, classes)",
"def one_hot(labels, classes=None):\n\n one_hot_ = K.utils.to_categorical(labels, classes)\n return(one_hot_)",
"def to_onehot(labels: torch.Tensor, num_classes: int) -> torch.Tensor:\n if len(labels.size()) == 1:... | [
"0.8250402",
"0.807683",
"0.80523187",
"0.7977843",
"0.7908335",
"0.7900327",
"0.7892233",
"0.7869711",
"0.7849721",
"0.7849721",
"0.7826951",
"0.7826122",
"0.77677035",
"0.7765413",
"0.77540547",
"0.77540547",
"0.77540547",
"0.77489346",
"0.7742955",
"0.7737176",
"0.77226317... | 0.76462805 | 33 |
Extract the labels into a 1D uint8 numpy array [index]. | def extract_labels(nlabels,filename, one_hot=False):
print('Extracting', filename,'bbbccicicicicib')
labels=numpy.loadtxt(filename,dtype='int64')
if one_hot:
print("LABELS ONE HOT")
print(labels.shape)
XXX=dense_to_one_hot(labels,nlabels)
print(XXX.shape)
return de... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels_array(self):\n return _build_label_vector_rows(\n [[(label, 1)] for label in self.labels], self.training_labels)[1:].T",
"def array2(self):\r\n profbox(whoami())\r\n # research\r\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\r\n labelnode = slicer.mrml... | [
"0.70427394",
"0.70352",
"0.68724084",
"0.6775525",
"0.67488664",
"0.67066264",
"0.67066264",
"0.66832286",
"0.6675897",
"0.65783316",
"0.657126",
"0.65644187",
"0.65461975",
"0.6527157",
"0.65213823",
"0.651859",
"0.6512153",
"0.65094626",
"0.6494245",
"0.6442707",
"0.642644... | 0.64324766 | 20 |
Copies the folder from the source directory into a docs folder eliminating commercial information. | def oh_folders(src, dest=dest):
copytree(src, dest, ignore=ignore_patterns(*ignore_list), dirs_exist_ok=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_docs():\n local('rsync -av --delete --exclude=.svn %s:%s/ /tmp/djangodocs/' %\n (env.hosts[0], env.deploy_base.child('docbuilds')))",
"def copy_project_docs(srctree):\n docdir = os.path.join(srctree, 'Doc')\n\n # This block shouldn't be here, but I do not yet know how to\n # embed... | [
"0.71197486",
"0.64806306",
"0.61687136",
"0.6106528",
"0.6040729",
"0.599639",
"0.59881204",
"0.59192413",
"0.5918901",
"0.5830127",
"0.5795234",
"0.57863706",
"0.5776979",
"0.57418394",
"0.57132345",
"0.5694525",
"0.5685527",
"0.5615512",
"0.5591277",
"0.5551153",
"0.554456... | 0.0 | -1 |
Remove references to elements in the ignore list. | def edit_summary():
with open("docs/SUMMARY.md", "r") as opened_file:
summary = opened_file.readlines()
with open("docs/SUMMARY.md", "w") as opened_file:
for line in summary:
if not any(ext in line for ext in ignore_list):
opened_file.write(line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_ignore_list(book_list):\n my_ignore_list = ['a','able','about','across','after','all','almost','also',\n 'am','an','and','any','are','as','at','be','because',\n 'been','but','by','can','cannot','could','did','do','does',\n 'for','from','get','g... | [
"0.6355515",
"0.63518995",
"0.62366766",
"0.6146372",
"0.609999",
"0.60373515",
"0.59647715",
"0.58614707",
"0.58380705",
"0.581101",
"0.57721406",
"0.5733889",
"0.56982344",
"0.5688912",
"0.56855273",
"0.5677034",
"0.5676934",
"0.5671325",
"0.5661625",
"0.56558764",
"0.56454... | 0.0 | -1 |
This function loops through directory and updates dates of files in said directory. | def update_date(dest=dest):
for root, _, files in os.walk(dest):
ignore = ["README.md","SUMMARY.md"]
_ = [edit_files(root + "/" + file) for file in files if (file not in ignore and file.endswith(".md"))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_files():\n configuration_settings = get_configuration()\n\n # Need to find all of the files that are stored in the input_files directories in order to start building the\n # reports that will be used to generate the static log files.\n for input_path in configuration_settings.processing.inp... | [
"0.7497474",
"0.65693516",
"0.6360544",
"0.6272613",
"0.62687546",
"0.6217366",
"0.58838624",
"0.58187634",
"0.5807831",
"0.57809776",
"0.57797885",
"0.57654995",
"0.5759113",
"0.57328516",
"0.570991",
"0.56900525",
"0.56631005",
"0.56558955",
"0.5641615",
"0.5629182",
"0.562... | 0.7363431 | 1 |
This function updates date of files passed into it. | def edit_files(i_file):
a_file = open(i_file, "r")
content = a_file.readlines()
content[3] = f"years: {datetime.now().year}\n"
content[4] = f'lastupdated: "{date.today()}"\n'
a_file = open(i_file, "w") #open the same file and overrite line3 & 4
a_file.writelines(content)
a_file.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_date(dest=dest):\n for root, _, files in os.walk(dest):\n ignore = [\"README.md\",\"SUMMARY.md\"]\n _ = [edit_files(root + \"/\" + file) for file in files if (file not in ignore and file.endswith(\".md\"))]",
"def changeDate(names, date, ctlFunc = lambda s, d: True): \n\n # parse ... | [
"0.7073105",
"0.6812823",
"0.66919583",
"0.6668282",
"0.62575287",
"0.6241051",
"0.61830145",
"0.6148155",
"0.59413326",
"0.5930518",
"0.58680063",
"0.5799601",
"0.57853353",
"0.5773595",
"0.5749723",
"0.57237613",
"0.5706964",
"0.57064885",
"0.57048666",
"0.56627303",
"0.566... | 0.6030693 | 8 |
Test combining each center's file errors | def test__combine_center_file_errors(syn):
expected_error = (
f"\t{ENT1.name} ({ENT1.id}):\n\nmy errors\nn\n\n"
f"\t{ENT1.name} ({ENT1.id}):\n\nerrors here\nf\n\n"
)
calls = [
mock.call("syn1234", downloadFile=False),
mock.call("syn2345", downloadFile=False),
]
with p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_single_error_merge(self):\n test_folder = base_path +'/test_data/merging_tests/error_test/'\n output_file = os.path.join(test_folder, \"output1.jpg\")\n\n self.assertRaises(mi.ImageError, lambda: mi.add_background(test_folder+\"dummy.txt\", test_folder+\"background.jpg\", output_file)... | [
"0.6594361",
"0.6371965",
"0.6179928",
"0.617114",
"0.613714",
"0.61048645",
"0.6091394",
"0.6054181",
"0.5993377",
"0.5975022",
"0.5965196",
"0.5943787",
"0.59276956",
"0.5922497",
"0.59199405",
"0.5838658",
"0.58281934",
"0.58267826",
"0.581185",
"0.58048946",
"0.57999486",... | 0.7143594 | 0 |
Test getting all center invalid errors | def test_get_center_invalid_errors(syn):
with patch.object(
syn, "tableQuery", return_value=QueryResponse
) as patch_query, patch.object(
write_invalid_reasons, "_combine_center_file_errors", return_value="errors"
) as patch_combine:
center_invalid = write_invalid_reasons.get_center_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_errors(self) -> None:",
"def storefront_check_errors():\n\n\tcurrentView = uidoc.ActiveView\n\tfamTypeDict = GetFamilyTypeDict(\"Fabrication-Error-Symbol\")\n\n\t# Clear existing error notations\n\terrorNotations = list(GetElementsInView(BuiltInCategory.OST_GenericAnnotation, Autodesk.Revit.DB.FamilyIn... | [
"0.68639857",
"0.65659684",
"0.6317057",
"0.6280998",
"0.624511",
"0.62418723",
"0.6231955",
"0.6174314",
"0.6160829",
"0.6155387",
"0.6125272",
"0.61134624",
"0.6105969",
"0.60783327",
"0.606288",
"0.60506743",
"0.604379",
"0.6016345",
"0.60074997",
"0.6006396",
"0.6003036",... | 0.73111194 | 0 |
Returns the highest magnification for the slide | def highest_mag(slide):
return int(slide.properties['aperio.AppMag']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mag(self):\n return self.photosamplers.get_estimate(mag=True)[0]",
"def get_mag_for_size(slide, size):\n max_size = slide.dimensions\n max_mag = highest_mag(slide)\n downsample = np.average([max_dim/size_dim for max_dim, size_dim in zip(max_size, size)])\n return max_mag/downsample",
"de... | [
"0.7143382",
"0.6984062",
"0.6947595",
"0.6700194",
"0.6502702",
"0.6465279",
"0.6439392",
"0.6389368",
"0.62770873",
"0.62758964",
"0.6203424",
"0.6182897",
"0.6060569",
"0.6010728",
"0.6000861",
"0.59334785",
"0.5931892",
"0.59017086",
"0.5889821",
"0.58670044",
"0.584315",... | 0.8554771 | 0 |
Returns the magnification for each level in a slide | def level_mags(slide):
return [highest_mag(slide)/downsample for downsample in slide.level_downsamples] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_level_mag(slide, level):\n return level_mags(slide)[level]",
"def get_thumbnail_magnification(slide):\n ratio = np.asarray(slide.dimensions) / np.asarray(slide.associated_images[\"thumbnail\"].size)\n # np.sqrt(np.prod(ratio))\n return ratio",
"def get_level_for_mag(slide, mag):\n level... | [
"0.7798809",
"0.6923862",
"0.66853",
"0.65677786",
"0.62147903",
"0.6124908",
"0.61031574",
"0.6090716",
"0.6088541",
"0.58556306",
"0.5820038",
"0.56304854",
"0.5626129",
"0.56065404",
"0.5559378",
"0.54275894",
"0.54266506",
"0.5425498",
"0.53985816",
"0.53818405",
"0.52535... | 0.78430814 | 0 |
Returns the dimensions of a level | def get_level_size(slide, level):
return slide.level_dimensions[level] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dimensions():",
"def getDimensions():",
"def _get_ndim(self):\n return len(self.level_shapes[0])",
"def depth(self):\n return _libsbml.Dimensions_depth(self)",
"def dimensions(self) -> int:\n return pulumi.get(self, \"dimensions\")",
"def get_map_size(level):\n if level < 5:\n... | [
"0.7337827",
"0.7250944",
"0.7064121",
"0.7035364",
"0.6847221",
"0.67899704",
"0.67407316",
"0.6720339",
"0.66824",
"0.66605484",
"0.66371953",
"0.6546749",
"0.6472022",
"0.6469843",
"0.64618737",
"0.6444262",
"0.6423922",
"0.6412058",
"0.6396843",
"0.6379703",
"0.6365779",
... | 0.8075793 | 0 |
Returns the magnification at a particular level | def get_level_mag(slide, level):
return level_mags(slide)[level] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_magnification(self, times):\n if self._model.n_lenses == 2:\n factor = 10.\n params = self._model.parameters\n t_1 = params.t_0 - factor * params.t_E\n t_2 = params.t_0 + factor * params.t_E\n self._model.set_magnification_methods([t_1, '... | [
"0.67559737",
"0.6685309",
"0.66784066",
"0.65893006",
"0.6497956",
"0.62938315",
"0.61198086",
"0.6092812",
"0.6024545",
"0.5632027",
"0.55412483",
"0.5471536",
"0.54661393",
"0.5413815",
"0.5413614",
"0.53920174",
"0.53455603",
"0.5330778",
"0.5330044",
"0.5313709",
"0.5275... | 0.7867714 | 0 |
Get the level corresponding to a certain magnification, if available | def get_level_for_mag(slide, mag):
level_mags_rounded = list(np.round(level_mags(slide), decimals = 2))
if mag in level_mags_rounded:
return level_mags_rounded.index(mag)
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_level_mag(slide, level):\n return level_mags(slide)[level]",
"def getLevel(unique_name):",
"def level_mags(slide):\n return [highest_mag(slide)/downsample for downsample in slide.level_downsamples]",
"def mag(self):\n return self.photosamplers.get_estimate(mag=True)[0]",
"def get_lumin... | [
"0.76260245",
"0.6262649",
"0.62293607",
"0.61587805",
"0.60415137",
"0.6033318",
"0.58130866",
"0.5732402",
"0.57084596",
"0.5647901",
"0.5613819",
"0.5604842",
"0.5599045",
"0.55820286",
"0.5574072",
"0.5559694",
"0.55576396",
"0.555535",
"0.55302167",
"0.5511368",
"0.54941... | 0.7825988 | 0 |
Get the magnification corresponding to an image size at the highest magnification | def get_mag_for_size(slide, size):
max_size = slide.dimensions
max_mag = highest_mag(slide)
downsample = np.average([max_dim/size_dim for max_dim, size_dim in zip(max_size, size)])
return max_mag/downsample | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mag(self):\n return self.photosamplers.get_estimate(mag=True)[0]",
"def highest_mag(slide):\n return int(slide.properties['aperio.AppMag'])",
"def get_size_for_mag(slide, mag):\n max_size = slide.dimensions\n max_mag = highest_mag(slide)\n downsample = max_mag/mag\n return [np.int(np.... | [
"0.7177108",
"0.71568376",
"0.6950366",
"0.67886364",
"0.6724605",
"0.65802383",
"0.62866354",
"0.6198589",
"0.60788",
"0.60172695",
"0.599912",
"0.5912535",
"0.5909752",
"0.5874121",
"0.5848604",
"0.58275664",
"0.5797984",
"0.5797821",
"0.57959604",
"0.57886523",
"0.5763161"... | 0.7147567 | 2 |
Get the image size the highest magnification image would have to be resized to get an equivalent magnification | def get_size_for_mag(slide, mag):
max_size = slide.dimensions
max_mag = highest_mag(slide)
downsample = max_mag/mag
return [np.int(np.round(dim/downsample)) for dim in max_size] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getZoomFactor(imageSize, maxW, maxH):\n\timageW, imageH = imageSize\n\tzoomW = float(imageW) / float(maxW)\n\tzoomH = float(imageH) / float(maxH)\n\treturn max(zoomW, zoomH)",
"def get_image_size(self):",
"def get_thumbnail_magnification(slide):\n ratio = np.asarray(slide.dimensions) / np.asarray(slide.... | [
"0.70223284",
"0.69094974",
"0.6904307",
"0.6871893",
"0.6834652",
"0.67987007",
"0.6753258",
"0.6662533",
"0.6641104",
"0.6629991",
"0.6623062",
"0.66070765",
"0.65710425",
"0.6462559",
"0.6438334",
"0.64352167",
"0.64264476",
"0.6413869",
"0.64073336",
"0.6405353",
"0.63959... | 0.721434 | 0 |
Outputs at Pillow Image for a particular magnification | def read_slide_at_mag(slide, mag):
exact_level = get_level_for_mag(slide, mag)
if exact_level is not None:
return slide.read_region((0,0), exact_level, get_level_size(slide, exact_level))
else:
max_size = slide.dimensions
region_size = tuple(get_size_for_mag(slide, mag))
down... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def large_image(self):\n pass",
"def mag(self):\n return self.photosamplers.get_estimate(mag=True)[0]",
"def _calculate_magnification(self, times):\n if self._model.n_lenses == 2:\n factor = 10.\n params = self._model.parameters\n t_1 = params.t_0 - factor ... | [
"0.60173213",
"0.5782513",
"0.5777427",
"0.5764191",
"0.56933355",
"0.56771076",
"0.56483626",
"0.5612517",
"0.5609735",
"0.56014514",
"0.5599658",
"0.55762804",
"0.55341315",
"0.55226684",
"0.5477635",
"0.5477049",
"0.546813",
"0.54632145",
"0.54585576",
"0.54283446",
"0.538... | 0.0 | -1 |
Generates tiles from whole slide images | def tile_gen_at_mag(wsi, mag, tile_size):
#Get size of WSI at Level 0 (Max Magnification)
x0, y0 = wsi.level_dimensions[0]
#Get size of WSI at the mag we want
x_mag, y_mag = get_size_for_mag(wsi, mag)
x_tiles = int(np.floor(x_mag/tile_size))
y_tiles = int(np.floor(y_mag/tile_size))
#Scale ti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tile_slides(slides_filepaths, desired_tile_with, desired_overlap, desired_magnification):\n containing_folders = []\n for slide_filepath in slides_filepaths:\n containing_folders.append(tile_slide(slide_filepath, desired_tile_with, desired_overlap, desired_magnification))\n return containing_fo... | [
"0.7096497",
"0.7032253",
"0.6989992",
"0.69054127",
"0.6749181",
"0.66839963",
"0.6649588",
"0.65237033",
"0.6499432",
"0.64959127",
"0.6372662",
"0.6356276",
"0.63422674",
"0.63199794",
"0.6305179",
"0.6302457",
"0.62703687",
"0.62687695",
"0.62687695",
"0.62516",
"0.617920... | 0.0 | -1 |
takes a command, telnet session, and a prompt and returns the output of the code | def respond(cmd,t,p):
t.write(cmd)
return wait(t,p) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_telnet_command(command):\n\n tn = telnetlib.Telnet(stb_parameters.STB_IP)\n tn.read_until(bytes(\"login: \", 'UTF-8'))\n tn.write(bytes(stb_parameters.STB_USER_NAME + \"\\n\", 'UTF-8'))\n tn.write(bytes(command + \"\\n\", 'UTF-8'))\n tn.write(bytes(\"exit\\n\", 'UTF-8'))\n result = tn.re... | [
"0.70798624",
"0.7071471",
"0.70600575",
"0.6706458",
"0.6631486",
"0.64974564",
"0.6339306",
"0.62638974",
"0.6244074",
"0.6220981",
"0.60587776",
"0.6056408",
"0.60353273",
"0.5993267",
"0.5937854",
"0.5930016",
"0.59039897",
"0.5903268",
"0.58991635",
"0.5847472",
"0.58356... | 0.56606126 | 28 |
takes a telnet session, and a prompt | def wait(t,p):
output_list = []
c = ''
d = ''
while p not in d:
c = t.read_very_eager()
if len(c) > 0:
d += c
print c
output_list.append(c)
if "Press any key to continue" in c or "--More--" in c:
t.write(" ")
output_list = ((''.join(output_list)).replace('\r\n','\n')).split('\n')
return output_l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def telnet_run(self, cmd_list, prompt_usr='Username:', prompt_pwd='Password:', prompt_ena='>',\n prompt_conf=']', timeout=2, LOGIN_LOG=0):\n prompt_usr = prompt_usr.encode(\"ascii\")\n prompt_pwd = prompt_pwd.encode(\"ascii\")\n prompt_ena = prompt_ena.encode(\"ascii\")\n ... | [
"0.7024742",
"0.67167115",
"0.6706943",
"0.65913546",
"0.65091944",
"0.645665",
"0.62801105",
"0.6189571",
"0.61475736",
"0.61325663",
"0.60985357",
"0.6096203",
"0.6044156",
"0.60315806",
"0.60073096",
"0.5959323",
"0.5922411",
"0.5920338",
"0.5898053",
"0.58856004",
"0.5876... | 0.0 | -1 |
Python function for importing the MNIST data set. It returns an iterator of 2tuples with the first element being the label and the second element being a numpy.uint8 2D array of pixel data for the given image. | def read(dataset = "training", path = "."):
if dataset is "training":
fname_img = os.path.join(path, 'train-images-idx3-ubyte')
fname_lbl = os.path.join(path, 'train-labels-idx1-ubyte')
elif dataset is "testing":
fname_img = os.path.join(path, 't10k-images-idx3-ubyte')
fname_lbl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readmnist(dataset = \"training\", path = \".\"):\n\n if dataset is \"training\":\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\n elif dataset is \"testing\":\n fname_img = os.path.join(path, 't10k-images.idx3-u... | [
"0.7315804",
"0.7006713",
"0.6858111",
"0.679963",
"0.67536896",
"0.66597587",
"0.6541016",
"0.6534925",
"0.64882743",
"0.6464874",
"0.64425945",
"0.6425871",
"0.6410244",
"0.63993555",
"0.63947785",
"0.63876855",
"0.6385198",
"0.638357",
"0.63787776",
"0.6377489",
"0.6373172... | 0.6018545 | 67 |
Render a given numpy.uint8 2D array of pixel data. | def show(image):
from matplotlib import pyplot
import matplotlib as mpl
fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
imgplot = ax.imshow(image, cmap=mpl.cm.Greys)
imgplot.set_interpolation('nearest')
ax.xaxis.set_ticks_position('top')
ax.yaxis.set_ticks_position('left')
pyplot.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_pixel_array(arr, figsize=(10, 10)):\n arr = arr.squeeze()\n plt.figure(figsize=figsize)\n plt.imshow(arr, cmap=plt.cm.bone)\n plt.show()",
"def render(self):\n np_img = np.array(self.prev_img, dtype=np.uint8)\n np_img = np.swapaxes(np_img, 0, 2)\n return np_img",
"def ... | [
"0.6824776",
"0.6289643",
"0.5894268",
"0.5886476",
"0.58250576",
"0.5715473",
"0.570549",
"0.5702945",
"0.5690092",
"0.56785333",
"0.567429",
"0.56699634",
"0.56405544",
"0.5639835",
"0.5638185",
"0.562523",
"0.56111133",
"0.5560625",
"0.5559693",
"0.5551056",
"0.55414987",
... | 0.0 | -1 |
Adds 5 latest blog posts as `latest_articles`, 5 latest comments as `latest_comments`, and all tags (annotated with `num_articles` field) as `tags` to the context, regardless of `request`. | def latest_content(request):
latest_articles = Article.published_articles()[:5]
latest_comments = Comment.objects.all().order_by('-pub_date')[:5]
tags = Tag.objects.annotate(num_articles=Count('article')).order_by(
'-num_articles')
contributors = Contributor.objects.annotate(
num_article... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def latest_blog_posts(self, request, *args, **kwargs):\n context = self.get_context(request, *args, **kwargs)\n context[\"latest_posts\"] = MyblogDetailPage.objects.live().public()[:1] \n return render(request, \"myblog/latest_posts.html\", context)",
"def last_five(request):\n fla... | [
"0.6630519",
"0.6064325",
"0.5982739",
"0.5916848",
"0.58361304",
"0.5788325",
"0.57815117",
"0.5755909",
"0.57152796",
"0.56332666",
"0.56171244",
"0.5601291",
"0.5582968",
"0.54634035",
"0.5452473",
"0.53599924",
"0.5354808",
"0.5313329",
"0.52591276",
"0.522024",
"0.521882... | 0.67686737 | 0 |
Format a Roku Channel name. | def format_channel_name(channel_number: str, channel_name: str | None = None) -> str:
if channel_name is not None and channel_name != "":
return f"{channel_name} ({channel_number})"
return channel_number | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def channel_name(radio_id: int, channel_id: int) -> str:\n return f\"COMM{radio_id} Ch {channel_id}\"",
"def channelName(self):\n channel_list = (\"Neutral\",\n \"BBC1\",\n \"BBC2\",\n \"ITV\",\n \"Channel 4... | [
"0.78294134",
"0.7059564",
"0.6983384",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
"0.68293834",
... | 0.7868498 | 1 |
Input filepath of financial data csv dump compile all the information into one dataframe return dataframe containing Adjusted price values of each security listed in directory | def compile_index_data(data_filepath,index_name):
# find existing .pickle file
filename = [_ for _ in glob.glob('*.pickle') if index_name in _ ][0].split('.')[0] + '_adj_close.csv'
# with open(pickle_list[0],'rb') as f:
# tickers = pickle.load(f)
tickers = os.listdir(data_filepath)
os.chdir(data_filepath)
# r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_df(self, file_path):\n df = pd.read_csv(file_path, sep=\";\")\n df.rename(columns={\"Get\": \"Currency\"}, inplace=True)\n df = df[df[\"Pay\"] == \"Chaos Orb\"]\n df = df[[\"League\", \"Date\", \"Currency\", \"Value\"]]\n df[\"Date\"] = pd.to_datetime(df[\"Date\"])\n ... | [
"0.65828145",
"0.62339157",
"0.6199246",
"0.6138019",
"0.61140287",
"0.6102608",
"0.6034207",
"0.6006899",
"0.59451014",
"0.5918473",
"0.5865274",
"0.5854998",
"0.58193326",
"0.58130115",
"0.57813156",
"0.5780981",
"0.57623285",
"0.5745247",
"0.5731047",
"0.57274765",
"0.5706... | 0.5412425 | 58 |
pricing data converted into percentage change to normalize data percentage change will be considered as features labels will be either buy, sell or hold. if each week, the company's increasing by 2% = buy if decreasing by 2% = sell, if neither, hold. Each model is made on a percompany basis, but each company is going t... | def process_data_for_labels(df, ticker, time_period):
data_ = df.fillna(0)
# ensuring NaN values are replaced by 0 incase data doesn't exist.
# Avoiding inplace as it does not convert NaNs as expected, and will return None
tickers = df.columns.values.tolist()
# grab all adj close values of security
for i in rang... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def percent_changes(self):\n\n # close_t = float(val[\"klines\"][\"1m\"].get(self.mw.cfg_manager.pair, {})[-5][4])\n klines_data = self.mw.klines.get(\"1m\")\n coin_data = klines_data.get(self.mw.cfg_manager.pair)\n\n if isinstance(coin_data, list):\n close_5m = float(self.mw... | [
"0.5864486",
"0.5679427",
"0.55887026",
"0.55827385",
"0.5496743",
"0.5447927",
"0.5396345",
"0.5391044",
"0.5382922",
"0.5358451",
"0.53466296",
"0.53371716",
"0.52985895",
"0.528991",
"0.52696675",
"0.52553165",
"0.5239735",
"0.5239484",
"0.5230781",
"0.5222127",
"0.522195"... | 0.5120163 | 33 |
Returns an instance of fetcher | def initialize() -> fetcher.Fetcher:
options = fetcher.Input(
command="some_cmd", config_file="looker.ini", section="Looker"
)
return fetcher.Fetcher(options) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fetcher(self):\n return self.__fetcher",
"def fetch(self) -> Fetch:\n return self._fetch",
"def get_fetcher(\n launcher_url: str, output_dir: str, spec: Optional[str] = None\n) -> WorkflowFetcherBase:\n parsed_url = ParsedUrl(launcher_url)\n\n if parsed_url.scheme not in FETCHER_... | [
"0.7616966",
"0.64553005",
"0.6100894",
"0.6082667",
"0.59977883",
"0.5952911",
"0.58968616",
"0.58818334",
"0.5799498",
"0.5791189",
"0.5787772",
"0.57814115",
"0.57779944",
"0.577231",
"0.57723045",
"0.5654948",
"0.56429166",
"0.56370324",
"0.56276923",
"0.56252486",
"0.561... | 0.6439661 | 2 |
fetcher.get_projects() should return a list of projects. | def test_get_projects_returns_projects(fc: fetcher.Fetcher):
projects = fc.get_projects()
assert isinstance(projects, list)
assert isinstance(projects[0], models.Project) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_projects(self):\n projects = []\n page = 1\n while not len(projects) % 100:\n projects += self._get('/projects?{0}'.format(urllib.urlencode({'per_page': 100, 'page': page})))\n if not projects:\n break\n page += 1\n return projects... | [
"0.8439259",
"0.8330137",
"0.81635183",
"0.790544",
"0.7656669",
"0.7634909",
"0.7559611",
"0.7557729",
"0.7551785",
"0.7523433",
"0.7494402",
"0.7446309",
"0.74364996",
"0.7427242",
"0.73962003",
"0.7385047",
"0.73531884",
"0.7350818",
"0.73503566",
"0.7344059",
"0.7321423",... | 0.862502 | 0 |
fetchet.get_projects() should be able to filter on project. | def test_get_projects_filters(fc: fetcher.Fetcher, test_project_name):
projects = fc.get_projects(test_project_name)
assert isinstance(projects, list)
assert len(projects) == 1
assert projects[0].name == test_project_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_projects(self):\n pass",
"def test_list_project_request(self):\n pass",
"def test_list_projects(self):\n pass",
"def test_list_projects(self):\n pass",
"def test_get_projects_returns_projects(fc: fetcher.Fetcher):\n projects = fc.get_projects()\n assert isinst... | [
"0.740072",
"0.7351347",
"0.7287984",
"0.7287984",
"0.72771144",
"0.72143286",
"0.7165112",
"0.71590155",
"0.7144451",
"0.7075294",
"0.7046728",
"0.7021743",
"0.70181876",
"0.69926757",
"0.698769",
"0.6950364",
"0.6894256",
"0.68472075",
"0.6795028",
"0.67938405",
"0.6792199"... | 0.829477 | 0 |
fetchet.get_projects() should error if filter is invalid | def test_get_projects_throws_if_project_does_not_exist(fc: fetcher.Fetcher):
with pytest.raises(exceptions.NotFoundError) as exc:
fc.get_projects("BadProject")
assert "An error occured while getting projects." in str(exc.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_projects_filters(fc: fetcher.Fetcher, test_project_name):\n projects = fc.get_projects(test_project_name)\n assert isinstance(projects, list)\n assert len(projects) == 1\n assert projects[0].name == test_project_name",
"def _get_filtered_projects(filters):\n projects_itr = (projects_l... | [
"0.8058686",
"0.71893626",
"0.70169073",
"0.6866926",
"0.6799763",
"0.67065436",
"0.66316026",
"0.66316026",
"0.6614815",
"0.66046983",
"0.65524906",
"0.6446057",
"0.64291626",
"0.6345218",
"0.63182366",
"0.6217229",
"0.6167629",
"0.616253",
"0.6144264",
"0.612364",
"0.611247... | 0.59895086 | 24 |
fetcher.get_models() should return a list of models. | def test_get_models_returns_models(fc: fetcher.Fetcher):
ml = fc.get_models()
assert isinstance(ml, list)
assert isinstance(ml[0], models.LookmlModel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_models(self, req, is_detail):\n context = req.environ['meteos.context']\n\n search_opts = {}\n search_opts.update(req.GET)\n\n # Remove keys that are not related to model attrs\n search_opts.pop('limit', None)\n search_opts.pop('offset', None)\n sort_key = ... | [
"0.7452906",
"0.72231185",
"0.7150281",
"0.71438277",
"0.70214987",
"0.69560665",
"0.69169444",
"0.6905092",
"0.68741965",
"0.6871369",
"0.6853938",
"0.6839921",
"0.67970765",
"0.67815137",
"0.6671083",
"0.66492426",
"0.6614827",
"0.65691483",
"0.6551473",
"0.64561534",
"0.64... | 0.769774 | 0 |
fetcher.get_models() should be able to filter on project or model. | def test_get_models_filters(fc: fetcher.Fetcher, test_project_name, test_model):
ml = fc.get_models(project=test_project_name)
assert all(m.project_name == test_project_name for m in ml)
ml = fc.get_models(model=test_model["name"])
assert all(m.name == test_model["name"] for m in ml)
ml = fc.get_m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_models(self, req, is_detail):\n context = req.environ['meteos.context']\n\n search_opts = {}\n search_opts.update(req.GET)\n\n # Remove keys that are not related to model attrs\n search_opts.pop('limit', None)\n search_opts.pop('offset', None)\n sort_key = ... | [
"0.72766924",
"0.66285986",
"0.6556921",
"0.6551836",
"0.6296319",
"0.626473",
"0.6252031",
"0.61985433",
"0.61647654",
"0.61226976",
"0.61226976",
"0.607028",
"0.60465264",
"0.6035401",
"0.60337895",
"0.59634507",
"0.5959686",
"0.5941662",
"0.5922241",
"0.59054995",
"0.58814... | 0.75294465 | 0 |
fetcher.get_models() should throw if a model is not found. | def test_get_models_throws_if_model_does_not_exist(fc: fetcher.Fetcher, project, model):
with pytest.raises(exceptions.NotFoundError) as exc:
fc.get_models(project=project, model=model)
assert "An error occured while getting models." in str(exc.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_models_returns_models(fc: fetcher.Fetcher):\n ml = fc.get_models()\n assert isinstance(ml, list)\n assert isinstance(ml[0], models.LookmlModel)",
"def get_models(self, app_name):\n try:\n models = list(apps.get_app_config(app_name).get_models())\n return models\... | [
"0.7327567",
"0.69435924",
"0.67743224",
"0.67731684",
"0.666128",
"0.66390353",
"0.6595562",
"0.6590047",
"0.64084816",
"0.6316313",
"0.6267025",
"0.62651926",
"0.626041",
"0.6233475",
"0.6200443",
"0.61957514",
"0.61935633",
"0.61921066",
"0.61672646",
"0.61589247",
"0.6154... | 0.75194955 | 0 |
fetcher.get_models() should throw if a model is not found. | def test_get_models_throws_if_project_does_not_exist(
fc: fetcher.Fetcher, project, model
):
with pytest.raises(exceptions.NotFoundError) as exc:
fc.get_models(project=project, model=model)
assert "An error occured while getting projects." in str(exc.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_models_throws_if_model_does_not_exist(fc: fetcher.Fetcher, project, model):\n with pytest.raises(exceptions.NotFoundError) as exc:\n fc.get_models(project=project, model=model)\n assert \"An error occured while getting models.\" in str(exc.value)",
"def test_get_models_returns_models(fc... | [
"0.75194955",
"0.7327567",
"0.69435924",
"0.67743224",
"0.67731684",
"0.66390353",
"0.6595562",
"0.6590047",
"0.64084816",
"0.6316313",
"0.6267025",
"0.62651926",
"0.626041",
"0.6233475",
"0.6200443",
"0.61957514",
"0.61935633",
"0.61921066",
"0.61672646",
"0.61589247",
"0.61... | 0.666128 | 5 |
fetcher.get_used_models() should return models that have queries against them. | def test_get_used_models(fc: fetcher.Fetcher, test_model):
used_models = fc.get_used_models()
assert isinstance(used_models, dict)
assert len(used_models) > 0
assert all(type(model_name) == str for model_name in used_models.keys())
assert all(type(query_count) == int for query_count in used_models.v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def availablemodels(self):\n return self.__models.keys()",
"def _get_models(self, req, is_detail):\n context = req.environ['meteos.context']\n\n search_opts = {}\n search_opts.update(req.GET)\n\n # Remove keys that are not related to model attrs\n search_opts.pop('limit'... | [
"0.70178705",
"0.66382486",
"0.6534866",
"0.631813",
"0.63044095",
"0.6285215",
"0.61792207",
"0.6041896",
"0.60361505",
"0.6007675",
"0.592958",
"0.5920479",
"0.58479476",
"0.5833444",
"0.58288264",
"0.5817674",
"0.58034897",
"0.58034897",
"0.58034897",
"0.58034897",
"0.5747... | 0.7987806 | 0 |
fetcher.get_explores() should return a list of explores. | def test_get_explores(fc: fetcher.Fetcher):
explores = fc.get_explores()
assert isinstance(explores, list)
assert len(explores) > 0
assert isinstance(explores[0], models.LookmlModelExplore) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explores_filters(fc: fetcher.Fetcher):\n explores = fc.get_explores(model=\"henry_dusty\")\n assert all(e.model_name == \"henry_dusty\" for e in explores)\n\n explores = fc.get_explores(model=\"henry_qa\", explore=\"explore_2_joins_all_used\")\n assert all(\n e.model_name == \"henry... | [
"0.6731509",
"0.6563917",
"0.6551571",
"0.63968503",
"0.63752097",
"0.5857632",
"0.57382774",
"0.5567012",
"0.54315007",
"0.54032236",
"0.5390805",
"0.53766435",
"0.52719086",
"0.52510387",
"0.52280146",
"0.52221656",
"0.5203557",
"0.5185477",
"0.5180662",
"0.5156471",
"0.514... | 0.7531671 | 0 |
fetcher.get_explores() should be able to filter on model and/or explore. | def test_get_explores_filters(fc: fetcher.Fetcher):
explores = fc.get_explores(model="henry_dusty")
assert all(e.model_name == "henry_dusty" for e in explores)
explores = fc.get_explores(model="henry_qa", explore="explore_2_joins_all_used")
assert all(
e.model_name == "henry_qa" and e.name == "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explores(fc: fetcher.Fetcher):\n explores = fc.get_explores()\n assert isinstance(explores, list)\n assert len(explores) > 0\n assert isinstance(explores[0], models.LookmlModelExplore)",
"def test_get_used_explores(fc: fetcher.Fetcher, test_model, test_used_explore_names):\n used_expl... | [
"0.753411",
"0.6666877",
"0.6630365",
"0.63271785",
"0.6167889",
"0.5833313",
"0.55136293",
"0.53865874",
"0.53228235",
"0.53056663",
"0.5212486",
"0.51720136",
"0.51571435",
"0.5055647",
"0.50480455",
"0.50150645",
"0.49779034",
"0.49160555",
"0.49039322",
"0.4895284",
"0.48... | 0.822642 | 0 |
fetcher.get_explores() should throw if an explore/model is not found. | def test_get_explores_throws_if_model_or_explore_does_not_exist(
fc: fetcher.Fetcher, model: Optional[str], explore: Optional[str], msg: str
):
with pytest.raises(exceptions.NotFoundError) as exc:
fc.get_explores(model=model, explore=explore)
assert msg in str(exc.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explores(fc: fetcher.Fetcher):\n explores = fc.get_explores()\n assert isinstance(explores, list)\n assert len(explores) > 0\n assert isinstance(explores[0], models.LookmlModelExplore)",
"def test_get_explores_filters(fc: fetcher.Fetcher):\n explores = fc.get_explores(model=\"henry_du... | [
"0.79972434",
"0.6808644",
"0.64591634",
"0.6081574",
"0.6081095",
"0.6056974",
"0.5249449",
"0.5153191",
"0.5144307",
"0.5057118",
"0.49663934",
"0.49415502",
"0.4938596",
"0.49360746",
"0.49263144",
"0.4916875",
"0.49087682",
"0.48916966",
"0.48450214",
"0.4824901",
"0.4805... | 0.73947066 | 1 |
fetcher.get_used_explores() should return all used explores. | def test_get_used_explores(fc: fetcher.Fetcher, test_model, test_used_explore_names):
used_explores = fc.get_used_explores(model=test_model["name"])
assert isinstance(used_explores, dict)
assert all(e in test_used_explore_names for e in used_explores) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_unused_explores(fc: fetcher.Fetcher, test_model, test_unused_explores):\n unused_explores = fc.get_unused_explores(model=test_model[\"name\"])\n assert all(e in test_unused_explores for e in unused_explores)",
"def test_get_explores_filters(fc: fetcher.Fetcher):\n explores = fc.get_explores... | [
"0.7264244",
"0.6198452",
"0.6186663",
"0.59214425",
"0.5807355",
"0.5651149",
"0.56107587",
"0.5609498",
"0.5529075",
"0.5527514",
"0.5387147",
"0.5349075",
"0.52784765",
"0.52772737",
"0.5273169",
"0.5267631",
"0.52531534",
"0.52378064",
"0.52269423",
"0.5195598",
"0.515275... | 0.7800213 | 0 |
fetcher.get_unused_explores() should return all unused explores. | def test_get_unused_explores(fc: fetcher.Fetcher, test_model, test_unused_explores):
unused_explores = fc.get_unused_explores(model=test_model["name"])
assert all(e in test_unused_explores for e in unused_explores) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_used_explores(fc: fetcher.Fetcher, test_model, test_used_explore_names):\n used_explores = fc.get_used_explores(model=test_model[\"name\"])\n assert isinstance(used_explores, dict)\n assert all(e in test_used_explore_names for e in used_explores)",
"def exploits(self):\n return self.... | [
"0.6674417",
"0.5879174",
"0.573975",
"0.5573522",
"0.5512234",
"0.5511594",
"0.54789424",
"0.5453956",
"0.54249877",
"0.5305752",
"0.52119917",
"0.5211895",
"0.5186949",
"0.5154393",
"0.5097592",
"0.50868165",
"0.50696427",
"0.4995546",
"0.49941427",
"0.49911252",
"0.4978347... | 0.7982038 | 0 |
fetcher.get_explore_fields() should return an explores fields. | def test_get_explore_fields_gets_fields(
fc: fetcher.Fetcher, test_model, test_explores_stats
):
test_explore = test_explores_stats[0]
explore = fc.get_explores(model=test_model["name"], explore=test_explore["name"])
assert isinstance(explore, list)
explore = explore[0]
assert isinstance(explore... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explore_fields_gets_fields_for_dimension_or_measure_only_explores(\n fc: fetcher.Fetcher, test_model, test_dimensions_or_measures_only_explores\n):\n expected = test_dimensions_or_measures_only_explores[0]\n explore = fc.get_explores(model=test_model[\"name\"], explore=expected[\"name\"])\n ... | [
"0.7630596",
"0.71610755",
"0.619276",
"0.5935856",
"0.5886932",
"0.56719977",
"0.56685346",
"0.56128865",
"0.5601622",
"0.55978966",
"0.55809444",
"0.5578002",
"0.55722994",
"0.54728",
"0.5469623",
"0.5441008",
"0.543378",
"0.5390191",
"0.5388459",
"0.5369778",
"0.5361909",
... | 0.8270363 | 0 |
fetcher.get_explore_fields() should return when an explore has only dimensions or only measures. | def test_get_explore_fields_gets_fields_for_dimension_or_measure_only_explores(
fc: fetcher.Fetcher, test_model, test_dimensions_or_measures_only_explores
):
expected = test_dimensions_or_measures_only_explores[0]
explore = fc.get_explores(model=test_model["name"], explore=expected["name"])
assert isins... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explore_fields_gets_fields(\n fc: fetcher.Fetcher, test_model, test_explores_stats\n):\n test_explore = test_explores_stats[0]\n explore = fc.get_explores(model=test_model[\"name\"], explore=test_explore[\"name\"])\n assert isinstance(explore, list)\n explore = explore[0]\n assert is... | [
"0.79898906",
"0.7255912",
"0.57427955",
"0.5689888",
"0.5485005",
"0.544207",
"0.5428259",
"0.54008704",
"0.5328612",
"0.52564484",
"0.5198791",
"0.5090246",
"0.5081006",
"0.5072066",
"0.50549966",
"0.5046278",
"0.49843732",
"0.49804208",
"0.49604252",
"0.49604252",
"0.49590... | 0.81051433 | 0 |
fetcher.get_explore_field_stats() should get the stats of all fields in an explore. | def test_get_explore_field_stats(
fc: fetcher.Fetcher,
looker_sdk: methods.Looker40SDK,
test_model,
test_used_explore_names,
test_explores_stats,
):
explore = fc.get_explores(
model=test_model["name"], explore=test_used_explore_names[0]
)[0]
actual_stats = fc.get_explore_field_st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_explore_fields_gets_fields(\n fc: fetcher.Fetcher, test_model, test_explores_stats\n):\n test_explore = test_explores_stats[0]\n explore = fc.get_explores(model=test_model[\"name\"], explore=test_explore[\"name\"])\n assert isinstance(explore, list)\n explore = explore[0]\n assert is... | [
"0.757388",
"0.66561705",
"0.5693254",
"0.5563461",
"0.5562313",
"0.55102324",
"0.55069894",
"0.54181457",
"0.5415948",
"0.53354806",
"0.53127414",
"0.528702",
"0.5241747",
"0.52340806",
"0.52330387",
"0.52114326",
"0.51936793",
"0.5185652",
"0.51400167",
"0.5138318",
"0.5132... | 0.7587318 | 0 |
fetcher.get_explore_join_stats() should return the stats of all joins in an explore. | def test_get_explore_join_stats(fc: fetcher.Fetcher, test_model):
explore = fc.get_explores(
model=test_model["name"], explore="explore_2_joins_1_used"
)[0]
field_stats = {
"explore_2_joins_1_used.d1": 10,
"explore_2_joins_1_used.d2": 5,
"explore_2_joins_1_used.d3": 0,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_join_info(node):\n operator_info = node['operatorInfo']\n analyze_info = node['AnalyzeInfo']\n\n if 'Join' in node['id']:\n # Join Node\n join_type = extract_join_type(operator_info)\n conditions = extract_join_conditions(operator_info)\n current_node = JoinPlan(joi... | [
"0.5480241",
"0.53656536",
"0.50666654",
"0.5061134",
"0.49818888",
"0.4904676",
"0.48338452",
"0.48054832",
"0.47597033",
"0.47334749",
"0.4718956",
"0.47070545",
"0.46772164",
"0.46477938",
"0.46049055",
"0.45803955",
"0.45192826",
"0.44968593",
"0.44656146",
"0.44228086",
... | 0.83031076 | 0 |
This is the main function. | def main(argv):
parser = OptionParser()
parser.add_option(
"--output-dir",
help="Output directory for generated files. Defaults to chromium root "
"directory.")
parser.add_option(
"-v", "--verbose", action="store_true", help="Verbose logging output.")
parser.add_option(
"-c", "--ch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main(... | [
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"0.9125712",
"... | 0.0 | -1 |
Compute Haversine distance between points. LatLongDistance(p1, p2) returns distance in meters between points p1 and p2. A point p is a list/array p=[longitude, latitude] | def latlong_distance(p1, p2):
radius = 6371 # km
lat1 = p1[1] * math.pi / 180.0
lat2 = p2[1] * math.pi / 180.0
lon1 = p1[0] * math.pi / 180.0
lon2 = p2[0] * math.pi / 180.0
deltaLat = lat2 - lat1
deltaLon = lon2 - lon1
a = (math.sin(deltaLat / 2)**2
+ math.cos(lat1) * math.co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def haversine(point_1, \n point_2):\n # Specify the radius of the Earth in kilometers\n earth_radius = 6372.8\n # Extract latitudes and longitudes from the provided points\n latitude_1 = point_1[0]\n latitude_2 = point_2[0]\n longitude_1 = point_1[1]\n longitude_2 = point_2[1]\n ... | [
"0.7411768",
"0.7283244",
"0.7281911",
"0.7275467",
"0.7160516",
"0.7140681",
"0.71359766",
"0.706824",
"0.7068029",
"0.7050806",
"0.70261496",
"0.70184296",
"0.69995123",
"0.6997063",
"0.69919103",
"0.6987301",
"0.69823533",
"0.69742984",
"0.6964179",
"0.6947977",
"0.6935867... | 0.71147573 | 7 |
Normalize audio file to range [1, 1] | def normalize(audio):
norm = audio/max(audio)
return norm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(filename,wout=True):\n n, data, data_dB,sr,ch=inputwav(filename)\n if ch==1:\n diff=0-max(data_dB)\n if ch==2:\n d1=0-max(data_dB[:,0])\n d2=0-max(data_dB[:,1])\n diff=max(d1,d2)\n print('Adding '+str(diff)+' dB...')\n data_dB_norm=data_dB+diff\n data_nor... | [
"0.6990606",
"0.69585127",
"0.6922056",
"0.6835355",
"0.6835355",
"0.66305023",
"0.64685136",
"0.64316094",
"0.6400724",
"0.6398994",
"0.63599336",
"0.6334538",
"0.63280183",
"0.62815994",
"0.62611055",
"0.62473464",
"0.6237534",
"0.6221386",
"0.6176301",
"0.6140515",
"0.6132... | 0.78221744 | 0 |
Load an audio file and divide into 10 second segments. | def segment_10s(audio, sr):
seg_files = {}
n_seg = int((len(audio)/sr)/10)
for i in range(n_seg):
segment = audio[10*i*sr:(i+1)*10*sr]
seg_files[i] = segment
return seg_files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, secs, path, concat=True):\n audio = np.empty((1,))\n secs_loaded = 0\n files_loaded = 0\n files = glob.glob(path + \"*.wav\")\n for file in files:\n (sr, samples) = wavfile.read(file)\n audio = np.concatenate((audio, samples))\n\n ... | [
"0.64271533",
"0.6278708",
"0.6274508",
"0.6185571",
"0.60926473",
"0.6001208",
"0.59411097",
"0.59162825",
"0.59099066",
"0.5908874",
"0.58851975",
"0.58825463",
"0.58139896",
"0.5805803",
"0.5801357",
"0.57745636",
"0.57619977",
"0.5760922",
"0.5745996",
"0.56929225",
"0.56... | 0.62473094 | 3 |
Load an audio file and segment into 10s increments Save each segment to the target directory. Append the gender of the speaker and the segment index to the filename. | def segment_audio(filename, y_value, split='train', clf='gender'):
filepath = 'recordings/recordings/' + filename + '.mp3'
audio, sr = librosa.load(filepath, sr=16000)
audio = normalize(audio)
# Add gender label to filename for later processing
sex = y_value
if sex == 'female':
filenam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def file_generator(files: list,\n segment_duration: float,\n sampleRate: int,\n db_thr: float or None = None,\n frame_length: int = 512,\n hop_length: int = 128,\n ) -> None:\n\n I = 0\n J = 0\n\n s... | [
"0.5985446",
"0.5802684",
"0.57816744",
"0.5737059",
"0.5693634",
"0.5681921",
"0.55937463",
"0.5582633",
"0.5564124",
"0.55507296",
"0.55322385",
"0.5512459",
"0.55056393",
"0.5496371",
"0.54751974",
"0.5456971",
"0.5410829",
"0.5401392",
"0.53417194",
"0.5321298",
"0.531510... | 0.70655805 | 0 |
Load an audio file (or segment). Add random noise to the file and save with new filename. | def noisy_data(filename, split='train', clf='gender'):
filepath = 'data/{}/{}/{}o.wav'.format(clf, split, filename)
audio, sr = librosa.load(filepath, sr=16000)
# Add noise
noisy = add_noise(audio)
# Write noise to file
sf.write('data/{}/{}/{}n.wav'.format(clf, split, filename), noisy, sr)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_audio(file_path):\n # load the audio file in its original sampling rate\n audio_data, sr = librosa.load(file_path, sr=sampling_rate)\n\n # get the common file name\n file_name = file_path.split(\"/\")[-1]\n file_name = file_name.split(\".wav\")[0]\n\n # calculate number of samples in the... | [
"0.62971425",
"0.6159043",
"0.5984587",
"0.59020734",
"0.58086365",
"0.5675305",
"0.56475496",
"0.5606833",
"0.559785",
"0.5565294",
"0.54593736",
"0.54581594",
"0.5443855",
"0.5441127",
"0.54234785",
"0.542045",
"0.5408668",
"0.53995633",
"0.53893155",
"0.5381253",
"0.537922... | 0.689111 | 0 |
Upload a file to S3 or move to another directory. INPUT_DIR is the name of the directory with parquets. DETECTIONS_DIR can be a | def upload_file(
input_dir,
output_dir,
partition,
node_id,
job_id,
pattern,
file_format
):
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s.%(funcName)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
logging.info(f"Job: ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload_data(dir, input_dir, s3_dir):\n config = _read_config(dir)\n sage_maker_client = sagemaker.SageMakerClient(config.aws_profile, config.aws_region)\n\n return sage_maker_client.upload_data(input_dir, s3_dir)",
"def upload_file_to_s3(bucket_name, input_filepath, output_filename):\n s3 = boto3... | [
"0.6746442",
"0.6491204",
"0.63522506",
"0.6235617",
"0.6157146",
"0.61324275",
"0.6127183",
"0.6115192",
"0.61045253",
"0.6098759",
"0.60934263",
"0.6089703",
"0.60668164",
"0.60577595",
"0.5977721",
"0.5973843",
"0.59473646",
"0.5942112",
"0.5934158",
"0.5906467",
"0.590605... | 0.0 | -1 |
Get the state of the fsm | def get_state(self, node_uuid, index):
return self.state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetState(self):\r\n \r\n return self.state",
"def getState():\n # TODO: this isn't nearly as meaningful as it used to be",
"def getState(self):\r\n return self._get_SS_State()#self.currentState\r",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\... | [
"0.77134407",
"0.76589096",
"0.76107895",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
"0.7550614",
... | 0.0 | -1 |
Get a lock on the bus | def bus_acquire(self, blocking=True):
if self._bus_lock.acquire(blocking):
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lock(name):\n return _handler_locks[name]",
"def get_lock():\n\n return multiprocessing.Lock()",
"def get_lock(self, name, try_=False):\n lock = Lock(self, name, try_)\n with lock as got_lock:\n yield got_lock",
"def get_lock(self):\n function_string = 'IFLOC... | [
"0.7457342",
"0.7200968",
"0.7150414",
"0.71146137",
"0.6958682",
"0.6892568",
"0.6885043",
"0.6851491",
"0.67310303",
"0.6696432",
"0.66290563",
"0.66086996",
"0.6608197",
"0.66038275",
"0.65713847",
"0.6433796",
"0.6428536",
"0.6421543",
"0.6370052",
"0.63416463",
"0.633213... | 0.569449 | 69 |
Release a lock on the bus | def bus_release(self):
self._bus_lock.release() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def release_lock():\r\n get_lock.n_lock -= 1\r\n assert get_lock.n_lock >= 0\r\n # Only really release lock once all lock requests have ended.\r\n if get_lock.lock_is_enabled and get_lock.n_lock == 0:\r\n get_lock.start_time = None\r\n get_lock.unlocker.unlock()",
"def release_lock(self... | [
"0.7924762",
"0.7834396",
"0.77969474",
"0.77904904",
"0.74435604",
"0.74268526",
"0.73679256",
"0.7322436",
"0.7123128",
"0.7118452",
"0.71132535",
"0.709967",
"0.7089947",
"0.70288163",
"0.7005624",
"0.699237",
"0.6928809",
"0.6910996",
"0.6896251",
"0.687286",
"0.6866911",... | 0.8140664 | 0 |
Get status of the lock | def bus_locked(self):
return self._bus_lock.locked() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lock_status(self) -> Dict[str, str]:\n self.__logger.debug('Eva.lock_status called')\n return self.__http_client.lock_status()",
"def getstatus(self):\n with self.lock:\n return (self.status, self.time_start)",
"def get_raw_status(self):\n self.__param_lock.acquire()\n ... | [
"0.79571366",
"0.72897905",
"0.72555906",
"0.72103953",
"0.70631886",
"0.7003551",
"0.6984304",
"0.6949121",
"0.69234353",
"0.69027823",
"0.6886226",
"0.6849591",
"0.68323433",
"0.67312163",
"0.6725681",
"0.67219126",
"0.67061067",
"0.6695192",
"0.6695192",
"0.6695192",
"0.66... | 0.0 | -1 |
Retrieve data Don't do long task in loop. Use a separated thread to not perturbate the nodeman | def loop(self, stopevent):
for bus in self.buses:
self.buses[bus].loop(stopevent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_thread(self, ip):\n get_data_thread = Thread(target=self.get_data, args=[ip])\n get_data_thread.start()",
"def fetch_data():\n data.fetch_data()\n data.start_updating()",
"def main(self):\n while True:\n if not self.data_server_command.empty():\n ... | [
"0.696191",
"0.6716008",
"0.65941787",
"0.6481667",
"0.6426779",
"0.6374192",
"0.62645483",
"0.61824685",
"0.610256",
"0.60537034",
"0.60457593",
"0.60247904",
"0.5971915",
"0.59577423",
"0.5926537",
"0.59190476",
"0.58765227",
"0.5859717",
"0.5845389",
"0.58351386",
"0.58195... | 0.0 | -1 |
Change the position of the pan | def set_position(self, node_uuid, index, data):
try:
servox = self._bus.nodeman.find_node('servox')
servoy = self._bus.nodeman.find_node('servoy')
logger.debug('[%s] - set_position of servos %s and %s', self.__class__.__name__, servox, servoy)
if data is None or d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def panTo(self, p=None):\n if p == None:\n p = self.focus\n MV = self.MV\n vr = self.getViewRight()\n vu = self.getViewUp()\n p = -p\n x = np.dot(p, vr) # dot product\n y = np.dot(p, vu)\n MV[3, :2] = x, y # set first two entries of 4th row to x, y... | [
"0.7055883",
"0.7055883",
"0.69751316",
"0.66623855",
"0.65398514",
"0.6447946",
"0.6447465",
"0.64395374",
"0.6402126",
"0.63889927",
"0.63513035",
"0.63486654",
"0.63106734",
"0.6296175",
"0.6237631",
"0.62298304",
"0.62075496",
"0.6197965",
"0.61601925",
"0.61556464",
"0.6... | 0.0 | -1 |
Decorator to be used in apimethods to serve the swaggerdocumentation for this api. | def api_documentation(api: str, summary: str, in_model: BaseModel,
out_model: BaseModel, out_description: str) -> Callable:
for model, name in ((in_model, 'Input'), (out_model, 'Output')):
doc.Object(
make_dataclass(
f'Api{api[1:].title()}{name}',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index():\n definition = {\n \"swagger\": \"2.0\",\n \"info\": {\n \"title\": flask.current_app.config.get(\"APPNAME\", \"Not specified\"),\n \"version\": flask.current_app.config.get(\"VERSION\", \"Not specified\"),\n },\n \"host\": request.host,\n \"... | [
"0.7308593",
"0.67804843",
"0.67267275",
"0.6568308",
"0.6500626",
"0.6489433",
"0.64708114",
"0.64436257",
"0.63863075",
"0.6336464",
"0.6331381",
"0.6279588",
"0.6140457",
"0.6124011",
"0.6117498",
"0.6093394",
"0.60924906",
"0.60902476",
"0.60646194",
"0.6054501",
"0.60270... | 0.6823912 | 1 |
Decorator to be used in apimethods to convert the requestdata to an instance of the passed `model`. This instance is passed to the decorated apiendpoint as the parameter `service_params`. | def api_inputmodel(api: str, model: BaseModel, servicename: str,
service_logger: logger) -> Callable:
def decorator(func):
@wraps(func)
async def function_wrapper(request, *args, **kwargs):
try:
service_params = model.parse_raw(request.body)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_outputmodel(api: str, model: BaseModel, servicename: str,\n service_logger: logger) -> Callable:\n\n def decorator(func):\n @wraps(func)\n async def function_wrapper(request, *args, **kwargs):\n service_result = await func(request, *args, **kwargs)\n ... | [
"0.6261429",
"0.61969465",
"0.5975331",
"0.56145257",
"0.5604642",
"0.55971265",
"0.558913",
"0.5562619",
"0.54409605",
"0.5427529",
"0.5384895",
"0.53138745",
"0.531021",
"0.5299018",
"0.52693087",
"0.52421254",
"0.5187899",
"0.5182848",
"0.51826674",
"0.5159831",
"0.5159831... | 0.7151013 | 0 |
Decorator to be used in apimethods to convert the responsedata of the decorated apimethod to a json based on the passed `model`. | def api_outputmodel(api: str, model: BaseModel, servicename: str,
service_logger: logger) -> Callable:
def decorator(func):
@wraps(func)
async def function_wrapper(request, *args, **kwargs):
service_result = await func(request, *args, **kwargs)
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json_response(func):\n\t@wraps(func)\n\tdef decorated_view(*args, **kwargs):\n\t\tdata = func(*args, **kwargs)\n\t\tdata = json.dumps(data)\n\t\tresponse = make_response(data)\n\t\tresponse.headers['Content-Type'] = 'application/json'\n\t\treturn response\n\treturn decorated_view",
"def json_response(func):\... | [
"0.6303589",
"0.6233411",
"0.6158551",
"0.61566204",
"0.61502767",
"0.6142237",
"0.6134618",
"0.60121006",
"0.60005003",
"0.5990344",
"0.59364825",
"0.59224707",
"0.59192204",
"0.5905445",
"0.58905154",
"0.58634555",
"0.5848181",
"0.5831524",
"0.58291614",
"0.58150035",
"0.57... | 0.6607163 | 0 |
Route to send calculator input | def operation_result():
input1 = request.form['Input1']
input2 = request.form['Input2']
input3 = request.form['Input3']
input4 = request.form['Input4']
input5 = request.form['Input5']
input6 = request.form['Input6']
try:
token_price_a_initial = float(input1)
token_pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculator(operation): \n \n operation = MATH[operation]\n a = int(request.args.get(\"a\"))\n b = int(request.args.get(\"b\"))\n total = operation(a, b)\n\n return f\"<h1>TOTAL: {total}</h1>\"",
"def all_arithmetic_operators(request: Any) -> Any:\n return request.param",
"def all_arith... | [
"0.6870682",
"0.62640357",
"0.62640357",
"0.6200235",
"0.60145706",
"0.6007947",
"0.5992822",
"0.59635174",
"0.5928874",
"0.58482105",
"0.58049804",
"0.5771265",
"0.5717723",
"0.56060153",
"0.5605487",
"0.5560057",
"0.55397177",
"0.5519091",
"0.54609567",
"0.5438152",
"0.5435... | 0.5568533 | 15 |
Create a new branch. | def create_branch(self, name, base_name, from_sha=False):
logger.debug(
'GitHubAPI.create_branch: name={}, base_name={}'.format(
name, base_name
)
)
# raise an error if we can find the branch, continue if we get
# a 404
try:
se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_branch(self):\n os.chdir(str(self.repository_path))\n sh.git.checkout('master')\n sh.git.checkout('-b', self.branch)\n logger.debug('Branch {} created', self.branch)",
"def create_branch(ctx, name, sha):\n\n try:\n\n gh = ctx.obj.github\n\n log.echo('Creati... | [
"0.8263331",
"0.77891356",
"0.76186675",
"0.72726834",
"0.71636385",
"0.7043409",
"0.69660765",
"0.6948939",
"0.6918359",
"0.6828066",
"0.6820213",
"0.6789778",
"0.67066014",
"0.660529",
"0.66019213",
"0.65866226",
"0.6435828",
"0.6376282",
"0.62368584",
"0.62368584",
"0.6212... | 0.6839864 | 9 |
Update attempt to update branch to the given SHA. | def update_branch(self, name, sha):
branch_info = {
'sha': sha,
}
resp = self.patch('git/refs/heads/{}'.format(name), json=branch_info)
try:
resp.raise_for_status()
except Exception:
logger.error(resp.json())
raise
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_latest_branch (product, which, main_branch):\n\n name = \"Latest_ACE7TAO3_\" + which\n\n vprint ('Fast-forwarding', name, 'to', main_branch)\n ex (\"cd $DOC_ROOT/\" + product + \" && git fetch . \" + main_branch + \":\" + name)",
"def update(self, branch=None):\n if branch is None:\n ... | [
"0.62394434",
"0.62033707",
"0.58707505",
"0.5823983",
"0.57316476",
"0.5548735",
"0.54924744",
"0.5490744",
"0.54566896",
"0.53568214",
"0.533697",
"0.53313905",
"0.5318119",
"0.5305053",
"0.52909243",
"0.52125496",
"0.5172792",
"0.51444185",
"0.5125727",
"0.5123589",
"0.511... | 0.70466286 | 0 |
Create a new pull request | def create_pull_request(self, base, head, title, body=None):
pull_info = {
'title': title,
'head': head,
'base': base
}
if body:
pull_info['body'] = body
logger.info(pull_info)
resp = self.post('pulls', json=pull_info)
try... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_pull_request(filepath, github_account):\n repo = _git.clone_from_github(\n _repo_path(), join(filepath, _repo_name()), github_account=github_account)\n branch = ('update-discovery-artifacts-' +\n datetime.datetime.now().strftime('%Y%m%d-%H%M%S'))\n repo.checkout_new(branch)\n i... | [
"0.70592564",
"0.704382",
"0.6956816",
"0.6912854",
"0.6759392",
"0.6718217",
"0.67178744",
"0.66204125",
"0.6516321",
"0.6229428",
"0.61973286",
"0.61781627",
"0.61508805",
"0.614511",
"0.614511",
"0.61279315",
"0.61080235",
"0.60647273",
"0.60609627",
"0.603208",
"0.6000777... | 0.62417126 | 9 |
Verify that the release is actually read to be released If the release is new (corresponds to a release branch), then we check that the release is merged into master. If we can not find the release branch, we assume that it is a hotfix and we verify that the major version number matches the latest release. | def check_release_status(self, release_name, release_branch):
logger.debug('GitHubAPI.check_release_status args: {}; {}'.format(
release_name, release_branch)
)
release_version = extract_release_branch_version(release_name)
release_branch_base = build_release_base_name(get_co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_release_branch():\n diff_string_config_yml = run_command(\"git diff origin/master .circleci/config.yml\")\n if re.search(r'[+-][ ]+CONTENT_VERSION: \".*', diff_string_config_yml):\n return True\n\n return False",
"def verify_tags(git_ref_target):\n latest_release = github_util.get_lates... | [
"0.69423383",
"0.6784403",
"0.66795766",
"0.6649919",
"0.6507445",
"0.64944094",
"0.63654304",
"0.6350596",
"0.6347604",
"0.63336277",
"0.6305721",
"0.6219666",
"0.62047046",
"0.61802447",
"0.6172858",
"0.612331",
"0.6118963",
"0.6113204",
"0.6088553",
"0.60614514",
"0.604839... | 0.73628855 | 0 |
Evaluate the mfcc_length for a given file | def get_mfcc_length_from_duration(duration):
length = int(duration // FRAME_STRIDE) - 1
return length | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wav2mfcc(file_path, max_len=44, n_mfcc=20):",
"def mfcc(path, windowsize, overlap, M):\n srate, data = scipy.io.wavfile.read(path)\n\n bank = filterbank(0, srate/2, M, srate, windowsize)\n buckets = bucketize(data/32768.0, windowsize, overlap)\n energies = buckets.dot(bank.transpose())\n\n ret... | [
"0.6658678",
"0.6523835",
"0.6392451",
"0.61464643",
"0.5918345",
"0.58868235",
"0.5885237",
"0.5809652",
"0.5772686",
"0.5743787",
"0.57237357",
"0.56915265",
"0.5688",
"0.5644551",
"0.56252927",
"0.5590044",
"0.5578385",
"0.55762726",
"0.5562501",
"0.5446046",
"0.54189724",... | 0.60624254 | 4 |
Reads in audio file, processes it | def process_audio_file(self, file_name):
sig, sr = librosa.load(file_name, mono=True)
return self._extract_function(sig, sr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_audio(f, downmix):\n if f.endswith('.mp3'):\n f = _mp3_hook(f)\n sr, audio = scipy.io.wavfile.read(f)\n if not audio.dtype is np.float32:\n audio = _normalize_pcm(audio)\n if downmix and len(audio.shape) == 2:\n audio = down_mix(audio)\n return sr, audio",
"def audioR... | [
"0.7045707",
"0.6956398",
"0.6821181",
"0.6742061",
"0.6704527",
"0.6699321",
"0.6644113",
"0.6615665",
"0.64650714",
"0.6453779",
"0.63955903",
"0.63811314",
"0.63749427",
"0.6367572",
"0.63429946",
"0.6340871",
"0.633396",
"0.6314544",
"0.6308602",
"0.6294938",
"0.6285965",... | 0.72694874 | 0 |
Reads in audio file, processes it | def process_signal(self, sig, sr):
return self._extract_function(sig, sr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_audio_file(self, file_name):\n sig, sr = librosa.load(file_name, mono=True)\n return self._extract_function(sig, sr)",
"def read_audio(f, downmix):\n if f.endswith('.mp3'):\n f = _mp3_hook(f)\n sr, audio = scipy.io.wavfile.read(f)\n if not audio.dtype is np.float32:\n ... | [
"0.72694874",
"0.7045707",
"0.6956398",
"0.6821181",
"0.6742061",
"0.6704527",
"0.6699321",
"0.6644113",
"0.6615665",
"0.64650714",
"0.6453779",
"0.63955903",
"0.63811314",
"0.63749427",
"0.6367572",
"0.63429946",
"0.6340871",
"0.633396",
"0.6314544",
"0.6308602",
"0.6294938"... | 0.0 | -1 |
Compute log mel filterbank features with deltas and double deltas | def _extract_fbank(self, sig, sr):
emphasized_signal = np.append(sig[0], sig[1:] - 0.97 * sig[:-1])
frame_length, frame_step = FRAME_SIZE * sr, FRAME_STRIDE * sr
signal_length = len(emphasized_signal)
frame_length = int(round(frame_length))
frame_step = int(round(frame_step))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logMelSpectrum(input, samplingrate):\n nfft = input.shape[1]\n N = input.shape[0]\n filters = trfbank(samplingrate, nfft)\n\n # plot Mel filters\n # plt.plot(filters)\n # plt.title('Mel filters')\n # plt.show()\n\n output = np.zeros((N, filters.shape[0]))\n for j in range(filters.sha... | [
"0.6378001",
"0.6166156",
"0.6106605",
"0.5986836",
"0.59717876",
"0.59704345",
"0.59436226",
"0.59277886",
"0.59004104",
"0.5880232",
"0.58595026",
"0.5850303",
"0.5847764",
"0.5805098",
"0.5797871",
"0.5773712",
"0.57430214",
"0.5730535",
"0.5728411",
"0.5695498",
"0.569287... | 0.0 | -1 |
Create the game, SpaceInvaders. Train or test it. | def __init__ (self,gameName,total_episodes=50,train_or_test=2):
#additional param:- doLoadNetwork=True
self.createGame(gameName)
### Training Hyperparameters
self.TOT_EPISODES = total_episodes #no. of episodes/epochs
self.MAX_STEPS = 50000 #max steps taken every episode/epoch
### Pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, game_name, skip_actions=4, num_frames=4, w=84, h=84):\n self.env = gym.make(game_name)\n self.num_frames = num_frames\n self.skip_actions = skip_actions\n self.w = w\n self.h = h\n\n if game_name == 'SpaceInvaders-v0':\n self.action_space=[1,2... | [
"0.6907318",
"0.68599695",
"0.6728783",
"0.66609395",
"0.6579913",
"0.6554996",
"0.6510835",
"0.64591074",
"0.64184606",
"0.6393087",
"0.63915473",
"0.6364802",
"0.6364802",
"0.6364802",
"0.6364802",
"0.6364802",
"0.6359255",
"0.635703",
"0.63438934",
"0.6340655",
"0.63222647... | 0.0 | -1 |
load the network from saved.h5 | def load_network(self):
self.dqn.load_network(self.path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_network(self, which_epoch):\n save_filename = '%s_net.pth' % which_epoch\n load_path = os.path.join(self.save_dir, save_filename)\n net = self.net\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print('loading the model from %s' % load_path)\... | [
"0.71672744",
"0.7150659",
"0.6883396",
"0.67808",
"0.6710601",
"0.66247654",
"0.6531737",
"0.64843845",
"0.64828396",
"0.6471173",
"0.6450578",
"0.64475465",
"0.6441468",
"0.64281887",
"0.6308086",
"0.6201771",
"0.6194544",
"0.61861485",
"0.61786836",
"0.61785096",
"0.617107... | 0.7140678 | 2 |
Train the model for a certain no of episodes | def trainAgent(self):
for episode in range(self.TOT_EPISODES):
#reset environment, stacked frames every episode.
state = self.env.reset()
rewards = 0
#preprocess and stack the frame/state.
state, self.stacked_frames = stack_frames(self.stack_size,
self.stacked_frames, state, True)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, num_episodes, max_episode_steps=100, save_freq=100, render=False):\n while self.episodes_done < num_episodes:\n self.trainOneEpisode(num_episodes, max_episode_steps, save_freq, render)\n self.saveCheckpoint()",
"def train(self, training_steps=10):",
"def train(\n ... | [
"0.75523275",
"0.743832",
"0.74258286",
"0.7422637",
"0.7364126",
"0.73365295",
"0.73187625",
"0.72586364",
"0.7242011",
"0.7233209",
"0.72105044",
"0.7161378",
"0.71507365",
"0.713142",
"0.71212167",
"0.71001995",
"0.7051916",
"0.7029939",
"0.7000444",
"0.6976201",
"0.693145... | 0.66573066 | 38 |
Test the agen and watch it play for one episode. | def simulate(self):
print("##################################")
print("SIMULATING GAME - SpaceInvaders..")
print("##################################")
# Play 3 episodes:
for i in range(3):
print("Playing Episode %d" % i)
state = self.env.reset()
#self.env.render()
done = False
tot... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test():\n env = gym.make('CartPole-v1')\n\n results = []\n for _ in range(100):\n results.append(episode(env, render=False, verbose=False))\n\n print(f'average={sum(results) / len(results)} '\n f'max={max(results)} '\n f'min={min(results)}')",
"def test_scraper(self):\n ... | [
"0.6574454",
"0.64675266",
"0.6428111",
"0.6335772",
"0.6264014",
"0.6199133",
"0.6197816",
"0.6196485",
"0.6193701",
"0.6170308",
"0.6169579",
"0.61569935",
"0.61476463",
"0.60803",
"0.6072124",
"0.60470563",
"0.6037859",
"0.6029739",
"0.60170627",
"0.60096955",
"0.59748065"... | 0.0 | -1 |
This function is called to check if a username / password combination is valid. | def check_auth(username, password):
return (username == app.config['USERNAME'] and
password == app.config['PASSWORD']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_auth(username, password, expected_user, expected_pw):\n return username == expected_user and password == expected_pw",
"def validate_authentication(self, username, password):\n return self.user_table[username]['pwd'] == password",
"def check_auth(username, password):\n return usernam... | [
"0.82211864",
"0.8146436",
"0.7975914",
"0.7962432",
"0.7885527",
"0.78588223",
"0.78382313",
"0.78288996",
"0.7815222",
"0.7798579",
"0.77856815",
"0.77700555",
"0.7760794",
"0.7754975",
"0.77548647",
"0.7750886",
"0.7749223",
"0.77322245",
"0.7715806",
"0.7685904",
"0.76736... | 0.7687129 | 19 |
Sends a 401 response that enables basic auth | def authenticate():
return Response(render_template('index.html', auth=False), 401,
{'WWW-Authenticate': 'Basic realm="Login Required"'}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authenticate():\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\"api\"'})",
"def authenticate():\n return Response(\n '', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )",
"def authenticate():\n return Response(\n 'You have to login with pro... | [
"0.8093736",
"0.80926424",
"0.7958403",
"0.7852648",
"0.7843114",
"0.7824419",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
... | 0.76140213 | 41 |
Check if no user login | def require_visitor(func):
@wraps(func)
def decorator(*args, **kwargs):
if g.user:
return redirect(url_for('site.home'))
return func(*args, **kwargs)
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_user_and_login(self) -> Response:\n pass",
"def check_auth_none(self, username):\n return AUTH_FAILED",
"def check_user_logged():\n global user\n if 'user' not in session:\n return False\n else:\n user = session.get('user')\n return user['username'] != ''",
"... | [
"0.7631167",
"0.7377581",
"0.7348826",
"0.7320364",
"0.72438157",
"0.7098895",
"0.70730084",
"0.70391387",
"0.6981259",
"0.6977111",
"0.6969315",
"0.6933913",
"0.69154346",
"0.6907214",
"0.6865833",
"0.6815512",
"0.6799823",
"0.67882526",
"0.67734057",
"0.67627156",
"0.670679... | 0.0 | -1 |
Check if user login | def require_user(func):
@wraps(func)
def decorator(*args, **kwargs):
if not g.user:
# flash('此操作需要登录账户')
return render_template('account/error.html', error='抱歉，您无权进行该操作！')
# return redirect(url_for('site.login'))
return func(*args, **kwargs)
return decor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_user_and_login(self) -> Response:\n pass",
"def is_correct_user(self, login, password):\n pass",
"def check_user_logged():\n global user\n if 'user' not in session:\n return False\n else:\n user = session.get('user')\n return user['username'] != ''",
"def log... | [
"0.8381395",
"0.8055585",
"0.7813263",
"0.7678583",
"0.7649151",
"0.7576734",
"0.7567418",
"0.7521423",
"0.75094885",
"0.7488563",
"0.74643886",
"0.7460811",
"0.7460811",
"0.7443086",
"0.7417814",
"0.74102914",
"0.7391327",
"0.73445153",
"0.73423046",
"0.72956836",
"0.7277331... | 0.0 | -1 |
Check if mobile user login | def require_mobile_user(func):
@wraps(func)
def decorator(*args, **kwargs):
if not g.user:
return redirect(url_for('wechat.signin'))
return func(*args, **kwargs)
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_mobile(request):\n MOBILE_AGENT_RE=re.compile(r\".*(iphone|mobile|androidtouch)\",re.IGNORECASE)\n\n if MOBILE_AGENT_RE.match(request.META['HTTP_USER_AGENT']):\n return True\n else:\n return False",
"def mobile(request):\n MOBILE_AGENT_RE = re.compile(\n r\".*(iphone|mo... | [
"0.6898011",
"0.689399",
"0.6369667",
"0.635195",
"0.63429105",
"0.63109106",
"0.62703073",
"0.6228723",
"0.62186426",
"0.6195903",
"0.6157435",
"0.61390567",
"0.6046515",
"0.60213834",
"0.5956583",
"0.59477335",
"0.5935797",
"0.5915573",
"0.58781195",
"0.58594924",
"0.585450... | 0.6534018 | 2 |
Check if user is admin | def require_admin(func):
@wraps(func)
def decorator(*args, **kwargs):
if not g.user:
# flash('此操作需要登录账户')
return redirect(url_for('admin.login'))
if g.user.name != 'admin':
abort(403)
return func(*args, **kwargs)
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_is_admin(user):\n return user in admins",
"def is_admin(user):\n return user.is_authenticated and user.id == app.config.get('ADMIN')",
"def is_admin(self, user):\n return user.name in self.admins",
"def is_admin_user(self):\n if \"is_admin\" in self._properties and self.is_ad... | [
"0.8688236",
"0.8687356",
"0.8556875",
"0.8554287",
"0.85044616",
"0.84716874",
"0.8450938",
"0.841185",
"0.84050906",
"0.8394017",
"0.8363089",
"0.83423585",
"0.83161926",
"0.8280715",
"0.82797027",
"0.82743096",
"0.82743096",
"0.8248748",
"0.82192075",
"0.8196186",
"0.81672... | 0.0 | -1 |
r""" Return the ``d x d`` identity matrices on ``nvar`` variables. | def symbolic_max_plus_identity(d, nvar, ch=None):
d = int(d)
nvar = int(nvar)
V = FreeModule(ZZ, nvar)
e = ()
zero = (V([0]*nvar),)
data = [[zero if i == j else e for j in range(d)] for i in range(d)]
return SymbolicMaxPlusMatrix(d, nvar, data, ch) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identity_matrix(self, n):\r\n IdM = self.zeros_matrix(n, n)\r\n for i in range(n):\r\n IdM[i][i] = 1.0\r\n \r\n return IdM",
"def identity(n):\r\n I = np.zeros((n, n))\r\n diag = np.ones(n)\r\n np.fill_diagonal(I, diag)\r\n return matrix(I)",
"d... | [
"0.6807005",
"0.63776374",
"0.63734645",
"0.63494134",
"0.6294045",
"0.6278014",
"0.6278014",
"0.61580557",
"0.61580557",
"0.61580557",
"0.615476",
"0.6121155",
"0.6051036",
"0.601457",
"0.58180785",
"0.5777933",
"0.57341456",
"0.5717382",
"0.5687784",
"0.5684385",
"0.5680099... | 0.0 | -1 |
r""" Return ``n`` independent symbolic matrices in dimension ``d``. | def symbolic_max_plus_matrices(d, n, ch=None, typ='sym'):
d = int(d)
n = int(n)
if d <= 0:
raise ValueError("d (= {}) must be postive".format(d))
nvar = n * d * d
V = FreeModule(ZZ, nvar)
B = ((b,) for b in V.basis())
matrices = []
if d == 1:
typ = 'full'
if typ ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def basis(d, symbolic=True):\n X = sym.symbols('X')\n if d == 0:\n phi_sym = [1]\n else:\n if symbolic:\n h = sym.Rational(1, d) # node spacing\n nodes = [2*i*h - 1 for i in range(d+1)]\n else:\n nodes = np.linspace(-1, 1, d+1)\n \n phi_sym = [Lagrange_poly... | [
"0.59795463",
"0.5888374",
"0.57391495",
"0.5711324",
"0.5686454",
"0.5563071",
"0.5492323",
"0.5435326",
"0.5423058",
"0.5419523",
"0.54059994",
"0.5392236",
"0.538575",
"0.5366352",
"0.5356909",
"0.53455615",
"0.5337914",
"0.5334625",
"0.5330213",
"0.53227186",
"0.53154725"... | 0.58973736 | 1 |
r""" Return a string that describes the convex hull engine. | def convex_hull_engine(self):
return self.convex_hull._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _repr_(self):\n desc = ''\n if self.n_vertices()==0:\n desc += 'The empty polyhedron'\n else:\n desc += 'A ' + repr(self.dim()) + '-dimensional polyhedron'\n desc += ' in '\n if self.field()==QQ: desc += 'QQ'\n else: desc += 'RDF'\n... | [
"0.66425604",
"0.63532376",
"0.6281747",
"0.60994506",
"0.60871357",
"0.5944821",
"0.5937618",
"0.5842721",
"0.5841963",
"0.5745582",
"0.57072836",
"0.5683671",
"0.5624012",
"0.5577006",
"0.55180144",
"0.54937017",
"0.5490255",
"0.5487594",
"0.54810053",
"0.5431776",
"0.54206... | 0.75023854 | 0 |
r""" Return the dimension of this matrix. | def dim(self):
return self._d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dimension(self):\n return self.__N",
"def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]",
"def dim(self):\n return len(self.shape)",
"def dim(self):\n return len(self.shape)",
"def dimensionality(self):\n return int(self.nDims)... | [
"0.84898525",
"0.84692967",
"0.83745944",
"0.83745944",
"0.8322008",
"0.8309151",
"0.8180309",
"0.81371695",
"0.8114333",
"0.8109193",
"0.8031762",
"0.8031762",
"0.8015657",
"0.7960735",
"0.7944764",
"0.7926571",
"0.79092103",
"0.78969157",
"0.787916",
"0.78600526",
"0.778453... | 0.7624366 | 52 |
r""" Return the number of variables used in this matrix. | def num_vars(self):
return self._nvars | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_variables(self):\n return len(self.variables)",
"def num_vars(self):\n return self.nvars",
"def nvar(self):\n return len(self.__vars)",
"def GetNumberOfVariables(self):\n\n # nvar = 0\n # for i in self.variables_order:\n # # DO NOT COUNT VARIABLES THAT GE... | [
"0.826646",
"0.80817354",
"0.79613394",
"0.7953327",
"0.79433763",
"0.7778536",
"0.7749949",
"0.75871086",
"0.74991745",
"0.74765337",
"0.74339026",
"0.72988725",
"0.71537995",
"0.71156085",
"0.7080469",
"0.69808406",
"0.691234",
"0.67460585",
"0.6729376",
"0.6723816",
"0.671... | 0.8000086 | 2 |
r""" To obtain an item of the matrix | def __getitem__(self, data):
i,j = data
return self._data[i][j] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, item):\n if type(item) is int:\n # select row by default\n if self.shape[0] == 1: # iterate by column if it's a row vector\n return self.values[0][item]\n elif self.shape[1] == 1: # iterate by row if it's a column vector\n ... | [
"0.75138944",
"0.7311626",
"0.7112711",
"0.7027379",
"0.69761306",
"0.68627983",
"0.6828977",
"0.6801616",
"0.67811024",
"0.6719613",
"0.6719613",
"0.6719613",
"0.6648522",
"0.6594458",
"0.6576159",
"0.65010285",
"0.64954424",
"0.6479522",
"0.6468668",
"0.6449649",
"0.6440751... | 0.61327946 | 42 |
r""" Multiplication of matrices | def __mul__(self, other):
if type(self) != type(other) and \
not isinstance(self, SymbolicMaxPlusMatrix) and \
not isinstance(other, SymbolicMaxPlusMatrix):
raise TypeError("can not multiply {} with {}".format(type(self),type(other)))
if self._d != other._d:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrix_mult(m1, m2):\n pass",
"def Multiply(M1,M2):\r\n M3=[]\r\n w=0\r\n while w<len(M2[0]):\r\n tap=[]\r\n t=0\r\n while t<len(M2):\r\n tap.append(M2[t][w])\r\n t=t+1\r\n M3.append(tap)\r\n w=w+1\r\n M=[]\r\n # Multiplying matrices\r... | [
"0.839403",
"0.77877283",
"0.7786913",
"0.76345795",
"0.7578386",
"0.752093",
"0.7499151",
"0.7495682",
"0.74534243",
"0.7433087",
"0.74056447",
"0.73597676",
"0.7326738",
"0.732322",
"0.7322675",
"0.731054",
"0.72843087",
"0.7257866",
"0.72538614",
"0.7223289",
"0.7222726",
... | 0.0 | -1 |
r""" Return the list of entries of this matrix. | def list(self):
return [self[i,j] for i in range(self._d) for j in range(self._d)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_list(self):\n data = []\n for row in self._matrix_data:\n for column in row:\n data.append(column)\n return data",
"def rows(self):\n return list(self)",
"def as_list_of_lists(self):\n return self._matrix_data",
"def readentries(self):\n ... | [
"0.74211484",
"0.7351907",
"0.7139602",
"0.7107239",
"0.7102002",
"0.7040875",
"0.700234",
"0.700234",
"0.69514894",
"0.6915959",
"0.6805772",
"0.68021935",
"0.67886513",
"0.6775163",
"0.6770315",
"0.6736421",
"0.67067957",
"0.66475236",
"0.6628927",
"0.66164464",
"0.65946597... | 0.69504046 | 9 |
r""" Return the list of equal coefficients between self and other. | def equal_coefficients(self, other):
d = self._d
return [(i,j) for i in range(d) for j in range(d) \
if self[i][j] == other[i][j]] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __xor__(self, other):\n\n sym_diff = [value for value in self if value not in other]\n sym_diff.extend([value for value in other if value not in self])\n\n return sym_diff",
"def GetEqualConstrains(self):\n return _gmat_py.Spacecraft_GetEqualConstrains(self)",
"def coefficients(... | [
"0.66310555",
"0.6198817",
"0.61889756",
"0.5865301",
"0.5818835",
"0.5683608",
"0.5683608",
"0.56740135",
"0.5648324",
"0.56273437",
"0.56273437",
"0.5593266",
"0.55242145",
"0.5514569",
"0.546532",
"0.5455155",
"0.5414487",
"0.5409538",
"0.5363544",
"0.53480685",
"0.5334692... | 0.78071773 | 0 |
r""" String when the object is printed | def _repr_(self):
return 'A {}x{} symbolic max plus matrix on {} variables'.format(
self.dim(), self.dim(), self.num_vars()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return self.printable()",
"def __str__(self):\r\n return repr(self)",
"def __str__(self):\n return repr(self)",
"def __str__(self):\n return \"<%s: %s>\" % (self.__class__, self.describe())",
"def __str__(self):\n return_string = self.name + \"\\n\" +... | [
"0.8097469",
"0.78782415",
"0.77841264",
"0.7769064",
"0.7669302",
"0.76466906",
"0.76466906",
"0.7623327",
"0.75980204",
"0.75980204",
"0.75980204",
"0.75980204",
"0.7578883",
"0.7571893",
"0.75686365",
"0.75658494",
"0.7563032",
"0.7543171",
"0.7536491",
"0.7536491",
"0.753... | 0.0 | -1 |
r""" Evaluates this symbolic matrix at the integer point ``p``. | def eval(self, p):
from max_plus.max_plus_int import minus_infinity, IntegerMaxPlusMatrix
F = FreeModule(ZZ, self._nvars)
p = F(p)
mat = []
d = self.dim()
for i in range(d):
row = []
for j in range(d):
pts = self[i,j]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self,p):\n if not self.initialized: self.__initialize__()\n if self.vp0: p_ = 1-p\n else: p_ = p\n if self.ids_to_consider is None:\n #sum on all parametrized cell\n cf = np.sum(self.V[self.p_ids-1]*p_)/self.V_tot - self.max_v_frac\n else:\n cf = np.sum((self.V[self.ids_t... | [
"0.6590414",
"0.64902985",
"0.5803352",
"0.576456",
"0.56841123",
"0.56735307",
"0.5545928",
"0.54923505",
"0.54681116",
"0.5413606",
"0.5399578",
"0.5339681",
"0.5316676",
"0.53084254",
"0.5288867",
"0.525981",
"0.52447516",
"0.5244498",
"0.5217221",
"0.521235",
"0.5206362",... | 0.6615458 | 0 |
r""" Return the dimension of the affine space spanned generated by each Newton polytopes. for triangular matrices, seems to stay 0 on the diagonal. | def get_vector_span(self, i, j):
from sage.rings.infinity import Infinity
from sage.matrix.constructor import matrix
data = self[i,j]
if not data:
return None
elif len(data) == 1:
return FreeModule(ZZ, self._nvars).submodule([])
else:
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dim(self) -> int:",
"def getlen(self):\n if self.onlydiag():\n return self.lendiag()\n else:\n return len(self)",
"def dimension(self):\n return 3*self.genus - 3 + self.n",
"def dim(self) -> int:\n return self.atoms.shape[:-1]",
"def dimension(self):\r\... | [
"0.67515165",
"0.67112654",
"0.6535919",
"0.653394",
"0.64353853",
"0.6379742",
"0.63764715",
"0.63629043",
"0.63574785",
"0.63428813",
"0.62986326",
"0.6278618",
"0.62567246",
"0.62425613",
"0.6237966",
"0.6212587",
"0.6183233",
"0.61782753",
"0.61762774",
"0.61756885",
"0.6... | 0.0 | -1 |
r""" Permutations (i1,j1) > (i2,j2) Make an exchange of rows/columns in matrix data. This is used in multiplication of full symbolic matrices. | def vertex_swap(d, n, l, i1, i2, j1, j2):
if i1 == i2 and j1 == j2:
return l
if i1 == j1:
# (i1,i1) -> (i2,i2)
assert i2 == j2
def swap(v):
swap2(d, n, v, i1, i2)
elif i1 == i2:
# (i,j1) -> (i,j2)
def swap(v):
swap2(d, n, v, j1, j2)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swap_columns(i, j, *args):\n output = list()\n for M in args:\n output.append(_cswap(i, j, M))\n return output",
"def swap_rows(i, j, *args):\n output = list()\n for M in args:\n output.append(_rswap(i, j, M))\n return output",
"def return_swaps( # pylint: disable=too-many-... | [
"0.6260572",
"0.61407316",
"0.60737467",
"0.58037573",
"0.5779625",
"0.5728096",
"0.56909776",
"0.5626455",
"0.5626066",
"0.55842173",
"0.5571164",
"0.5571073",
"0.5566883",
"0.55655205",
"0.55617666",
"0.5537897",
"0.55265135",
"0.5522779",
"0.55212414",
"0.5504172",
"0.5502... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.