text:
@article{Kalra2005,
 abstract = {OBJECTIVE: Small vessel disease is more common in Afro-Caribbeans than Caucasians. We investigated underlying differences in metabolic, inflammatory, and vascular responses that may predispose Afro-Caribbeans to small vessel pathology. METHODS AND RESULTS: Seventy-eight Afro-Caribbeans aged 35-75 years, with no vascular disease or medications, were compared with 82 matched Caucasians for metabolic variables, fasting insulin, interleukin 6, tumor necrosis factor (TNF) alpha, and cytoplasmic repressor protein levels. Carotid intima media thickness (CIMT) was measured ultrasonographically. Small vessel function was assessed by measuring the absolute change from baseline in the reflectance index (RI) of the digital volume pulse during IV infusion of albuterol (5 microg/min, DeltaRIALB) and glyceryl tri nitrate (5 microg/min, DeltaRIGTN). Large artery elasticity was measured as the stiffness index (SI) and derived from the time to pulse wave reflection adjusted for subject height. Afro-Caribbeans had significantly higher diastolic blood pressure (80.3 versus 77.6 mm Hg; P=0.033), fasting insulin (14.0 versus 10.6 microU/mL; P=0.026), TNF-alpha (6.7 versus 4.3; pg/mL; P=0.001), and interleukin 6 (2.3 versus 1.5 pg/mL; P=0.036) levels compared with Caucasians. CIMT was greater (0.81+/-0.20 versus 0.75+/-0.18 mm; P=0.02) and small vessel reactivity attenuated (mean DeltaRIALB 6.8+/-8.0% versus 12.3+/-8.%; P<0.0001) in Afro-Caribbeans, but their large artery elasticity (mean index of large artery stiffness 9.9 versus 9.7 m/s; P=0.48) was comparable with Caucasians. CIMT was independently associated with an index of large artery stiffness (beta=0.03; P=0.002) in Caucasians but not in Afro-Caribbeans. There were independent relationships among Afro-Caribbean ethnicity, TNF-alpha, and insulin levels. CONCLUSIONS: Selective impairment of small artery function may contribute to excess small vessel disease in Afro-Caribbeans.},
 address = {United States},
 article-pii = {01.ATV.0000183887.76087.6a},
 author = {Kalra, Lalit and Rambaran, Curtis and Chowienczyk, Philip and Goss, David and Hambleton, Ian and Ritter, James and Shah, Ajay and Wilks, Rainford and Forrester, Terrence},
 comment = {Arterioscler Thromb Vasc Biol. 2005 Nov;25(11):2240-2. PMID: 16258149},
 completed = {20060112},
 doi = {10.1161/01.ATV.0000183887.76087.6a},
 electronic-issn = {1524-4636},
 electronic-publication = {20050825},
 history = {2005/08/27 09:00 [entrez]},
 issue = {11},
 journal = {Arteriosclerosis, thrombosis, and vascular biology},
 keywords = {Adult, African Continental Ancestry Group/*statistics & numerical data, Aged, Arteries/immunology/metabolism, Biomarkers, Blood Pressure, Body Mass Index, Cardiovascular Diseases/*ethnology/*immunology/metabolism, European Continental Ancestry Group/*statistics & numerical data, Female, Humans, Incidence, Male, Metabolic Syndrome/ethnology/immunology/metabolism, Middle Aged, Prevalence, Risk Factors, United Kingdom/epidemiology, West Indies/ethnology},
 language = {eng},
 linking-issn = {1079-5642},
 month = {Nov},
 nlm-unique-id = {9505803},
 owner = {NLM},
 pages = {2362-7},
 publication-status = {ppublish},
 registry-number = {0 (Biomarkers)},
 revised = {20171116},
 source = {Arterioscler Thromb Vasc Biol. 2005 Nov;25(11):2362-7. doi: 10.1161/01.ATV.0000183887.76087.6a. Epub 2005 Aug 25.},
 status = {MEDLINE},
 subset = {IM},
 title = {Ethnic differences in arterial responses and inflammatory markers in Afro-Caribbean and Caucasian subjects.},
 title-abbreviation = {Arterioscler Thromb Vasc Biol},
 volume = {25},
 year = {2005}
}

license: MIT


text:
DESCRIPTION = "SIP is a C++/Python Wrapper Generator"
AUTHOR = "Phil Thompson"
HOMEPAGE = "http://www.riverbankcomputing.co.uk/sip"
SECTION = "devel"
PRIORITY = "optional"
LICENSE = "GPL"
LIC_FILES_CHKSUM = "file://LICENSE;md5=6c43e134c9d8e019b34f3160ebedb924"
PR = "r0"

SRC_URI = "http://riverbankcomputing.co.uk/static/Downloads/sip4/sip-${PV}.tar.gz"

SRC_URI[md5sum] = "76192829cc42ec558db46e4f9e1d8ba9"
SRC_URI[sha256sum] = "ec295f71ef339c5b98db5650865f2c6c1200c4085b7a3f33f284111e1f534ac1"

S = "${WORKDIR}/sip-${PV}"

inherit qmake_base native python-dir

EXTRA_QMAKEVARS_POST += "CONFIG=console"

export BUILD_SYS
export HOST_SYS
export STAGING_LIBDIR
export STAGING_INCDIR

do_configure() {
    python configure.py
}

do_install() {
    oe_runmake 'DESTDIR=${D}' install
}

license_type: permissive

branch_name: refs/heads/master

extension: bb


text:
@Book{DummyBook:1,
author = "John Doe",
title = "Untitled Book",
publisher = "Dummy Publisher",
year = 2019,
}
@article{DummyArticle:1,
author = "John Doe",
title = "Untitled article",
publisher = "Dummy Publisher",
year = 2019,
}
@article{DummyArticle:2,
author = "John Doe",
title = "Untitled article",
publisher = "Dummy Publisher",
year = 2019,
}

branch_name: refs/heads/main

extension: bib


text:
package collector

import (
	"context"
	"fmt"
	"time"

	"github.com/marema31/kin/cache"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
	"github.com/sirupsen/logrus"
)

func parseLabel(log *logrus.Entry, name string, labels map[string]string) (cache.ContainerInfo, bool) {
	if _, ok := labels["kin_name"]; ok {
		log.Debugf("Found %v", name)

		return cache.ContainerInfo{
			ID:    name,
			Name:  labels["kin_name"],
			URL:   labels["kin_url"],
			Type:  labels["kin_type"],
			Group: labels["kin_group"],
		}, true
	}

	return cache.ContainerInfo{}, false
}

func listServices(ctx context.Context, log *logrus.Entry, cli *client.Client) (*[]cache.ContainerInfo, error) {
	services, err := cli.ServiceList(ctx, types.ServiceListOptions{})
	if err != nil {
		log.Errorf("cannot retrieve list of container: %v", err)
		return nil, err
	}

	log.Debugf("There is currently %d containers running", len(services))

	ci := make([]cache.ContainerInfo, 0)

	for _, service := range services {
		if infos, ok := parseLabel(log, service.Spec.Name, service.Spec.Annotations.Labels); ok {
			ci = append(ci, infos)
		}
	}

	return &ci, nil
}

func listContainers(ctx context.Context, log *logrus.Entry, cli *client.Client) (*[]cache.ContainerInfo, error) {
	containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
	if err != nil {
		log.Errorf("cannot retrieve list of container: %v", err)
		return nil, err
	}

	log.Debugf("There is currently %d containers running", len(containers))

	ci := make([]cache.ContainerInfo, 0)

	for _, container := range containers {
		if infos, ok := parseLabel(log, container.Names[0], container.Labels); ok {
			ci = append(ci, infos)
		}
	}

	return &ci, nil
}

func refreshList(ctx context.Context, log *logrus.Entry, cli *client.Client, db *cache.Cache, swarmMode bool) error {
	var (
		ci  *[]cache.ContainerInfo
		err error
	)

	switch {
	case swarmMode:
		ci, err = listServices(ctx, log, cli)
	default:
		ci, err = listContainers(ctx, log, cli)
	}

	if err != nil {
		return err
	}

	err = db.RefreshData(log, *ci)
	if err != nil {
		return fmt.Errorf("cannot push test data in cache: %w", err)
	}

	return nil
}

//Run poll regurlarly the docker daemon and fill cache with updated list of container labelled for kin.
func Run(ctx context.Context, log *logrus.Entry, db *cache.Cache, swarmMode bool) error {
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		log.Errorf("cannot connect to docker daemon: %v", err)
		return err
	}

	//Initialize the list
	err = refreshList(ctx, log, cli, db, swarmMode)
	if err != nil {
		return err
	}

	ticker := time.NewTicker(10 * time.Second) //nolint: gomnd
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return nil
		case <-ticker.C:
			err := refreshList(ctx, log, cli, db, swarmMode)
			if err != nil {
				return err
			}
		}
	}
}

extension: go


text:
set(DIVIDE_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libdivide)
set(DBMS_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/src ${ClickHouse_BINARY_DIR}/src)
set(DOUBLE_CONVERSION_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/double-conversion)
set(METROHASH_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libmetrohash/src)

repository: svasilenkov/ClickHouse

repo_name: svasilenkov/ClickHouse

extension: cmake


text:
@article{example3,
  title = {Postmortem Study of Cause of Death Among Children Hospitalized With Respiratory Illness in Kenya},
  author={Njuguna HN, Zaki SR, Roberts DJ, Rogena E, Walong E, Fligner CL, Keating MK, Gachii AK, Maleche-Obimbo E, Irimu G, Mathaiya J, Orata N, Lopokoiyit R, Maina J, Emukule GO, Onyango CO, Gikunju S, Owuor C, Kinuthia P, Bunei M, Carvalho MG, Fields B, Mott JA, Widdowson MA, Chaves SS},
  journal = {he Pediatric Infectious Disease Journal},
  year    = 2021,
  volume  = online,
  number  = First - Issue,
  doi = doi: 10.1097/INF.0000000000003159
}

repository: DCollinsOwuor/website

repo_name: DCollinsOwuor/website


text:
DESCRIPTION = "Perl5 access to Berkeley DB version 1.x"
SECTION = "libs"
LICENSE = "Artistic|GPLv1+"
DEPENDS = "virtual/db"
RDEPENDS_${PN} += "perl-module-extutils-makemaker"
PR = "r1"

BBCLASSEXTEND = "native"

SRC_URI = "http://search.cpan.org/CPAN/authors/id/P/PM/PMQS/DB_File-${PV}.tar.gz;name=db-file-perl-${PV}"
SRC_URI[db-file-perl-1.820.md5sum] = "28979bee29d8075b0dffab02fe29df6e"
SRC_URI[db-file-perl-1.820.sha256sum] = "eae8d2d2144504118773f3e1787321d2c757e7c5abf0a60591c73495352ddf4a"

S = "${WORKDIR}/DB_File-${PV}"

do_configure_prepend() {
	export DB_FILE_LIB=${STAGING_LIBDIR}
}

inherit cpan

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
inherit pypi setuptools
require python-keyring.inc

RDEPENDS_${PN} += "\
	${PYTHON_PN}-lang \
	${PYTHON_PN}-textutils \
"

repository: derekstraka/meta-iot-cloud

repo_name: derekstraka/meta-iot-cloud

gha_license_id: MIT


text:
DESCRIPTION = "A shell-script tool for converting XML files to various formats"
HOMEPAGE = "https://fedorahosted.org/xmlto/"
SECTION = "docs/xmlto"
LICENSE = "GPLv2"

LIC_FILES_CHKSUM = "file://COPYING;md5=59530bdf33659b29e73d4adb9f9f6552"

PR = "r1"

SRC_URI = "https://fedorahosted.org/releases/x/m/xmlto/xmlto-${PV}.tar.gz \
           file://obsolete_automake_macros.patch \
"
SRC_URI[md5sum] = "a88cd3f08789b4825d1ac89fa065170d"
SRC_URI[sha256sum] = "c52b56d929e8d20fc19cd3b7ec238f8d039730c56ee311cc352e843147e3e31a"

inherit autotools

BBCLASSEXTEND = "native nativesdk"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace

gha_language: Python


text:
% Encoding: UTF-8

@InProceedings{MeansOfGrads2011a,
  author    = {Fabian Timm, Erhardt Barth},
  title     = {{ACCURATE} {EYE} {CENTRE} {LOCALISATION} {BY} {MEANS} {OF} {GRADIENTS}},
  booktitle = {Proceedings of the International Conference on Computer Vision Theory and Applications},
  year      = {2011},
  publisher = {{SciTePress} - Science and and Technology Publications},
  doi       = {10.5220/0003326101250130},
}

@Book{eyeControllPresentAndFuture,
  title     = {Eye-controlled media: present and future state},
  publisher = {University of Copenhagen DIKU},
  year      = {1995},
  author    = {Glenstrup A. J., Engell-Nielsen T.},
}

@InProceedings{Violaa,
  author    = {P. Viola and M. Jones},
  title     = {Rapid object detection using a boosted cascade of simple features},
  booktitle = {Proceedings of the 2001 {IEEE} Computer Society Conference on Computer Vision and Pattern Recognition. {CVPR} 2001},
  publisher = {{IEEE} Comput. Soc},
  doi       = {10.1109/cvpr.2001.990517},
}

@InProceedings{Violab,
  author    = {P. Viola and M. Jones},
  title     = {Robust real-time face detection},
  booktitle = {Proceedings Eighth {IEEE} International Conference on Computer Vision. {ICCV} 2001},
  publisher = {{IEEE} Comput. Soc},
  doi       = {10.1109/iccv.2001.937709},
}

@Article{Turk1991,
  author    = {Matthew Turk and Alex Pentland},
  title     = {Eigenfaces for Recognition},
  journal   = {Journal of Cognitive Neuroscience},
  year      = {1991},
  volume    = {3},
  number    = {1},
  pages     = {71--86},
  month     = {jan},
  doi       = {10.1162/jocn.1991.3.1.71},
  publisher = {{MIT} Press - Journals},
}

@Article{PerveenN2013,
  author  = {Perveen N.},
  title   = {An overview on template matching methodologies and its applications},
  journal = {International Journal of Research in Computer and Communication Technology},
  year    = {2013},
}

@InCollection{Rawlinson2010,
  author    = {Tim Rawlinson and Abhir Bhalerao and Li Wang},
  title     = {Principles and Methods for Face Recognition and Face Modelling},
  booktitle = {Handbook of Research on Computational Forensics, Digital Crime, and Investigation},
  publisher = {{IGI} Global},
  year      = {2010},
  pages     = {53--78},
  doi       = {10.4018/978-1-60566-836-9.ch003},
}

@InCollection{Edwards1998,
  author    = {G. J. Edwards and T. F. Cootes and C. J. Taylor},
  title     = {Face recognition using active appearance models},
  booktitle = {Lecture Notes in Computer Science},
  publisher = {Springer Berlin Heidelberg},
  year      = {1998},
  pages     = {581--595},
  doi       = {10.1007/bfb0054766},
}

@InCollection{Choa,
  author    = {Woon Cho and Taekyung Kim and Joonki Paik},
  title     = {Gait Recognition Using Active Shape Models},
  booktitle = {Advanced Concepts for Intelligent Vision Systems},
  publisher = {Springer Berlin Heidelberg},
  pages     = {384--394},
  doi       = {10.1007/978-3-540-74607-2_35},
}

@Book{Martin2017,
  title     = {Clean Architecture},
  publisher = {Prentice Hall},
  year      = {2017},
  author    = {Martin, Robert C.},
  isbn      = {0134494164},
  date      = {2017-09-10},
  ean       = {9780134494166},
  pagetotal = {432},
  url       = {https://www.ebook.de/de/product/26274524/robert_c_martin_clean_architecture.html},
}

@PhdThesis{Blink2014,
  author = {Tomasz Jarzynski},
  title  = {Eye Blinking Detection and Analysis},
  school = {Gliwice, Siegen},
  year   = {2014},
}

@Comment{jabref-meta: databaseType:bibtex;}

repository: AChep/khpi-latex

repo_name: AChep/khpi-latex

gha_language: TeX


text:
inherit pypi setuptools
require python-azure-cli-find.inc

RDEPENDS_${PN} += "\
    ${PYTHON_PN}-textutils \
"

repository: DasRoteSkelett/meta-iot-cloud

repo_name: DasRoteSkelett/meta-iot-cloud


text:
package sandbox_test

import (
	"testing"
	"time"

	"github.com/cri-o/cri-o/internal/hostport"
	"github.com/cri-o/cri-o/internal/lib/sandbox"
	. "github.com/cri-o/cri-o/test/framework"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"github.com/sirupsen/logrus"
	types "k8s.io/cri-api/pkg/apis/runtime/v1"
)

// TestSandbox runs the created specs
func TestSandbox(t *testing.T) {
	RegisterFailHandler(Fail)
	RunFrameworkSpecs(t, "Sandbox")
}

var (
	t           *TestFramework
	testSandbox *sandbox.Sandbox
)

var _ = BeforeSuite(func() {
	t = NewTestFramework(NilFunc, NilFunc)
	t.Setup()

	logrus.SetLevel(logrus.PanicLevel)
})

var _ = AfterSuite(func() {
	t.Teardown()
})

func beforeEach() {
	// Setup test vars
	var err error
	testSandbox, err = sandbox.New("sandboxID", "", "", "", "",
		make(map[string]string), make(map[string]string), "", "",
		&types.PodSandboxMetadata{}, "", "", false, "", "", "",
		[]*hostport.PortMapping{}, false, time.Now(), "", nil, nil)
	Expect(err).To(BeNil())
	Expect(testSandbox).NotTo(BeNil())
}

repository: cri-o/cri-o

repo_name: cri-o/cri-o

gha_language: Go


text:
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
// ------------------------------------------------------------

package logger

import (
	"strings"
	"sync"
)

const (
	// LogTypeLog is normal log type
	LogTypeLog = "log"
	// LogTypeRequest is Request log type
	LogTypeRequest = "request"

	// Field names that defines Dapr log schema
	logFieldTimeStamp = "time"
	logFieldLevel     = "level"
	logFieldType      = "type"
	logFieldScope     = "scope"
	logFieldMessage   = "msg"
	logFieldInstance  = "instance"
	logFieldDaprVer   = "ver"
	logFieldAppID     = "app_id"
)

// LogLevel is Dapr Logger Level type
type LogLevel string

const (
	// DebugLevel has verbose message
	DebugLevel LogLevel = "debug"
	// InfoLevel is default log level
	InfoLevel LogLevel = "info"
	// WarnLevel is for logging messages about possible issues
	WarnLevel LogLevel = "warn"
	// ErrorLevel is for logging errors
	ErrorLevel LogLevel = "error"
	// FatalLevel is for logging fatal messages. The system shuts down after logging the message.
	FatalLevel LogLevel = "fatal"

	// UndefinedLevel is for undefined log level
	UndefinedLevel LogLevel = "undefined"
)

// globalLoggers is the collection of Dapr Logger that is shared globally.
// TODO: User will disable or enable logger on demand.
var globalLoggers = map[string]Logger{}
var globalLoggersLock = sync.RWMutex{}

// Logger includes the logging api sets
type Logger interface {
	// EnableJSONOutput enables JSON formatted output log
	EnableJSONOutput(enabled bool)

	// SetAppID sets dapr_id field in log. Default value is empty string
	SetAppID(id string)
	// SetOutputLevel sets log output level
	SetOutputLevel(outputLevel LogLevel)

	// WithLogType specify the log_type field in log. Default value is LogTypeLog
	WithLogType(logType string) Logger

	// Info logs a message at level Info.
	Info(args ...interface{})
	// Infof logs a message at level Info.
	Infof(format string, args ...interface{})
	// Debug logs a message at level Debug.
	Debug(args ...interface{})
	// Debugf logs a message at level Debug.
	Debugf(format string, args ...interface{})
	// Warn logs a message at level Warn.
	Warn(args ...interface{})
	// Warnf logs a message at level Warn.
	Warnf(format string, args ...interface{})
	// Error logs a message at level Error.
	Error(args ...interface{})
	// Errorf logs a message at level Error.
	Errorf(format string, args ...interface{})
	// Fatal logs a message at level Fatal then the process will exit with status set to 1.
	Fatal(args ...interface{})
	// Fatalf logs a message at level Fatal then the process will exit with status set to 1.
	Fatalf(format string, args ...interface{})
}

// toLogLevel converts to LogLevel
func toLogLevel(level string) LogLevel {
	switch strings.ToLower(level) {
	case "debug":
		return DebugLevel
	case "info":
		return InfoLevel
	case "warn":
		return WarnLevel
	case "error":
		return ErrorLevel
	case "fatal":
		return FatalLevel
	}

	// unsupported log level by Dapr
	return UndefinedLevel
}

// NewLogger creates new Logger instance.
func NewLogger(name string) Logger {
	globalLoggersLock.Lock()
	defer globalLoggersLock.Unlock()

	logger, ok := globalLoggers[name]
	if !ok {
		logger = newDaprLogger(name)
		globalLoggers[name] = logger
	}

	return logger
}

func getLoggers() map[string]Logger {
	globalLoggersLock.RLock()
	defer globalLoggersLock.RUnlock()

	l := map[string]Logger{}
	for k, v := range globalLoggers {
		l[k] = v
	}

	return l
}


text:
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://COPYING;md5=106bcadf06f1d36b417baffe40ded960"

BBCLASSEXTEND = "native"

SRC_URI = "https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.5/src/hdf5-1.10.5.tar.bz2"

# force shared library build
SRC_URI += "file://${PV}/0002-Add-configure-options-to-build-static-and-shared-lib.patch"

# avoid generating of the H5Tinit.c and H5lib_settings.c files
SRC_URI += "file://${PV}/0002-hdf5-c.patch"

#Add --with-c-max-real-precision and --enable-float-128
SRC_URI += "file://${PV}/0001-Add-new-option-for-c-max-real-precision-and-float-12.patch"

# H5Tinit.c and H5lib_settings.c files for each platform
SRC_URI += "${H5_CONFIG_FILES}"

H5_CONFIG_FILES ?= " \
"

H5_CONFIG_FILES_qoriq = " \
    file://${PV}/qoriq/H5Tinit.c \
    file://${PV}/qoriq/H5lib_settings.c \
"

H5_CONFIG_FILES_intel-x86-common = " \
    file://${PV}/cct/H5Tinit.c \
    file://${PV}/cct/H5lib_settings.c \
"

SRC_URI[md5sum] = "7c19d6b81ee2a3ba7d36f6922b2f90d3"
SRC_URI[sha256sum] = "68d6ea8843d2a106ec6a7828564c1689c7a85714a35d8efafa2fee20ca366f44"

DEPENDS += "zlib"
S = "${WORKDIR}/hdf5-1.10.5"
# Increment revision number if package changes...
PR = "r1"

EXTRA_OECONF = "--with-szlib=no --with-pthread=no --enable-threadsafe=no --enable-cxx=yes"
EXTRA_OECONF += "--with-c-max-real-precision=21 --enable-float-128=no"
EXTRA_OECONF += "--enable-shared=yes --enable-static=no"
EXTRA_OECONF += "hdf5_cv_fp_to_integer_overflow_works=yes"
EXTRA_OECONF += "hdf5_cv_ldouble_to_long_special=no"
EXTRA_OECONF += "hdf5_cv_long_to_ldouble_special=no"
EXTRA_OECONF += "hdf5_cv_ldouble_to_llong_accurate=yes"
EXTRA_OECONF += "hdf5_cv_llong_to_ldouble_correct=yes"
EXTRA_OECONF += "hdf5_cv_disable_some_ldouble_conv=no"

PROVIDES += "${PN}-tests ${PN}-tests-dbg ${PN}-examples"
PACKAGES += "${PN}-tests ${PN}-tests-dbg ${PN}-examples"

FILES_${PN} += "${libdir}/libhdf5.settings"
FILES_${PN}-tests = "${libdir}/hdf5-tests/[a-z]*"
FILES_${PN}-tests-dbg = "${libdir}/hdf5-tests/.debug"
FILES_${PN}-examples = "${datadir}/hdf5_examples"

inherit autotools pkgconfig

INSANE_SKIP_${PN}-tests += "already-stripped"
INSANE_SKIP_${PN} += "already-stripped"

# add files generated by HDF5 during compilation; these cannot be
# generated during cross-compilation
do_configure_append_qoriq() {
    cp ${WORKDIR}/${PV}/qoriq/H5*.c ${B}/src/
}

do_configure_append_intel-x86-common() {
    cp ${WORKDIR}/${PV}/cct/H5*.c ${B}/src/
}

do_install_append() {
    install -d ${D}/${libdir}/hdf5-tests
    cp -r ${B}/test/.libs/* ${D}/${libdir}/hdf5-tests/
    rm ${D}/${libdir}/hdf5-tests/*.a
    rm ${D}/${libdir}/hdf5-tests/*.o
    rm ${D}/${libdir}/hdf5-tests/*.la
}

repository: icshwi/yocto-ess

repo_name: icshwi/yocto-ess


text:
package integration

// Config is the configuration for the integration app.
type Config struct {
	AutomaticFinalizeBlock bool
	AutomaticCommit        bool
}

// Option is a function that can be used to configure the integration app.
type Option func(*Config)

// WithAutomaticFinalizeBlock calls ABCI finalize block.
func WithAutomaticFinalizeBlock() Option {
	return func(cfg *Config) {
		cfg.AutomaticFinalizeBlock = true
	}
}

// WithAutomaticCommit enables automatic commit.
// This means that the integration app will automatically commit the state after each msgs.
func WithAutomaticCommit() Option {
	return func(cfg *Config) {
		cfg.AutomaticCommit = true
	}
}

repository: cosmos/cosmos-sdk

repo_name: cosmos/cosmos-sdk


text:
@article{bekelman_scope_2003,
	title = {Scope and impact of financial conflicts of interest in biomedical research: a systematic review},
	volume = {289},
	issn = {0098-7484},
	url = {http://www.ncbi.nlm.nih.gov/pubmed/12533125},
	shorttitle = {Scope and impact of financial conflicts of interest in biomedical research},
	abstract = {Abstract: "{CONTEXT}: Despite increasing awareness about the potential impact of financial conflicts of interest on biomedical research, no comprehensive synthesis of the body of evidence relating to financial conflicts of interest has been performed. {OBJECTIVE}: To review original, quantitative studies on the extent, impact, and management of financial conflicts of interest in biomedical research. {DATA} {SOURCES}: Studies were identified by searching {MEDLINE} (January 1980-October 2002), the Web of Science citation database, references of articles, letters, commentaries, editorials, and books and by contacting experts. {STUDY} {SELECTION}: All English-language studies containing original, quantitative data on financial relationships among industry, scientific investigators, and academic institutions were included. A total of 1664 citations were screened, 144 potentially eligible full articles were retrieved, and 37 studies met our inclusion criteria. {DATA} {EXTRACTION}: One investigator (J.E.B.) extracted data from each of the 37 studies. The main outcomes were the prevalence of specific types of industry relationships, the relation between industry sponsorship and study outcome or investigator behavior, and the process for disclosure, review, and management of financial conflicts of interest. {DATA} {SYNTHESIS}: Approximately one fourth of investigators have industry affiliations, and roughly two thirds of academic institutions hold equity in start-ups that sponsor research performed at the same institutions. Eight articles, which together evaluated 1140 original studies, assessed the relation between industry sponsorship and outcome in original research. Aggregating the results of these articles showed a statistically significant association between industry sponsorship and pro-industry conclusions (pooled Mantel-Haenszel odds ratio, 3.60; 95% confidence interval, 2.63-4.91). Industry sponsorship was also associated with restrictions on publication and data sharing. The approach to managing financial conflicts varied substantially across academic institutions and peer-reviewed journals. {CONCLUSIONS}: Financial relationships among industry, scientific investigators, and academic institutions are widespread. Conflicts of interest arising from these ties can influence biomedical research in important ways."},
	pages = {454--465},
	number = {4},
	journaltitle = {{JAMA}: The Journal of the American Medical Association},
	shortjournal = {{JAMA}},
	author = {Bekelman, Justin E and Li, Yan and Gross, Cary P},
	urldate = {2011-11-16},
	date = {2003-01-22},
	pmid = {12533125}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
@InProceedings{winner15,
  supplementary = {Supplementary:winner15-supp.pdf},
  title = {Inference in a Partially Observed Queuing Model with Applications in Ecology},
  author = {Kevin Winner and Garrett Bernstein and Dan Sheldon},
  pages = {2512-2520},
  abstract = {We consider the problem of inference in a probabilistic model for transient populations where we wish to learn about arrivals, departures, and population size over all time, but the only available data are periodic counts of the population size at specific observation times. The underlying model arises in queueing theory (as an M/G/inf queue) and also in ecological models for short-lived animals such as insects. Our work applies to both systems. Previous work in the ecology literature focused on maximum likelihood estimation and made a simplifying independence assumption that prevents inference over unobserved random variables such as arrivals and departures. The contribution of this paper is to formulate a latent variable model and develop a novel Gibbs sampler based on Markov bases to perform inference using the correct, but intractable, likelihood function. We empirically validate the convergence behavior of our sampler and demonstrate the ability of our model to make much finer-grained inferences than the previous approach.},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
%
@article{Oleary2012,
  author    = {Paul O'Leary and
               Matthew Harker},
  title     = {A Framework for the Evaluation of Inclinometer Data in the
               Measurement of Structures},
  journal   = {IEEE T. Instrumentation and Measurement},
  volume    = {61},
  number    = {5},
  year      = {2012},
  pages     = {1237-1251},
  ee        = {http://dx.doi.org/10.1109/TIM.2011.2180969}
}
%
@inproceedings{
oleary2008b,
   Author = {O'Leary, P. and Harker, M.},
   Title = {An Algebraic Framework for Discrete Basis Functions in Computer Vision},
   BookTitle = {2008 $6^{\textrm{th}}$ ICVGIP},
   Address= {Bhubaneswar, India},
   Publisher = {IEEE},
   Pages = {150-157},
 Year = {2008} }

@inproceedings{oleary2010C,
   Author = {O'Leary, P. and Harker, M.},
   Title = {Discrete Polynomial Moments and Savitzky-Golay Smoothing},
   BookTitle = {Waset Special Journal},
   Volume = {72},
   DOI = {},
   Pages = {439--443},
Year = {2010}}
%


text:
@ARTICLE{Applegate2012-ah,
title       = "An assessment of key model parametric uncertainties in
projections of {G}reenland {I}ce {S}heet behavior",
author      = "Applegate, P J and Kirchner, N and Stone, E J and Keller, K
and Greve, R",
journal     = "The Cryosphere",
volume      =  6,
number      =  3,
pages       = "589--606",
month       =  "30~" # may,
year        =  2012,
url         = "http://goo.gl/6n55O0",
keywords    = "Ice Sheets; Parametric Uncertainties",
issn        = "1994-0424",
doi         = "10.5194/tc-6-589-2012",
original_id = "5b42a4b1-366f-0439-87ce-046bba66c139"
}


text:
const Node = require('../index');
const assert = require('assert');

let node1 = new Node();
node1.once('bound', () => {
    let node2 = new Node();
    node2.once('error', error => {
        assert(error.code === 'EADDRINUSE');
        process.exit(0);
    });
    node2.bind(53454);
});
node1.bind(53454);

setTimeout(process.exit.bind(process, 1), 5000);

extension: js


text:
@inproceedings{portaz2020qiss,
 author = {Portaz, Maxime and Nivaggioli, Adrien and Randrianarivo, Hicham and Kacher, Ilyes and Peyronnet, Sylvain},
 booktitle = {Advances in Information Retrieval},
 pages = {486},
 publisher = {Springer International Publishing},
 title = {QISS: An Open Source Image Similarity Search Engine},
 year = {2020}
}


text:
// Copyright 2023 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package beta

import (
	"github.com/GoogleCloudPlatform/declarative-resource-client-library/dcl"
)

func DCLServerTlsPolicySchema() *dcl.Schema {
	return &dcl.Schema{
		Info: &dcl.Info{
			Title:       "NetworkSecurity/ServerTlsPolicy",
			Description: "The NetworkSecurity ServerTlsPolicy resource",
			StructName:  "ServerTlsPolicy",
			HasIAM:      true,
		},
		Paths: &dcl.Paths{
			Get: &dcl.Path{
				Description: "The function used to get information about a ServerTlsPolicy",
				Parameters: []dcl.PathParameters{
					dcl.PathParameters{
						Name:        "serverTlsPolicy",
						Required:    true,
						Description: "A full instance of a ServerTlsPolicy",
					},
				},
			},
			Apply: &dcl.Path{
				Description: "The function used to apply information about a ServerTlsPolicy",
				Parameters: []dcl.PathParameters{
					dcl.PathParameters{
						Name:        "serverTlsPolicy",
						Required:    true,
						Description: "A full instance of a ServerTlsPolicy",
					},
				},
			},
			Delete: &dcl.Path{
				Description: "The function used to delete a ServerTlsPolicy",
				Parameters: []dcl.PathParameters{
					dcl.PathParameters{
						Name:        "serverTlsPolicy",
						Required:    true,
						Description: "A full instance of a ServerTlsPolicy",
					},
				},
			},
			DeleteAll: &dcl.Path{
				Description: "The function used to delete all ServerTlsPolicy",
				Parameters: []dcl.PathParameters{
					dcl.PathParameters{
						Name:     "project",
						Required: true,
						Schema: &dcl.PathParametersSchema{
							Type: "string",
						},
					},
					dcl.PathParameters{
						Name:     "location",
						Required: true,
						Schema: &dcl.PathParametersSchema{
							Type: "string",
						},
					},
				},
			},
			List: &dcl.Path{
				Description: "The function used to list information about many ServerTlsPolicy",
				Parameters: []dcl.PathParameters{
					dcl.PathParameters{
						Name:     "project",
						Required: true,
						Schema: &dcl.PathParametersSchema{
							Type: "string",
						},
					},
					dcl.PathParameters{
						Name:     "location",
						Required: true,
						Schema: &dcl.PathParametersSchema{
							Type: "string",
						},
					},
				},
			},
		},
		Components: &dcl.Components{
			Schemas: map[string]*dcl.Component{
				"ServerTlsPolicy": &dcl.Component{
					Title:           "ServerTlsPolicy",
					ID:              "projects/{{project}}/locations/{{location}}/serverTlsPolicies/{{name}}",
					ParentContainer: "project",
					LabelsField:     "labels",
					HasCreate:       true,
					HasIAM:          true,
					SchemaProperty: dcl.Property{
						Type: "object",
						Required: []string{
							"name",
							"project",
							"location",
						},
						Properties: map[string]*dcl.Property{
							"allowOpen": &dcl.Property{
								Type:        "boolean",
								GoName:      "AllowOpen",
								Description: "Optional. Determines if server allows plaintext connections. If set to true, server allows plain text connections. By default, it is set to false. This setting is not exclusive of other encryption modes. For example, if allow_open and mtls_policy are set, server allows both plain text and mTLS connections. See documentation of other encryption modes to confirm compatibility.",
							},
							"createTime": &dcl.Property{
								Type:        "string",
								Format:      "date-time",
								GoName:      "CreateTime",
								ReadOnly:    true,
								Description: "Output only. The timestamp when the resource was created.",
								Immutable:   true,
							},
							"description": &dcl.Property{
								Type:        "string",
								GoName:      "Description",
								Description: "Optional. Free-text description of the resource.",
							},
							"labels": &dcl.Property{
								Type: "object",
								AdditionalProperties: &dcl.Property{
									Type: "string",
								},
								GoName:      "Labels",
								Description: "Optional. Set of label tags associated with the resource.",
							},
							"location": &dcl.Property{
								Type:        "string",
								GoName:      "Location",
								Description: "The location for the resource",
								Immutable:   true,
							},
							"mtlsPolicy": &dcl.Property{
								Type:        "object",
								GoName:      "MtlsPolicy",
								GoType:      "ServerTlsPolicyMtlsPolicy",
								Description: "Optional. Defines a mechanism to provision peer validation certificates for peer to peer authentication (Mutual TLS - mTLS). If not specified, client certificate will not be requested. The connection is treated as TLS and not mTLS. If allow_open and mtls_policy are set, server allows both plain text and mTLS connections.",
								Required: []string{
									"clientValidationCa",
								},
								Properties: map[string]*dcl.Property{
									"clientValidationCa": &dcl.Property{
										Type:        "array",
										GoName:      "ClientValidationCa",
										Description: "Required. Defines the mechanism to obtain the Certificate Authority certificate to validate the client certificate.",
										SendEmpty:   true,
										ListType:    "list",
										Items: &dcl.Property{
											Type:   "object",
											GoType: "ServerTlsPolicyMtlsPolicyClientValidationCa",
											Properties: map[string]*dcl.Property{
												"certificateProviderInstance": &dcl.Property{
													Type:        "object",
													GoName:      "CertificateProviderInstance",
													GoType:      "ServerTlsPolicyMtlsPolicyClientValidationCaCertificateProviderInstance",
													Description: "The certificate provider instance specification that will be passed to the data plane, which will be used to load necessary credential information.",
													Conflicts: []string{
														"grpcEndpoint",
													},
													Required: []string{
														"pluginInstance",
													},
													Properties: map[string]*dcl.Property{
														"pluginInstance": &dcl.Property{
															Type:        "string",
															GoName:      "PluginInstance",
															Description: "Required. Plugin instance name, used to locate and load CertificateProvider instance configuration. Set to \"google_cloud_private_spiffe\" to use Certificate Authority Service certificate provider instance.",
														},
													},
												},
												"grpcEndpoint": &dcl.Property{
													Type:        "object",
													GoName:      "GrpcEndpoint",
													GoType:      "ServerTlsPolicyMtlsPolicyClientValidationCaGrpcEndpoint",
													Description: "gRPC specific configuration to access the gRPC server to obtain the CA certificate.",
													Conflicts: []string{
														"certificateProviderInstance",
													},
													Required: []string{
														"targetUri",
													},
													Properties: map[string]*dcl.Property{
														"targetUri": &dcl.Property{
															Type:        "string",
															GoName:      "TargetUri",
															Description: "Required. The target URI of the gRPC endpoint. Only UDS path is supported, and should start with “unix:”.",
														},
													},
												},
											},
										},
									},
								},
							},
							"name": &dcl.Property{
								Type:        "string",
								GoName:      "Name",
								Description: "Required. Name of the ServerTlsPolicy resource.",
								Immutable:   true,
							},
							"project": &dcl.Property{
								Type:        "string",
								GoName:      "Project",
								Description: "The project for the resource",
								Immutable:   true,
								ResourceReferences: []*dcl.PropertyResourceReference{
									&dcl.PropertyResourceReference{
										Resource: "Cloudresourcemanager/Project",
										Field:    "name",
										Parent:   true,
									},
								},
							},
							"serverCertificate": &dcl.Property{
								Type:        "object",
								GoName:      "ServerCertificate",
								GoType:      "ServerTlsPolicyServerCertificate",
								Description: "Optional. Defines a mechanism to provision server identity (public and private keys). Cannot be combined with allow_open as a permissive mode that allows both plain text and TLS is not supported.",
								Properties: map[string]*dcl.Property{
									"certificateProviderInstance": &dcl.Property{
										Type:        "object",
										GoName:      "CertificateProviderInstance",
										GoType:      "ServerTlsPolicyServerCertificateCertificateProviderInstance",
										Description: "The certificate provider instance specification that will be passed to the data plane, which will be used to load necessary credential information.",
										Conflicts: []string{
											"grpcEndpoint",
										},
										Required: []string{
											"pluginInstance",
										},
										Properties: map[string]*dcl.Property{
											"pluginInstance": &dcl.Property{
												Type:        "string",
												GoName:      "PluginInstance",
												Description: "Required. Plugin instance name, used to locate and load CertificateProvider instance configuration. Set to \"google_cloud_private_spiffe\" to use Certificate Authority Service certificate provider instance.",
											},
										},
									},
									"grpcEndpoint": &dcl.Property{
										Type:        "object",
										GoName:      "GrpcEndpoint",
										GoType:      "ServerTlsPolicyServerCertificateGrpcEndpoint",
										Description: "gRPC specific configuration to access the gRPC server to obtain the cert and private key.",
										Conflicts: []string{
											"certificateProviderInstance",
										},
										Required: []string{
											"targetUri",
										},
										Properties: map[string]*dcl.Property{
											"targetUri": &dcl.Property{
												Type:        "string",
												GoName:      "TargetUri",
												Description: "Required. The target URI of the gRPC endpoint. Only UDS path is supported, and should start with “unix:”.",
											},
										},
									},
								},
							},
							"updateTime": &dcl.Property{
								Type:        "string",
								Format:      "date-time",
								GoName:      "UpdateTime",
								ReadOnly:    true,
								Description: "Output only. The timestamp when the resource was updated.",
								Immutable:   true,
							},
						},
					},
				},
			},
		},
	}
}


text:
package kata

func johnAndAnn(n int) ([]int, []int) {
	john := make([]int, n)
	john[0] = 0
	ann := make([]int, n)
	ann[0] = 1
	for i := 1; i < n; i++ {
		john[i] = i - ann[john[i-1]]
		ann[i] = i - john[ann[i-1]]
	}
	return john, ann
}

func Ann(n int) []int {
	_, a := johnAndAnn(n)
	return a
}
func John(n int) []int {
	j, _ := johnAndAnn(n)
	return j
}
func SumJohn(n int) int {
	j, _ := johnAndAnn(n)
	var sum = 0
	for i := 0; i < n; i++ {
		sum += j[i]
	}
	return sum
}
func SumAnn(n int) int {
	_, a := johnAndAnn(n)
	var sum = 0
	for i := 0; i < n; i++ {
		sum += a[i]
	}
	return sum
}


text:
@article{Ohkawa_2010,
 author = {Ohkawa, Taro and Volkman, Loy E. and Welch, Matthew D.},
 title = {Actin-based motility drives baculovirus transit to the nucleus and cell surface},
 journal = {Journal of Cell Biology},
 publisher = {Rockefeller University Press},
 year = {2010},
 month = {jul},
 number = {2},
 volume = {190},
 pages = {187--195},
 url = {https://doi.org/10.1083%2Fjcb.201001162},
 doi = {10.1083/jcb.201001162}
}


text:
SUMMARY = "IoT RefKit ostree helper, scripts, services, et al."

LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://LICENSE-BSD;md5=f9f435c1bd3a753365e799edf375fc42"

SRC_URI = " \
  file://${PN} \
"

DEPENDS = "ostree"

inherit autotools pkgconfig systemd distro_features_check

REQUIRED_DISTRO_FEATURES = "ostree systemd"

S = "${WORKDIR}/${PN}"

PACKAGES += "${PN}-initramfs"

FILES_${PN}-initramfs = " \
    ${bindir}/refkit-ostree \
"

FILES_${PN} = " \
    ${bindir}/refkit-ostree-update \
    ${systemd_unitdir}/system/* \
    ${datadir}/${PN} \
"

# Our systemd services.
SYSTEMD_SERVICE_${PN} = " \
    refkit-patch-ostree-param.service \
    refkit-update.service \
    refkit-reboot.service \
    refkit-update-post-check.service \
"

EXTRA_OECONF += " \
            --with-systemdunitdir=${systemd_unitdir}/system \
"

RDEPENDS_${PN} += "ostree"

repository: intel/intel-iot-refkit

repo_name: intel/intel-iot-refkit


text:
@article{sensmier_study_of_vehicle_structural_layouts_post_WWII_aircraft,
author = "Mark Sensmeier and Jamshid Samareh",
title  = "A Study Of Vehicle Structural Layouts In Post-WWII Aircraft",
journal= "45th AIAA/ASME/ASCE/AHS/ASC Structures, Structural Dynamics and Materials Conference",
year   = 2004,
month  = 4,
}

repository: JustinClough/grasp

repo_name: JustinClough/grasp


text:
SUMMARY = "Balto web demo"
DESCRIPTION = "Balto web demo"
HOMEPAGE = ""
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=1da6a62a56f42d0f37c25f5d4dc6fa94"

SRCREV="18f48f2fabbe6c80e943af14aad3d12bdbcb7070"
SRC_URI = "git://github.com/baltoboard/webdemo.git;branch=master"
S = "${WORKDIR}/git"

SRV_DIR ?= "${servicedir}/www"

do_install_append () {
    install -d ${D}${SRV_DIR}
    cp -r ${S}/demo ${D}${SRV_DIR}
    cp -r ${S}/cgi-bin ${D}${SRV_DIR}
}

FILES_${PN} += "${SRV_DIR}"

PACKAGE_ARCH = "${MACHINE_ARCH}"
COMPATIBLE_MACHINE = "balto"


text:
package pogo

import (
	"github.com/pkg/errors"
	"github.com/sanggonlee/pogo/internal/query"
	"github.com/sanggonlee/pogo/postgres13"
)

// StatActivity13 is a convenience method for running a query on pg_stat_activity view.
// It is meant to be used for Postgres v13.
// If you want to select rows with certain conditions, pass a non-empty where argument,
// which will be injected as WHERE {where} in the query.
func (qr QueryRunner) StatActivity13(where string, joins ...query.Queryable) ([]postgres13.StatActivityJoined, error) {
	if v := GetPostgresVersion(); v != Postgres13 {
		return nil, getVersionMismatchError(Postgres13, v)
	}

	queryable := StatActivityView.
		Where(where).
		With(joins...)

	rows, err := qr.For(queryable)
	if err != nil {
		return nil, errors.Wrap(err, "querying pg_stat_activity")
	}
	defer rows.Close()

	ss := make([]postgres13.StatActivityJoined, 0)
	for rows.Next() {
		var s postgres13.StatActivityJoined
		dest := s.ScanDestinations(queryable.Joins)

		if err := rows.Scan(dest...); err != nil {
			return nil, errors.Wrap(err, "scanning pg_stat_activity row")
		}

		ss = append(ss, s)
	}

	return ss, nil
}

// StatReplication13 is a convenience method for running a query on pg_stat_replication view.
// It is meant to be used for Postgres v13.
// If you want to select rows with certain conditions, pass a non-empty where argument,
// which will be injected as WHERE {where} in the query.
func (qr QueryRunner) StatReplication13(where string, joins ...query.Queryable) ([]postgres13.StatReplicationJoined, error) {
	if v := GetPostgresVersion(); v != Postgres13 {
		return nil, getVersionMismatchError(Postgres13, v)
	}

	queryable := StatReplicationView.
		Where(where).
		With(joins...)

	rows, err := qr.For(queryable)
	if err != nil {
		return nil, errors.Wrap(err, "querying pg_stat_replication")
	}
	defer rows.Close()

	ss := make([]postgres13.StatReplicationJoined, 0)
	for rows.Next() {
		var s postgres13.StatReplicationJoined
		dest := s.ScanDestinations(queryable.Joins)

		if err := rows.Scan(dest...); err != nil {
			return nil, errors.Wrap(err, "scanning pg_stat_replication row")
		}

		ss = append(ss, s)
	}

	return ss, nil
}

// StatTable13 is a convenience method for running a query on pg_stat_user_tables view.
// It is meant to be used for Postgres v13.
// If you want to select rows with certain conditions, pass a non-empty where argument,
// which will be injected as WHERE {where} in the query.
func (qr QueryRunner) StatTable13(where string, joins ...query.Queryable) ([]postgres13.StatTableJoined, error) {
	if v := GetPostgresVersion(); v != Postgres13 {
		return nil, getVersionMismatchError(Postgres13, v)
	}

	queryable := StatUserTablesView.
		Where(where).
		With(joins...)

	rows, err := qr.For(queryable)
	if err != nil {
		return nil, errors.Wrap(err, "querying pg_stat_user_tables")
	}
	defer rows.Close()

	ss := make([]postgres13.StatTableJoined, 0)
	for rows.Next() {
		var s postgres13.StatTableJoined
		dest := s.ScanDestinations(queryable.Joins)

		if err := rows.Scan(dest...); err != nil {
			return nil, errors.Wrap(err, "scanning pg_stat_user_tables row")
		}

		ss = append(ss, s)
	}

	return ss, nil
}

// Locks13 is a convenience method for running a query on pg_locks view.
// It is meant to be used for Postgres v13.
// If you want to select rows with certain conditions, pass a non-empty where argument,
// which will be injected as WHERE {where} in the query.
func (qr QueryRunner) Locks13(where string, joins ...query.Queryable) ([]postgres13.LockJoined, error) {
	if v := GetPostgresVersion(); v != Postgres13 {
		return nil, getVersionMismatchError(Postgres13, v)
	}

	queryable := LocksView.
		Where(where).
		With(joins...)

	rows, err := qr.For(queryable)
	if err != nil {
		return nil, errors.Wrap(err, "querying pg_locks")
	}
	defer rows.Close()

	ls := make([]postgres13.LockJoined, 0)
	for rows.Next() {
		var l postgres13.LockJoined
		dest := l.ScanDestinations(queryable.Joins)

		if err := rows.Scan(dest...); err != nil {
			return nil, errors.Wrap(err, "scanning pg_locks row")
		}

		ls = append(ls, l)
	}

	return ls, nil
}

repository: sanggonlee/pogo

repo_name: sanggonlee/pogo


text:
@article{article,
author = {Hochreiter, Sepp and Schmidhuber, Jürgen},
year = {1997},
month = {12},
pages = {1735-80},
title = {Long Short-term Memory},
volume = {9},
journal = {Neural computation},
doi = {10.1162/neco.1997.9.8.1735}
}


text:
@inproceedings{ngc-Liu1999,
 author = {Liu, Congyue and Ezhilchelvan, Paul D and Barcellos, Marinho Pilla},
 booktitle = {NGC Workshop},
 file = {:Users/mbarcell/Google Drive (mbarcell@waikato.ac.nz)/Work/Research/MendeleyPaperBase/Liu, Ezhilchelvan, Barcellos/NGC Workshop_1999_Liu, Ezhilchelvan, Barcellos.pdf:pdf},
 month = {nov},
 publisher = {Springer-Verlag},
 title = {A Multicast Transport Protocol for Reliable Group Applications},
 url = {http://portal.acm.org/citation.cfm?id=648088.747478&coll=DL&dl=GUIDE&CFID=14775519&CFTOKEN=75724076 papers3://publication/uuid/92D31718-9200-476B-9E87-A57713E8D1D3},
 year = {1999}
}

repository: marinho-barcellos/academic-kickstart

repo_name: marinho-barcellos/academic-kickstart


text:
// Copyright 2021 VMware, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

package handlers

import (
	"github.com/go-openapi/runtime/middleware"
	"github.com/pkg/errors"

	"github.com/vmware-tanzu/tanzu-framework/apis/config/v1alpha1"
	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/config"
	featuresclient "github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/features"
	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/web/server/models"
	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/web/server/restapi/operations/edition"
	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/web/server/restapi/operations/features"
)

// GetFeatureFlags handles requests to GET features
func (app *App) GetFeatureFlags(params features.GetFeatureFlagsParams) middleware.Responder {
	cfg, err := config.GetClientConfig()
	if err != nil {
		return features.NewGetFeatureFlagsInternalServerError().WithPayload(Err(errors.Wrap(err, "unable to get client configuration")))
	}
	payload := models.Features{}
	for pluginName, featureMap := range cfg.ClientOptions.Features {
		payload[pluginName] = convertFeatureMap(featureMap)
	}
	return features.NewGetFeatureFlagsOK().WithPayload(payload)
}

// convertFeatureMap converts a config file v1alpha1.FeatureMap to payload models.FeatureMap both of which are just hash maps
func convertFeatureMap(featureMap v1alpha1.FeatureMap) models.FeatureMap {
	result := models.FeatureMap{}
	for key, value := range featureMap {
		result[key] = value
	}
	return result
}

// GetTanzuEdition returns the Tanzu edition
func (app *App) GetTanzuEdition(params edition.GetTanzuEditionParams) middleware.Responder {
	featuresClient, err := featuresclient.New(app.AppConfig.TKGConfigDir, "")
	if err != nil {
		return edition.NewGetTanzuEditionInternalServerError().WithPayload(Err(errors.Wrap(err, "unable to get feature flags client")))
	}

	tanzuEdition, err := featuresClient.GetFeatureFlag("edition")
	if err != nil {
		return edition.NewGetTanzuEditionInternalServerError().WithPayload(Err(errors.Wrap(err, "unable to get tanzu edition")))
	}

	return edition.NewGetTanzuEditionOK().WithPayload(tanzuEdition)
}

repository: larry-x-yu/tanzu-framework

repo_name: larry-x-yu/tanzu-framework


text:
require xkeyboard-config.inc

SRCREV = "547ae8589afb208d7b44ffe1e0ff7aba466c2ee3"
SRCREV_palmpre = "a961c7b00f077e8923e32192243db46b10a702b7"
PV = "2.0+gitr${SRCPV}"
PR = "${INC_PR}.1"

SRC_URI = "git://anongit.freedesktop.org/xkeyboard-config;protocol=git;branch=master"
SRC_URI_palmpre = "git://git.shr-project.org/repo/xkeyboard-config.git;protocol=http;branch=palmpre"

PACKAGE_ARCH_palmpre = "${MACHINE_ARCH}"

S = "${WORKDIR}/git"


text:
Automatically generated by Mendeley Desktop 1.16.3
Any changes to this file will be lost if it is regenerated by Mendeley.

BibTeX export options can be customized via Options -> BibTeX in Mendeley Desktop

@article{Eliasmith:2012:LargeScaleModel,
abstract = {A central challenge for cognitive and systems neuroscience is to relate the incredibly complex behavior of animals to the equally complex activity of their brains. Recently described, large-scale neural models have not bridged this gap between neural activity and biological function. In this work, we present a 2.5-million-neuron model of the brain (called "Spaun") that bridges this gap by exhibiting many different behaviors. The model is presented only with visual image sequences, and it draws all of its responses with a physically modeled arm. Although simplified, the model captures many aspects of neuroanatomy, neurophysiology, and psychological behavior, which we demonstrate via eight diverse tasks.},
author = {Eliasmith, Chris and Stewart, Terrence C and Choo, Xuan and Bekolay, Trevor and DeWolf, Travis and Tang, Y. and Rasmussen, Daniel},
doi = {10.1126/science.1225266},

issn = {0036-8075},
journal = {Science (80-. ).},
keywords = {Behavior,Brain,Brain: anatomy {\&} histology,Brain: physiology,Humans,Models,Neural Networks (Computer),Neurological,Software},
month = {nov},
number = {6111},
pages = {1202--1205},
title = {{A Large-Scale Model of the Functioning Brain}},
url = {http://www.sciencemag.org/cgi/doi/10.1126/science.1225266},
volume = {338},
year = {2012}
}
@incollection{Steels:2012:SymbolGroundingProblem,
abstract = {In the nineteen eighties, a lot of ink was spent on the question of$\backslash$nsymbol grounding, largely triggered by Searle�s Chinese Room story.$\backslash$nSearle�s article had the advantage of stirring up discussion about$\backslash$nwhen and how symbols could be about things in the world, whether$\backslash$nintelligence involves representa- tions or not, what embodiment means$\backslash$nand under what conditions cognition is embodied, etc. But almost$\backslash$ntwenty years of philosophical discussion have shed little light on$\backslash$nthe issue, partly because the discussion has been mixed up with arguments$\backslash$nwhether artificial intelligence was possible or not. Today I believe$\backslash$nthat sufficient progress has been made in cognitive science and AI$\backslash$nthat we can move forward and study the processes involved in representations$\backslash$ninstead of worrying about the general framework with which this should$\backslash$nbe done.},

author = {Steels, Luc},
booktitle = {Symb. EmbodimentDebates Mean. Cogn.},
doi = {10.1093/acprof:oso/9780199217274.003.0012},

isbn = {9780191696060},
issn = {978-0199217274},
keywords = {Color guessing game,Embodiment,Language emergence,Meanings,Symbol grounding problem,Symbols},
month = {oct},
number = {2005},
pages = {223--244},
publisher = {Oxford University Press},
title = {{The symbol grounding problem has been solved, so what's next?}},
url = {http://www.oxfordscholarship.com/view/10.1093/acprof:oso/9780199217274.001.0001/acprof-9780199217274-chapter-12},
year = {2008}
}
@article{Patyk-Lonska:2011:DistributedRepresentationsBased,
abstract = {Authors revise the concept of a distributed representation of data as well as two previously developed mod- els: Holographic Reduced Representation (HRR) and Binary Spatter Codes (BSC). A Geometric Analogue (GAc — "c" stands for continuous as opposed to its discrete version) of HRR is introduced – it employs role-filler binding based on geometric products. Atomic objects are real-valued vectors in n-dimensional Euclidean space while complex data structures belong to a hierarchy of multivectors. The paper reports on a test aimed at comparison of GAc with HRR and BSC. The test is analogous to the one proposed by Tony Plate in the mid 90s. We repeat Plate's test on GAc and compare the results with the original HRR and BSC — we concentrate on comparison of recognition percentage for the three models for comparable data size, rather than on the time taken to achieve high percentage. Results show that the best models for storing and recognizing multiple similar structures are GAc and BSC with recognition percentage highly above 90. The paper ends with remarks on perspective applications of geometric algebra to quantum algorithms.},
author = {Patyk-L{\'{o}}nska, Agnieszka and Czachor, Marek and Aerts, Diederik},

issn = {03505596},
journal = {Inform.},
keywords = {BSC,Distributed representation of data,Geometric algebra,HRR,Scaling},
number = {4},
pages = {407--417},
title = {{Distributed representations based on geometric Algebra: The continuous model}},
volume = {35},
year = {2011}
}
@article{Kleyko:2016:HolographicGraphNeuron,
abstract = {This article proposes the use of Vector Symbolic Architectures for implementing Hierarchical Graph Neuron, an architecture for memorizing patterns of generic sensor stimuli. The adoption of a Vector Symbolic representation ensures a one-layered design for the approach, while maintaining the previously reported properties and performance characteristics of Hierarchical Graph Neuron, and also improving the noise resistance of the architecture. The proposed architecture enables a linear (with respect to the number of stored entries) time search for an arbitrary sub-pattern.},
archivePrefix = {arXiv},
arxivId = {1501.03784},
author = {Kleyko, Denis and Osipov, Evgeny and Senior, Alexander and Khan, Asad I. and Sekercioglu, Yasar Ahmet},
doi = {10.1109/TNNLS.2016.2535338},
eprint = {1501.03784},

issn = {21622388},
journal = {IEEE Trans. Neural Networks Learn. Syst.},
pages = {1--9},
title = {{Holographic Graph Neuron: A Bioinspired Architecture for Pattern Processing}},
year = {2016}
}
@inbook{Kanerva:1994:SpatterCodeEncoding,
abstract = {The Spatter Code is a high-dimensional (e.g., N = 10,000), random$\backslash$ncode that encodes “high-level concepts” in terms of their “low-level$\backslash$nattributes” so that concepts at different levels can be mixed freely. The binary$\backslash$nspatter code is the simplest. It has two N-bit codewords for each concept or$\backslash$nitem, a “high-level,” or dense, word with many randomly placed 1s and a$\backslash$n“low-level,” or sparse, word with a few (that are contained in the many). The$\backslash$ndense codewords can be used as inputs to an associative memory. The sparse$\backslash$ncodewords are used in encoding new concepts. When several items (attributes,$\backslash$nconcepts, chunks) are combined to form a new item, the two codewords for$\backslash$nthe new item are made from the sparse codewords of its constituents as follows:$\backslash$nthe new dense word is the logical {\{}OR{\}} of the constituents (i.e., their sum$\backslash$nthresholded at 0.5), and the new sparse word has 1s where the constituent$\backslash$nwords overlap (i.e., their sum thresholded at 1.5). When the parameters for the$\backslash$ncode are chosen properly, the number of 1s in the codewords is maintained as$\backslash$nnew items are encoded from combinations of old ones.},
address = {London},
author = {Kanerva, Pentti},
booktitle = {ICANN '94},
doi = {10.1007/978-1-4471-2097-1_52},
editor = {Marinaro, Maria and Morasso, Pietro G},

isbn = {978-3-540-19887-1},
pages = {226--229},
publisher = {Springer London},
title = {{The Spatter Code for Encoding Concepts at Many Levels}},
url = {http://link.springer.com/chapter/10.1007/978-1-4471-2097-1{\_}52 http://link.springer.com/10.1007/978-1-4471-2097-1{\_}52},
year = {1994}
}
@article{Vogt:2002:PhysicalSynbolGrounding,

author = {Vogt, Paul},
doi = {10.1016/S1389-0417(02)00051-7},

issn = {13890417},
journal = {Cogn. Syst. Res.},
month = {sep},
number = {3},
pages = {429--457},
title = {{The physical symbol grounding problem}},
url = {http://linkinghub.elsevier.com/retrieve/pii/S1389041702000517},
volume = {3},
year = {2002}
}
@article{Levy:2008:VectorSymbolicArchitectures,
abstract = {We provide an overviewofVector Symbolic Architectures (VSA), a class of structured associative memory models that offers a number of desirable features for artificial general intelligence. By directly encoding structure using familiar, computationally efficient algorithms, VSA bypasses many of the problems that have consumed unnecessary effort and attention in previous connectionist work. Example applications from opposite ends of the AI spectrum – visual map-seeking circuits and structured analogy processing – attest to the generality and power of the VSA approach in building new solutions for AI.},
author = {Levy, Simon D and Gayler, Ross W.},

isbn = {978-1-58603-833-5},
issn = {09226389},
journal = {Proc. First Conf. Artif. Gen. Intell.},
keywords = {associative memory,binary spatter codes,connectionism,distributed representations,holographic reduced representation,vector symbolic architectures},
pages = {414--418},
pmid = {1000185213},
title = {{Vector Symbolic Architectures: A New Building Material for Artificial General Intelligence}},
url = {www.cs.wlu.edu/{~}levy/pubs/agi{\_}2008{\_}levy{\_}gayler.pdf$\backslash$nhttp://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.108.6978$\backslash$nhttp://sites.google.com/site/rgayler/agi{\_}2008{\_}levy{\_}gayler.pdf?attredirects=0},
year = {2008}
}
@article{Recchia:2015:EncodingSequentialInformation,
abstract = {Circular convolution and random permutation have each been proposed as neurally plausible binding operators capable of encoding sequential information in semantic memory. We perform several controlled comparisons of circular convolution and random permutation as means of encoding paired associates as well as encoding sequential information. Random permutations outperformed convolution with respect to the number of paired associates that can be reliably stored in a single memory trace. Performance was equal on semantic tasks when using a small corpus, but random permutations were ultimately capable of achieving superior performance due to their higher scalability to large corpora. Finally, “noisy” permutations in which units are mapped to other units arbitrarily (no one-to-one mapping) perform nearly as well as true permutations. These findings increase the neurological plausibility of random permutations and highlight their utility in vector space models of semantics.},

author = {Recchia, Gabriel and Sahlgren, Magnus and Kanerva, Pentti and Jones, Michael N.},
doi = {10.1155/2015/986574},

issn = {1687-5265},
journal = {Comput. Intell. Neurosci.},
pages = {1--18},
pmid = {25954306},
title = {{Encoding Sequential Information in Semantic Space Models: Comparing Holographic Reduced Representation and Random Permutation}},
url = {http://www.hindawi.com/journals/cin/2015/986574/},
volume = {2015},
year = {2015}
}
@article{Golosio:2015:CognitiveNeuralArchitecture,
abstract = {Communicative interactions involve a kind of procedural knowledge that is used by the human brain for processing verbal and nonverbal inputs and for language production. Although considerable work has been done on modeling human language abilities, it has been difficult to bring them together to a comprehensive tabula rasa system compatible with current knowledge of how verbal information is processed in the brain. This work presents a cognitive system, entirely based on a large-scale neural architecture, which was developed to shed light on the procedural knowledge involved in language elaboration. The main component of this system is the central executive, which is a supervising system that coordinates the other components of the working memory. In our model, the central executive is a neural network that takes as input the neural activation states of the short-term memory and yields as output mental actions, which control the flow of information among the working memory components through neural gating mechanisms. The proposed system is capable of learning to communicate through natural language starting from tabula rasa, without any a priori knowledge of the structure of phrases, meaning of words, role of the different classes of words, only by interacting with a human through a text-based interface, using an open-ended incremental learning process. It is able to learn nouns, verbs, adjectives, pronouns and other word classes, and to use them in expressive language. The model was validated on a corpus of 1587 input sentences, based on literature on early language assessment, at the level of about 4-years old child, and produced 521 output sentences, expressing a broad range of language processing functionalities.},
archivePrefix = {arXiv},
arxivId = {1506.03229},
author = {Golosio, Bruno and Cangelosi, Angelo and Gamotina, Olesya and Masala, Giovanni Luca},
doi = {10.1371/journal.pone.0140866},
eprint = {1506.03229},

isbn = {10.1371/journal.pone.0140866},
issn = {19326203},
journal = {PLoS One},
number = {11},
pmid = {26560154},
title = {{A cognitive neural architecture able to learn and communicate through natural language}},
volume = {10},
year = {2015}
}
@inproceedings{DeVine:2010:Semanticoscillations,
abstract = {In computational linguistics, information retrieval and applied cognition, words and concepts are often represented as vectors in high dimensional spaces computed from a corpus of text. These high dimensional spaces are often referred to as Semantic Spaces. We describe a novel and efficient approach to computing these semantic spaces via the use of complex valued vector representations. We report on the practical implementation of the proposed method and some associated experiments. We also briefly discuss how the proposed system relates to previous theoretical work in Information Retrieval and Quantum Mechanics and how the notions of probability, logic and geometry are integrated within a single Hilbert space representation. In this sense the proposed system has more general application and gives rise to a variety of opportunities for future research.},
address = {Arlington, Virginia},
author = {{De Vine}, Lance and Bruza, Peter},
booktitle = {AAAI Fall Symp. Ser.},

keywords = {algorithm,holography,linguistics,quantum,semantics},
number = {48-55},
pages = {48--55},
publisher = {AAAI Press},
title = {{Semantic Oscillations: Encoding Context and Structure in Complex Valued Holographic Vectors}},
url = {http://www.aaai.org/ocs/index.php/FSS/FSS10/paper/download/2277/2680},
year = {2010}
}
@article{Harnad:1990:SymbolGroundingProblem,
abstract = {There has been much discussion recently about the scope and limits of purely symbolic models of the mind and about the proper role of connectionism in cognitive modeling. This paper describes the "symbol grounding problem": How can the semantic interpretation of a formal symbol system be made intrinsic to the system, rather than just parasitic on the meanings in our heads? How can the meanings of the meaningless symbol tokens, manipulated solely on the basis of their (arbitrary) shapes, be grounded in anything but other meaningless symbols? The problem is analogous to trying to learn Chinese from a Chinese/Chinese dictionary alone. A candidate solution is sketched: Symbolic representations must be grounded bottom-up in nonsymbolic representations of two kinds: (1) iconic representations, which are analogs of the proximal sensory projections of distal objects and events, and (2) categorical representations, which are learned and innate feature detectors that pick out the invariant features of object and event categories from their sensory projections. Elementary symbols are the names of these object and event categories, assigned on the basis of their (nonsymbolic) categorical representations. Higher-order (3) symbolic representations, grounded in these elementary symbols, consist of symbol strings describing category membership relations (e.g. "An X is a Y that is Z"). Connectionism is one natural candidate for the mechanism that learns the invariant features underlying categorical representations, thereby connecting names to the proximal projections of the distal objects they stand for. In this way connectionism can be seen as a complementary component in a hybrid nonsymbolic/symbolic model of the mind, rather than a rival to purely symbolic modeling. Such a hybrid model would not have an autonomous symbolic "module," however; the symbolic functions would emerge as an intrinsically "dedicated" symbol system as a consequence of the bottom-up grounding of categories' names in their sensory representations. Symbol manipulation would be governed not just by the arbitrary shapes of the symbol tokens, but by the nonarbitrary shapes of the icons and category invariants in which they are grounded. {\textcopyright} 1990.},

archivePrefix = {arXiv},
arxivId = {arXiv:cs.AI/9906002},
author = {Harnad, Stevan},
doi = {10.1016/0167-2789(90)90087-6},
eprint = {9906002},

isbn = {0167-2789},
issn = {01672789},
journal = {Phys. D Nonlinear Phenom.},
number = {1-3},
pages = {335--346},
primaryClass = {arXiv:cs.AI},
title = {{The symbol grounding problem}},
volume = {42},
year = {1990}
}
@article{Levy:2013:LearningBehaviorHierarchies,
abstract = {We propose a knowledge-representation architecture allowing a robot to learn arbitrarily complex, hierarchical / symbolic relationships between sensors and actuators. These relationships are encoded in high-dimensional, low-precision vectors that are very robust to noise. Low-dimensional (single-bit) sensor values are projected onto the high-dimensional representation space using low-precision random weights, and the appropriate actions are then computed using elementwise vector multiplication in this space. The high-dimensional action representations are then projected back down to low-dimensional actuator signals via a simple vector operation like dot product. As a proof-of-concept for our architecture, we use it to implement a behavior-based controller for a simulated robot with three sensors (touch sensor, left/right light sensor) and two actuators (wheels). We conclude by discussing the prospects for deriving such representations automatically. Copyright {\textcopyright} 2013, Association for the Advancement of Artificial Intelligence. All rights reserved.},
author = {Levy, Simon D. and Bajracharya, Suraj and Gayler, Ross W.},

isbn = {9781577356233},
journal = {AAAI Work. - Tech. Rep.},
keywords = {Behavior-based robotics,Knowledge representation,Vector symbolic architectures},
pages = {25--27},
title = {{Learning behavior hierarchies via high-dimensional sensor projection}},
volume = {WS-13-12},
year = {2013}
}
@article{Plate:1995:HolographicReducedRepresentations,
abstract = {Associative memories are conventionally used to represent data with very simple structure: sets of pairs of vectors. This paper describes a method for representing more complex compositional structure in distributed representations. The method uses circular convolution to associate items, which are represented by vectors. Arbitrary variable bindings, short sequences of various lengths, simple frame-like structures, and reduced representations can be represented in a fixed width vector. These representations are items in their own right and can be used in constructing compositional structures. The noisy reconstructions extracted from convolution memories can be cleaned up by using a separate associative memory that has good reconstructive properties.},
archivePrefix = {arXiv},
arxivId = {arXiv:1011.1669v3},
author = {Plate, Tony A.},
doi = {10.1109/72.377968},
eprint = {arXiv:1011.1669v3},

isbn = {1045-9227},
issn = {19410093},
journal = {IEEE Trans. Neural Networks},
number = {3},
pages = {623--641},
pmid = {18263348},
title = {{Holographic Reduced Representations}},
volume = {6},
year = {1995}
}
@book{Kleyko:2016:PatternRecognitionVector,
abstract = {Pattern recognition is an area constantly enlarging its theoretical and practical horizons. Applications of pattern recognition and machine learning can be found in many areas of the present day world including health-care, robotics, manufacturing, economics, automation, transportation, etc. Despite some success in many domains pattern recognition algorithms are still far from being close to their biological vis-a-vis – human brain. New possibilities in the area of pattern recognition may be achieved by application of biologically inspired approaches. This thesis presents the usage of a bio-inspired method of representing concepts and their meaning – Vector Symbolic Architectures – in the context of pattern recognition with possible applications in intelligent transportation systems, automation systems, and language processing. Vector Symbolic Architectures is an approach for encoding and manipulating distributed representations of information. They have previously been used mainly in the area of cognitive computing for representing and reasoning upon semantically bound information. First, it is shown that Vector Symbolic Architectures are capable of pattern classification of temporal patterns. With this approach, it is possible to represent, learn and subsequently classify vehicles using measurements from vibration sensors. Next, an architecture called Holographic Graph Neuron for one-shot learning of patterns of generic sensor stimuli is proposed. The architecture is based on implementing the Hierarchical Graph Neuron approach using Vector Symbolic Architectures. Holographic Graph Neuron shows the previously reported performance characteristics of Hierarchical Graph Neuron while maintaining the simplicity of its design. The Holographic Graph Neuron architecture is applied in two domains: fault detection and longest common substrings search. In the area of fault detection the architecture showed superior performance compared to classical methods of artificial intelligence while featuring zero configuration and simple operations. The application of the architecture for longest common substrings search showed its ability to robustly solve the task given that the length of a common substring is longer than 4{\%} of the longest pattern. Furthermore, the required number of operations on binary vectors is equal to the suffix trees approach, which is the fastest traditional algorithm for this problem. In summary, the work presented in this thesis extends understanding of the performance proprieties of distributed representations and opens the way for new applications.},
author = {Kleyko, Denis},

isbn = {978-91-7583-536-5},
title = {{Pattern Recognition with Vector Symbolic Architectures}},
year = {2016}
}
@article{Paradis:2013:FindingSemanticEquivalence,
abstract = {The challenges of machine semantic understanding have not yet been satisfactorily solved by automated methods. In our approach, the semantics and syntax of words, phrases and documents are represented by deep semantic vectors that capture both the structure and semantic meaning of the language. Our experiment reproduces the experiment done by Patwardhan and Pedersen 2006, but uses random index vectors for the words, glosses and tweets. Our model first determines random index vectors from glosses and definitions for words from WordNet. From these foundational semantic vectors, random index vectors that represent phrases, sentences or tweets are determined. Our set of algorithms relies on high-dimensional distributed representations, and their effectiveness and versatility derive from the unintuitive properties of such representations: from the mathematical properties of high-dimensional spaces. High-dimensional vector representations have been used successfully in modeling human cognition, such as memory and learning. Our semantic vectors are high-dimensional and capture the meaning of a language expression, such as a word, phrase, query, news article, story or a message. A key benefit of our method is that the dimensionality of the vectors remains constant as we add data; this also allows good generalization to rarely seen words, which "borrow strength" from their more frequent neighbors. {\textcopyright} 2013 The Authors. Published by Elsevier B.V.},

author = {Paradis, Rosemary D. and Guo, Jinhong K. and Moulton, Jack and Cameron, David and Kanerva, Pentti},
doi = {10.1016/j.procs.2013.09.302},

issn = {18770509},
journal = {Procedia Comput. Sci.},
keywords = {Artificial intelligence,Computational linguistics,High-dimension,Machine learning,Random index,Social networking},
pages = {454--459},
publisher = {Elsevier Masson SAS},
title = {{Finding semantic equivalence of text using random index vectors}},
url = {http://dx.doi.org/10.1016/j.procs.2013.09.302},
volume = {20},
year = {2013}
}

repository: HBPNeurorobotics/holographic

repo_name: HBPNeurorobotics/holographic

gha_language: Jupyter Notebook


text:
@article{wang2016new,
 author = {Wang, Jinjiang and Xie, Junyao and Zhao, Rui and Mao, Kezhi and Zhang, Laibin},
 journal = {IEEE Transactions on Instrumentation and Measurement},
 number = {11},
 pages = {2527--2537},
 publisher = {IEEE},
 title = {A new probabilistic kernel factor analysis for multisensory data fusion: application to tool condition monitoring},
 volume = {65},
 year = {2016}
}

repository: rzntu/academic-kickstart

repo_name: rzntu/academic-kickstart


text:
DESCRIPTION = "Python package for creating and manipulating graphs and networks"
HOMEPAGE = "http://networkx.github.io/"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=a24ea029adac8935699bf69b2e38c728"

SRC_URI[sha256sum] = "109cd585cac41297f71103c3c42ac6ef7379f29788eb54cb751be5a663bb235a"

inherit pypi setuptools3

RDEPENDS_${PN} += "\
                   ${PYTHON_PN}-decorator \
                   "

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott

gha_language: BitBake


text:
package model

import "time"

type Notice struct {
	ID             int
	NoticeCategory string
	Title          string
	Content        string
	CreatedBy      string
	CreatedAt      time.Time
	UpdatedAt      time.Time
	PublishAt      time.Time
	DeletedAt      time.Time
}

repository: mohuani/notice

repo_name: mohuani/notice


text:
require tzcode-native.inc

LICENSE = "PD"
LIC_FILES_CHKSUM = "file://README;md5=3ae8198f82258417ce29066d3b034035"

# Note that elsie.nci.nih.gov removes old versions when new is coming out
# So if this doesn't build for you because of missing source file, just
# bump it to the latest available version, removing old one
# Also, tzdata (and it is needed to build tzcode) version can differ from
# tzcode version, thus this variable

TZDATA_PV = "2011h"

PR = "${INC_PR}.1"

SRC_URI[tzcode-2011g.md5sum] = "ecb564279b28c5b184421c525d997d6c"
SRC_URI[tzcode-2011g.sha256sum] = "636c735d8df1276cc8ab88bc31bb36a21f91ed34e26d181303ecd8fe48021bc2"
SRC_URI[tzdata-2011h.md5sum] = "546d27b6c1e5e1097bd512651815017f"
SRC_URI[tzdata-2011h.sha256sum] = "c098786d053736dd18d4f1fbebdf41554c6fd702a36f75c18f1c66712d2abc24"

repository: lawwama/meta-oe

repo_name: lawwama/meta-oe


text:
package main

import (
	"crypto/sha512"
	"os"

	"github.com/mdwhatcott/helps/hashing"
)

func main() {
	hashing.Hash(os.Stdin, sha512.New(), os.Stdout)
}

repository: mdwhatcott/helps

repo_name: mdwhatcott/helps


text:
package sourceKeeper

import (
	"fmt"
	"git.anphabe.net/event/anphabe-event-hub/config"
	"git.anphabe.net/event/anphabe-event-hub/domain/model/scanItem"
	"git.anphabe.net/event/anphabe-event-hub/domain/service"
	"go.uber.org/zap"
	"strings"
	"sync"
	"time"
)

const SyncTime time.Duration = 5 * time.Minute

type Keeper struct {
	conf         []config.DbSource
	repoRegistry service.RepositoryRegistryInterface
	dbSources    map[string]*Communicator
	nextImports  map[string]time.Time
	stop         chan struct{}
	importChan   chan string
	activityChan chan *activityLog
	logger       *zap.Logger
}

type activityLog struct {
	repoName string
	itemKey  string
	activity scanItem.ItemActivity
}

func NewSourceKeeper(cfg []config.DbSource, registry service.RepositoryRegistryInterface, logger *zap.Logger) *Keeper {

	instance := &Keeper{
		conf: cfg,
		repoRegistry: registry,
		dbSources:    make(map[string]*Communicator),
		nextImports:  make(map[string]time.Time),
		stop:         make(chan struct{}, 1),
		activityChan: make(chan *activityLog, 30),
		importChan:   make(chan string, 2),
		logger:       logger,
	}

	return instance
}

func (i *Keeper) Stop() {
	i.stop <- struct{}{}
}

func (i *Keeper) init() {
	for _, cfgDbSource := range i.conf {
		_, _ = i.repoRegistry.GetRepository(cfgDbSource.Name)
		i.updateNextImport(cfgDbSource.Name)
		i.dbSources[cfgDbSource.Name] = NewCommunicator(cfgDbSource, i.logger)
	}
}

func (i *Keeper) Start(wg *sync.WaitGroup) {
	i.init()

	// start broker
	go func() {
		tick := time.NewTicker(1 * time.Minute)
		var wgChild sync.WaitGroup

		defer func() {
			tick.Stop()
			wgChild.Wait()

			close(i.stop)
			close(i.activityChan)
			close(i.importChan)

			i.repoRegistry.Shutdown()
			wg.Done()

			i.logger.Info("SourceKeeper Stopped")
		}()

		i.logger.Info("SourceKeeper Started")

		for {
			select {
			case <-i.stop:
				i.logger.Info("SourceKeeper going to stop")
				return

			case activity, ok := <-i.activityChan:
				if ok {
					wgChild.Add(1)
					go i.pushActivityToSource(*activity, &wgChild)
				}

			case _, ok := <-tick.C:
				if ok {
					if repoName := i.pickImportSource(); repoName != "" {
						i.importChan <- repoName
					}
				}

			case repoName, ok := <-i.importChan:
				if ok {
					if repoName != "" {
						wgChild.Add(1)
						go i.importFromSource(repoName, &wgChild)
					}
				}
			}
		}
	}()
}

func (i *Keeper) StartImport(repoName string) bool {
	if _, err := i.repoRegistry.GetRepository(repoName); nil == err {
		fmt.Println(repoName)
		i.importChan <- repoName
		return true
	}

	return false
}

func (i *Keeper) GetItemDetail(repoName string, itemKey string) (*scanItem.ItemDetail, bool) {
	return i.getRepository(repoName).GetItemDetail(itemKey)
}

func (i *Keeper) GetItems(repoName string) []*scanItem.ScanItem {
	return i.getRepository(repoName).Items()
}

func (i *Keeper) ScanItem(repoName string, itemKey string, activityName string, properties map[string]string) (*scanItem.ItemDetail, bool) {
	i.addItemActivity(repoName, itemKey, activityName, properties)
	return i.GetItemDetail(repoName, itemKey)
}

func (i *Keeper) addItemActivity(repoName string, itemKey string, action string, properties map[string]string) *scanItem.ItemActivities {
	if _, found := i.GetItemDetail(repoName, itemKey); found {
		activity := scanItem.NewActivity(action, properties)
		activityLog := &activityLog{
			repoName: repoName,
			itemKey:  itemKey,
			activity: activity,
		}

		i.activityChan <- activityLog

		return i.getRepository(repoName).AddItemActivity(itemKey, activity)
	}

	return nil
}

func (i *Keeper) pushActivityToSource(log activityLog, wg *sync.WaitGroup) {
	defer wg.Done()

	// convert action-moment into string
	properties := log.activity.Data
	properties[log.activity.Action] = log.activity.Created.Format("2 Jan 2006 15:04:05")

	dbSource := i.dbSources[log.repoName]
	finish := dbSource.Update(log.itemKey, properties)

	if finish {
		i.logger.Info("Successful push activity", zap.String("dbName", log.repoName), zap.String("itemKey", log.itemKey))
	} else {
		// send back to queue to re-process
		sendBack := log
		i.activityChan <- &sendBack
		i.logger.Error("Fail pushing activity", zap.String("dbName", log.repoName), zap.String("itemKey", log.itemKey))
	}
}

func (i *Keeper) importFromSource(repoName string, wg *sync.WaitGroup) {
	defer wg.Done()

	_ = i.dbSources[repoName].Import(i.saveItems)
	i.updateNextImport(repoName)
}

func (i *Keeper) pickImportSource() string {
	for name, t := range i.nextImports {
		now := time.Now()
		if now.After(t) {
			return name
		}
	}

	return ""
}

func (i *Keeper) saveItems(repoName string, idField string, data []map[string]string) int {
	repo := i.getRepository(repoName)
	count := 0

	for _, item := range data {
		if key, found := item[idField]; found {

			if key = strings.TrimSpace(key); key != "" {
				_, err := repo.NewItem(key, item)

				if nil != err {
					i.logger.Error("Communicator: could not new item", zap.String("dbName", repoName))
				} else {
					count += 1
				}
			} else {
				i.logger.Error("Communicator: key empty", zap.String("dbName", repoName))
			}
		}
	}

	return count
}

func (i *Keeper) updateNextImport(repoName string) {
	if nextRun, exist := i.nextImports[repoName]; exist {
		i.nextImports[repoName] = nextRun.Add(SyncTime)
		i.logger.Info("Next importing schedule", zap.String("dbName", repoName), zap.Time("time", i.nextImports[repoName]))
	} else {
		i.nextImports[repoName] = time.Now()
	}
}

func (i *Keeper) getRepository(repoName string) scanItem.RepositoryInterface {
	if repo, err := i.repoRegistry.GetRepository(repoName); nil == err {
		return repo
	} else {
		panic(err)
	}
}

repository: megamcloud/GSheet-Proxy

repo_name: megamcloud/GSheet-Proxy


text:
package chain

import "github.com/pkg/errors"

var ErrorNotFoundTransaction = errors.New("not found the transaction")

var ErrBlockNoTransactions = errors.New("block does not contain any transactions")

var ErrBlockSizeTooBig = errors.New("block serialized is too big")

var ErrBlockTooManyTransactions = errors.New("block has too many transactions")

var ErrFirstTxNotCoinbase = errors.New("first transaction in block is not a coinbase")

var ErrNotVerifyTransaction = errors.New("block has not verfiy transaction")

var ErrMultipleCoinbases = errors.New("block contains second coinbase transaction")

var ErrBlockBadMerkleRoot = errors.New("block merkle root is invalid")

var ErrBlockDuplicateTx = errors.New("block contains duplicate transaction")

repository: asimashfaq/dotcoin

repo_name: asimashfaq/dotcoin


text:
package controllers

import (
	"github.com/astaxie/beego"
	"github.com/grokify/oauth2more/multiservice"
	"github.com/grokify/oauth2more/scim"

	"github.com/grokify/beegoutil"
	"github.com/grokify/beegoutil/demo1/conf"
	"github.com/grokify/beegoutil/demo1/templates"
)

type LoginController struct {
	beego.Controller
	Logger *beegoutil.BeegoLogsMore
}

func (c *LoginController) Get() {
	cfg := conf.NewConfig()
	c.Logger = cfg.Logger()
	log := c.Logger

	log.Info("Start Login Controller")

	err := conf.InitOAuth2Config()
	if err != nil {
		log.Infof("ERR [%v]\n", err.Error())
	}
	conf.InitSession(log)

	s1 := c.GetSession("loggedIn")
	s2 := c.GetSession("user")
	if s1 == nil || s2 == nil {
		log.Info("I_IS_USER_LOGGED_IN [no]")
		c.LoginPage()
	} else {
		loggedIn := s1.(bool)
		if loggedIn == false {
			c.LoginPage()
		} else {
			log.Info("I_IS_USER_LOGGED_IN [yes]")
			c.LoggedinPage(s2.(scim.User))
		}
	}
}

func (c *LoginController) LoginPage() {
	data := templates.LoginData{
		BaseUri:           beego.AppConfig.String("baseuri"),
		OAuth2Configs:     conf.OAuth2Configs,
		OAuth2RedirectURI: beego.AppConfig.String("oauth2redirecturi"),
		OAuth2State:       multiservice.RandomState("demo", true),
		DemoRepoURI:       templates.DemoRepoURI}

	templates.WriteLoginPage(c.Ctx.ResponseWriter, data)
}

func (c *LoginController) LoggedinPage(user scim.User) {
	data := templates.LoggedinData{
		User:        user,
		DemoRepoURI: templates.DemoRepoURI}
	if len(user.Emails) > 0 {
		data.PrimaryEmail = user.Emails[0]
	}

	templates.WriteLoggedinPage(c.Ctx.ResponseWriter, data)
}

repository: yansuan/beegoutil

repo_name: yansuan/beegoutil


text:
// Mux Go - Copyright 2019 Mux Inc.
// NOTE: This file is auto generated. Do not edit this file manually.

package muxgo

type ListVideoViewExportsResponse struct {
	Data          []ExportDate `json:"data,omitempty"`
	TotalRowCount int32        `json:"total_row_count,omitempty"`
	Timeframe     []int32      `json:"timeframe,omitempty"`
}

repository: muxinc/mux-go

repo_name: muxinc/mux-go


text:
@Misc{paulin:mail,
  author       = {Christine Paulin-Mohring},
  howpublished = {Personal communication},
  year	       = 2006
}

@Misc{norell:iird-formal,
  author  = {Ulf Norell},
  howpublished = {{\tt http://www.cs.chalmers.se/\~{}ulfn/papers/iird/index.html}}
}

repository: agda/agda

repo_name: agda/agda

gha_license_id: NOASSERTION

gha_language: Haskell


text:
@inproceedings{Ahbe2018b,
 address = {Miami Beach, FL, USA},
 author = {Ahbe, Eva and Wood, Tony A and Smith, Roy S},
 booktitle = {2018 IEEE Conference on Decision and Control (CDC)},
 date = {2018-12-17/2018-12-19},
 doi = {10.1109/CDC.2018.8619106},
 month = {Dec},
 pages = {6501--6506},
 title = {Transverse Contraction-Based Stability Analysis for Periodic Trajectories of Controlled Power Kites with Model Uncertainty},
 year = {2018}
}


text:
@article{pytorch-tensor-intro,
	author    = {facebook},
	title     = {pytorch tutorial tensor},
	journal   = {pytorch.org},
	volume    = {1603.02754},
	year      = {2019},
	url       = {https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html},
	archivePrefix = {arXiv},
	eprint    = {1603.02754},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{csdn-blog-my-tensor1,
	author    = {最老程序员},
	title     = {PyTorch学习笔记1---张量},
	journal   = {blog.csdn.net},
	volume    = {yt7589},
	year      = {2019},
	url       = {https://blog.csdn.net/Yt7589/article/details/103348336},
	archivePrefix = {arXiv},
	eprint    = {1603.02754},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}
@Book{deep-learning-with-pytorch,
   author =   "Eli Stevens, Luca Antiga",
   title =   "Deep Learning with PyTorch",
   publisher =   "Manning",
   address = "www.manning.com",
   year =   "2019"
}
@Book{dl-tf-theano,
   author =   "闫涛，周琦",
   title =   "深度学习算法实践---基于Theano和TensorFlow",
   publisher =   "电子工业出版社",
   address = "北京市丰台区",
   year =   "2017"
}
@article{pytorch-nn-in-detail1,
	author    = {Jeremy Howard},
	title     = {WHAT IS TORCH.NN REALLY?},
	journal   = {pytorch.org},
	volume    = {tutorials},
	year      = {2019},
	url       = {https://pytorch.org/tutorials/beginner/nn_tutorial.html},
	archivePrefix = {pytorch.org},
	eprint    = {1603.02754},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{maxtrix-capsules-with-em-routing,
	author    = {. E. Hinton, S. Sabour, and N. Frosst},
	title     = {Matrix Capsules with EM routing},
	journal   = {International Conference on Learning Representations},
	volume    = {tutorials},
	year      = {2018},
	url       = {https://pytorch.org/},
	archivePrefix = {pytorch.org},
	eprint    = {1603.02754},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{spatial-ransformer-etworks,
	author    = {M. Jaderberg, K. Simonyan, A. Zisserman, and K. Kavukcuoglu},
	title     = {Spatial Transformer Networks},
	journal   = {arxiv.org},
	volume    = {1506.02025v1},
	year      = {2015},
	url       = {https://arxiv.org/abs/1506.02025v1},
	archivePrefix = {pytorch.org},
	eprint    = {1603.02754},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{deep-residual-earning-for-image-recognition,
	author    = {Kaiming HeX,iangyu Zhang,Shaoqing Ren,Jian Sun},
	title     = {Deep Residual Learning for Image Recognition},
	journal   = {arxiv.org},
	volume    = {1512.03385},
	year      = {2015},
	url       = {https://arxiv.org/abs/1512.03385},
	archivePrefix = {pytorch.org},
	eprint    = {1512.03385},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{lstm-theory-tutorial,
	author    = {colah},
	title     = {Understanding LSTMs},
	journal   = {colah.blog},
	volume    = {2015-08-Understanding-LSTMs},
	year      = {2015},
	url       = {https://colah.github.io/posts/2015-08-Understanding-LSTMs/},
	archivePrefix = {pytorch.org},
	eprint    = {1512.03385},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{neural-turing-machines,
	author    = {Alex Graves,Greg Wayne, Ivo Danihelka},
	title     = {Neural Turing Machines},
	journal   = {arxiv.org},
	volume    = {1410.5401},
	year      = {2014},
	url       = {https://arxiv.org/abs/1410.5401},
	archivePrefix = {arxiv.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{chinese-poetry,
	author    = {broadview},
	title     = {Chinese Poetry Generation Tutorial},
	journal   = {github.com},
	volume    = {1410.5401},
	year      = {2017},
	url       = {https://github.com/chinese-poetry/chinese-poetry},
	archivePrefix = {arxiv.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{pytorch-official-chatbot-tutorial,
	author    = {pytorch},
	title     = {PyTorch Chatbot Tutorial},
	journal   = {pythorch.org},
	volume    = {1410.5401},
	year      = {2017},
	url       = {https://pytorch.org/tutorials/beginner/chatbot_tutorial.html},
	archivePrefix = {arxiv.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{cornell-movie-dialogs-corpus,
	author    = {Cristian Danescu-Niculescu-Mizil and Lillian Lee},
	title     = {Chameleons in imagined conversations: A new approach to understanding coordination of linguistic style in dialogs},
	journal   = {www.cs.cornell.edu},
	volume    = {1410.5401},
	year      = {2011},
	url       = {https://www.cs.cornell.edu/~cristian/Cornell_Movie-Dialogs_Corpus.html},
	archivePrefix = {arxiv.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{attention-is-all-you-need,
	author    = {Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin},
	title     = {Attention is All You Need},
	journal   = {papers.nips.cc},
	volume    = {7181},
	year      = {2017},
	url       = {http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf},
	archivePrefix = {arxiv.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{sequence-to-sequence-with-transformer-pytext,
	author    = {pytorch.org},
	title     = {Sequence to Sequence Modeling with nn.Transformer Torchtext},
	journal   = {pytorch.org},
	volume    = {tutorials/beginner},
	year      = {2019},
	url       = {https://pytorch.org/tutorials/beginner/transformer_tutorial.html},
	archivePrefix = {pytorch.org},
	eprint    = {1410.5401},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{reformer-paper,
	author    = {Nikita Kitaev,Lukasz Kaiser,Anselm Levskaya},
	title     = {REFORMER: THE EFFICIENT TRANSFORMER},
	journal   = {ICLR2020},
	volume    = {2001.04451},
	year      = {2020},
	url       = {https://openreview.net/pdf?id=rkgNKkHtvB},
	archivePrefix = {openreview.net},
	eprint    = {2001.04451},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{reformer-pytorch-github,
	author    = {lucidrains},
	title     = {reformer-pytorch},
	journal   = {github.com},
	volume    = {lucidrains},
	year      = {2020},
	url       = {https://github.com/lucidrains/reformer-pytorch},
	archivePrefix = {openreview.net},
	eprint    = {2001.04451},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{transformer-chatbot-github,
	author    = {chloerobotics},
	title     = {chloebot},
	journal   = {github.com},
	volume    = {chloerobotics},
	year      = {2020},
	url       = {https://github.com/chloerobotics/chloebot},
	archivePrefix = {github.com},
	eprint    = {2001.04451},
	timestamp = {Wed, 07 Jun 2017 14:40:11 +0200},
	biburl    = {https://dblp.org/rec/bib/journals/corr/BakryEEE15},
	bibsource = {dblp computer science bibliography, https://dblp.org}
}


text:
@article{krylov2015a-light-induced9335947,
 address = {United States},
 author = {Grigorenko, Bella L. and Nemukhin, Alexander V. and Polyakov, Igor V. and Khrenova, Maria G. and Krylov, Anna I.},
 doi = {10.1021/acs.jpcb.5b02271},
 issn = {1089-5647; 1520-6106},
 journal = {Journal of Physical Chemistry B},
 language = {english},
 number = {17},
 pages = {5444--5452},
 publisher = {United States},
 title = {A Light-Induced Reaction with Oxygen Leads to Chromophore Decomposition and Irreversible Photobleaching in GFP-type Proteins},
 volume = {119},
 year = {2015}
}

repository: polyakoviv/LCC

repo_name: polyakoviv/LCC


text:
// Thanks https://austingwalters.com/radix-sort-in-go/
package main

import (
	"fmt"
	"strconv"

	"github.com/dreddsa5dies/algorithm/util"
)

func main() {
	s1 := util.RandomInt() // срез int

	fmt.Println("Unsorted List:", s1)

	sortedList := radixSort(s1)

	fmt.Println("Sorted List:", sortedList)
}

// Finds the largest number in an array
func findLargestNum(array []int) int {
	largestNum := 0

	for i := 0; i < len(array); i++ {
		if array[i] > largestNum {
			largestNum = array[i]
		}
	}
	return largestNum
}

// Radix Sort
func radixSort(array []int) []int {

	fmt.Println("Running Radix Sort on Unsorted List")

	// Base 10 is used
	largestNum := findLargestNum(array)
	size := len(array)
	significantDigit := 1
	semiSorted := make([]int, size, size)

	// Loop until we reach the largest significant digit
	for largestNum/significantDigit > 0 {

		fmt.Println("\tSorting: "+strconv.Itoa(significantDigit)+"'s place", array)

		bucket := [10]int{0}

		// Counts the number of "keys" or digits that will go into each bucket
		for i := 0; i < size; i++ {
			bucket[(array[i]/significantDigit)%10]++
		}

		// Add the count of the previous buckets
		// Acquires the indexes after the end of each bucket location in the array
		// Works similar to the count sort algorithm
		for i := 1; i < 10; i++ {
			bucket[i] += bucket[i-1]
		}

		// Use the bucket to fill a "semiSorted" array
		for i := size - 1; i >= 0; i-- {
			bucket[(array[i]/significantDigit)%10]--
			semiSorted[bucket[(array[i]/significantDigit)%10]] = array[i]
		}

		// Replace the current array with the semisorted array
		for i := 0; i < size; i++ {
			array[i] = semiSorted[i]
		}

		fmt.Println("\n\tBucket: ", bucket)

		// Move to next significant digit
		significantDigit *= 10
	}

	return array
}


text:
@inproceedings{wenger2020calibration,
  author    = {Jonathan Wenger and Hedvig Kjellstr{\"{o}}m and Rudolph Triebel},
  booktitle = {23rd International Conference on Artificial Intelligence and Statistics ({AISTATS})},
  editor    = {Silvia Chiappa and Roberto Calandra},
  keywords  = {calibration, non-parametric, gaussian processes, classification},
  pages     = {178--190},
  pdf       = {http://proceedings.mlr.press/v108/wenger20a/wenger20a.pdf},
  publisher = {{PMLR}},
  series    = {Proceedings of Machine Learning Research},
  title     = {Non-Parametric Calibration for Classification},
  url       = {http://proceedings.mlr.press/v108/wenger20a.html},
  volume    = {108},
  year      = {2020}
}


text:
package name

import "github.com/030/n3dr/internal/app/n3dr/connection"

type Nexus3 struct {
	*connection.Nexus3
}