text:
@misc{sutton:1998,
  title={Introduction to reinforcement learning. Vol. 135},
  author={Sutton, Richard S and Barto, Andrew G},
  year={1998},
  publisher={Cambridge: MIT press}
}

@article{dhariwal:2017,
  title={Openai baselines},
  author={Dhariwal, Prafulla and Hesse, Christopher and Klimov, Oleg and Nichol, Alex and Plappert, Matthias and Radford, Alec and Schulman, John and Sidor, Szymon and Wu, Yuhuai and Zhokhov, Peter},
  url={https://github.com/openai/baselines},
  year={2017}
}

@article{schaarschmidt:2017,
  title={Tensorforce: A tensorflow library for applied reinforcement learning},
  author={Schaarschmidt, Michael and Kuhnle, Alexander and Fricke, Kai},
  url={https://github.com/tensorflow/tensorflow},
  year={2017}
}

@article{liang:2017,
  title={Ray rllib: A composable and scalable reinforcement learning library},
  author={Liang, Eric and Liaw, Richard and Nishihara, Robert and Moritz, Philipp and Fox, Roy and Gonzalez, Joseph and Goldberg, Ken and Stoica, Ion},
  journal={arXiv preprint arXiv:1712.09381},
  year={2017}
}

@article{caspi:2017,
  title={Reinforcement Learning Coach.(Dec. 2017)},
  author={Caspi, Itai and Leibovich, Gal and Novik, Gal},
  doi={10.5281/zenodo.1134899},
  url={https://doi.org/10.5281/zenodo.1134899},
  volume={1134899},
  year={2017}
}

@inproceedings{abadi:2016,
  title={Tensorflow: A system for large-scale machine learning},
  author={Abadi, Mart{\'\i}n and Barham, Paul and Chen, Jianmin and Chen, Zhifeng and Davis, Andy and Dean, Jeffrey and Devin, Matthieu and Ghemawat, Sanjay and Irving, Geoffrey and Isard, Michael and others},
  booktitle={12th USENIX Symposium on Operating Systems Design and Implementation OSDI 16)},
  pages={265--283},
  year={2016}
}

@article{brockman:2016,
  title={Openai gym},
  author={Brockman, Greg and Cheung, Vicki and Pettersson, Ludwig and Schneider, Jonas and Schulman, John and Tang, Jie and Zaremba, Wojciech},
  journal={arXiv preprint arXiv:1606.01540},
  year={2016}
}

@misc{kerasrl:2019, title={keras-rl/keras-rl}, url={https://github.com/keras-rl/keras-rl}, journal={GitHub}, author={Matthias Plappert}, year={2019}, month={Mar}}

@article{castro:2018,
  title={Dopamine: A research framework for deep reinforcement learning},
  author={Castro, Pablo Samuel and Moitra, Subhodeep and Gelada, Carles and Kumar, Saurabh and Bellemare, Marc G},
  journal={arXiv preprint arXiv:1812.06110},
  year={2018}
}

@article{mnih:2013,
  title={Playing atari with deep reinforcement learning},
  author={Mnih, Volodymyr and Kavukcuoglu, Koray and Silver, David and Graves, Alex and Antonoglou, Ioannis and Wierstra, Daan and Riedmiller, Martin},
  journal={arXiv preprint arXiv:1312.5602},
  year={2013}
}

@article{plappert:2017,
  title={Parameter space noise for exploration},
  author={Plappert, Matthias and Houthooft, Rein and Dhariwal, Prafulla and Sidor, Szymon and Chen, Richard Y and Chen, Xi and Asfour, Tamim and Abbeel, Pieter and Andrychowicz, Marcin},
  journal={arXiv preprint arXiv:1706.01905},
  year={2017}
}

@incollection{sutton2000,
  title = {Policy Gradient Methods for Reinforcement Learning with Function Approximation},
  author = {Sutton, Richard S and David A. McAllester and Satinder P. Singh and Mansour, Yishay},
  booktitle = {{Advances in Neural Information Processing Systems 12}},
  editor = {S. A. Solla and T. K. Leen and K. M\"{u}ller},
  pages = {1057--1063},
  year = {2000},
  publisher = {MIT Press},
}

@inproceedings{silver2014deterministic,
  title = 	 {Deterministic Policy Gradient Algorithms},
  author = 	 {David Silver and Guy Lever and Nicolas Heess and Thomas Degris and Daan Wierstra and Martin Riedmiller},
  booktitle = 	 {{Proceedings of the 31st International Conference on Machine Learning}},
  pages = 	 {387--395},
  year = 	 {2014},
  editor = 	 {Eric P. Xing and Tony Jebara},
  volume = 	 {32},
  number =       {1},
  series = 	 {Proceedings of Machine Learning Research},
  address = 	 {Bejing, China},
  month = 	 {22--24 Jun},
  publisher = 	 {{PMLR}},
  url = 	 {http://proceedings.mlr.press/v32/silver14.html},
}

@article{schulman:2017,
  title={Proximal policy optimization algorithms},
  author={Schulman, John and Wolski, Filip and Dhariwal, Prafulla and Radford, Alec and Klimov, Oleg},
  journal={arXiv preprint arXiv:1707.06347},
  year={2017}
}

@article{savva:2019,
  title={Habitat: A platform for embodied ai research},
  author={Savva, Manolis and Kadian, Abhishek and Maksymets, Oleksandr and Zhao, Yili and Wijmans, Erik and Jain, Bhavana and Straub, Julian and Liu, Jia and Koltun, Vladlen and Malik, Jitendra and others},
  journal={arXiv preprint arXiv:1904.01201},
  year={2019}
}

@article{chen:2018,
  title={Bayesian optimization in alphago},
  author={Chen, Yutian and Huang, Aja and Wang, Ziyu and Antonoglou, Ioannis and Schrittwieser, Julian and Silver, David and de Freitas, Nando},
  journal={arXiv preprint arXiv:1812.06855},
  year={2018}
}

@inproceedings{ha:2018,
  title={Recurrent world models facilitate policy evolution},
  author={Ha, David and Schmidhuber, J{\"u}rgen},
  booktitle={Advances in Neural Information Processing Systems},
  pages={2450--2462},
  year={2018}
}

@misc{TFAgents,
  title={TF-Agents: A library for Reinforcement Learning in TensorFlow},
  author={Sergio Guadarrama, Anoop Korattikara, Oscar Ramirez,
    Pablo Castro, Ethan Holly, Sam Fishman, Ke Wang, Ekaterina Gonina, Neal Wu,
    Chris Harris, Vincent Vanhoucke, Eugene Brevdo},
  url={"https://github.com/tensorflow/agents"},
  year={2018}
}

@misc{hill:2019,
  title={hill-a/stable-baselines},
  url={https://github.com/hill-a/stable-baselines},
  author={Hill},
  year={2019},
  month={Jun}
}

@inproceedings{paszke2017automatic,
  title={Automatic Differentiation in PyTorch},
  author={Paszke, Adam and Gross, Sam and Chintala, Soumith and Chanan, Gregory and Yang, Edward and DeVito, Zachary and Lin, Zeming and Desmaison, Alban and Antiga, Luca and Lerer, Adam},
  booktitle={NIPS Autodiff Workshop},
  year={2017}
}

repository: DeepKhantwal/rl

repo_name: DeepKhantwal/rl


text:
DESCRIPTION = ""Hash::FieldHash" provides the field hash mechanism which supports the \
inside-out technique."

SECTION = "libs"
LICENSE = "Artistic-1.0 | GPL-1.0-or-later"
PR = "r0"

MAINTAINER=	"Poky <poky@yoctoproject.org>"
HOMEPAGE=	"https://metacpan.org/release/Hash-FieldHash"

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0-or-later;md5=30c0b8a5048cc2f4be5ff15ef0d8cf61"

SRC_URI = "https://cpan.metacpan.org/authors/id/G/GF/GFUJI/Hash-FieldHash-0.15.tar.gz \
           file://Build_PL_add-dot-to-INC.patch \
"

SRC_URI[md5sum] = "0d3d32801d0638d120dcf3f670a1ae17"
SRC_URI[sha256sum] = "5c515707a5433796a5697b118ddbf1f216d13c5cd52f2b64292e76f7d9b7e8f1"
DEPENDS += "module-build-perl-native"
DEPENDS += "test-leaktrace-perl-native"

S = "${WORKDIR}/Hash-FieldHash-${PV}"

EXTRA_CPAN_BUILD_FLAGS="--config cc="${CC}" --config ccflags="${CFLAGS}" --config ld="${CCLD} ${LDFLAGS}""

inherit cpan_build

do_compile() {
	export LD="${CCLD} ${LDFLAGS}"
	cpan_build_do_compile
}

BBCLASSEXTEND = "native"

license: MIT

repository: rehsack/meta-cpan

license_type: permissive

repo_name: rehsack/meta-cpan

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
package charm

import (
	"fmt"
	"io"
	"os"
	"strings"

	"github.com/charmbracelet/lipgloss"
	"github.com/muesli/reflow/indent"
)

func Margin(i ...int) Style {
	return NewStyle(lipgloss.NewStyle().Margin(i...))
}

func Indent(level uint) io.Writer {
	return indent.NewWriterPipe(os.Stdout, level, nil)
}

func IndentWriter(w io.Writer, level uint) io.Writer {
	return indent.NewWriterPipe(w, level, nil)
}

func IndentString(level uint, str string) string {
	return indent.String(str, level)
}

func Factory[T any](x T) func() T {
	return func() T {
		return x
	}
}

func SnakeToTitle(s any) string {
	return strings.Title(strings.ReplaceAll(strings.ToLower(fmt.Sprint(s)), "_", " "))
}

repository: digitalocean/doctl

repo_name: digitalocean/doctl

branch_name: refs/heads/main

gha_language: Go

extension: go


text:
require xorg-proto-common.inc
DESCRIPTION = "DRI2 extension headers"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "1d70f0653b0b3a837853262dc5d34da4"
SRC_URI[archive.sha256sum] = "69def6d1f64b3699ec9c729596d8b096623a62bdda6bbea78ed690421d174c11"

repository: trini/openembedded

repo_name: trini/openembedded


text:
@article{Wong-2020-Tracking,
    title = "Tracking the phenology of photosynthesis using carotenoid‐sensitive and near‐infrared reflectance vegetation indices in a temperate evergreen and mixed deciduous forest",
    author = "Wong, Christopher Y.S.  and
      D{'}Odorico, Petra  and
      Arain, M. Altaf  and
      Ensminger, Ingo",
    journal = "New Phytologist, Volume 226, Issue 6",
    volume = "226",
    number = "6",
    year = "2020",
    publisher = "Wiley",
    url = "https://aclanthology.org/G20-64001",
    doi = "10.1111/nph.16479",
    pages = "1682--1695",
    abstract = "Photosynthetic phenology is an important indicator of annual gross primary productivity (GPP). Assessing photosynthetic phenology remotely is difficult for evergreen conifers as they remain green year-round. Carotenoid-based vegetation indices such as the photochemical reflectance index (PRI) and chlorophyll/carotenoid index (CCI) are promising tools to remotely track the invisible phenology of photosynthesis by assessing carotenoid pigment dynamics. PRI, CCI and the near-infrared reflectance of vegetation (NIRV ) index may act as proxies of photosynthetic efficiency (ɛ), an important parameter in light-use efficiency models, or direct proxies of photosynthesis. To understand the physiological mechanisms reflected by PRI and CCI and the ability of vegetation indices to act as proxies of photosynthetic activity for estimating GPP, we measured leaf pigment composition, PRI, CCI, NIRV and photosynthetic activity at the leaf and canopy scales over 2 years in an evergreen and mixed deciduous forest. PRI and CCI captured the large seasonal carotenoid/chlorophyll ratio changes and good relationships were observed between PRI-ɛ and CCI-photosynthesis and NIRV -photosynthesis. PRI-, CCI- and NIRV -based models effectively tracked observed seasonal GPP. We propose that carotenoid-based and near-infrared reflectance vegetation indices may provide useful proxies of photosynthetic activity and can improve remote sensing-based models of GPP in evergreen and deciduous forests.",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python

extension: bib


text:
package modules

import (
	"testing"
	"time"
)

// BenchmarkHalfLifeDistribution creates a benchmark to estimate how long it
// takes to add a performance number to a half life distribution bucket.
//
// i7 processor: 1600 nanoseconds per new stat.
func BenchmarkHalfLifeDistribution(b *testing.B) {
	hld := NewHalfLifeDistribution()
	for i := 0; i < b.N; i++ {
		hld.AddRequest(time.Millisecond, 0)
	}
}

repository: UrkelLabs/sia

repo_name: UrkelLabs/sia


text:
@article{James2016,
abstract = {Provides a concise overview of roles, meetings, rules, and artifacts within a Scrum organization. Updated for 2016.},
author = {James, Michael},
journal = {Dzone},
pages = {6},
title = {{The Ultimate Scrum Reference Card}},
url = {https://dzone.com/refcardz/scrum},
Urlaccessdate = {2017-01-25},
year = {2016}
}

gha_language: TeX


text:
@inproceedings{dutta17NoiseSense,
 abstract = {Noise pollution in urban areas is a subject of grave concern and it is being recognized globally in different countries and cities. People are facing many health-related problems because of this. Therefore, in the proposed work, we envisioned to tackle the challenge of acquiring real time and spatially fine-grained noise pollution data with a community-driven sensing infrastructure. Mobile crowdsourcing over smartphones presents a new paradigm for collecting context aware sensing data of a vast area like a city. Thus, the proposed system exploits the power of mobile crowdsourcing. The proposed system monitors the present noise level in the surroundings of the user and also generates city's noise pollution footprints. The noise map reflects the real-time pollution scenario of the city which changes with time. The prototype of the system has been evaluated with extensive experiments based on crowdsourced sensing data collected by volunteers in Kolkata city.},
 booktitle = {2017 IEEE International Conference on Advanced Networks and Telecommunications Systems (ANTS)},
 doi = {10.1109/ANTS.2017.8384103},
 issn = {},
 keywords = {Noise pollution, Noise monitoring, Energy efficient, Smart city, Noise-map},
 month = {Dec},
 number = {},
 pages = {1-6},
 title = {NoiseSense: Crowdsourced context aware sensing for real time noise pollution monitoring of the city},
 volume = {},
 year = {2017}
}

repository: pradippramanick/academic-kickstart

repo_name: pradippramanick/academic-kickstart


text:
@article{,
urldate = {2020-02-27},
abstract = {It is of substantial interest to study the effects of genes, genetic pathways, and networks on the risk of complex diseases. These genetic constructs each contain multiple SNPs, which are often correlated and function jointly, and might be large in number. However, only a sparse subset of SNPs in a genetic construct is generally associated with the disease of interest. In this article, we propose the generalized higher criticism (GHC) to test for the association between an SNP set and a disease outcome. The higher criticism is a test traditionally used in high-dimensional signal detection settings when marginal test statistics are independent and the number of parameters is very large. However, these assumptions do not always hold in genetic association studies, due to linkage disequilibrium among SNPs and the finite number of SNPs in an SNP set in each genetic construct. The proposed GHC overcomes the limitations of the higher criticism by allowing for arbitrary correlation structures among the SNPs in an SNP-set, while performing accurate analytic p-value calculations for any finite number of SNPs in the SNP-set. We obtain the detection boundary of the GHC test. We compared empirically using simulations the power of the GHC method with existing SNP-set tests over a range of genetic regions with varied correlation structures and signal sparsity. We apply the proposed methods to analyze the CGEM breast cancer genome-wide association study. Supplementary materials for this article are available online.},
accession-number = {28736464},
author = {Barnett, Ian and Mukherjee, Rajarshi and Lin, Xihong},
doi = {10.1080/01621459.2016.1192039},
edition = {2017/05/03},
end-page = {76},
isbn-issn = {0162-1459 and 1537-274X},
issue = {517},
journal-abbreviation-2 = {J Am Stat Assoc},
journal-full-format = {Journal of the American Statistical Association},
keywords = {*Correlated test statistics and *Detection boundary and *Genetic association testing and *Higher criticism and *Multiple hypothesis testing and *Signal detection},
language = {eng},
link-to-full-text = {https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5517103/},
name-of-database = {PubMed},
primary-date = {2017},
primary-title = {The Generalized Higher Criticism for Testing SNP-Set Effects in Genetic Association Studies},
start-page = {64},
type = {JOUR},
url = {https://www.ncbi.nlm.nih.gov/pubmed/28736464},
user-definable-1 = {28736464[pmid]},
user-definable-2 = {PMC5517103[pmcid]},
volume = {112},
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
# Copyright (c) 2008-2010 High Performance Computing Center Stuttgart,
#                         University of Stuttgart.  All rights reserved.
#
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#

# OMPI_FORTRAN_GET_SIZEOF(type, variable to set)
# ------------------------------------------

INCLUDE(fortran_find_ext_symbol_convention)

MACRO(OMPI_FORTRAN_GET_SIZEOF TYPE OUTPUT_VARIABLE)
  MESSAGE(STATUS "Check size of Fortran 77 ${TYPE}...")

  OMPI_FORTRAN_MAKE_C_FUNCTION(ompi_ac_size_fn size)

  FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.f
    "\t program fsize \n"
    "\t external size \n "
    "\t ${TYPE} x(2) \n"
    "\t call size(x(1),x(2)) \n"
    "\t end \n")

  IF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.h)
    SET(ompi_conftest_h "#include \"conftest.h\"")
  ELSE(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.h)
    SET(ompi_conftest_h "")
  ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.h)

  FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.c
       "#include <stdio.h> \n"
       "#include <stdlib.h> \n"
       "${ompi_conftest_h} \n"
       "#ifdef __cplusplus \n"
       "extern \"C\" { \n"
       "#endif \n"
       ""
       "void ${ompi_ac_size_fn}(char *a, char *b) \n"
       "{ \n"
       "    int diff = (int) (b - a); \n"
       "    FILE *f=fopen(\"conftestval\", \"w\"); \n"
       "    if (!f) exit(1); \n"
       "    fprintf(f, \"%d\\n\", diff); \n"
       "    fclose(f); \n"
       "} \n"
       "#ifdef __cplusplus \n"
       "} \n"
       "#endif \n")

  # generate the C object file
  EXECUTE_PROCESS(COMMAND ${CC} ${OMPI_C_OPTION_COMPILE} conftest.c ${OMPI_C_OUTPUT_OBJ}conftest_c.obj
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
    OUTPUT_VARIABLE OUTPUT
    RESULT_VARIABLE RESULT
    ERROR_VARIABLE ERROR)

  # generate the Fortran object file
  # some Fortran compilers don't allow to compile and link in one step. :-(
  EXECUTE_PROCESS(COMMAND ${FORTRAN} ${FORTRAN_OPTION_COMPILE} conftest.f ${FORTRAN_OUTPUT_OBJ}conftest.obj
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
    OUTPUT_VARIABLE OUTPUT
    RESULT_VARIABLE RESULT
    ERROR_VARIABLE ERROR)

  # link the C and Fortran object files.
  EXECUTE_PROCESS(COMMAND ${FORTRAN} conftest.obj conftest_c.obj ${FORTRAN_OUTPUT_EXE}conftest.exe
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
    OUTPUT_VARIABLE OUTPUT
    RESULT_VARIABLE RESULT
    ERROR_VARIABLE ERROR)

  EXECUTE_PROCESS(COMMAND conftest.exe
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
    OUTPUT_VARIABLE OUTPUT
    RESULT_VARIABLE RESULT
    ERROR_VARIABLE ERROR)

#  MESSAGE("RESULT:${RESULT}")

  IF(RESULT)
    MESSAGE(FATAL_ERROR "Could not determine size of ${TYPE}.")
  ELSE(RESULT)
    IF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval)
      # read out type size value from the file, and write back to the output variable
      FILE(READ ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval ${OUTPUT_VARIABLE})
      STRING(REPLACE "\n" "" ${OUTPUT_VARIABLE} ${${OUTPUT_VARIABLE}})
      MESSAGE(STATUS "Check size of Fortran 77 ${TYPE}...${${OUTPUT_VARIABLE}}")
    ELSE(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval)
      MESSAGE(FATAL_ERROR "Could not determine size of ${TYPE}.")
    ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval)
  ENDIF(RESULT)

ENDMACRO(OMPI_FORTRAN_GET_SIZEOF TYPE OUTPUT_VARIABLE)

repository: dotnwat/adio-ceph

repo_name: dotnwat/adio-ceph

extension: cmake


text:
package main

import (
	"os"
	"runtime"
	"syscall"
	"testing"
)

var (
	onCI         = len(os.Getenv("CI")) > 0
	gopath       = os.Getenv("GOPATH")
	testDataPath = gopath + "/src/github.com/TommyStarK/claptrap/testdata"
)

func init() {
	if len(gopath) == 0 {
		panic("$GOPATH not set")
	}

	if !onCI {
		testDataPath = "testdata"
	}
}

func TestClaptrapInstanciationShouldFail(t *testing.T) {
	if _, err := newClaptrap("invalid", nil); err == nil {
		t.Fatal("provided invalid path, should have failed to instanciate claptrap")
	}
}

func TestClaptrapBehaviorOnLargeFile(t *testing.T) {
	c, err := newClaptrap(testDataPath, nil)
	if err != nil {
		t.Fatal(err)
	}

	ch := make(chan [3]string)
	c.testMode = true
	c.testchan = ch

	triggerWrite := make(chan chan struct{}, 1)
	triggerUpdate := make(chan chan struct{}, 1)
	triggerRename := make(chan chan struct{}, 1)
	triggerRemove := make(chan chan struct{}, 1)
	witness := make(chan struct{}, 1)

	go c.trap()

	go func(triggerWrite chan chan struct{}) {
		writeDone := <-triggerWrite
		writeBigFile(testDataPath+"/bigfile", testContent, c.errors)
		writeDone <- struct{}{}
	}(triggerWrite)

	go func(triggerUpdate chan chan struct{}) {
		updateDone := <-triggerUpdate
		writeFile(testDataPath+"/bigfile", testContent, c.errors)
		updateDone <- struct{}{}
	}(triggerUpdate)

	go func(triggerRename chan chan struct{}) {
		renameDone := <-triggerRename
		renameFile(testDataPath+"/bigfile", testDataPath+"/bigf", c.errors)
		renameDone <- struct{}{}
	}(triggerRename)

	go func(triggerRemove chan chan struct{}) {
		removeDone := <-triggerRemove
		removeFile(testDataPath+"/bigf", c.errors)
		removeDone <- struct{}{}
	}(triggerRemove)

	triggerWrite <- witness
	<-witness
	close(triggerWrite)
	processResult(t, "CREATE", testDataPath+"/bigfile", ch)

	triggerUpdate <- witness
	<-witness
	close(triggerUpdate)
	processResult(t, "UPDATE", testDataPath+"/bigfile", ch)

	triggerRename <- witness
	<-witness
	close(triggerRename)
	processResult(t, "RENAME", testDataPath+"/bigfile", ch)

	triggerRemove <- witness
	<-witness
	close(triggerRemove)
	processResult(t, "REMOVE", testDataPath+"/bigf", ch)

	c.sigchan <- os.Signal(syscall.SIGTERM)

	close(ch)
	close(witness)
}

func TestConvertSignalToInt(t *testing.T) {
	for _, test := range []struct {
		name     string
		signal   os.Signal
		expected int
	}{
		{
			name:     "nil",
			signal:   nil,
			expected: 1,
		},
		{
			name:     "not supported",
			signal:   syscall.SIGABRT,
			expected: 1,
		},
		{
			name:     "sigint",
			signal:   syscall.SIGINT,
			expected: 2,
		},
		{
			name:     "sigkill",
			signal:   syscall.SIGKILL,
			expected: 9,
		},
		{
			name:     "sigterm",
			signal:   syscall.SIGTERM,
			expected: 15,
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			if c := convertSignalToInt(test.signal); c != test.expected {
				t.Errorf("expected: %d, but got: %d", test.expected, c)
			}
		})
	}
}

func TestMain(m *testing.M) {
	os.Exit(m.Run())
}

func processResult(t *testing.T, expectedAction, expectedTarget string, ch chan [3]string) {
	result := <-ch
	action, target, timestamp := result[0], result[1], result[2]

	if len(timestamp) == 0 {
		t.Fatal("timestamp should not be empty")
	}
	if action != expectedAction || target != expectedTarget {
		t.Fatalf("event caught should be '%s' and target '%s' but got: [%s|%s] ", expectedAction, expectedTarget, action, target)
	}
}

func writeBigFile(path, content string, errchan chan error) {
	var f *os.File
	f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		errchan <- err
		return
	}

	for i := 0; i < runtime.NumCPU()*1000; i++ {
		if _, err := f.WriteString(content); err != nil {
			errchan <- err
			return
		}
	}

	if err := f.Sync(); err != nil {
		errchan <- err
		return
	}
	if err := f.Close(); err != nil {
		errchan <- err
		return
	}
}

repository: TommyStarK/claptrap

repo_name: TommyStarK/claptrap


text:
L4T_DEB_COPYRIGHT_MD5 = "fab0c15b4bbf7f8d5ac2bd6673d4211c"
DEPENDS = "libdrm patchelf-native"

L4T_DEB_TRANSLATED_BPN = "nvidia-l4t-core"

require tegra-debian-libraries-common.inc

LICENSE += "& BSD-3-Clause"
LIC_FILES_CHKSUM += "file://usr/share/doc/nvidia-tegra/LICENSE.minigbm;md5=72f855f00b364ec8bdc025e1a36b39c3"

MAINSUM = "26463537a9d0b0438c89cbdabc3242d8e73410f023ed1d11ceb40a18e49b4fd7"

TEGRA_LIBRARIES_TO_INSTALL = "\
    tegra/libnvgbm.so \
"

do_install:append() {
    patchelf --set-soname libnvgbm.so.1 ${D}${libdir}/libnvgbm.so
}

DEBIAN_NOAUTONAME:${PN} = "1"
DEBIAN_NOAUTONAME:${PN}-dev = "1"
DEBIAN_NOAUTONAME:${PN}-dbg = "1"
FILES_SOLIBSDEV = ""
SOLIBS = ".so*"
RRECOMMENDS:${PN} = "kernel-module-nvgpu"

repository: SOL-Space-Operating-Linux/meta-tegra

repo_name: SOL-Space-Operating-Linux/meta-tegra


text:
#
# 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.
#
# Tries to find OdinData headers and libraries.
#
# Usage of this module as follows:
#
#  find_package(OdinData)
#
# Variables used by this module, they can change the default behaviour and need
# to be set before calling find_package:
#
#  ODINDATA_ROOT_DIR  Set this variable to the root installation of
#                  	  OdinData Library if the module has problems finding
#                     the proper installation path.
#
# Variables defined by this module:
#
#  ODINDATA_FOUND              System has OdinData libs/headers
#  ODINDATA_LIBRARIES          The OdinData libraries
#  ODINDATA_INCLUDE_DIRS       The location of OdinData headers

message ("\nLooking for odinData headers and libraries")

if (ODINDATA_ROOT_DIR)
    message (STATUS "Root dir: ${ODINDATA_ROOT_DIR}")
endif ()

find_package(PkgConfig)
IF (PkgConfig_FOUND)
    message("using pkgconfig")
    pkg_check_modules(PC_ODINDATA odinData)
ENDIF(PkgConfig_FOUND)

# Set the name of the frameProcessor library
if (NOT APPLE)
    set(LIB_RECEIVER FrameReceiver)
    set(LIB_PROCESSOR FrameProcessor)
    set(LIB_SIMULATOR FrameSimulator)
else(NOT APPLE)
    set(LIB_RECEIVER OdinFrameReceiver)
    set(LIB_PROCESSOR OdinFrameProcessor)
    set(LIB_SIMULATOR OdinFrameSimulator)
endif(NOT APPLE)

set(ODINDATA_DEFINITIONS ${PC_ODINDATA_CFLAGS_OTHER})

find_path(ODINDATA_INCLUDE_DIR
	NAMES
		ClassLoader.h
    PATHS
		${ODINDATA_ROOT_DIR}/include
        ${PC_ODINDATA_INCLUDEDIR}
        ${PC_ODINDATA_INCLUDE_DIRS}
)

find_path(FRAMERECEIVER_INCLUDE_DIR
	NAMES
		FrameDecoder.h
	PATHS
		${ODINDATA_ROOT_DIR}/include/frameReceiver
        ${PC_ODINDATA_INCLUDEDIR}
        ${PC_ODINDATA_INCLUDE_DIRS}
)

find_path(FRAMEPROCESSOR_INCLUDE_DIR
	NAMES
		DataBlock.h
	PATHS
		${ODINDATA_ROOT_DIR}/include/frameProcessor
        ${PC_ODINDATA_INCLUDEDIR}
        ${PC_ODINDATA_INCLUDE_DIRS}
)

find_path(FRAMESIMULATOR_INCLUDE_DIR
    NAMES
        FrameSimulatorPlugin.h
    PATHS
        ${ODINDATA_ROOT_DIR}/include/frameSimulator
        ${PC_ODINDATA_INCLUDEDIR}
        ${PC_ODINDATA_INCLUDE_DIRS}
)

find_library(ODINDATA_LIBRARY
    NAMES
		OdinData
    PATHS
		${ODINDATA_ROOT_DIR}/lib
        ${PC_ODINDATA_LIBDIR}
        ${PC_ODINDATA_LIBRARY_DIRS}
)

find_library(FRAMERECEIVER_LIBRARY
	NAMES
		${LIB_RECEIVER}
	PATHS
		${ODINDATA_ROOT_DIR}/lib
		${PC_ODINDATA_LIBDIR}
		${PC_ODINDATA_LIBRARY_DIRS}
)

find_library(FRAMEPROCESSOR_LIBRARY
	NAMES
		${LIB_PROCESSOR}
	PATHS
		${ODINDATA_ROOT_DIR}/lib
		${PC_ODINDATA_LIBDIR}
		${PC_ODINDATA_LIBRARY_DIRS}
)

find_library(FRAMESIMULATOR_LIBRARY
    NAMES
        ${LIB_SIMULATOR}
    PATHS
        ${ODINDATA_ROOT_DIR}/lib
        ${PC_ODINDATA_LIBDIR}
        ${PC_ODINDATA_LIBRARY_DIRS}
)

include(FindPackageHandleStandardArgs)

# handle the QUIETLY and REQUIRED arguments and set ODINDATA_FOUND to TRUE
# if all listed variables are TRUE
find_package_handle_standard_args(ODINDATA
	DEFAULT_MSG
    ODINDATA_LIBRARY
    ODINDATA_INCLUDE_DIR
    FRAMERECEIVER_INCLUDE_DIR
    FRAMEPROCESSOR_LIBRARY
    FRAMEPROCESSOR_INCLUDE_DIR
    FRAMESIMULATOR_LIBRARY
    FRAMESIMULATOR_INCLUDE_DIR
)

mark_as_advanced(ODINDATA_INCLUDE_DIR FRAMERECEIVER_INCLUDE_DIR FRAMEPROCESSOR_INCLUDE_DIR ODINDATA_LIBRARY FRAMEPROCESSOR_LIBRARY FRAMESIMULATOR_LIBRARY)

if (ODINDATA_FOUND)
    set(ODINDATA_INCLUDE_DIRS ${ODINDATA_INCLUDE_DIR} ${FRAMERECEIVER_INCLUDE_DIR} ${FRAMEPROCESSOR_INCLUDE_DIR} ${FRAMESIMULATOR_INCLUDE_DIR})
    set(ODINDATA_LIBRARIES ${ODINDATA_LIBRARY} ${FRAMERECEIVER_LIBRARY} ${FRAMEPROCESSOR_LIBRARY} ${FRAMESIMULATOR_LIBRARY})

    get_filename_component(ODINDATA_LIBRARY_DIR ${ODINDATA_LIBRARY} PATH)
    get_filename_component(ODINDATA_LIBRARY_NAME ${ODINDATA_LIBRARY} NAME_WE)

    mark_as_advanced(ODINDATA_LIBRARY_DIR ODINDATA_LIBRARY_NAME)

	message (STATUS "Include directories: ${ODINDATA_INCLUDE_DIRS}")
	message (STATUS "Libraries: ${ODINDATA_LIBRARIES}")
endif ()

repository: stfc-aeg/hexitec-detector

repo_name: stfc-aeg/hexitec-detector


text:
CUDA_PKG = "${BPN}"

require cuda-shared-binaries-${PV}.inc

MAINSUM = "fe29d0a639620c161a732cdff520670142e986d795bb3f7afd7c06e41dca340e"
MAINSUM:x86-64 = "06d1a867618b3a9367bb052af33ec265521ffe99c4eb71fcdaa101e1f1247de0"

BBCLASSEXTEND = "native nativesdk"

repository: danielwangksu/meta-tegra

repo_name: danielwangksu/meta-tegra


text:
inherit systemd

SUMMARY = "Install and start a systemd service"
SECTION = "lightec"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

DEPENDS += "lightec"

#here we specify the source we want to build
SRC_URI = "\
            file://lightec.sh \
            file://lightec.service \
        "

S = "${WORKDIR}"

SYSTEMD_SERVICE_${PN} = "lightec.service"

#bitbake task
do_install() {
   install -d ${D}${bindir}
   install -m 0755 ${WORKDIR}/lightec.sh ${D}${bindir}
   install -d ${D}${systemd_unitdir}/system
   install -m 0644 ${WORKDIR}/lightec.service ${D}${systemd_unitdir}/system
}

#Pack the path
FILES_${PN} += "/usr/bin/"
FILES_${PN} += "/lib/systemd/system"

REQUIRED_DISTRO_FEATURES= "systemd"

repository: sjgarani/lightec

repo_name: sjgarani/lightec


text:
similitudControllers.controller('similitudNavegar', ['$translate', '$routeParams', '$scope', 'temporalData', 'globalData', 'sparqlQuery', 'searchData', '$route', '$window',
    function ($translate, $routeParams, $scope, temporalData, globalData, sparqlQuery, searchData, $route, $window) {

        //se colocan en null los indicadores de selección de silabos
        temporalData.selectedSyllabusID_A = null;
        temporalData.selectedSyllabusID_B= null;

        $translate.use($routeParams.lang);
        $scope.if_B = function ()
        {
            $('#seleccionandoB').css('display', '');
            $('#otrosilabo').css('display', 'none');
        };
        $scope.themes = [];
        $scope.institutions = [];
        //waitingDialog.show();
        loadInstitutions();
        function loadInstitutions() {

            //Esta Query no funciona si solo se tiene una institución en el repositorio,
            // es por eso que por el momento se le colocará manualmente el ID y LABEL de la unica institución existente
            var queryInstitutions = globalData.PREFIX

                    + ' CONSTRUCT {?institucion aiiso:name  ?nameinstitucion } '
                    + ' WHERE { '
                    + '     SELECT DISTINCT ?institucion ?nameinstitucion  '
                    + '         WHERE { '
                    + '             ?institucion a aiiso:Institution . '
                    + '             ?institucion aiiso:name ?nameinstitucion '
                    + '         } '
                    + ' } ';
            sparqlQuery.querySrv({query: queryInstitutions}, function (rdf) {
                //   waitingDialog.show();
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted["@graph"])
                    {
                        _.map(compacted["@graph"], function (silb) {
                            var model = {};
                            model["id"] = silb["@id"];
                            model["name"] = silb["aiiso:name"]["@value"];
                            $scope.institutions.push({instID: model["id"], instNAME: model["name"]});
                        });
                        applyvaluesInstitutions();
                        waitingDialog.hide();
                    } else
                    { //unicamente si no existe ninguna institucion en el repositorio, no debería pasar
                        var model = {};
                        model["id"] = compacted["@id"];
                        model["name"] = compacted["aiiso:name"]["@value"];
                        $scope.institutions.push({instID: model["id"], instNAME: model["name"]});
                        applyvaluesInstitutions();
                        //alert("No se han recuperado Instituciones");
                        waitingDialog.hide();
                    }
                });
            });
        }

        function applyvaluesInstitutions() {
            $scope.$apply(function () {
                $scope.institutionsFinal = $scope.institutions;
            });
        }
        ;
        //Cuando el usuario selecciona la institución
        $scope.$watch('selectedInstitutionA', function () {//Funcion para cuando se selecciona la Research Area
            loadDependenciasA($scope.selectedInstitutionA); //query and load resource related with selected theme
        });
        $scope.$watch('selectedInstitutionB', function () {//Funcion para cuando se selecciona la Research Area
            loadDependenciasB($scope.selectedInstitutionB); //query and load resource related with selected theme
        });
        //Para saber cuando el usuario seleccione la dependencia.
        $scope.$watch('selectedDependenciaA', function () {
            loadSilabosA($scope.selectedInstitutionA, $scope.selectedDependenciaA)
            temporalData.selectedDependenciaA = $scope.selectedDependenciaA;
        });
        //Para saber cuando el usuario seleccione la dependencia.
        $scope.$watch('selectedDependenciaB', function () {
            loadSilabosB($scope.selectedInstitutionB, $scope.selectedDependenciaB)
            temporalData.selectedDependenciaB = $scope.selectedDependenciaB;
        });
        $scope.$watch('selectedSilaboA', function () {

            temporalData.selectedSyllabusA = $scope.selectedSilaboA;
            if (typeof temporalData.selectedSyllabusA === 'undefined')
            {
            } else
            {
                $('#contenidoNavegarA').css('display', '');
                $('#otrosilabo').css('display', '');
                mostrarFullSilaboA(temporalData.selectedSyllabusA);
            }
        });
        $scope.$watch('selectedSilaboB', function () {

            temporalData.selectedSyllabusB = $scope.selectedSilaboB;
            if (typeof temporalData.selectedSyllabusB === 'undefined')
            {
            } else
            {
                $('#contenidoNavegarB').css('display', '');
                mostrarFullSilaboB(temporalData.selectedSyllabusB);
                similitudPrealmacenada(temporalData.selectedSyllabusA, temporalData.selectedSyllabusB);
            }
        });

        function loadDependenciasMapping(compacted)
        {
            var listadodependencias = [];
            _.map(compacted["@graph"], function (silb) {
                var model = {};
                //model["Publication"] = pub["foaf:publications"]["@id"];
                model["dependencia"] = silb["@id"];
                model["name"] = silb["aiiso:name"]["@value"];
                listadodependencias.push({depenID: model["dependencia"], depenNAME: model["name"]});
            });
            return listadodependencias;

        }
        function loadDependenciasA(institution)
        {
            var queryDependencias = String.format(globalData.queryDependencias, institution);
            var listadodependencias = [];
            sparqlQuery.querySrv({query: queryDependencias}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    waitingDialog.hide();
                    if (compacted["@graph"])
                    {
                        listadodependencias = loadDependenciasMapping(compacted)
                        applyvaluesDependenciasA(listadodependencias);
                    } else// se ha recuperado una dependencia
                    if (compacted["@id"]) {
                        listadodependencias = loadDependenciasMapping({"@graph": [compacted]})
                        applyvaluesDependenciasA(listadodependencias);
                    }
                    else // no se ha recuperado ninguna dependencia
                    {

                    }

                }); //end jsonld.compact
            }); //end sparqlService

        }//end loadDependenciasA

        function loadDependenciasB(institution)
        {
            var queryDependencias = String.format(globalData.queryDependencias, institution);
            var listadodependencias = [];
            sparqlQuery.querySrv({query: queryDependencias}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    waitingDialog.hide();
                    if (compacted["@graph"])
                    {
                        listadodependencias = loadDependenciasMapping(compacted)
                        applyvaluesDependenciasB(listadodependencias);
                    } else// se ha recuperado una dependencia
                    if (compacted["@id"]) {
                        listadodependencias = loadDependenciasMapping({"@graph": [compacted]})
                        applyvaluesDependenciasB(listadodependencias);
                    }
                    else // no se ha recuperado ninguna dependencia
                    {

                    }
                }); //end jsonld.compact
            }); //end sparqlService

        }//end loadDependenciasB

        function applyvaluesDependenciasA(dependencias) {
            $scope.$apply(function () {
                $scope.dependenciasFinalA = dependencias;
            });
        }

        function applyvaluesDependenciasB(dependencias) {
            $scope.$apply(function () {
                $scope.dependenciasFinalB = dependencias;
            });
        }

        function loadSilabosMapping(compacted)
        {
            var listadoSilabos = [];
            _.map(compacted["@graph"], function (silb) {
                var model = {};
                //model["Publication"] = pub["foaf:publications"]["@id"];
                model["silabo"] = silb["@id"];
                model["name"] = silb["aiiso:name"]["@value"];
                model["creation"] = silb["ies:date_creation"].substring(0, 10);
                listadoSilabos.push({silaboID: model["silabo"], silaboNAME: model["name"], silaboCREATION: model["creation"]});
            });
            return listadoSilabos;
        }

        function loadSilabosA(institucion, dependencia) {
            var querysilabos = String.format(globalData.queryLoadSilabos, dependencia, institucion);
            var listadoSilabos = [];
            sparqlQuery.querySrv({query: querysilabos}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted["@graph"])
                    {
                        listadoSilabos = loadSilabosMapping(compacted);
                        applyvaluesSilabosA(listadoSilabos);
                        waitingDialog.hide();
                    } else//no retrieve data
                    {
                        //alert("No se han recuperado datos de las dependencias");
                        waitingDialog.hide();
                    }
                }); //end jsonld.compact
            }); //end sparqlService
        }// end loadSilabos

        function loadSilabosB(institucion, dependencia) {
            var querysilabos = String.format(globalData.queryLoadSilabos, dependencia, institucion);
            var listadoSilabos = [];
            sparqlQuery.querySrv({query: querysilabos}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted["@graph"])
                    {
                        listadoSilabos = loadSilabosMapping(compacted);
                        applyvaluesSilabosB(listadoSilabos);
                        waitingDialog.hide();
                    } else//no retrieve data
                    {
                        //alert("No se han recuperado datos de las dependencias");
                        waitingDialog.hide();
                    }
                }); //end jsonld.compact
            }); //end sparqlService
        }// end loadSilabos

        function applyvaluesSilabosA(listadoSilabos) {
            $scope.$apply(function () {
                $scope.silabosFinalA = listadoSilabos;
            });
        }
        function applyvaluesSilabosB(listadoSilabos) {
            $scope.$apply(function () {
                $scope.silabosFinalB = listadoSilabos;
            });
        }

        function fullSilaboMapping(compacted, silaboID)
        {
            var fullSilabo = {};
            var model = {};

            if (compacted["@graph"])
            {
                var contenido = [];
                _.map(compacted["@graph"], function (silabo) {
                    if (silabo["@id"] == silaboID)
                    {
                        model["silabo"] = silabo["@id"];
                        model["name"] = silabo["aiiso:name"]["@value"];
                        model["description"] = silabo["aiiso:description"]["@value"];
                        model["dependenciaID"] = silabo["ies:is_taught_by"]["@id"];
                        model["dependencia"] = silabo["ies:name_academic_unit"]["@value"];
                        model["institucionID"] = silabo["ies:has_institution"]["@id"];
                        model["institucion"] = silabo["ies:name_institution"]["@value"];
                        model["creacion"] = silabo["ies:date_creation"].substring(0, 10);
                        model["creditos"] = silabo["ies:credits"];
                        model["institucion"] = silabo["ies:name_institution"]["@value"];
                        model["objective"] = silabo["ies:objective"]
                        var objetivos = [];
                        objetivos.push(silabo["ies:objective"]);
                        model["objective"] = silabo["ies:objective"].length > 1 ? silabo["ies:objective"] : objetivos;
                        model["chapter"] = silabo["ies:chapter"];
                    } else
                    {
                        var capitulo = [];
                        capitulo.push(silabo["ies:chapter"]["@value"]);
                        for (var i = 0; i < silabo["ies:subchapter"].length; i++)
                        {
                            capitulo.push(silabo["ies:subchapter"][i]["@value"]);
                        }
                        //}
                        contenido.push(capitulo);
                    }
                    model["chapter"] = contenido;
                });
            } else
            {
                var contenido = [];
                model["silabo"] = compacted["@id"];
                model["name"] = compacted["aiiso:name"]["@value"];
                model["description"] = compacted["aiiso:description"]["@value"];
                model["dependenciaID"] = compacted["ies:is_taught_by"]["@id"];
                model["dependencia"] = compacted["ies:name_academic_unit"]["@value"];
                model["institucionID"] = compacted["ies:has_institution"]["@id"];
                model["institucion"] = compacted["ies:name_institution"]["@value"];
                model["creacion"] = compacted["ies:date_creation"].substring(0, 10);
                model["creditos"] = compacted["ies:credits"];
                model["objective"] = compacted["ies:objective"]
                var objetivos = [];
                objetivos.push(compacted["ies:objective"]);
                model["objective"] = compacted["ies:objective"].length > 1 ? compacted["ies:objective"] : objetivos;
                //var capitulo = [];
                //capitulo .push("No se ha encontrado contenido académico")
                //contenido.push(capitulo)
                model["chapter"] = contenido;
            }
            fullSilabo = {id: model["silabo"], creacion: model["creacion"],
                creditos: model["creditos"], content: model["chapter"],
                objectives: model["objective"], description: model["description"],
                name: model["name"], dependencia: model["dependencia"],
                dependenciaID: model["dependenciaID"], institucion: model["institucion"],
                institucionID: model["institucionID"]};
            return  {schema: {fields: ["name", "description", "objectives", "content",
                        "dependencia", "institucion", "creacion", "creditos"],
                    fields_to_compare: ["name", "description", "objectives", "content"]},
                data: fullSilabo};
        }
        function mostrarFullSilaboA(silaboID)
        {
            var query = String.format(globalData.queryFullSilabos, silaboID);
            var fullSilaboData = [];
            sparqlQuery.querySrv({query: query}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted)
                    {
                        fullSilaboData = fullSilaboMapping(compacted, silaboID);
                        applyFullSilaboA(silaboID, fullSilaboData);
                        waitingDialog.hide();
                    } else//no retrieve data
                    {
                        //alert("No se han recuperado datos de las dependencias");
                        waitingDialog.hide();
                    }
                }); //end jsonld.compact
            }); //end sparqlService
        }
        ; //Fin mostrarFullSilaboA

        function mostrarFullSilaboB(silaboID)
        {
            var query = String.format(globalData.queryFullSilabos, silaboID);
            var fullSilaboData = [];
            sparqlQuery.querySrv({query: query}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted)
                    {
                        fullSilaboData = fullSilaboMapping(compacted, silaboID);
                        applyFullSilaboB(silaboID, fullSilaboData);
                        waitingDialog.hide();
                    } else//no retrieve data
                    {
                        //alert("No se han recuperado datos de las dependencias");
                        waitingDialog.hide();
                    }
                }); //end jsonld.compact
            }); //end sparqlService
        }
        ; //Fin mostrarFullSilaboB

        function applyFullSilaboA(silaboID, fullSilaboData)
        {
            $scope.$apply(function () {
                // $scope.showSilaboA = fullSilabo[0];
                $scope.dataA = fullSilaboData;
                $scope.labelA = "Silabo A";
                temporalData.selectedSyllabusID_A = silaboID;
                temporalData.silaboAlmacenadoA = fullSilaboData;
            });
        }
        ;
        function applyFullSilaboB(silaboID, fullSilaboData)
        {
            $scope.$apply(function () {
                // $scope.showSilaboB = fullSilabo;
                $scope.dataB = fullSilaboData;
                $scope.labelB = "Silabo B";
                temporalData.selectedSyllabusID_B = silaboID;
                temporalData.silaboAlmacenadoB = fullSilaboData;
            });
        }
        ;
        function similitudPrealmacenada(silaboA, silaboB) {
            waitingDialog.show("Calculando Similitud");
            var querySimilitud = globalData.PREFIX

                    + ' CONSTRUCT {?similarityResource ies:total_value>  ?value }'
                    + ' WHERE {'
                    //+ '     SELECT DISTINCT ?o  (str(?o) as ?label)'
                    + '     SELECT DISTINCT ?temporalResource ?value  '
                    + '         WHERE {'
                    + '             <' + silaboA + '> <ies:has_similarity> ?similarityResource. '
                    + '             <' + silaboB + '> <ies:has_similarity> ?similarityResource. '
                    + '             ?similarityResource ies:total_value> ?value '
                    + '         } '
                    + ' }';
            var similitud = [];
            sparqlQuery.querySrv({query: querySimilitud}, function (rdf) {
                jsonld.compact(rdf, globalData.CONTEXT, function (err, compacted) {
                    if (compacted && compacted["ies:value"])
                    {
                        var model = {};
                        model["id"] = compacted["@id"];
                        model["value"] = compacted["ies:total_value"]["@value"];
                        similitud.push({similitudID: model["id"], similitudValue: model["value"]});
                        applyvaluesSimilitud(similitud);
                        waitingDialog.hide();
                    } else
                    {
                        calcularSimilitud();
                        alert("No se ha recuperado información, consulte al administrador")
                        waitingDialog.hide();
                    }
                });
            });
        }
        ;
        function applyvaluesSimilitud(similitud) {
            $("#scrollToValue").css('display', '');
            $('html,body').animate({
                scrollTop: $("#scrollToValue").offset().top}, "slow")
            $scope.$apply(function () {
                $scope.similitudFinal = similitud;
            });
        }
        ;
        $scope.searchDialog = function () {
            $('#searchDialog').modal('show');
        };
        $scope.safeApply = function (fn) {
            var phase = this.$root.$$phase;
            if (phase == '$apply' || phase == '$digest') {
                if (fn && (typeof (fn) === 'function')) {
                    fn();
                }
            } else {
                this.$apply(fn);
            }
        };
        String.format = function () {
            // The string containing the format items (e.g. "{0}")
            // will and always has to be the first argument.
            var theString = arguments[0];
            // start with the second argument (i = 1)
            for (var i = 1; i < arguments.length; i++) {
                // "gm" = RegEx options for Global search (more than one instance)
                // and for Multiline search
                var regEx = new RegExp("\\{" + (i - 1) + "\\}", "gm");
                theString = theString.replace(regEx, arguments[i]);
            }
            return theString;
        };
    }]); //end groupTagsController

extension: js


text:
@article{Khoe:1994:CML:2288694.2294265,
    author = {Khoe, G. -D.},
    title = {Coherent multicarrier lightwave technology for flexible capacity networks},
    journal = {Comm. Mag.},
    issue_date = {March 1994},
    volume = {32},
    number = {3},
    month = mar,
    year = {1994},
    issn = {0163-6804},
    pages = {22--33},
    numpages = {12},
    url = {http://dx.doi.org/10.1109/35.267438},
    doi = {10.1109/35.267438},
    acmid = {2294265},
    publisher = {IEEE Press},
    address = {Piscataway, NJ, USA},
}
@misc{opencv,
  title={Open Source Computer Vision Library},
  author={OpenCV},
  year={2018},
  howpublished = {\url{https://github.com/opencv/opencv}}
}
@book{forsyth, place={Boston}, title={Computer vision: a modern approach}, publisher={Pearson}, author={Forsyth, David and Ponce, Jean}, year={2011}}

@article{opencv_library,
    author = {Bradski, G.},
    citeulike-article-id = {2236121},
    journal = {Dr. Dobb's Journal of Software Tools},
    keywords = {bibtex-import},
    posted-at = {2008-01-15 19:21:54},
    priority = {4},
    title = {{The OpenCV Library}},
    year = {2000}
}

gha_language: Jupyter Notebook


text:
@article{bonnet_science_2022,
author = {Timothée Bonnet  and Michael B. Morrissey  and Pierre de Villemereuil  and Susan C. Alberts  and Peter Arcese  and Liam D. Bailey  and Stan Boutin  and Patricia Brekke  and Lauren J. N. Brent  and Glauco Camenisch  and Anne Charmantier  and Tim H. Clutton-Brock  and Andrew Cockburn  and David W. Coltman  and Alexandre Courtiol  and Eve Davidian  and Simon R. Evans  and John G. Ewen  and Marco Festa-Bianchet  and Christophe de Franceschi  and Lars Gustafsson  and Oliver P. Höner  and Thomas M. Houslay  and Lukas F. Keller  and Marta Manser  and Andrew G. McAdam  and Emily McLean  and Pirmin Nietlisbach  and Helen L. Osmond  and Josephine M. Pemberton  and Erik Postma  and Jane M. Reid  and Alexis Rutschmann  and Anna W. Santure  and Ben C. Sheldon  and Jon Slate  and Céline Teplitsky  and Marcel E. Visser  and Bettina Wachter  and Loeske E. B. Kruuk },
title = {Genetic variance in fitness indicates rapid contemporary adaptive evolution in wild animals},
journal = {Science},
volume = {376},
number = {6596},
pages = {1012-1016},
year = {2022},
doi = {10.1126/science.abk0853},
URL = {https://www.science.org/doi/abs/10.1126/science.abk0853}
}

gha_language: HTML


text:
@InProceedings{10.1007/978-3-319-10443-0_6,
author="Wachinger, Christian
and Golland, Polina
and Reuter, Martin",
editor="Golland, Polina
and Hata, Nobuhiko
and Barillot, Christian
and Hornegger, Joachim
and Howe, Robert",
title="BrainPrint : Identifying Subjects by Their Brain",
booktitle="Medical Image Computing and Computer-Assisted Intervention -- MICCAI 2014",
year="2014",
publisher="Springer International Publishing",
address="Cham",
pages="41--48",
isbn="978-3-319-10443-0"
}


text:
SECTION = "libs"
DEPENDS = "gtk+ glib-2.0 libxml2"
DESCRIPTION = "A GTK+ HTML rendering library."
LICENSE = "LGPLv2"
LIC_FILES_CHKSUM = "file://COPYING.LIB;md5=55ca817ccb7d5b5b66355690e9abc605"

SRCREV = "1161"
PV = "2.11.0+svnr${SRCPV}"
PR = "r5"

SRC_URI = "svn://svn.gnome.org/svn/gtkhtml2/;module=trunk;protocol=http \
           http://git.yoctoproject.org/cgit/cgit.cgi/web-patches/plain/css-stylesheet-user.patch;striplevel=0;name=patch2 \
           http://git.yoctoproject.org/cgit/cgit.cgi/web-patches/plain/css-media.patch;striplevel=0;name=patch3 \
           http://git.yoctoproject.org/cgit/cgit.cgi/web-patches/plain/add-end-element-signal.patch;striplevel=0;name=patch4 \
           http://git.yoctoproject.org/cgit/cgit.cgi/web-patches/plain/add-dom-functions.patch;striplevel=0;name=patch5 \
           http://git.yoctoproject.org/cgit/cgit.cgi/web-patches/plain/iain-mem-leak.patch;striplevel=0;name=patch6 \
           file://0001-tests-main.c-fix-build-with-glib-2.36.patch \
"

SRC_URI[patch2.md5sum] = "05fc3627ca364095702dc804f41c8391"
SRC_URI[patch2.sha256sum] = "df5cca50a8f95333505d7920929fea251daea3be25be6834a1c50a742d9eb674"

SRC_URI[patch3.md5sum] = "d3fe4cda3545f3e4718f1acc186608ab"
SRC_URI[patch3.sha256sum] = "3aefaa17ffa38143bf5df1161c51ab402d35bfbee41ab4643c313edf569165d5"

SRC_URI[patch4.md5sum] = "651b1601d8a1b21c8a3040fadb729043"
SRC_URI[patch4.sha256sum] = "d067e8331bf9c6851f1c6067d991a7f54327f532900b405ebdf8e149c071f381"

SRC_URI[patch5.md5sum] = "041be9711a16e629d01487664ba97152"
SRC_URI[patch5.sha256sum] = "42956fb41341cf82ae8bce18b4cf96a7e2aa631b1b60657afb6d7e9be7cd138c"

SRC_URI[patch6.md5sum] = "4e11dc7899d68f2be2e06ccee01d296d"
SRC_URI[patch6.sha256sum] = "1e2cc080e654c1839c5cb4b4adf4c62a23e7da208427f3ba0b16cfed9e5cfa98"

S = "${WORKDIR}/trunk"

inherit pkgconfig autotools

EXTRA_OECONF = " --disable-accessibility"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace


text:
@InProceedings{tran12b,
  title = {Learning From Ordered Sets and Applications in Collaborative Ranking},
  author = {T. Tran and D. Phung  and  S. Venkatesh},
  pages = {427--442},
  abstract = {Ranking over sets arise when users choose between groups of items. For example, a group may be of those movies deemed 5 stars to them, or a customized tour package. It turns out, to model this data type properly, we need to investigate the general combinatorics problem of partitioning a set and ordering the subsets. Here we construct a probabilistic log-linear model over a set of ordered subsets. Inference in this combinatorial space is highly challenging: The space size approaches (N!=2)6:93145^{N+1} as N approaches infinity. We propose a split-and-merge Metropolis-Hastings procedure that can explore the state-space efficiently. For discovering hidden aspects in the data, we enrich the model with latent binary variables so that the posteriors can be efficiently evaluated. Finally, we evaluate the proposed model on large-scale collaborative filtering tasks and demonstrate that it is competitive against state-of-the-art methods.},
  pdf = {http://jmlr.org/proceedings/papers/v25/tran12b/tran12b.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
@unpublished{Jansson:02,
 author = {H. Jansson},
 month = {May},
 note = {Licentiate thesis},
 title = {Identification for control: Using sensitivity information to improve quality of restricted complexity models},
 year = {2002}
}

repository: hhjalmars/academic-kickstart

repo_name: hhjalmars/academic-kickstart


text:
DESCRIPTION = "nodeJS Evented I/O for V8 JavaScript"
HOMEPAGE = "http://nodejs.org"
LICENSE = "MIT & ISC & BSD-2-Clause & BSD-3-Clause & Artistic-2.0 & Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=bc1f9ebe76be76f163e3b675303ad9cd"

CVE_PRODUCT = "nodejs node.js"

DEPENDS = "openssl file-replacement-native"
DEPENDS:append:class-target = " qemu-native"
DEPENDS:append:class-native = " c-ares-native"

inherit pkgconfig python3native qemu ptest

COMPATIBLE_MACHINE:armv4 = "(!.*armv4).*"
COMPATIBLE_MACHINE:armv5 = "(!.*armv5).*"
COMPATIBLE_MACHINE:mips64 = "(!.*mips64).*"

COMPATIBLE_HOST:riscv64 = "null"
COMPATIBLE_HOST:riscv32 = "null"
COMPATIBLE_HOST:powerpc = "null"

SRC_URI = "http://nodejs.org/dist/v${PV}/node-v${PV}.tar.xz \
           file://0001-Disable-running-gyp-files-for-bundled-deps.patch \
           file://0004-v8-don-t-override-ARM-CFLAGS.patch \
           file://big-endian.patch \
           file://mips-less-memory.patch \
           file://system-c-ares.patch \
           file://0001-liftoff-Correct-function-signatures.patch \
           file://0001-mips-Use-32bit-cast-for-operand-on-mips32.patch \
           file://run-ptest \
           "

SRC_URI:append:class-target = " \
           file://0001-Using-native-binaries.patch \
           "
SRC_URI:append:toolchain-clang:x86 = " \
           file://libatomic.patch \
           "
SRC_URI:append:toolchain-clang:powerpc64le = " \
           file://0001-ppc64-Do-not-use-mminimal-toc-with-clang.patch \
           "
SRC_URI[sha256sum] = "80c0faadf5ea39c213ccb9aa5c2432977a0f1b5a0b766852abd0de06f2770406"

S = "${WORKDIR}/node-v${PV}"

# v8 errors out if you have set CCACHE
CCACHE = ""

def map_nodejs_arch(a, d):
    import re

    if   re.match('i.86$', a): return 'ia32'
    elif re.match('x86_64$', a): return 'x64'
    elif re.match('aarch64$', a): return 'arm64'
    elif re.match('(powerpc64|powerpc64le|ppc64le)$', a): return 'ppc64'
    elif re.match('powerpc$', a): return 'ppc'
    return a

ARCHFLAGS:arm = "${@bb.utils.contains('TUNE_FEATURES', 'callconvention-hard', '--with-arm-float-abi=hard', '--with-arm-float-abi=softfp', d)} \
                 ${@bb.utils.contains('TUNE_FEATURES', 'neon', '--with-arm-fpu=neon', \
                    bb.utils.contains('TUNE_FEATURES', 'vfpv3d16', '--with-arm-fpu=vfpv3-d16', \
                    bb.utils.contains('TUNE_FEATURES', 'vfpv3', '--with-arm-fpu=vfpv3', \
                    '--with-arm-fpu=vfp', d), d), d)}"
ARCHFLAGS:append:mips = " --v8-lite-mode"
ARCHFLAGS:append:mipsel = " --v8-lite-mode"
ARCHFLAGS ?= ""

PACKAGECONFIG ??= "ares brotli icu zlib"

PACKAGECONFIG[ares] = "--shared-cares,,c-ares"
PACKAGECONFIG[brotli] = "--shared-brotli,,brotli"
PACKAGECONFIG[icu] = "--with-intl=system-icu,--without-intl,icu"
PACKAGECONFIG[libuv] = "--shared-libuv,,libuv"
PACKAGECONFIG[nghttp2] = "--shared-nghttp2,,nghttp2"
PACKAGECONFIG[shared] = "--shared"
PACKAGECONFIG[zlib] = "--shared-zlib,,zlib"

# We don't want to cross-compile during target compile,
# and we need to use the right flags during host compile,
# too.
EXTRA_OEMAKE = "\
    CC.host='${CC} -pie -fPIE' \
    CFLAGS.host='${CPPFLAGS} ${CFLAGS}' \
    CXX.host='${CXX} -pie -fPIE' \
    CXXFLAGS.host='${CPPFLAGS} ${CXXFLAGS}' \
    LDFLAGS.host='${LDFLAGS}' \
    AR.host='${AR}' \
    \
    builddir_name=./ \
"

EXTRANATIVEPATH += "file-native"

python prune_sources() {
    import shutil

    shutil.rmtree(d.getVar('S') + '/deps/openssl')
    if 'ares' in d.getVar('PACKAGECONFIG'):
        shutil.rmtree(d.getVar('S') + '/deps/cares')
    if 'brotli' in d.getVar('PACKAGECONFIG'):
        shutil.rmtree(d.getVar('S') + '/deps/brotli')
    if 'libuv' in d.getVar('PACKAGECONFIG'):
        shutil.rmtree(d.getVar('S') + '/deps/uv')
    if 'nghttp2' in d.getVar('PACKAGECONFIG'):
        shutil.rmtree(d.getVar('S') + '/deps/nghttp2')
    if 'zlib' in d.getVar('PACKAGECONFIG'):
        shutil.rmtree(d.getVar('S') + '/deps/zlib')
}
do_unpack[postfuncs] += "prune_sources"

# V8's JIT infrastructure requires binaries such as mksnapshot and
# mkpeephole to be run in the host during the build. However, these
# binaries must have the same bit-width as the target (e.g. a x86_64
# host targeting ARMv6 needs to produce a 32-bit binary). Instead of
# depending on a third Yocto toolchain, we just build those binaries
# for the target and run them on the host with QEMU.
python do_create_v8_qemu_wrapper () {
    """Creates a small wrapper that invokes QEMU to run some target V8 binaries
    on the host."""
    qemu_libdirs = [d.expand('${STAGING_DIR_HOST}${libdir}'),
                    d.expand('${STAGING_DIR_HOST}${base_libdir}')]
    qemu_cmd = qemu_wrapper_cmdline(d, d.getVar('STAGING_DIR_HOST'),
                                    qemu_libdirs)
    wrapper_path = d.expand('${B}/v8-qemu-wrapper.sh')
    with open(wrapper_path, 'w') as wrapper_file:
        wrapper_file.write("""#!/bin/sh

# This file has been generated automatically.
# It invokes QEMU to run binaries built for the target in the host during the
# build process.

%s "$@"
""" % qemu_cmd)
    os.chmod(wrapper_path, 0o755)
}

do_create_v8_qemu_wrapper[dirs] = "${B}"
addtask create_v8_qemu_wrapper after do_configure before do_compile

LDFLAGS:append:x86 = " -latomic"

CROSS_FLAGS = "--cross-compiling"
CROSS_FLAGS:class-native = "--no-cross-compiling"

# Node is way too cool to use proper autotools, so we install two wrappers to forcefully inject proper arch cflags to workaround gypi
do_configure () {
    GYP_DEFINES="${GYP_DEFINES}" export GYP_DEFINES
    # $TARGET_ARCH settings don't match --dest-cpu settings
    python3 configure.py --verbose --prefix=${prefix} \
               --shared-openssl \
               --without-dtrace \
               --without-etw \
               --dest-cpu="${@map_nodejs_arch(d.getVar('TARGET_ARCH'), d)}" \
               --dest-os=linux \
               --libdir=${baselib} \
               ${CROSS_FLAGS} \
               ${ARCHFLAGS} \
               ${PACKAGECONFIG_CONFARGS}
}

do_compile () {
    install -D ${RECIPE_SYSROOT_NATIVE}/etc/ssl/openssl.cnf ${B}/deps/openssl/nodejs-openssl.cnf
    install -D ${B}/v8-qemu-wrapper.sh ${B}/out/Release/v8-qemu-wrapper.sh
    oe_runmake BUILDTYPE=Release
}

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

do_install_ptest () {
    cp -r  ${B}/out/Release/cctest ${D}${PTEST_PATH}/
    cp -r ${B}/test ${D}${PTEST_PATH}
    chown -R root:root ${D}${PTEST_PATH}
}

PACKAGES =+ "${PN}-npm"
FILES:${PN}-npm = "${nonarch_libdir}/node_modules ${bindir}/npm ${bindir}/npx ${bindir}/corepack"
RDEPENDS:${PN}-npm = "bash python3-core python3-shell python3-datetime \
    python3-misc python3-multiprocessing"

PACKAGES =+ "${PN}-systemtap"
FILES:${PN}-systemtap = "${datadir}/systemtap"

BBCLASSEXTEND = "native"

repository: openbmc/openbmc

repo_name: openbmc/openbmc

gha_license_id: NOASSERTION


text:
@article{PPR:PPR74760,
 author = {Byrne EM and Zhu Z and Qi T and Skene NG and Bryois J and Pardinas AF and Stahl E and Smoller JW and Rietschel M and Owen MJ and Walters JT and O’Donovan MC and McGrath JG and Major Depressive Disorder Working Group of the Psychiatric Genomics Consortium},
 doi = {10.1101/592899},
 title = {Conditional GWAS analysis identifies putative disorder-specific SNPs for psychiatric disorders}
}

repository: SarahMarzi/neurogenomics-lab-website

repo_name: SarahMarzi/neurogenomics-lab-website


text:
# Copyright (c) 2013-2018 LG Electronics, Inc.

SUMMARY = "Settings Service"
AUTHOR = "Radhika S <radhika.s@lge.com>"
SECTION = "webos/base"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

DEPENDS = "glib-2.0 glibmm luna-service2 libpbnjson pmloglib openssl libbson boost"
RDEPENDS:${PN} = "settingsservice-conf python3"

PV = "1.0.22-17+git${SRCPV}"
inherit webos_cmake
inherit webos_system_bus
inherit webos_public_repo
inherit systemd
inherit pkgconfig

SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE:${PN} = "settings-service-recovery.service settings-service.service"

SRC_URI = "${WEBOSOSE_GIT_REPO_COMPLETE} \
file://0001-settingsservice-Add-service-files-for-systemd-script.patch \
file://0002-service-update-SettingsService-path.patch \
"

S = "${WORKDIR}/git"

SRCREV = "29ff049918d5b9e48afea58d421f0bc56fbd9852"

WEBOS_SYSTEM_BUS_MANIFEST_TYPE = "SERVICE"

VIRTUAL-RUNTIME_bash ?= "bash"
RDEPENDS:${PN}:append:class-target = " ${VIRTUAL-RUNTIME_bash}"

do_install:append() {
    install -d ${D}${systemd_unitdir}/system
    install -m 0644 ${S}/files/systemd/settings-service-recovery.service ${D}${systemd_unitdir}/system/
    install -m 0644 ${S}/files/systemd/settings-service.service ${D}${systemd_unitdir}/system/
}

repository: webOS-ports/meta-webos-ports

repo_name: webOS-ports/meta-webos-ports

branch_name: refs/heads/kirkstone


text:
# Generated by superflore -- DO NOT EDIT
#
# Copyright Open Source Robotics Foundation

inherit ros_distro_melodic
inherit ros_superflore_generated

DESCRIPTION = "The ROS packages in this repository were created to provide an improved     alternative Inverse Kinematics solver to the popular inverse Jacobian     methods in KDL.  TRAC-IK handles joint-limited chains better than KDL     without increasing solve time."
AUTHOR = "Patrick Beeson <pbeeson@traclabs.com>"
ROS_AUTHOR = "Patrick Beeson"
HOMEPAGE = "http://wiki.ros.org/trac_ik"
SECTION = "devel"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://package.xml;beginline=14;endline=14;md5=d566ef916e9dedc494f5f793a6690ba5"

ROS_CN = "trac_ik"
ROS_BPN = "trac_ik"

ROS_BUILD_DEPENDS = ""

ROS_BUILDTOOL_DEPENDS = " \
    catkin-native \
"

ROS_EXPORT_DEPENDS = " \
    trac-ik-examples \
    trac-ik-kinematics-plugin \
    trac-ik-lib \
    trac-ik-python \
"

ROS_BUILDTOOL_EXPORT_DEPENDS = ""

ROS_EXEC_DEPENDS = " \
    trac-ik-examples \
    trac-ik-kinematics-plugin \
    trac-ik-lib \
    trac-ik-python \
"

# Currently informational only -- see http://www.ros.org/reps/rep-0149.html#dependency-tags.
ROS_TEST_DEPENDS = ""

DEPENDS = "${ROS_BUILD_DEPENDS} ${ROS_BUILDTOOL_DEPENDS}"
# Bitbake doesn't support the "export" concept, so build them as if we needed them to build this package (even though we actually
# don't) so that they're guaranteed to have been staged should this package appear in another's DEPENDS.
DEPENDS += "${ROS_EXPORT_DEPENDS} ${ROS_BUILDTOOL_EXPORT_DEPENDS}"

RDEPENDS_${PN} += "${ROS_EXEC_DEPENDS}"

# matches with: https://github.com/traclabs/trac_ik-release/archive/release/melodic/trac_ik/1.5.1-1.tar.gz
ROS_BRANCH ?= "branch=release/melodic/trac_ik"
SRC_URI = "git://github.com/traclabs/trac_ik-release;${ROS_BRANCH};protocol=https"
SRCREV = "54d1d6f07291a4807eb374bfe4f50deb047e3256"
S = "${WORKDIR}/git"

ROS_BUILD_TYPE = "catkin"

inherit ros_${ROS_BUILD_TYPE}

repository: jianchangfeng/meta-ros

repo_name: jianchangfeng/meta-ros


text:
@InProceedings{sorokina09,
  title = {Application of Additive Groves Ensemble with Multiple Counts Feature Evaluation to KDD Cup09 Small Data Set},
  author = {Daria Sorokina},
  pages = {101--109},
  abstract = {This paper describes a field trial for a recently developed ensemble called Additive Groves on KDD Cup09 competition. Additive Groves were applied to three tasks provided at the competition using the small data set. On one of the three tasks, appetency, we achieved the best result among participants who similarly worked with the small dataset only. Postcompetition analysis showed that less successfull result on another task, churn, was partially due to insufficient preprocessing of nominal attributes. Code for Additive Groves is publicly available as a part of TreeExtra package. Another part of this package provides an important preprocessing technique also used for this competition entry, feature evaluation through bagging with multiple counts.},
  pdf = {http://jmlr.org/proceedings/papers/v7/sorokina09/sorokina09.pdf},
}


text:
SUMMARY = "Software for ISOBlue2"
HOMEPAGE = "http://https://github.com/OATS-Group/isoblue2/"
LICENSE = "CLOSED"
LIC_FILES_CHKSUM = ""

SRC_URI = "https://github.com/OATS-Group/isoblue2/archive/isoblue-software_${PV}.tar.gz;downloadfilename=isoblue-software_${PV}.tar.gz"
SRC_URI[md5sum] = "456b0c2fa67c926d35581d4267c50087"
SRC_URI[sha256sum] = "556d08c110c21562c31dfa74fe7fad76b684ef2519a295cf5ffaf39ec897f3d7"
DEPENDS = "librdkafka avro-c libpthread-stubs"

S = "${WORKDIR}/isoblue2-isoblue-software_${PV}/software/producer"

inherit autotools

do_configure () {
	oe_runconf
}

do_compile () {
	oe_runmake
}

do_install () {
	# install the compiled program
	install -d ${D}/opt/bin
	install -m 0755 ${WORKDIR}/build/can_watchdog/can_watchdog ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/build/kafka_can_log/kafka_can_log ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/build/debug_tools/net_strength ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/build/debug_tools/can_msg_rate ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/build/debug_tools/heartbeat ${D}/opt/bin/

    # install the python script
    install -m 0755 ${WORKDIR}/isoblue2-isoblue-software_${PV}/software/producer/kafka_gps_log/kafka_gps_log.py ${D}/opt/bin/

	# install the scripts
	install -m 0755 ${WORKDIR}/isoblue2-isoblue-software_${PV}/misc/get_pgns.sh ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/isoblue2-isoblue-software_${PV}/misc/get_presence.sh ${D}/opt/bin/
	install -m 0755 ${WORKDIR}/isoblue2-isoblue-software_${PV}/misc/gps_log_watchdog.sh ${D}/opt/bin/

    #install the schema directory
    install -d ${D}/opt/schema
    install -m 0644 ${WORKDIR}/isoblue2-isoblue-software_${PV}/software/schema/*.avsc ${D}/opt/schema
}

FILES_${PN} += " \
	/opt/bin/can_watchdog \
	/opt/bin/kafka_can_log \
	/opt/bin/heartbeat \
	/opt/bin/net_strength \
	/opt/bin/can_msg_rate \
	/opt/bin/get_pgns.sh \
	/opt/bin/get_presence.sh \
	/opt/bin/gps_log_watchdog.sh \
	/opt/bin/kafka_gps_log.py \
	/opt/schema/*.avsc \
"

repository: ISOBlue/meta-isoblue

repo_name: ISOBlue/meta-isoblue


text:
/*
 * Copyright (c) 2020 Juan Medina.
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */

package main

import (
	"fmt"
	"github.com/juan-medina/goecs"
	"github.com/juan-medina/gosge"
	"github.com/juan-medina/gosge/components/animation"
	"github.com/juan-medina/gosge/components/color"
	"github.com/juan-medina/gosge/components/device"
	"github.com/juan-medina/gosge/components/effects"
	"github.com/juan-medina/gosge/components/geometry"
	"github.com/juan-medina/gosge/components/sprite"
	"github.com/juan-medina/gosge/components/ui"
	"github.com/juan-medina/gosge/events"
	"github.com/juan-medina/gosge/options"
	"github.com/rs/zerolog/log"
)

// Game options
var opt = options.Options{
	Title:      "GOSGE Animation Game",
	BackGround: color.Gopher,
	Icon:       "resources/icon.png",
	// Uncomment this for using windowed mode
	// Windowed:   true,
	// Width:      2048,
	// Height:     1536,
}

// Game constants
const (
	fontName   = "resources/go_regular.fnt"               // font name for the bottom text
	fontSize   = 60                                       // bottom text size
	fontLayer  = -10                                      // the layer for the top will be on front
	robotSheet = "resources/robot.json"                   // sprite sheet with the robot animation
	robotIdle  = "Idle_%02d.png"                          // robot idle animations frames name
	robotRun   = "Run_%02d.png"                           // robot running animation frames name name
	robotPosY  = 220                                      // Y position for our robot
	robotLayer = 0                                        // layer for our robot, above the city bellow the text
	runAnim    = "run"                                    // name for the running animation
	idleAnim   = "idle"                                   // name for the idle animation
	numLayers  = 8                                        // number of layers for the city
	layerFile  = "resources/background/city/layer_%d.png" // each layer frame name
	moveSpeed  = 75                                       // our movement speed
)

var (
	// designResolution is how our game is designed
	designResolution = geometry.Size{Width: 1920, Height: 1080}
	// robot is our robot sprite
	robot goecs.EntityID
	// gameScale is our game scale
	gameScale geometry.Scale
)

func main() {
	if err := gosge.Run(opt, loadGame); err != nil {
		log.Fatal().Err(err).Msg("error running the game")
	}
}

func loadGame(eng *gosge.Engine) error {
	// gameScale has a geometry.Scale from the real screen size to our designResolution
	gameScale = eng.GetScreenSize().CalculateScale(designResolution)

	// pre-load font
	if err := eng.LoadFont(fontName); err != nil {
		return err
	}

	// pre-load the city layers sprites
	for l := 1; l <= numLayers; l++ {
		// generate the layer file name
		layerFile := fmt.Sprintf(layerFile, l)
		// pre-load the sprite
		if err := eng.LoadSprite(layerFile, geometry.Point{}); err != nil {
			return err
		}
	}

	// Load the sprite sheet with the robot animations
	if err := eng.LoadSpriteSheet(robotSheet); err != nil {
		return err
	}

	// get the ECS world
	world := eng.World()

	// for each city layer
	for l := int32(1); l <= numLayers; l++ {
		// generate the layer file name
		layerFile := fmt.Sprintf(layerFile, l)
		// add a sprite that will be attached to the sprite that we scroll
		attached := world.AddEntity(
			sprite.Sprite{
				Name:  layerFile,
				Scale: gameScale.Max,
			},
			geometry.Point{X: -9000}, // we move it out of the screen
			effects.Layer{Depth: float32(l)},
		)
		// add each layer to the screen
		world.AddEntity(
			sprite.Sprite{
				Name:  layerFile,
				Scale: gameScale.Max,
			},
			geometry.Point{},
			effects.Layer{Depth: float32(l)}, // each layer is have it own depth
			attach{id: attached},             // attach the layer that is attached
		)
	}

	// calculate the position for our robot
	spritePos := geometry.Point{
		X: designResolution.Width / 2 * gameScale.Point.X,
		Y: (designResolution.Height - robotPosY) * gameScale.Max,
	}

	// add the robot with it animations
	robot = world.AddEntity(
		spritePos,
		animation.Animation{
			Sequences: map[string]animation.Sequence{
				runAnim: {
					Sheet:  robotSheet,
					Base:   robotRun,
					Scale:  gameScale.Max * 0.5,
					Frames: 8,
					Delay:  0.065,
				},
				idleAnim: {
					Sheet:  robotSheet,
					Base:   robotIdle,
					Scale:  gameScale.Max * 0.5,
					Frames: 10,
					Delay:  0.065,
				},
			},
			Current: idleAnim, // current animation is idle
			Speed:   1,
		},
		effects.Layer{Depth: robotLayer},
	)

	// add the bottom text
	world.AddEntity(
		ui.Text{
			String:     "press <ESC> to close, cursors to move",
			HAlignment: ui.CenterHAlignment,
			VAlignment: ui.BottomVAlignment,
			Font:       fontName,
			Size:       fontSize * gameScale.Max,
		},
		geometry.Point{
			X: designResolution.Width / 2 * gameScale.Point.X,
			Y: designResolution.Height * gameScale.Max,
		},
		effects.AlternateColor{
			Time: .25,
			From: color.White,
			To:   color.White.Alpha(0),
		},
		effects.Layer{Depth: fontLayer},
	)

	// system that move our robot and the layers
	world.AddSystem(robotMoveSystem)

	// listen to keys
	world.AddListener(keysListener, events.TYPE.KeyUpEvent, events.TYPE.KeyDownEvent)

	return nil
}

// a component to have an attached entity
type attach struct {
	id goecs.EntityID
}

func (a attach) Type() goecs.ComponentType {
	return attachType
}

// the goecs.ComponentType of the attach struct
var attachType = goecs.NewComponentType()

// on update
func robotMoveSystem(world *goecs.World, delta float32) error {
	// get the robot id
	robotEnt := world.Get(robot)
	// get the animation from our robot
	anim := animation.Get.Animation(robotEnt)
	// if its running
	if anim.Current == runAnim {
		// get from the ECS all the entities that have a layer a position and an attachment
		for it := world.Iterator(effects.TYPE.Layer, geometry.TYPE.Point, attachType); it != nil; it = it.Next() {
			// get the entity
			ent := it.Value()

			/// get the layer and the position
			ly := effects.Get.Layer(ent)
			pos := geometry.Get.Point(ent)

			// the direction that we are moving in 1/-1 format
			direction := float32(1)
			if anim.FlipX {
				direction = -1
			}

			// what is the width of this layer is
			layerWidth := designResolution.Width * gameScale.Max

			// moving according the direction we are facing
			pos.X -= delta * moveSpeed * (8 - ly.Depth) * direction * gameScale.Max

			// check if we need to wrap since we are completely off-screen
			if pos.X < -layerWidth {
				pos.X = 0
			} else if pos.X > layerWidth {
				pos.X = 0
			}

			// this will be attachment pos
			attachPos := geometry.Point{}

			// if the layer is moving to the right
			if pos.X > 0 {
				attachPos.X = pos.X - layerWidth // attach to the left
			} else {
				attachPos.X = pos.X + layerWidth // attach to the right
			}
			// get the robot id
			id := ent.Get(attachType).(attach).id
			world.Get(id).Set(attachPos)
			// update layer pos
			ent.Set(pos)
		}
	}
	return nil
}

// notified on events
func keysListener(world *goecs.World, e goecs.Component, _ float32) error {
	switch v := e.(type) {
	// is we get a key down event
	case events.KeyDownEvent:
		// it is the left o right cursor change animations
		if v.Key == device.KeyRight || v.Key == device.KeyLeft {
			// get the robot id
			robotEnt := world.Get(robot)
			// get the animation
			anim := animation.Get.Animation(robotEnt)

			// if we are idle
			if anim.Current == idleAnim {
				anim.Current = runAnim // run
			}
			// we flip the animation if the key was left
			anim.FlipX = v.Key == device.KeyLeft
			// update the entity animation
			robotEnt.Set(anim)
		}
	case events.KeyUpEvent:
		// it is the left o right cursor change animations
		if v.Key == device.KeyRight || v.Key == device.KeyLeft {
			// get the robot id
			robotEnt := world.Get(robot)
			// get the animation
			anim := animation.Get.Animation(robotEnt)

			// if we are running
			if anim.Current == runAnim {
				anim.Current = idleAnim // idle
			}

			// we flip the animation if the key was left
			anim.FlipX = v.Key == device.KeyLeft
			// update the entity animation
			robotEnt.Set(anim)
		}
	}
	return nil
}

repository: juan-medina/gosge

repo_name: juan-medina/gosge