J junaid1460

Floyd-warshall's algorithm with Distance Vector plugin

The code below is a plugin to this algorithm to generate path.

	import math
	def generate_dist_vector(size, start, tot_length, length):
	tmp = [start]
	count = 0
	l, r = -length, tot_length - length
	for i in range(size):
	left = tmp[0]
	right = tmp[count]
	left += (l*2)
	right += (r*2)

	from IPython.display import HTML, display
	class Tag:
	def __init__(self, name, value):
	self.name = name
	self.value = value
	def __repr__(self):
	return "<%s>%s</%s>"%(self.name, str(self.value), self.name)

	class Linear:
	def __init__(self, data):

	import { Injectable } from '@angular/core';
	import { blueGrace } from './themes';
	const themeKey = 'app:theme';

	export const themeStore = {
	'Blue Grace': blueGrace,
	'Default': null
	};

	export const blueGrace = {
	appSidebarClass: 'blue_grace_sidebar',
	sidebarSectionClass: 'blue_grace_sidebar_section',
	'app-inputs': 'blue_grace_app_inputs',
	'app-tags': 'blue_grace_app_inputs',
	'app-sources': 'blue_grace_app_inputs',
	'myCustomThemeKey': 'myCustomClass',
	};

	import { Directive, Input, OnInit, ElementRef, Renderer2 } from '@angular/core';
	import { ThemeService } from './theme.service';

	@Directive({
	selector: '[appTheme]'
	})
	export class ThemeDirective implements OnInit {
	@Input('appTheme') appTheme: string; // appTheme="customClassKey"
	constructor(
	private themeService: ThemeService,

	// Create batches out of big array
	// Map those batches to a lambda
	export async function asyncBatchMap<T, F>(
	items: ReadonlyArray<T>,
	predicate: (input: T[]) => Promise<F>,
	batchSize: number = 10,
	): Promise<F[]> {
	const newContainer = items.map((e) => e);
	const result: F[] = [];
	while (newContainer.length > 0) {