text:
package matrix

import (
	"testing"

	"github.com/calbim/ray-tracer/src/tuple"
	"github.com/calbim/ray-tracer/src/util"
)

func TestMatrixConstruction(t *testing.T) {
	m := New([]float64{1, 2, 3, 4, 5.5, 6.5, 7.5, 8.5,
		9, 10, 11, 12, 13.5, 14.5, 15.5, 16.5})
	if m.At(0, 0) != 1 {
		t.Errorf("wanted m(0,0)=%v,got %v", 1, m.At(0, 0))
	}
	if m.At(0, 3) != 4 {
		t.Errorf("wanted m(0,3)=%v,got %v", 4, m.At(0, 3))
	}
	if m.At(1, 0) != 5.5 {
		t.Errorf("wanted m(1,0)=%v,got %v", 5.5, m.At(1, 0))
	}
	if m.At(1, 2) != 7.5 {
		t.Errorf("wanted m(1,2)=%v,got %v", 7.5, m.At(1, 2))
	}
	if m.At(2, 2) != 11 {
		t.Errorf("wanted m(2,2)=%v,got %v", 11, m.At(2, 2))
	}
	if m.At(3, 0) != 13.5 {
		t.Errorf("wanted m(3,0)=%v,got %v", 13.5, m.At(3, 0))
	}
	if m.At(3, 2) != 15.5 {
		t.Errorf("wanted (3,2)=%v,got %v", 15.5, m.At(3, 2))
	}
}

func TestTwoByTwoMatrix(t *testing.T) {
	m := New([]float64{-3, 5, 1, -2})
	if m.At(0, 0) != -3 {
		t.Errorf("m(0,0) is %v, should be -3", m.At(0, 0))
	}
	if m.At(0, 1) != 5 {
		t.Errorf("m(0,1) is %v, should be 5", m.At(0, 1))
	}
	if m.At(1, 0) != 1 {
		t.Errorf("m(1,0) is %v, should be 1", m.At(1, 0))
	}
	if m.At(1, 1) != -2 {
		t.Errorf("m(1,1) is %v, should be 7.5", m.At(1, 1))
	}
}

func TestThreeByThreeMatrix(t *testing.T) {
	m := New([]float64{-3, 5, 0, 1, -2, 7, 0, 1, 1})
	if m.At(0, 0) != -3 {
		t.Errorf("m(0,0) is %v, should be -3", m.At(0, 0))
	}
	if m.At(1, 1) != -2 {
		t.Errorf("m(1,1) is %v, should be -2", m.At(1, 1))
	}
	if m.At(2, 2) != 1 {
		t.Errorf("m(2,2) is %v, should be 1", m.At(2, 2))
	}
}

func TestIdentical(t *testing.T) {
	m := New([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9,
		8, 7, 6, 5, 4, 3, 2})
	n := New([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9,
		8, 7, 6, 5, 4, 3, 2})
	if !m.Equals(n) {
		t.Errorf("wanted m==n, got m!=n")
	}
}

func TestNonIdentical(t *testing.T) {
	m := New([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9,
		8, 7, 6, 5, 4, 3, 2})
	n := New([]float64{2, 3, 4, 5, 6, 7, 8, 9,
		8, 7, 6, 5, 4, 3, 2, 1})
	if m.Equals(n) {
		t.Errorf("wanted m!=n, got m=n")
	}
}

func TestMultiply(t *testing.T) {
	m := New([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9,
		8, 7, 6, 5, 4, 3, 2})
	n := New([]float64{-2, 1, 2, 3, 3, 2, 1, -1, 4,
		3, 6, 5, 1, 2, 7, 8})
	product := m.Multiply(n)
	expected := New([]float64{20, 22, 50, 48, 44,
		54, 114, 108, 40, 58, 110, 102, 16, 26, 46, 42})
	if !product.Equals(expected) {
		t.Errorf("wanted m*n=%v, got %v", expected, product)
	}
}

func TestMultiplyWithTuple(t *testing.T) {
	m := New([]float64{1, 2, 3, 4, 2, 4, 4, 2, 8,
		6, 4, 1, 0, 0, 0, 1})
	tup := tuple.Tuple{X: 1, Y: 2, Z: 3, W: 1}
	product := m.MultiplyTuple(tup)
	if !product.Equals(tuple.Tuple{X: 18, Y: 24, Z: 33, W: 1}) {
		t.Errorf("wanted m*tup=%v, got %v", product, tuple.Tuple{X: 18, Y: 24, Z: 33, W: 1})
	}

}

func TestMultiplyWithIdentity(t *testing.T) {
	m := New([]float64{0, 1, 2, 4, 1, 2, 4, 8,
		2, 4, 8, 16, 4, 8, 16, 32})
	expected := m.Multiply(Identity)
	if !m.Equals(expected) {
		t.Errorf("wanted m*Identity=m, got %v", m.Multiply(Identity))
	}
}
func TestTranspose(t *testing.T) {
	m := New([]float64{0, 9, 3, 0, 9, 8, 0, 8,
		1, 8, 5, 3, 0, 0, 5, 8})
	expected := New([]float64{0, 9, 1, 0, 9, 8, 8,
		0, 3, 0, 5, 5, 0, 8, 3, 8})
	transpose := m.Transpose()
	if !transpose.Equals(expected) {
		t.Errorf("wanted m.Transpose()=%v, got %v", expected, transpose)
	}
}

func TestTransposeIdentity(t *testing.T) {
	transpose := Identity.Transpose()
	if !transpose.Equals(Identity) {
		t.Errorf("wanted Identity.Transpose()=Identity")
	}
}

func TestDeterminant(t *testing.T) {
	m := New([]float64{1, 5, -3, 2})
	if m.Determinant() != 17 {
		t.Errorf("wanted determinant=%v, got %v", m.Determinant(), 17)
	}
}

func TestSubmatrix(t *testing.T) {
	m := New([]float64{1, 5, 0, -3, 2, 7, 0, 6, -3})
	n := m.Submatrix(0, 2)
	expected := New([]float64{-3, 2, 0, 6})
	if !n.Equals(expected) {
		t.Errorf("wanted submatrix=%v, got %v", expected, n)
	}

	m = New([]float64{-6, 1, 1, 6, -8, 5, 8, 6, 1, 0, 8, 2, -7, 1, -1, 1})
	n = m.Submatrix(2, 1)
	expected = New([]float64{-6, 1, 6, -8, 8, 6, -7, -1, 1})
	if !n.Equals(expected) {
		t.Errorf("wanted submatrix=%v, got %v", expected, n)
	}
}

func TestMinor(t *testing.T) {
	m := New([]float64{3, 5, 0, 2, -1, -7, 6, -1, 5})
	sub := m.Submatrix(1, 0)
	if sub.Determinant() != 25 {
		t.Errorf("wanted determinant=%v, got %v", 25, sub.Determinant())
	}
	if m.Minor(1, 0) != 25 {
		t.Errorf("wanted minor=%v, got %v", 25, m.Minor(1, 0))
	}
}

func TestCofactor(t *testing.T) {
	m := New([]float64{3, 5, 0, 2, -1, -7, 6, -1, 5})
	if m.Cofactor(0, 0) != -12 {
		t.Errorf("wanted cofactor at (0,0)=%v, got %v", -12, m.Cofactor(0, 0))
	}
	if m.Cofactor(1, 0) != -25 {
		t.Errorf("wanted cofactor at (1,0)=%v, got %v", -25, m.Cofactor(1, 0))
	}
}
func TestDeterminantThreeByThreeMatrix(t *testing.T) {
	m := New([]float64{1, 2, 6, -5, 8, -4, 2, 6, 4})
	if m.Cofactor(0, 0) != 56 || m.Cofactor(0, 1) != 12 || m.Cofactor(0, 2) != -46 {
		t.Errorf("cofactors are wrong")
	}
	if m.Determinant() != -196 {
		t.Errorf("wanted determinant=%v, got %v", -196, m.Determinant())
	}
}
func TestDeterminantFourByFourMatrix(t *testing.T) {
	m := New([]float64{-2, -8, 3, 5, -3, 1, 7, 3, 1, 2, -9, 6, -6, 7, 7, -9})
	if m.Cofactor(0, 0) != 690 || m.Cofactor(0, 1) != 447 || m.Cofactor(0, 2) != 210 || m.Cofactor(0, 3) != 51 {
		t.Errorf("cofactors are wrong")
	}
	if m.Determinant() != -4071 {
		t.Errorf("wanted determinant=%v, got %v", -4071, m.Determinant())
	}
}

func TestInvertibility(t *testing.T) {
	m := New([]float64{6, 4, 4, 4, 5, 5, 7, 6, 4, -9, 3, -7, 9, 1, 7, -6})
	if m.Determinant() != -2120 {
		t.Errorf("wanted determinant=%v, got %v", -2120, m.Determinant())
	}
	if !m.Invertible() {
		t.Errorf("wanted matrix to be invertible")
	}
	m = New([]float64{-4, 2, -2, 3, 9, 6, 2, 6, 0, -5, 1, -5, 0, 0, 0, 0})
	if m.Determinant() != 0 {
		t.Errorf("wanted determinant=%v, got %v", 0, m.Determinant())
	}
}

func TestInverse(t *testing.T) {
	m := New([]float64{-5, 2, 6, -8, 1, -5, 1, 8, 7, 7, -6, -7, 1, -3, 7, 4})
	b, err := m.Inverse()
	if err != nil {
		t.Error(err)
	}
	if m.Determinant() != 532 {
		t.Errorf("wanted determinant=%v, got %v", 532, m.Determinant())
	}
	if m.Cofactor(2, 3) != -160 || !util.Equals(b.At(3, 2), float64(-160)/532) || m.Cofactor(3, 2) != 105 || !util.Equals(b.At(2, 3), float64(105)/532) {
		t.Errorf("inverse is incorrect")
	}
	expected := New([]float64{0.21805, 0.45113, 0.24060, -0.04511, -0.80827, -1.45677, -0.44361, 0.52068, -0.07895, -0.22368, -0.05263, 0.19737, -0.52256, -0.81391, -0.30075, 0.30639})
	if !b.Equals(expected) {
		t.Errorf("wanted inverse=%v, got %v", expected, b)
	}

	m = New([]float64{8, -5, 9, 2, 7, 5, 6, 1, -6, 0, 9, 6, -3, 0, -9, -4})
	b, err = m.Inverse()
	if err != nil {
		t.Error(err)
	}
	expected = New([]float64{-0.15385, -0.15385, -0.28205, -0.53846, -0.07692, 0.12308, 0.02564, 0.03077, 0.35897, 0.35897, 0.43590, 0.92308, -0.69231, -0.69231, -0.76923, -1.92308})
	if !b.Equals(expected) {
		t.Errorf("wanted inverse=%v, got %v", expected, b)
	}

	m = New([]float64{9, 3, 0, 9, -5, -2, -6, -3, -4, 9, 6, 4, -7, 6, 6, 2})
	b, err = m.Inverse()
	if err != nil {
		t.Error(err)
	}
	expected = New([]float64{-0.04074, -0.07778, 0.14444, -0.22222, -0.07778, 0.03333, 0.36667, -0.33333, -0.02901, -0.14630, -0.10926, 0.12963, 0.17778, 0.06667, -0.26667, 0.33333})
	if !b.Equals(expected) {
		t.Errorf("wanted inverse=%v, got %v", expected, b)
	}
}

repository: calbim/ray-tracer

repo_name: calbim/ray-tracer


text:
// +build document

package app

// 服务器swagger
/*
Package app 生成swagger文档

文档规则请参考：https://github.com/swaggo/swag#declarative-comments-format

使用方式：

	go get -u github.com/swaggo/swag/cmd/swag
	make swagger

*/
// import (
// 	"github.com/suisrc/zgo/config"
//
// 	"github.com/gin-gonic/gin"
// 	ginSwagger "github.com/swaggo/gin-swagger"
// 	swaggerFiles "github.com/swaggo/gin-swagger/swaggerFiles"
// )
//
// // Swagger swagger
// type Swagger gin.IRoutes
//
// // NewSwagger swagger
// func NewSwagger(app *gin.Engine) Swagger {
// 	if config.C.Swagger {
// 		return app.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
// 	}
// 	return nil
// }

repository: suisrc/zgo

license_type: permissive

repo_name: suisrc/zgo

branch_name: refs/heads/master

gha_language: Go

extension: go


text:
package postgres

import (
	"context"
	"fmt"

	"github.com/jackc/pgx/v4/pgxpool"
	"github.com/kelseyhightower/envconfig"
)

type Config struct {
	Host     string `envconfig:"POSTGRES_HOST" required:"true"`
	Port     int    `envconfig:"POSTGRES_PORT" required:"true"`
	User     string `envconfig:"POSTGRES_USER" required:"true"`
	Password string `envconfig:"POSTGRES_PASSWORD" required:"true"`
	Database string `envconfig:"POSTGRES_DB" required:"true"`
	SSLMode  string `envconfig:"POSTGRES_SSLMODE" default:"disable"`
}

func (c Config) ConnectionString() string {
	return fmt.Sprintf(
		"user=%v password=%v host=%v port=%v dbname=%v sslmode=%v",
		c.User, c.Password, c.Host, c.Port, c.Database, c.SSLMode,
	)
}

func LoadConfig() (Config, error) {
	ret := Config{}
	return ret, envconfig.Process("", &ret)
}

func NewPool(ctx context.Context, cfg Config) (*pgxpool.Pool, error) {
	return pgxpool.Connect(ctx, cfg.ConnectionString())
}

func Setup(ctx context.Context) (*pgxpool.Pool, error) {
	cfg, err := LoadConfig()
	if err != nil {
		return nil, err
	}
	return NewPool(ctx, cfg)
}

license: MIT

repository: kewka/go-url-shortener

repo_name: kewka/go-url-shortener

branch_name: refs/heads/main


text:
/**
 * @param {string} s
 * @param {number} k
 * @return {string}
 */
 var licenseKeyFormatting = function(s, k) {

    //  convert s to uppercase and remove the dashes
    s = s.replaceAll("-","").toUpperCase();

    let runningK = 0;
    let result = "";

    for (let i=s.length-1; i>=0; i--) {

        if (runningK === k) {
            runningK = 0;
            result = result.concat("-");
        }

        result = result.concat(s.charAt(i));
        runningK++;
    }

    let finalResult = "";

    for (let i=result.length-1; i>=0; i--) {
        finalResult = finalResult.concat(result.charAt(i));
    }

    return finalResult;
};

repository: GokulRG/JSAlgos

repo_name: GokulRG/JSAlgos

extension: js


text:
require ${COREBASE}/meta/recipes-core/images/core-image-minimal.bb

SUMMARY = "An image with packagegroup-ros-world installed"
DESCRIPTION = "${SUMMARY}"

inherit ros_distro_${ROS_DISTRO}
inherit ${ROS_DISTRO_TYPE}_image

IMAGE_INSTALL_append = " \
    packagegroup-ros-world \
"

repository: jianchangfeng/meta-ros

repo_name: jianchangfeng/meta-ros

gha_license_id: MIT

extension: bb


text:
/*
Copyright 2016 Skippbox, Ltd.

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 client

import (
	"log"

	"github.com/sunny0826/kubewatch-chart/config"
	"github.com/sunny0826/kubewatch-chart/pkg/controller"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/dingtalk"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/flock"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/hipchat"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/mattermost"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/msteam"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/slack"
	"github.com/sunny0826/kubewatch-chart/pkg/handlers/webhook"
)

// Run runs the event loop processing with given handler
func Run(conf *config.Config) {

	var eventHandler = ParseEventHandler(conf)
	controller.Start(conf, eventHandler)
}

// ParseEventHandler returns the respective handler object specified in the config file.
func ParseEventHandler(conf *config.Config) handlers.Handler {

	var eventHandler handlers.Handler
	switch {
	case len(conf.Handler.Slack.Channel) > 0 || len(conf.Handler.Slack.Token) > 0:
		eventHandler = new(slack.Slack)
	case len(conf.Handler.Hipchat.Room) > 0 || len(conf.Handler.Hipchat.Token) > 0:
		eventHandler = new(hipchat.Hipchat)
	case len(conf.Handler.Mattermost.Channel) > 0 || len(conf.Handler.Mattermost.Url) > 0:
		eventHandler = new(mattermost.Mattermost)
	case len(conf.Handler.Flock.Url) > 0:
		eventHandler = new(flock.Flock)
	case len(conf.Handler.Webhook.Url) > 0:
		eventHandler = new(webhook.Webhook)
	case len(conf.Handler.MSTeams.WebhookURL) > 0:
		eventHandler = new(msteam.MSTeams)
	case len(conf.Handler.Dingtalk.Token) > 0:
		eventHandler = new(dingtalk.DingTalk)
	default:
		eventHandler = new(handlers.Default)
	}
	if err := eventHandler.Init(conf); err != nil {
		log.Fatal(err)
	}
	return eventHandler
}


text:
DESCRIPTION = "Gesture recognition input method for X11"
LICENSE = "GPL"
SECTION = "x11"
PRIORITY = "optional"
MAINTAINER = "Phil Blundell <pb@handhelds.org>"
PR = "r3"

DEPENDS = "x11 xft xtst xpm"

SRC_URI = "http://www.oesources.org/source/xstroke-0.6.tar.gz \
	file://auto-disable.patch;patch=1;pnum=0"

inherit autotools pkgconfig

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
@article{BETTER_SCRIPTS_GAMES,
 author = {White, Walker and Koch, Christoph and Gehrke, Johannes and Demers, Alan},
 title = {Better Scripts, Better Games},
 journal = {Queue},
 issue_date = {November/December 2008},
 volume = {6},
 issue = {7},
 month = {November},
 year = {2008},
 issn = {1542-7730},
 pages = {18--25},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/1483101.1483106},
 doi = {http://doi.acm.org/10.1145/1483101.1483106},
 acmid = {1483106},
 publisher = {ACM},
 address = {New York, NY, USA},
}

@INPROCEEDINGS{MODULAR_DSL,
    author = {Paul Hudak},
    title = {Modular Domain Specific Languages and Tools},
    booktitle = {in Proceedings of Fifth International Conference on Software Reuse},
    year = {1998},
    pages = {134--142},
    publisher = {IEEE Computer Society Press}
}

@INPROCEEDINGS{MONADIC_DSL,
    author = {Keith Wansbrough and Keith Wansbrough and John Hamer and John Hamer},
    title = {A modular monadic action semantics},
    booktitle = {In Conference on Domain-Specific Languages},
    year = {1997},
    pages = {157--170}
}

@ARTICLE{DSL_BIB,
    author = {Arie Van Deursen and Paul Klint and Joost Visser},
    title = {Domain-Specific Languages: An Annotated Bibliography},
    journal = {ACM SIGPLAN NOTICES},
    year = {2000},
    volume = {35},
    pages = {26--36}
}

@misc{XNA_LOOP,
  author = {},
  title = {XNA main loop},
  howpublished = {http://msdn.microsoft.com/en-us/library/bb203873.aspx}
}

@misc{XNA,
  author = {},
  title = {XNA on MSDN},
  howpublished = {http://msdn.microsoft.com/en-us/library/bb200104.aspx}
}

@misc{XNA_XBOX,
  author = {},
  title = {XNA on the Xbox},
  howpublished = {http://msdn.microsoft.com/en-us/library/bb975643.aspx}
}

@misc{XNA_WP7,
  author = {},
  title = {XNA on Windows Phone 7},
  howpublished = {http://msdn.microsoft.com/en-us/library/ff472340(v=vs.92).aspx}
}

@article{DECL_IMP,
 author = {Wadler, Philip},
 title = {How to declare an imperative},
 journal = {ACM Comput. Surv.},
 volume = {29},
 number = {3},
 year = {1997},
 issn = {0360-0300},
 pages = {240--263},
 doi = {http://doi.acm.org/10.1145/262009.262011},
 publisher = {ACM},
 address = {New York, NY, USA},
 }

@INPROCEEDINGS{COMPR_MON,
    author = {Philip Wadler},
    title = {Comprehending Monads},
    booktitle = {Mathematical Structures in Computer Science},
    year = {1992},
    pages = {61--78}
}

@ARTICLE{MOGGI_MON,
    author = {Eugenio Moggi},
    title = {Notions of Computation and Monads},
    journal = {Information and Computation},
    year = {1989},
    volume = {93},
    pages = {55--92}
}

@inproceedings{LINQ_MON,
 author = {Meijer, Erik},
 title = {There is no impedance mismatch: (language integrated query in visual basic 9)},
 booktitle = {Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications},
 series = {OOPSLA '06},
 year = {2006},
 isbn = {1-59593-491-X},
 location = {Portland, Oregon, USA},
 pages = {710--711},
 numpages = {2},
 url = {http://doi.acm.org/10.1145/1176617.1176686},
 doi = {http://doi.acm.org/10.1145/1176617.1176686},
 acmid = {1176686},
 publisher = {ACM},
 address = {New York, NY, USA},
}

@MISC{EFF_MON,
    author = {Philip Wadler and Peter Thiemann},
    title = {The Marriage of Effects and Monads},
    year = {1998}
}

@inproceedings{EXTENSIONS_X3D,
 author = {Figueroa, Pablo and Medina, Omer and Jim\'{e}nez, Roger and Mart\'{\i}nez, Jos\'{e} and Albarrac\'{\i}n, Camilo},
 title = {Extensions for interactivity and retargeting in X3D},
 booktitle = {Proceedings of the tenth international conference on 3D Web technology},
 series = {Web3D '05},
 year = {2005},
 isbn = {1-59593-012-4},
 location = {Bangor, United Kingdom},
 pages = {103--110},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/1050491.1050506},
 doi = {http://doi.acm.org/10.1145/1050491.1050506},
 acmid = {1050506},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {InTml, interaction methods, methods for representing Web3D applications, object behaviors, specification language for interactions},
}

@article{virtual_humans,
	location = {http://www.scientificcommons.org/53104194},
	title = {Simplifying the Integration of Virtual Humans into Dialog-like VR Systems},
	author = {Jung, Y. and Behr, J.},
	year = {2009},
	keywords = {multimedia information systems, Augmented reality (AR), Virtual reality (VR), 3D Graphics, realism, 3D animation},
}

@inproceedings{JINX,
 author = {Soares, Luciano P. and Zuffo, Marcelo K.},
 title = {JINX: an X3D browser for VR immersive simulation based on clusters of commodity computers},
 booktitle = {Proceedings of the ninth international conference on 3D Web technology},
 series = {Web3D '04},
 year = {2004},
 isbn = {1-58113-845-8},
 location = {Monterey, California},
 pages = {79--86},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/985040.985052},
 doi = {http://doi.acm.org/10.1145/985040.985052},
 acmid = {985052},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {X3D, cluster computing, parallel rendering},
}

@inproceedings{BEHAVIOR_3D,
 author = {Dachselt, Raimund and Rukzio, Enrico},
 title = {Behavior3D: an XML-based framework for 3D graphics behavior},
 booktitle = {Proceedings of the eighth international conference on 3D Web technology},
 series = {Web3D '03},
 year = {2003},
 isbn = {1-58113-644-7},
 location = {Saint Malo, France},
 pages = {101--ff},
 url = {http://doi.acm.org/10.1145/636593.636609},
 doi = {http://doi.acm.org/10.1145/636593.636609},
 acmid = {636609},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Contigra, Extensible 3D (X3D), SMIL, XML-Schema, animation, behavior language, dynamic grammar, object behaviors},
}

@inproceedings{SCRIPTING_FOR_VRML_X3D,
 author = {Huang, Zhisheng and Eli\"{e}ns, Anton and Visser, Cees},
 title = {Implementation of a scripting language for VRML/X3D-based embodied agents},
 booktitle = {Proceedings of the eighth international conference on 3D Web technology},
 series = {Web3D '03},
 year = {2003},
 isbn = {1-58113-644-7},
 location = {Saint Malo, France},
 pages = {91--100},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/636593.636608},
 doi = {http://doi.acm.org/10.1145/636593.636608},
 acmid = {636608},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {STEP, VRML/X3D, XSTEP, agents, distributed logic Programming, h-anim},
}

@inproceedings{X3D_OGL_ES,
 author = {Nadalutti, Daniele and Chittaro, Luca and Buttussi, Fabio},
 title = {Rendering of X3D content on mobile devices with OpenGL ES},
 booktitle = {Proceedings of the eleventh international conference on 3D web technology},
 series = {Web3D '06},
 year = {2006},
 isbn = {1-59593-336-0},
 location = {Columbia, Maryland},
 pages = {19--26},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/1122591.1122594},
 doi = {http://doi.acm.org/10.1145/1122591.1122594},
 acmid = {1122594},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {3D rendering, OpenGL ES, X3D, mobile devices, sign language},
}

@inproceedings{X3D_SHADERS,
 author = {de Carvalho, Gon\c{c}alo Nuno Moutinho and Gill, Tony and Parisi, Tony},
 title = {X3D programmable shaders},
 booktitle = {Proceedings of the ninth international conference on 3D Web technology},
 series = {Web3D '04},
 year = {2004},
 isbn = {1-58113-845-8},
 location = {Monterey, California},
 pages = {99--108},
 numpages = {10},
 url = {http://doi.acm.org/10.1145/985040.985055},
 doi = {http://doi.acm.org/10.1145/985040.985055},
 acmid = {985055},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {GPU, VRML, X3D, programmable shading, real-time shading, stream processors},
}

@inproceedings{X3D,
 author = {Daly, Leonard and Brutzman, Don},
 title = {X3D: extensible 3D graphics standard},
 booktitle = {ACM SIGGRAPH ASIA 2008 courses},
 series = {SIGGRAPH Asia '08},
 year = {2008},
 location = {Singapore},
 pages = {22:1--22:6},
 articleno = {22},
 numpages = {6},
 url = {http://doi.acm.org/10.1145/1508044.1508066},
 doi = {http://doi.acm.org/10.1145/1508044.1508066},
 acmid = {1508066},
 publisher = {ACM},
 address = {New York, NY, USA},
}

@inproceedings{FUNCTION_BASED_X3D,
 author = {Liu, Qi and Sourin, Alexei},
 title = {Function-based shape modeling and visualization in X3D},
 booktitle = {Proceedings of the eleventh international conference on 3D web technology},
 series = {Web3D '06},
 year = {2006},
 isbn = {1-59593-336-0},
 location = {Columbia, Maryland},
 pages = {131--141},
 numpages = {11},
 url = {http://doi.acm.org/10.1145/1122591.1122609},
 doi = {http://doi.acm.org/10.1145/1122591.1122609},
 acmid = {1122609},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {3D web visualization, X3D, computer animation, function-based shape modeling, metamorphose},
}

@inproceedings{FUNCTION_BASED_HAPTIC_X3D,
 author = {Wei, Lei and Sourin, Alexei and Stocker, Herbert},
 title = {Function-based haptic collaboration in X3D},
 booktitle = {Proceedings of the 14th International Conference on 3D Web Technology},
 series = {Web3D '09},
 year = {2009},
 isbn = {978-1-60558-432-4},
 location = {Darmstadt, Germany},
 pages = {15--23},
 numpages = {9},
 url = {http://doi.acm.org/10.1145/1559764.1559767},
 doi = {http://doi.acm.org/10.1145/1559764.1559767},
 acmid = {1559767},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {3D web visualization, X3D, collaborative platform, function-based shape modeling, haptic interaction, implicit functions, parametric functions, physical properties},
}

@misc{UNFOLD_MONAD,
  author = {Maggiore, Giuseppe and Orsini, Renzo and Bugliesi, Michele},
  title = {Monadic Scripting for Computer Games},
  howpublished = {http://www.dsi.unive.it/\~{}maggiore}
}

url: https://raw.githubusercontent.com/vs-team/Papers/58fa4a3b4c8185ad30bf9a142002d87ceca756e6/1. Internal (for preview only)/references.bib

repository: vs-team/Papers

repo_name: vs-team/Papers

extension: bib


text:
package routes

import (
	vars "github.com/out-of-mind/catalog/variables"

	"github.com/gorilla/mux"

	"net/http"
	"strconv"
)

func selectHandler(w http.ResponseWriter, r *http.Request) {
	c, _ := r.Cookie("session_token")
	sessionToken := c.Value

	userId, _ := vars.Cache.Get(vars.CTX, sessionToken).Result()
	userIdInt, err := strconv.Atoi(userId)
	if err != nil {
		vars.Log.Error(err)
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("500 Internal Server Error"))
		return
	}

	id := mux.Vars(r)["id"]
	_, err = vars.DB.Exec("UPDATE users SET group_id=(SELECT groups.group_id FROM groups WHERE groups.select_link=$1) WHERE user_id=$2", id, userIdInt)
	if err != nil {
		vars.Log.Error(err)
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("500 Internal Server Error"))
		return
	}

	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
}

repository: Out-Of-Mind/catalog

repo_name: Out-Of-Mind/catalog


text:
DESCRIPTION = "Firmware files for use with TI wl18xx"
LICENSE = "TI-TSPA"
LIC_FILES_CHKSUM = "file://LICENCE;md5=4977a0fe767ee17765ae63c435a32a9e"

inherit allarch

PV = "R8.5+git${SRCPV}"

PR = "r6"

PROVIDES += "wl12xx-firmware"
RPROVIDES_${PN} += "wl12xx-firmware"
RREPLACES_${PN} += "wl12xx-firmware"
RCONFLICTS_${PN} += "wl12xx-firmware"

# Tag: R8.5
SRCREV = "02df01f8b9557b2cf920d14bdaaabde2373e3d7e"
BRANCH = "ap_dfs"
SRC_URI = "git://git.ti.com/wilink8-wlan/wl18xx_fw.git;protocol=git;branch=${BRANCH} \
           file://0001-Add-Makefile-for-SDK.patch \
          "

S = "${WORKDIR}/git"

do_compile() {
    :
}

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

FILES_${PN} = "/lib/firmware/ti-connectivity/*"

repository: varigit/meta-arago-var

repo_name: varigit/meta-arago-var