text:
@ARTICLE{Mueller07,
  author = {Matthias Müller and Bruno Heidelberger and Marcus Hennix and
	John Ratcliff},
  title = {Position based dynamics},
  journal = {Journal of Visual Communication and Image Representation},
  year = {2007},
  volume = {18},
  pages = {109--118},
  number = {2},
  doi = {http://dx.doi.org/10.1016/j.jvcir.2007.01.005},
  issn = {1047-3203},
  publisher = {Academic Press, Inc.},
}

@INPROCEEDINGS{Diziol2011,
  author = {Raphael Diziol and Jan Bender and Daniel Bayer},
  title = {Robust Real-Time Deformation of Incompressible Surface Meshes},
  booktitle = {Proceedings of ACM SIGGRAPH/Eurographics Symposium on Computer
	Animation},
  year = {2011},
  series = {SCA '11},
  publisher = {Eurographics Association},
  location = {Vancouver, Canada},
}

@ARTICLE{Muller2005,
  author = {Müller, Matthias and Heidelberger, Bruno and Teschner, Matthias
	and Gross, Markus},
  title = {Meshless deformations based on shape matching},
  journal = {ACM Trans. Graph.},
  year = {2005},
  volume = {24},
  pages = {471--478},
  number = {3},
  doi = {http://doi.acm.org/10.1145/1073204.1073216},
  issn = {0730-0301},
  keywords = {shape matching},
  location = {Los Angeles, California},
  publisher = {ACM}
}

@ARTICLE{Bender2013,
  author = {Jan Bender and Daniel Weber and Raphael Diziol},
  title = {Fast and stable cloth simulation based on multi-resolution shape matching},
  journal = {Computers \& Graphics },
  year = {2013},
   volume = {37},
  pages = {945 - 954},
  number = {8},
  doi = {http://dx.doi.org/10.1016/j.cag.2013.08.003},
  issn = {0097-8493},
  url = {http://www.sciencedirect.com/science/article/pii/S0097849313001283}
}

@article{Macklin:2013:PBF,
 author = {Macklin, Miles and Müller, Matthias},
 title = {Position based fluids},
 journal = {ACM Trans. Graph.},
 issue_date = {July 2013},
 volume = {32},
 number = {4},
 month = jul,
 year = {2013},
 issn = {0730-0301},
 pages = {104:1--104:12},
 articleno = {104},
 numpages = {12},
 url = {http://doi.acm.org/10.1145/2461912.2461984},
 doi = {10.1145/2461912.2461984},
 acmid = {2461984},
 publisher = {ACM},
  keywords = {PCISPH, SPH, constraint fluids, fluid simulation, position based dynamics},
}

@article{BMOTM2014,
title =      "A Survey on Position-Based Simulation Methods in Computer Graphics",
author =     "Jan Bender and Matthias Müller and Miguel A. Otaduy and Matthias Teschner and Miles Macklin",
year = {2014},
volume = {33},
pages = {228--251},
number = {6},
journal = {Computer Graphics Forum},
doi = {10.1111/cgf.12346},
issn = {1467-8659},
url = {http://dx.doi.org/10.1111/cgf.12346}
}

@ARTICLE{Bender2014,
  author = {Jan Bender and Dan Koschier and Patrick Charrier and Daniel Weber},
  title = {Position-Based Simulation of Continuous Materials},
  journal = {Computers \& Graphics },
  year = {2014},
  volume = {44},
  pages = {1 - 10},
  number = {0},
  doi = {http://dx.doi.org/10.1016/j.cag.2014.07.004},
  issn = {0097-8493}
}

@article{Deul2014,
   author = {Crispin Deul and Patrick Charrier and Jan Bender},
   title = {Position-Based Rigid Body Dynamics},
   journal = {Computer Animation and Virtual Worlds},
   year = {2014},
	doi = {10.1002/cav.1614},
  issn = {1546-427X},
  publisher = {John Wiley \& Sons, Ltd},
  url = {http://dx.doi.org/10.1002/cav.1614}
}

@INPROCEEDINGS{Mueller2014,
  author = {Müller, Matthias and Chentanez, Nuttapong and Kim, Tae-Yong and Macklin, Miles},
  title = {Strain Based Dynamics},
  booktitle = {Proceedings of ACM SIGGRAPH/Eurographics Symposium on Computer
	Animation},
  year = {2014},
  publisher = {Eurographics Association},
  location = {Copenhagen, Denmark}
}

@inproceedings{BMOT2013,
  title =      "Position-based Methods for the Simulation of Solid Objects in Computer Graphics",
  author =     "Jan Bender and Matthias Müller and Miguel A. Otaduy and Matthias Teschner",
  year =       "2013",
  booktitle =  "EUROGRAPHICS 2013 State of the Art Reports",
  publisher =  "Eurographics Association",
  location =   "Girona, Spain"
}

@inproceedings{BMM2015,
  title =      "Position-Based Simulation Methods in Computer Graphics",
  author =     "Jan Bender and Matthias Müller and Miles Macklin",
  year =       "2015",
  booktitle =  "EUROGRAPHICS 2015 Tutorials",
  publisher =  "Eurographics Association",
  location =   "Zurich, Switzerland"
}

@article{Akinci:2012,
 author = {Akinci, Nadir and Ihmsen, Markus and Akinci, Gizem and Solenthaler, Barbara and Teschner, Matthias},
 title = {Versatile Rigid-fluid Coupling for Incompressible SPH},
 journal = {ACM Trans. Graph.},
 issue_date = {July 2012},
 volume = {31},
 number = {4},
 month = jul,
 year = {2012},
 issn = {0730-0301},
 pages = {62:1--62:8},
 articleno = {62},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/2185520.2185558},
 doi = {10.1145/2185520.2185558},
 acmid = {2185558},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {fluid simulation, fluid-solid coupling, physically-based animation, smoothed particle hydrodynamics},
}

@InProceedings{MMC16,
  author    = {Macklin, Miles and Müller, Matthias and Chentanez, Nuttapong},
  title     = {XPBD: Position-based Simulation of Compliant Constrained Dynamics},
  booktitle = {ACM Motion in Games},
  year      = {2016},
  series    = {MIG '16},
  pages     = {49--54},
  publisher = {ACM},
  acmid     = {2994272},
  doi       = {10.1145/2994258.2994272},
  isbn      = {978-1-4503-4592-7},
  keywords  = {constrained dynamics, physics simulation, position based dynamics},
  location  = {Burlingame, California},
  numpages  = {6},
  url       = {http://doi.acm.org/10.1145/2994258.2994272},
}


text:
package jobworker

import (
	"context"
	"fmt"
	"sort"
	"sync"
	"time"
)

type Driver interface {
	Open(attrs map[string]interface{}) (Connector, error)
}

var (
	driversMu   sync.RWMutex
	name2Driver = make(map[string]Driver)

	ErrJobDuplicationDetected = fmt.Errorf("job duplication detected")
	ErrNoActiveConn           = fmt.Errorf("no active conn")
)

func Register(name string, driver Driver) {
	driversMu.Lock()
	defer driversMu.Unlock()
	if driver == nil {
		panic("JWDK: Register Driver is nil")
	}
	if _, dup := name2Driver[name]; dup {
		panic("JWDK: Register called twice for Driver " + name)
	}
	name2Driver[name] = driver
}

func Open(driverName string, attrs map[string]interface{}) (Connector, error) {
	driversMu.RLock()
	driveri, ok := name2Driver[driverName]
	driversMu.RUnlock()
	if !ok {
		return nil, fmt.Errorf("JWDK: unknown driver %q (forgotten import?)", driverName)
	}
	return driveri.Open(attrs)
}

type Subscription interface {
	Active() bool
	Queue() chan *Job
	UnSubscribe() error
}

type SubscribeInput struct {
	Queue    string
	Metadata map[string]string
}

type SubscribeOutput struct {
	Subscription Subscription
}

type EnqueueInput struct {
	Queue           string
	Content         string
	Metadata        map[string]string
	CustomAttribute map[string]*CustomAttribute
}

type EnqueueOutput struct{}

type EnqueueBatchInput struct {
	Queue   string
	Entries []*EnqueueBatchEntry
}

type EnqueueBatchEntry struct {
	ID              string // Uniq ID
	Content         string
	Metadata        map[string]string
	CustomAttribute map[string]*CustomAttribute
}

type EnqueueBatchOutput struct {
	Failed     []string // Uniq ID
	Successful []string // Uniq ID
}

type CompleteJobInput struct {
	Job *Job
}

type CompleteJobOutput struct{}

type FailJobInput struct {
	Job *Job
}

type FailJobOutput struct{}

type Connector interface {
	Name() string
	Subscribe(ctx context.Context, input *SubscribeInput) (*SubscribeOutput, error)
	Enqueue(ctx context.Context, input *EnqueueInput) (*EnqueueOutput, error)
	EnqueueBatch(ctx context.Context, input *EnqueueBatchInput) (*EnqueueBatchOutput, error)
	CompleteJob(ctx context.Context, input *CompleteJobInput) (*CompleteJobOutput, error)
	FailJob(ctx context.Context, input *FailJobInput) (*FailJobOutput, error)
	Close() error
	SetLoggerFunc(f LoggerFunc)
}

type ConnectorProvider struct {
	retrySeconds time.Duration

	mu          sync.RWMutex
	deadRetryAt map[Connector]time.Time

	priority2Conn map[int]Connector
}

func (p *ConnectorProvider) SetRetrySeconds(sec time.Duration) {
	p.retrySeconds = sec
}

func (p *ConnectorProvider) Register(priority int, conn Connector) {
	p.mu.Lock()
	if p.priority2Conn == nil {
		p.priority2Conn = make(map[int]Connector)
	}
	p.priority2Conn[priority] = conn
	p.mu.Unlock()
}

func (p *ConnectorProvider) GetConnsInPriorityOrder() []Connector {
	keys := make([]int, 0, len(p.priority2Conn))

	p.mu.Lock()
	for k := range p.priority2Conn {
		keys = append(keys, k)
	}
	p.mu.Unlock()

	sort.Ints(keys)

	var sorted []Connector
	for _, k := range keys {
		sorted = append(sorted, p.priority2Conn[k])
	}

	return sorted
}

func (p *ConnectorProvider) GetActiveConnsInPriorityOrder() []Connector {
	keys := make([]int, 0, len(p.priority2Conn))

	p.mu.Lock()
	for k := range p.priority2Conn {
		keys = append(keys, k)
	}
	p.mu.Unlock()

	sort.Ints(keys)

	var sorted []Connector
	for _, k := range keys {
		conn := p.priority2Conn[k]
		if p.IsDead(conn) {
			continue
		}
		sorted = append(sorted, conn)
	}

	return sorted
}

func (p *ConnectorProvider) MarkDead(conn Connector) {
	p.mu.Lock()

	if p.deadRetryAt == nil {
		p.deadRetryAt = make(map[Connector]time.Time)
	}

	p.deadRetryAt[conn] = time.Now().Add(p.retrySeconds)
	p.mu.Unlock()
}

func (p *ConnectorProvider) IsDead(conn Connector) bool {
	p.mu.Lock()
	defer p.mu.Unlock()

	if p.deadRetryAt == nil {
		p.deadRetryAt = make(map[Connector]time.Time)
	}

	if retryAt, dead := p.deadRetryAt[conn]; dead {
		if retryAt.Before(time.Now()) {
			delete(p.deadRetryAt, conn)
			return false
		}
		return true
	}
	return false
}

func (p *ConnectorProvider) Close() {
	for _, conn := range p.priority2Conn {
		_ = conn.Close()
	}
}

license: MIT

repository: go-jwdk/jobworker

license_type: permissive

repo_name: go-jwdk/jobworker

branch_name: refs/heads/master

extension: go


text:
import React, { Component, Fragment } from 'react';
import PropTypes from 'prop-types';

import { ProgramSession } from './ProgramSession';
import { TimeSlotInfo } from './TimeSlotInfo';
import { TimeSlotModal } from './TimeSlotModal';
import { patchTimeSlot } from '../../apiCalls';

class ScheduleSlot extends Component {
  constructor(props) {
    super(props);
    this.state = {
      hoverDrag: false,
      modalShowing: false,
      title: this.props.slot.title || '',
      track: this.props.slot.track_id || '',
      presenter: this.props.slot.presenter || '',
      description: this.props.slot.description || '',
    };
  }

  onDragOver = (e) => {
    e.preventDefault();
    this.setState({ hoverDrag: true });
  };

  onDragLeave = (e) => {
    e.preventDefault();
    this.setState({ hoverDrag: false });
  };

  onDrop = (slot, e) => {
    e.preventDefault();
    const session = this.props.draggedSession;
    const { handleMoveSessionResponse, changeDragged } = this.props;

    if (session.slot) {
      if (session.slot.program_session_id === slot.program_session_id) {
        changeDragged(null);
        return;
      }
    }

    patchTimeSlot(slot, session)
      .then((response) => response.json())
      .then((data) => {
        const { errors } = data;

        if (errors) {
          this.props.showErrors(errors);
          return;
        }

        if (session.slot) {
          patchTimeSlot(session.slot, null)
            .then((response) => response.json())
            .then((data) => {
              const { sessions, slots, unscheduled_sessions } = data;
              handleMoveSessionResponse(sessions, unscheduled_sessions, slots, session);
            });
        } else {
          const { sessions, slots, unscheduled_sessions } = data;
          handleMoveSessionResponse(sessions, unscheduled_sessions, slots);
        }
        changeDragged(null);
        this.setState({ hoverDrag: false });
      })
      .catch((error) => console.error('Error:', error));
  };

  onDrag = (programSession) => {
    const { title, description, track, presenter } = this.state;
    this.props.changeDragged(
      Object.assign(programSession, {
        slot: Object.assign(this.props.slot, {
          title,
          description,
          track_id: track,
          presenter,
        }),
      })
    );
  };

  showModal = () => {
    if (!this.state.modalShowing) {
      this.setState({ modalShowing: true });
    }
  };

  closeModal = () => {
    this.setState({ modalShowing: false });
  };

  updateSlot = (e) => {
    const { name, value } = e.target;
    this.setState({
      [name]: value,
    });
  };

  render() {
    const {
      slot,
      ripTime,
      startTime,
      sessions,
      tracks,
      unscheduledSessions,
      handleMoveSessionResponse,
      sessionFormats,
      roomName,
    } = this.props;
    const { title, track, presenter, description } = this.state;

    const slotStartTime = ripTime(slot.start_time);
    const slotEndTime = ripTime(slot.end_time);
    let background = this.state.hoverDrag ? '#f9f6f1' : '#fff';

    const style = {
      top: (slotStartTime - startTime) * 90 + 'px',
      height: (slotEndTime - slotStartTime) * 90 + 'px',
      background,
    };

    let matchedSession;
    let session;

    if (slot.program_session_id) {
      matchedSession = sessions.find((session) => session.id === slot.program_session_id);
      session = <ProgramSession session={matchedSession} onDrag={this.onDrag} tracks={tracks} />;
    }
    let timeSlotInfo = <TimeSlotInfo slot={slot} tracks={tracks} />;

    return (
      <div
        className="schedule_slot"
        style={style}
        key={slot.id}
        onDragOver={(e) => this.onDragOver(e)}
        onDragLeave={(e) => this.onDragLeave(e)}
        onDrop={(e) => this.onDrop(slot, e)}
        onClick={this.showModal}
      >
        {session || timeSlotInfo}
        {this.state.modalShowing === true && (
          <TimeSlotModal
            slot={this.props.slot}
            matchedSession={matchedSession}
            unscheduledSessions={unscheduledSessions}
            tracks={tracks}
            closeModal={this.closeModal}
            sessions={sessions}
            handleMoveSessionResponse={handleMoveSessionResponse}
            sessionFormats={sessionFormats}
            title={title}
            track={track}
            presenter={presenter}
            description={description}
            updateSlot={this.updateSlot}
            roomName={roomName}
          />
        )}
      </div>
    );
  }
}

ScheduleSlot.propTypes = {
  slot: PropTypes.object,
  ripTime: PropTypes.func,
  startTime: PropTypes.number,
  changeDragged: PropTypes.func,
  draggedSession: PropTypes.object,
  handleMoveSessionResponse: PropTypes.func,
  tracks: PropTypes.array,
  unscheduledSessions: PropTypes.array,
  showErrors: PropTypes.func,
  roomName: PropTypes.string,
};

export { ScheduleSlot };

repository: rubycentral/cfp-app

repo_name: rubycentral/cfp-app

branch_name: refs/heads/main

gha_license_id: MIT

gha_language: Ruby

extension: js


text:
SUMMARY = "dhdutil utility"
DESCRIPTION = "dhdutil utility for BCM chipset"
SECTION = "test-tools"
LICENSE = "CLOSED"

PV = "r1.141"
PR = "r47"

S = "${EDISONREPO_TOP_DIR}/broadcom_tools/wlan/dhdutil"

do_install() {
    install -v -d  ${D}/usr/sbin/
    install -m 0755 ${B}/dhdutil ${D}/usr/sbin
}

repository: TeamElevate/edison

repo_name: TeamElevate/edison

extension: bb


text:
DESCRIPTION = "Authorization Protocol for X."
SECTION = "x11/libs"
PRIORITY = "optional"
#MAINTAINER = ""
LICENSE= "MIT"

DEPENDS = "xproto util-macros"
PROVIDES = "xau"

XORG_PN = "libXau"

include xorg-xlibs.inc

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
package common

import (
	"github.com/julienschmidt/httprouter"
	"net/http"
)

type CRUDServer interface {
	Create(http.ResponseWriter, *http.Request, httprouter.Params)
	Delete(http.ResponseWriter, *http.Request, httprouter.Params)
	Update(http.ResponseWriter, *http.Request, httprouter.Params)
	Read(http.ResponseWriter, *http.Request, httprouter.Params)
	Path() string
	Router(*httprouter.Router)
}

repository: cuihovah/hcham

repo_name: cuihovah/hcham


text:
@proceedings{ws-2010-ontologies,
    title = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    editor = "Oltramari, Alessandro  and
      Vossen, Piek  and
      Lu, Qin",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3300",
}
@inproceedings{vossen-etal-2010-kyoto,
    title = "{KYOTO}: an open platform for mining facts",
    author = "Vossen, Piek  and
      Rigau, German  and
      Agirre, Eneko  and
      Soroa, Aitor  and
      Monachini, Monica  and
      Bartolini, Roberto",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3301",
    pages = "1--10",
}
@inproceedings{nagata-etal-2010-using,
    title = "Using Goi-Taikei as an Upper Ontology to Build a Large-Scale {J}apanese Ontology from {W}ikipedia",
    author = "Nagata, Masaaki  and
      Shibaki, Yumi  and
      Yamamoto, Kazuhide",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3302",
    pages = "11--18",
}
@inproceedings{daoud-etal-2010-multilingual,
    title = "Multilingual Lexical Network from the Archives of the Digital Silk Road",
    author = "Daoud, Hans-Mohammad  and
      Kageura, Kyo  and
      Boitet, Christian  and
      Kitamoto, Asanobu  and
      Mangeot, Mathieu",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3303",
    pages = "19--27",
}
@inproceedings{van-der-plas-tiedemann-2010-finding,
    title = "Finding Medical Term Variations using Parallel Corpora and Distributional Similarity",
    author = {van der Plas, Lonneke  and
      Tiedemann, J{\"o}rg},
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3304",
    pages = "28--37",
}
@inproceedings{vor-der-bruck-2010-learning,
    title = "Learning Semantic Network Patterns for Hypernymy Extraction",
    author = {vor der Br{\"u}ck, Tim},
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3305",
    pages = "38--47",
}
@inproceedings{choi-etal-2010-intrinsic,
    title = "Intrinsic Property-based Taxonomic Relation Extraction from Category Structure",
    author = "Choi, DongHyun  and
      Kim, Eun-Kyung  and
      Shim, Sang-Ah  and
      Choi, Key-Sun",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3306",
    pages = "48--57",
}
@inproceedings{conway-etal-2010-developing,
    title = "Developing a Biosurveillance Application Ontology for Influenza-Like-Illness",
    author = "Conway, Mike  and
      Dowling, John  and
      Chapman, Wendy",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3307",
    pages = "58--66",
}
@inproceedings{boguslavsky-etal-2010-interfacing,
    title = "Interfacing the Lexicon and the Ontology in a Semantic Analyzer",
    author = "Boguslavsky, Igor  and
      Iomdin, Leonid  and
      Sizov, Victor  and
      Timoshenko, Svetlana",
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3308",
    pages = "67--76",
}
@inproceedings{cadilhac-etal-2010-ontolexical,
    title = "Ontolexical resources for feature-based opinion mining: a case-study",
    author = {Cadilhac, Ana{\"\i}s  and
      Benamara, Farah  and
      Aussenac-Gilles, Nathalie},
    booktitle = "Proceedings of the 6th Workshop on {O}ntologies and {L}exical {R}esources",
    month = aug,
    year = "2010",
    address = "Beijing, China",
    publisher = "Coling 2010 Organizing Committee",
    url = "https://www.aclweb.org/anthology/W10-3309",
    pages = "77--86",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_license_id: NOASSERTION

gha_language: TeX

extension: bib


text:
package main

import (
	"github.com/alexbosworth/grpc-proxy/looprpc"
	"github.com/gin-gonic/gin"
	"google.golang.org/grpc"
	"google.golang.org/grpc/metadata"
	"net/http"
)

// Arguments for get loop out terms request
type loopOutTermsRequest struct {
	ProtocolVersion string `json:"protocol_version" binding:"required"`
}

// Get the terms for loop out
func loopOutTerms(c *gin.Context) {
	headers := requestHeaders{}

	// Exit early when the headers cannot be bound
	if err := c.ShouldBindHeader(&headers); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"details": err.Error()})
		return
	}

	// Map the request into its type
	var req loopOutTermsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"details": err.Error()})
		return
	}

	_, hasProtocol := looprpc.ProtocolVersion_value[req.ProtocolVersion]

	// Exit early when the protocol is not defined
	if !hasProtocol {
		c.JSON(
			http.StatusBadRequest,
			gin.H{"details": "ExpectedKnownProtocolVersionToGetTerms"},
		)
		return
	}

	// Get a connection to the server
	client, connectionError := swapClient()

	// Exit early when there is a connection issue
	if connectionError != nil {
		c.JSON(
			http.StatusServiceUnavailable,
			gin.H{"details": "FailedToConnectToSwapServer"},
		)
		return
	}

	// Map the arguments into a request
	loopReq := looprpc.ServerLoopOutTermsRequest{
		ProtocolVersion: looprpc.ProtocolVersion(
			looprpc.ProtocolVersion_value[req.ProtocolVersion],
		),
	}

	// gRPC responses have "trailers" for metadata in addition to headers
	responseTrailers := metadata.MD{}

	grpcResponse, loopErr := client.LoopOutTerms(
		headers.asGrpcContext(),
		&loopReq,
		grpc.Trailer(&responseTrailers),
	)

	// Exit early when an error is encountered
	if loopErr != nil {
		returnGrpcError(c, loopErr, responseTrailers)
		return
	}

	// Return the response from the server
	c.JSON(http.StatusOK, grpcResponse)
}

repository: alexbosworth/grpc-proxy

repo_name: alexbosworth/grpc-proxy


text:
SUMMARY = "install wpa_supplicant_custom.conf"
SECTION = "PETALINUX/apps"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

SRC_URI = "file://rt2870.bin \
	   file://rtl8192cufw.bin \
	   file://rtl8192cufw_TMSC.bin \
	"

S = "${WORKDIR}"

FILESEXTRAPATHS_prepend := "${THISDIR}/files:"

do_install() {
	install -d ${D}/${base_libdir}/firmware/
	install -d ${D}/${base_libdir}/firmware/rtlwifi
	install -m 0755 ${S}/rt2870.bin ${D}/${base_libdir}/firmware/
	install -m 0755 ${S}/rtl8192cufw.bin ${D}/${base_libdir}/firmware/rtlwifi
	install -m 0755 ${S}/rtl8192cufw_TMSC.bin ${D}/${base_libdir}/firmware/rtlwifi
}

FILES_${PN} += "${base_libdir}/firmware/*"

repository: jacobfeder/xilmake

repo_name: jacobfeder/xilmake


text:
/****************************************************
Copyright 2018 The ont-eventbus Authors

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.
*****************************************************/

/***************************************************
Copyright 2016 https://github.com/AsynkronIT/protoactor-go

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 zmqremote

import (
	"github.com/ontio/ontology-eventbus/actor"
	"github.com/ontio/ontology-eventbus/log"
	zmq "github.com/pebbe/zmq4"
)

var (
	edpReader *endpointReader
	conn      *zmq.Socket
)

func Start(address string) {

	actor.ProcessRegistry.RegisterAddressResolver(remoteHandler)
	actor.ProcessRegistry.Address = address

	spawnActivatorActor()
	startEndpointManager()

	edpReader = &endpointReader{}

	conn, _ = zmq.NewSocket(zmq.ROUTER)
	err := conn.Bind("tcp://" + address)
	if err != nil {
		plog.Error("failed to Bind", log.Error(err))
	}
	plog.Info("Starting Proto.Actor server", log.String("address", address))
	go func() {
		edpReader.Receive(conn)
	}()
}

func Shutdonw() {
	edpReader.suspend(true)
	stopEndpointManager()
	stopActivatorActor()
	conn.Close()
}

repository: ontio/ontology-eventbus

repo_name: ontio/ontology-eventbus

gha_language: Go


text:
---
---
References
==========

@article{Bagh16b,
title = {Online Adaptable Learning Rates for the Game Connect-4},
author = { Samineh Bagheri and Markus Thill and Patrick Koch and Wolfgang Konen},
doi = {10.1109/TCIAIG.2014.2367105},
year = {2016},
date = {2016-01-01},
journal = {IEEE Transactions on Computational Intelligence and AI in Games},
volume = {8},
number = {1},
pages = {33-42},
note = {accepted 11/2014},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@INPROCEEDINGS{Thill12,
  author = {Thill, Markus and Koch, Patrick and Konen, Wolfgang},
  title = {{{Reinforcement learning with n-tuples on the game Connect-4}}},
  year = {2012},
  editor = {Coello Coello, Carlos and others},
  pages = {184--194},
  publisher = {Springer, Heidlberg},
  keywords = {FiwaSoma},
  owner = {konen},
  timestamp = {2010.09.13},
  booktitle = { Proceedings of the 12th International Conference on Parallel Problem Solving from Nature (PPSN)}
}

@TECHREPORT{Thill12a,
  author = {M. Thill},
  title = {{Using n-tuple systems with TD learning for strategic board games
	(in German)}},
  institution = {Cologne University of Applied Science},
  year = {2012},
  type = {{CIOP} Report},
  number = {01/12},
  issn = {2191-365X},
  owner = {wolfgang},
  timestamp = {2012.02.12}
}

@INPROCEEDINGS{Thill14,
  author = {Thill, Markus and Bagheri, Samineh and Koch, Patrick and Konen, Wolfgang
	},
  title = {{Temporal Difference Learning with Eligibility Traces for the Game
	Connect Four}},
  booktitle = {Proceedings of the 2014 IEEE International Conference on Computational Intelligence and Games (CIG)},
  year = {2014},
  pages = {586--591},
  organization = {IEEE}
}

@inproceedings{Thill2017SORAD,
  title={{Online anomaly detection on the Webscope S5 dataset: A comparative study}},
  author={Thill, Markus and Konen, Wolfgang and B{\"a}ck, Thomas},
  booktitle={IEEE Conference on Evolving and Adaptive Intelligent Systems (EAIS 2017)},
  pages={1},
  year={2017},
  organization={Springer}
}

@INPROCEEDINGS{Thill2017ITISE,
  author = {Thill, Markus and Konen, Wolfgang and B{\"a}ck, Thomas},
  title = {Time Series Anomaly Detection with Discrete Wavelet Transforms and Maximum Likelihood Estimation},
  booktitle = {International Work-Conference on Time Series (ITISE 2017)},
  year = {accepted Jul. 2017}
}

@misc{ThilKon14,
title = {Connect-4 Game Playing Framework (C4GPF)},
author = { Markus Thill and Wolfgang Konen},
url = {http://github.com/MarkusThill/Connect-Four},
year = {2014},
keywords = {},
pubstate = {published},
tppubtype = {misc}
}

@techreport{Bagh14a,
title = {Online Adaptable Learning Rates for the Game Connect-4},
author = { Samineh Bagheri and Markus Thill and Patrick Koch and Wolfgang Konen},
doi = {10.1109/TCIAIG.2014.2367105},
year = {2014},
date = {2014-01-01},
number = {TR 03/2014},
institution = {CIplus},
note = {Preprint version of the article in IEEE Transactions on Computational Intelligence and AI in Games, 2016},
keywords = {},
pubstate = {published},
tppubtype = {techreport}
}

repository: MarkusThill/GitHubPagesWorking

repo_name: MarkusThill/GitHubPagesWorking


text:
/*
 * Pureport Control Plane
 *
 * Pureport API
 *
 * API version: 1.0.0
 * Contact: support@pureport.com
 * Generated by: OpenAPI Generator (https://openapi-generator.tech)
 */

package client

// AwsDirectConnectConnectionAllOf struct for AwsDirectConnectConnectionAllOf
type AwsDirectConnectConnectionAllOf struct {
	// The AWS Account ID, a 12-digit number that you use to construct Amazon Resource Names (ARNs).
	AwsAccountId string `json:"awsAccountId,omitempty"`
	// The AWS Region for the connection. This has been deprecated in favor of cloudRegion.
	AwsRegion                string                    `json:"awsRegion,omitempty"`
	BgpPasswordConfiguration *BgpPasswordConfiguration `json:"bgpPasswordConfiguration,omitempty"`
	CloudRegion              *Link                     `json:"cloudRegion,omitempty"`
	// The asset link for the clouds services associated with this connection.
	CloudServices []Link `json:"cloudServices,omitempty"`
	// The whitelisted cloud services CIDR blocks.
	CloudServicesPrefixWhitelist []string              `json:"cloudServicesPrefixWhitelist,omitempty"`
	Peering                      *PeeringConfiguration `json:"peering,omitempty"`
}

repository: pureport/pureport-sdk-go

repo_name: pureport/pureport-sdk-go

branch_name: refs/heads/develop


text:
package service

import (
	"fmt"
	"github.com/geekymedic/neon/service/middleware"
	"net"
	"sync"

	"github.com/geekymedic/neon"
	"github.com/geekymedic/neon/config"
	"github.com/geekymedic/neon/logger"
	"github.com/geekymedic/neon/version"

	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"google.golang.org/grpc"
)

var _rpcServer *grpc.Server

func Main() error {
	fmt.Println(version.Version())

	var path string
	cmd := cobra.Command{
		RunE: func(cmd *cobra.Command, args []string) error {

			err := config.Load(&path)

			if err != nil {
				return err
			}

			var (
				address = viper.GetString("Address")
			)

			err = neon.LoadPlugins(viper.GetViper())

			if err != nil {
				return err
			}
			for _, opt := range beforeAppRun {
				if err := opt(); err != nil {
					logger.With("err", err).Error("fail to execute before app run hook")
					return err
				}
			}

			defer func() {
				for _, opt := range beforeAppExit {
					if err := opt(); err != nil {
						logger.With("err", err).Error("fail to execute before app exit hook")
					}
				}
			}()
			l, err := net.Listen("tcp", address)

			if err != nil {
				logger.Errorf("listen %s fail,%s", address, err)
				return err
			} else {
				logger.Info("listen %s", l.Addr())
			}
			Server()
			err = _rpcServer.Serve(l)

			if err != nil {
				logger.Errorf("%s", err)
				return err
			}

			return nil
		},
	}

	flags := cmd.Flags()
	flags.BoolVar(&_flags.Debug, "debug", false, "use debug mode")
	flags.StringVarP(&path, "config", "c", "config", "config path")
	return cmd.Execute()

}

var once sync.Once

func Server() *grpc.Server {
	once.Do(func() {
		_rpcServer = grpc.NewServer(grpc.UnaryInterceptor(middleware.GrpcServerChainMiddleware()))
	})
	return _rpcServer
}

repository: geekymedic/neon

repo_name: geekymedic/neon


text:
@article{zhang2013palm,
  title={Palm-Print Classification by Global Features},
  author={Zhang, Bob and Li, Wei and Qing, Pei and Zhang, David},
  journal={Systems, Man, and Cybernetics: Systems, IEEE Transactions on},
  volume={43},
  number={2},
  pages={370--378},
  year={2013},
  publisher={IEEE}
}

@patent{CN106641933A,
  author={白鹭，陈春光，乔生繁，刘雪松，宋云龙，陈壬贤，于德海，刘嘉，于乐淘，贾忱然，李静，樊星，覃炜瞳，李铁，姜玉稀，章干，卿培},
  title={路灯设备},
  country={CN},
  patentid={CN106641933A},
  date={2017-05-10},
  langauge={zh},
}

@patent{CN106781644A,
  author={白鹭，陈春光，乔生繁，刘雪松，宋云龙，于德海，陈壬贤，贾忱然，于乐淘，李阳，刘嘉，姜玉稀，章干，卿培},
  title={路灯充电桩及其停车位管理方法、装置和系统},
  country={CN},
  patentid={CN106781644A},
  date={2017-05-31},
  langauge={zh},
}

@patent{CN206222158U,
  author={白鹭，陈春光，徐绍军，乔生繁，刘雪松，宋云龙，于德海，陈壬贤，于乐淘，刘嘉，贾忱然，姜玉稀，章干，卿培},
  title={路灯设备盒},
  country={CN},
  patentid={CN206222158U},
  date={2017-06-06},
  langauge={zh},
}

@patent{CN107274695A,
  author={姜玉稀，周繁，卿培，帅应红},
  title={智能照明系统、智能车辆及其车辆辅助驾驶系统和方法},
  country={CN},
  patentid={CN107274695A},
  date={2017-10-20},
  langauge={zh},
}

@patent{CN105828459A,
  author={姜玉稀，廖红印，卿培，李应启},
  title={场所车辆管理系统、车载终端及车辆},
  country={CN},
  patentid={CN105828459A},
  date={2016-08-03},
  langauge={zh},
}

repository: edwardtoday/resume

repo_name: edwardtoday/resume


text:
DESCRIPTION = "Node-RED nodes for Google Cloud Platform"
AUTHOR = "Cloud Partner Engineering"
HOMEPAGE = "https://github.com/GoogleCloudPlatform/node-red-contrib-google-cloud.git"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57"

DEPENDS = "nodejs-native"

RDEPENDS_${PN} = "\
	bash \
	node-red \
"

SRC_URI = "git://github.com/GoogleCloudPlatform/${PN}.git;branch=master"
SRCREV = "2e646aaf897da0d54a7ee5df55c4de3ac2eac86c"

PR = "r3"

S = "${WORKDIR}/git"

def get_nodejs_arch(d):
    target_arch = d.getVar('TRANSLATED_TARGET_ARCH', True)

    if target_arch == "x86-64":
        target_arch = "x64"
    elif target_arch == "aarch64":
        target_arch = "arm64"
    elif target_arch == "powerpc":
        target_arch = "ppc"
    elif target_arch == "powerpc64":
        target_arch = "ppc64"
    elif (target_arch == "i486" or target_arch == "i586" or target_arch == "i686"):
        target_arch = "ia32"

    return target_arch

NODE_MODULES_DIR = "${prefix}/lib/node_modules"
NPM_CACHE_DIR ?= "${WORKDIR}/npm_cache"
NPM_REGISTRY ?= "http://registry.npmjs.org/"
NPM_ARCH = "${@get_nodejs_arch(d)}"
NPM_INSTALL_FLAGS = "--production --without-ssl --insecure --no-optional --verbose --unsafe-perm"

do_compile() {
	export NPM_CONFIG_CACHE="${NPM_CACHE_DIR}"

	# Clear cache
	npm cache clear

	npm --registry=${NPM_REGISTRY} --arch=${NPM_ARCH} --target_arch=${NPM_ARCH} ${NPM_INSTALL_FLAGS} install
	npm prune --production
}

do_install() {
	install -d ${D}${NODE_MODULES_DIR}/${PN}
	cp -R ${S}/* ${D}${NODE_MODULES_DIR}/${PN}
}

PACKAGES = "${PN}"

FILES_${PN} += "${NODE_MODULES_DIR}/${PN}"

INHIBIT_PACKAGE_DEBUG_SPLIT = "1"

INSANE_SKIP_${PN} = "staticdev file-rdeps"

repository: MentorEmbedded/meta-iot-cloud

repo_name: MentorEmbedded/meta-iot-cloud

gha_language: BitBake


text:
require atk.inc

SRC_URI = "http://download.gnome.org/sources/atk/1.20/${PN}-${PV}.tar.bz2"

SRC_URI[md5sum] = "b1a9e28d9f54ea306bd85a4c84b25fb8"
SRC_URI[sha256sum] = "1f3b2f2cbb5b0d8da0924970c66c3ecbfe13c4e4360b0af1db7545401a3747c9"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@inproceedings{10.1145/3366424.3383535,
author = {Wang, Xiaolan and Suhara, Yoshihiko and Nuno, Natalie and Li, Yuliang and Li, Jinfeng and Carmeli, Nofar and Angelidis, Stefanos and Kandogann, Eser and Tan, Wang-Chiew},
title = {ExtremeReader: An Interactive Explorer for Customizable and Explainable Review Summarization},
year = {2020},
isbn = {9781450370240},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3366424.3383535},
doi = {10.1145/3366424.3383535},
booktitle = {Companion Proceedings of the Web Conference 2020},
pages = {176–180},
numpages = {5},
keywords = {Opinion summarization, Explanation mining},
location = {Taipei, Taiwan},
series = {WWW ’20}
}


text:
# Documentation: https://cmake.org/cmake/help/book/mastering-cmake/chapter/Cross%20Compiling%20With%20CMake.html

# Target OS: Docs say to set this to "Generic" but I kinda want to call it "Arduino" ??
# Automatically sets CMAKE_CROSSCOMPILING to True (use that mostly, not this value?)
set(CMAKE_SYSTEM_NAME Generic)

# Arduino IDE Version, maybe?
# Described as "the version of your target system"
set(CMAKE_SYSTEM_VERSION 1.8.19)

# Docs say "anything I want" and is used to load a
# ${CMAKE_SYSTEM_NAME}-COMPILER_ID-${CMAKE_SYSTEM_PROCESSOR}.cmake file
# So I guess I could factor things nicely into pieces, enabling this set of stuff to be
# generated & installed in a global (or user-global) location, right?
set(CMAKE_SYSTEM_PROCESSOR Adafruit-nRF52480)

set(targettriple arm-none-eabi)

# You can use CMAKE_HOST_* (SYSTEM/SYSTEM_NAME/SYST EM_VERSION/SYSTEM_PROCESSOR/WIN32/UNIX/APPLE)
# for host dependent stuff in here if you want...

# Compiler names

# *Prepended* to the search directories
if(CMAKE_HOST_WIN32)
  set(CMAKE_FIND_ROOT_PATH "c:/program files (x86)/Arm GNU Toolchain arm-none-eabi/11.2 2022.02" "c:/program files (x86)/Arduino/hardware/tools/arm")
  set(CMAKE_C_COMPILER "c:/program files (x86)/Arm GNU Toolchain arm-none-eabi/11.2 2022.02/bin/arm-none-eabi-gcc.exe")
  set(CMAKE_CXX_COMPILER "c:/program files (x86)/Arm GNU Toolchain arm-none-eabi/11.2 2022.02/bin/arm-none-eabi-g++.exe")
  set(ARDUINO_ADAFRUIT_DIR "$ENV{HOME}/AppData/Local/Arduino15/packages/adafruit")

# Docs say this is unnecessary for GNU toolchains...
# set (CMAKE_CXX_COMPILER g++)
elseif(CMAKE_HOST_APPLE)
  # Definitely wrong currently
  set(CMAKE_FIND_ROOT_PATH "$ENV{HOME}/Library/Arduino15/packages/adafruit/tools/arm-none-eabi-gcc/9-2019q4/")
  set(CMAKE_C_COMPILER "$ENV{HOME}/Library/Arduino15/packages/adafruit/tools/arm-none-eabi-gcc/9-2019q4/bin/arm-none-eabi-gcc")
  set(CMAKE_CXX_COMPILER "$ENV{HOME}/Library/Arduino15/packages/adafruit/tools/arm-none-eabi-gcc/9-2019q4/bin/arm-none-eabi-g++")
  set(ARDUINO_ADAFRUIT_DIR "$ENV{HOME}/Library/Arduino15/packages/adafruit")
elseif(CMAKE_HOST_UNIX)
  # Definitely wrong currently
  set(CMAKE_FIND_ROOT_PATH "/usr/local/bin" "/usr/bin")
endif()

set(CMAKE_C_COMPILER_TARGET ${targettriple})
set(CMAKE_CXX_COMPILER_TARGET ${targettriple})

# Skip tests, because the test requires not just compilation, but *linking*.
# In order to link, you need to build some of the hardware support libraries.
# Thus, it won't link, so the *compiler* test fails.
# BRILLIANT!
set(CMAKE_C_COMPILER_WORKS 1 CACHE INTERNAL "")
set(CMAKE_CXX_COMPILER_WORKS 1 CACHE INTERNAL "")

# adjust the default behavior of the FIND_XXX() commands:
# search programs in the host environment
# KBF: I think this shouldn't be "NEVER" because a number of programs are host-only things
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

# search headers and libraries in the target environment
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# Sure would be nice if I could do this and have it stick:
# set (CMAKE_CXX_SOURCE_FILE_EXTNEIONS c++;cc;cpp;cxx;ino;C;CPP;CXX)

# Need to add some flags, yeah?
set(BUILD_CORE_PATH "${ARDUINO_ADAFRUIT_DIR}/hardware/nrf52/1.3.0/cores/nRF5/")
set(BUILD_MCU cortex-m4)
set(BUILD_FLOAT_FLAGS "-mfloat-abi=hard -mfpu=fpv4-sp-d16 -u _printf_float")
set(BUILD_ARCH NRF52)
set(BUILD_F_CPU 64000000)
set(BUILD_SD_FWID 0x00B6)
set(BUILD_SD_VERSION 6.1.1)
set(BUILD_SD_NAME s140)
set(NORDIC_PATH "${BUILD_CORE_PATH}/nordic")
set(RTOS_PATH "${BUILD_CORE_PATH}/freertos")
set(COMPILER_LDFLAGS "-mcpu=${BUILD_MCU} -mthumb ${BUILD_FLOAT_FLAGS} -Wl,--cref -Wl,--check-sections -Wl,--gc-sections -Wl,--unresolved-symbols=report-all -Wl,--warn-common -Wl,--warn-section-align -Wl,--wrap=malloc -Wl,--wrap=free --specs=nano.specs --specs=nosys.specs")
set(RUNTIME_TOOLS_CMSIS_5_7_0_PATH "${ARDUINO_ADAFRUIT_DIR}/tools/CMSIS/5.7.0")
set(COMPILER_ARM_CMSIS_LDFLAGS "-L${RUNTIME_TOOLS_CMSIS_5_7_0_PATH}/CMSIS/DSP/Lib/GCC/ -larm_cortexM4lf_math")
set(COMPILER_CPP_FLAGS "-mcpu=${BUILD_MCU} -mthumb -g ${COMPILER_WARNING_FLAGS} ${BUILD_FLOAT_FLAGS} -ffunction-sections -fdata-sections -fno-threadsafe-statics -nostdlib --param max-inline-insns-single=500 -fno-rtti -fno-exceptions -MMD")
set(BUILD_FLAGS_NRF "${COMPILER_OPTIMIZATION_FLAG} ${BUILD_DEBUG_FLAGS} ${BUILD_LOGGER_FLAGS} ${BUILD_SYSVIEW_FLAGS} ${COMPILER_ARM_CMSIS_C_FLAGS}")

add_compile_definitions(
  F_CPU=${BUILD_F_CPU}
  ARDUINO=1819
  ARDUINO_NRF52840_ITSYBITSY
  ARDUINO_NRF52_ITSYBITSY
  ARDUINO_ARCH_${BUILD_ARCH}
  ARDUINO_BSP_VERSION="1.2.0"
  SOFTDEVICE_PRESENT
  ARDUINO_NRF52_ADAFRUIT
  NRF52_SERIES
  DDX_CC_TEE
  LFS_NAME_MAX=64
  NRF52840_XXAA
)
set(CMAKE_CPP_FLAGS "${COMPILER_CPP_FLAGS} ${BUILD_FLAGS_NRF}")
include_directories(
  AFTER
  ${BUILD_CORE_PATH}
  ${BUILD_CORE_PATH}/../../variants/itsybitsy_nrf52840_express
  ${NORDIC_PATH}
  ${NORDIC_PATH}/nrfx
  ${NORDIC_PATH}/nrfx/hal
  ${NORDIC_PATH}/nrfx/mdk
  ${NORDIC_PATH}/nrfx/soc
  ${NORDIC_PATH}/nrfx/drivers/include
  ${NORDIC_PATH}/nrfx/drivers/src
  ${NORDIC_PATH}/softdevice/${BUILD_SD_NAME}_nrf52_${BUILD_SD_VERSION}_API/include
  ${NORDIC_PATH}/softdevice/${BUILD_SD_NAME}_nrf52_${BUILD_SD_VERSION}_API/include/nrf52
  ${RTOS_PATH}/Source/include
  ${RTOS_PATH}/config
  ${RTOS_PATH}/portable/GCC/nrf52
  ${RTOS_PATH}/portable/CMSIS/nrf52
  ${BUILD_CORE_PATH}/sysview/SEGGER
  ${BUILD_CORE_PATH}/sysview/Config
  ${RUNTIME_PLATFORM_PATH}/libraries/Adafruit_TinyUSB_Arduino/src/arduino
  ${RUNTIME_TOOLS_CMSIS_5_7_0_PATH}/CMSIS/Core/Include/
  ${RUNTIME_TOOLS_CMSIS_5_7_0_PATH}/CMSIS/DSP/Include/
)
link_directories(AFTER
 ${BUILD_CORE_PATH}/linker
 ${RUNTIME_TOOLS_CMSIS_5_7_0_PATH}/CMSIS/DSP/Lib/GCC/
)
# ${COMPILER_CPP_FLAGS}
# ${BUILD_FLAGS_NRF} ${SYS_INCLUDES}
set(CMAKE_EXE_LINKER_FLAGS
  "-Ofast -Wl,--gc-sections -save-temps -Tnrf52840_s140_v6.ld -Wl,-Map,ye-old-map-file.map ${COMPILER_LDFLAGS} -lm -Wl,--start-group ${COMPILER_ARM_CMSIS_LDFLAGS} -Wl,--end-group")

# "${BUILD_PATH}/system.a"
# ${COMPILER_LIBRARIES_LDFLAGS}
# -Wl,--end-group

repository: kevinfrei/FreiKey

repo_name: kevinfrei/FreiKey

extension: cmake


text:
// Copyright (c) 2018 HyperHQ Inc.
//
// SPDX-License-Identifier: Apache-2.0
//

package template

import (
	"context"
	"fmt"
	"os"
	"runtime"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"

	vc "github.com/kata-containers/kata-containers/src/runtime/virtcontainers"
	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/mock"
)

const testDisabledAsNonRoot = "Test disabled as requires root privileges"

func TestTemplateFactory(t *testing.T) {
	// template is broken on arm64, so, temporarily disable it on arm64
	if runtime.GOARCH == "arm64" || os.Geteuid() != 0 {
		t.Skip(testDisabledAsNonRoot)
	}

	assert := assert.New(t)

	templateWaitForAgent = 1 * time.Microsecond

	testDir := t.TempDir()

	hyperConfig := vc.HypervisorConfig{
		KernelPath: testDir,
		ImagePath:  testDir,
	}
	vmConfig := vc.VMConfig{
		HypervisorType:   vc.MockHypervisor,
		HypervisorConfig: hyperConfig,
	}

	err := vmConfig.Valid()
	assert.Nil(err)

	ctx := context.Background()

	url, err := mock.GenerateKataMockHybridVSock()
	assert.NoError(err)
	defer mock.RemoveKataMockHybridVSock(url)
	vc.MockHybridVSockPath = url

	hybridVSockTTRPCMock := mock.HybridVSockTTRPCMock{}
	err = hybridVSockTTRPCMock.Start(url)
	assert.NoError(err)
	defer hybridVSockTTRPCMock.Stop()

	// New
	f, err := New(ctx, vmConfig, testDir)
	assert.Nil(err)

	// Config
	assert.Equal(f.Config(), vmConfig)

	// GetBaseVM
	vm, err := f.GetBaseVM(ctx, vmConfig)
	assert.Nil(err)

	err = vm.Stop(ctx)
	assert.Nil(err)

	// Fetch
	tt := template{
		statePath: testDir,
		config:    vmConfig,
	}

	assert.Equal(tt.Config(), vmConfig)

	err = tt.checkTemplateVM()
	assert.Error(err)

	_, err = os.Create(tt.statePath + "/memory")
	assert.Nil(err)
	err = tt.checkTemplateVM()
	assert.Error(err)

	_, err = os.Create(tt.statePath + "/state")
	assert.Nil(err)
	err = tt.checkTemplateVM()
	assert.Nil(err)

	err = tt.createTemplateVM(ctx)
	assert.Nil(err)

	vm, err = tt.GetBaseVM(ctx, vmConfig)
	assert.Nil(err)

	err = vm.Stop(ctx)
	assert.Nil(err)

	vm, err = f.GetBaseVM(ctx, vmConfig)
	assert.Nil(err)

	err = vm.Stop(ctx)
	assert.Nil(err)

	err = tt.createTemplateVM(ctx)
	assert.Nil(err)

	vm, err = tt.GetBaseVM(ctx, vmConfig)
	assert.Nil(err)

	err = vm.Stop(ctx)
	assert.Nil(err)

	vm, err = f.GetBaseVM(ctx, vmConfig)
	assert.Nil(err)

	err = vm.Stop(ctx)
	assert.Nil(err)

	// make tt.statePath is busy
	os.Chdir(tt.statePath)

	// CloseFactory, there is no need to call tt.CloseFactory(ctx)
	f.CloseFactory(ctx)

	//umount may take more time. Check periodically if the mount exists
	waitTime, delay := 20, 1*time.Second
	for check := waitTime; check > 0; {
		// expect tt.statePath not exist, if exist, it means this case failed.
		_, err = os.Stat(tt.statePath)
		if err != nil {
			break
		}
		check -= 1
		time.Sleep(delay)
	}
	assert.True(os.IsNotExist(err), fmt.Sprintf("mount still present after waiting %d seconds", waitTime))
}

repository: kata-containers/kata-containers

repo_name: kata-containers/kata-containers

gha_language: Rust


text:
file(REMOVE_RECURSE
  "CMakeFiles/03_DateTime.dir/03.TimeCalculation.cpp.obj"
  "03_DateTime.pdb"
  "03_DateTime.exe"
  "03_DateTime.exe.manifest"
  "lib03_DateTime.dll.a"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/03_DateTime.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

repository: bozhikovstanislav/Cpp-SoftUni

repo_name: bozhikovstanislav/Cpp-SoftUni


text:
---
---

@article{Shen2021CoCAttAC,
  abbr={2021CoCAtt},
  title={CoCAtt: A Cognitive-Conditioned Driver Attention Dataset},
  author={Yuan Shen and Niviru Wijayaratne and Pranav Sriram and Aamir Hasan and Peter Du and Katherine Rose Driggs-Campbell},
  journal={ArXiv},
  year={2021},
  pdf={https://arxiv.org/pdf/2111.10014},
  abstract={The task of driver attention prediction has drawn considerable interest among researchers in robotics and the autonomous vehicle industry. Driver attention prediction can play an instrumental role in mitigating and preventing high-risk events, like collisions and casualties. However, existing driver attention prediction models neglect the distraction state and intention of the driver, which can significantly influence how they observe their surroundings. To address these issues, we present a new driver attention dataset, CoCAtt (Cognitive-Conditioned Attention). Unlike previous driver attention datasets, CoCAtt includes per-frame annotations that describe the distraction state and intention of the driver. In addition, the attention data in our dataset is captured in both manual and autopilot modes using eye-tracking devices of different resolutions. Our results demonstrate that incorporating the above two driver states into attention modeling can improve the performance of driver attention prediction. To the best of our knowledge, this work is the first to provide autopilot attention data. Furthermore, CoCAtt is currently the largest and the most diverse driver attention dataset in terms of autonomy levels, eye tracker resolutions, and driving scenarios.},
  selected={true}
}

@inproceedings{shen2021autopreview,
  abbr={2021AutoPrev},
  title={AutoPreview: A Framework for Autopilot Behavior Understanding},
  author={Shen, Yuan and Wijayaratne, Niviru and Du, Peter and Jiang, Shanduojiao and Driggs-Campbell, Katherine},
  booktitle={Extended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems},
  pages={1--6},
  year={2021},
  abstract={The behavior of self driving cars may differ from people expectations, (e.g. an autopilot may unexpectedly relinquish control). This expectation mismatch can cause potential and existing users to distrust self driving technology and can increase the likelihood of accidents. We propose a simple but effective framework, AutoPreview, to enable consumers to preview a target autopilot potential actions in the real world driving context before deployment. For a given target autopilot, we design a delegate policy that replicates the target autopilot behavior with explainable action representations, which can then be queried online for comparison and to build an accurate mental model. To demonstrate its practicality, we present a prototype of AutoPreview integrated with the CARLA simulator along with two potential use cases of the framework. We conduct a pilot study to investigate whether or not AutoPreview provides deeper understanding about autopilot behavior when experiencing a new autopilot policy for the first time. Our results suggest that the AutoPreview method helps users understand autopilot behavior in terms of driving style comprehension, deployment preference, and exact action timing prediction.},
  pdf={https://arxiv.org/pdf/2102.13034},
  selected={true}
}

gha_language: HTML


text:
require gsettings-desktop-schemas.inc
SRC_URI[archive.md5sum] = "370610e29b37d063ede3ef0f29c06eb9"
SRC_URI[archive.sha256sum] = "4cb4cd7790b77e5542ec75275237613ad22f3a1f2f41903a298cf6cc996a9167"

repository: nicepixels/citadel

repo_name: nicepixels/citadel


text:
DESCRIPTION = "Webkit browser engine, EFL edition"
LICENSE = "GPL"
DEPENDS = "icu libxslt sqlite3 gperf-native bison-native flex-native jpeg \
           libpng libxt fontconfig cairo freetype glib-2.0 libsoup-2.4 \
           libxml2 pango eina ecore evas edje"

SRCREV = "65655"
PV = "1.1.11+svnr${SRCPV}"
PR = "r9"

SRCREV_FORMAT = "webcore-rwebkit"

SRC_URI = "\
  svn://svn.webkit.org/repository/webkit/trunk/;module=JavaScriptCore;proto=http;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=JavaScriptGlue;proto=http;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=WebCore;proto=http;name=webcore;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=WebKit;proto=http;name=webkit;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=WebKitLibraries;proto=http;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=WebKitTools;proto=http;subdir=src \
  svn://svn.webkit.org/repository/webkit/trunk/;module=cmake;proto=http;subdir=src \
  file://cmakeconfig.h.cmake \
  file://CMakeLists.txt \
  file://install-efl-launcher.patch \
 "

S = "${WORKDIR}/src"

inherit cmake lib_package pkgconfig

#EXTRA_OECMAKE = "-DPORT=Efl"
EXTRA_OECMAKE = "-DPORT=Efl -DSHARED_CORE=ON"

do_unpack_append() {
	bb.build.exec_func('do_move_files', d)
}

do_move_files() {
	mv "${WORKDIR}/cmakeconfig.h.cmake" "${S}"
	mv "${WORKDIR}/CMakeLists.txt" "${S}"
}

LEAD_SONAME = "libewebkit.so"
PACKAGES =+ "${PN}launcher-dbg ${PN}launcher"

FILES_${PN} += "${datadir}/webkit-1.0/theme/default.edj"
FILES_${PN}launcher = "${bindir}/EWebLauncher"
FILES_${PN}launcher-dbg = "${bindir}/.debug/EWebLauncher"

repository: libo/openembedded

repo_name: libo/openembedded


text:
// Copyright 2021 the Exposure Notifications Server authors
//
// 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 secrets

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"
	"time"
)

func init() {
	RegisterManager("FILESYSTEM", NewFilesystem)
}

// Compile-time check to verify implements interface.
var _ SecretVersionManager = (*Filesystem)(nil)

// Filesystem is a local filesystem based secret manager, primarily used for
// local development and testing.
type Filesystem struct {
	root string
	mu   sync.Mutex
}

// NewFilesystem creates a new filesystem-based secret manager.
func NewFilesystem(ctx context.Context, cfg *Config) (SecretManager, error) {
	root := cfg.FilesystemRoot
	if root != "" {
		if err := os.MkdirAll(root, 0o700); err != nil {
			return nil, err
		}
	}

	return &Filesystem{
		root: root,
	}, nil
}

// GetSecretValue returns the secret if it exists, otherwise an error.
func (sm *Filesystem) GetSecretValue(ctx context.Context, name string) (string, error) {
	sm.mu.Lock()
	defer sm.mu.Unlock()

	pth := filepath.Join(sm.root, name)
	b, err := os.ReadFile(pth)
	if err != nil {
		return "", fmt.Errorf("failed to read file: %w", err)
	}
	return string(b), nil
}

// CreateSecretVersion creates a new secret version on the given parent with the
// provided data. It returns a reference to the created version.
func (sm *Filesystem) CreateSecretVersion(ctx context.Context, parent string, data []byte) (string, error) {
	sm.mu.Lock()
	defer sm.mu.Unlock()

	root := filepath.Join(sm.root, parent)
	if err := os.MkdirAll(root, 0o700); err != nil {
		return "", fmt.Errorf("failed to create parent for secret version: %w", err)
	}

	version := strconv.FormatInt(time.Now().UnixNano(), 10)
	pth := filepath.Join(root, version)
	if err := os.WriteFile(pth, data, 0o600); err != nil {
		return "", fmt.Errorf("failed to create secret file: %w", err)
	}
	return strings.TrimPrefix(strings.TrimPrefix(pth, sm.root), string(filepath.Separator)), nil
}

// DestroySecretVersion destroys the secret version with the given name. If the
// version does not exist, no action is taken.
func (sm *Filesystem) DestroySecretVersion(ctx context.Context, name string) error {
	sm.mu.Lock()
	defer sm.mu.Unlock()

	pth := filepath.Join(sm.root, name)
	if err := os.Remove(pth); err != nil && !os.IsNotExist(err) {
		return fmt.Errorf("failed to destroy secret version: %w", err)
	}
	return nil
}


text:
set_property(DIRECTORY PROPERTY VS_GLOBAL_SECTION_POST_ExtensibilityGlobals Key1=Value1)
set_property(DIRECTORY PROPERTY VS_GLOBAL_SECTION_POST_TestSec Key2=Value2 Key3=Value3)


text:
#
# base recipe: meta/recipes-devtools/dpkg/dpkg_1.17.4.bb
# base branch: daisy
#

require dpkg.inc
PR = "${INC_PR}.0"

inherit systemd

do_install_append () {
	rm ${D}${bindir}/update-alternatives
	if [ "${PN}" = "dpkg-native" ]; then
		sed -i -e 's|^#!.*${bindir}/perl-native.*/perl|#!/usr/bin/env nativeperl|' ${D}${bindir}/dpkg-*
	else
		sed -i -e 's|^#!.*${bindir}/perl-native.*/perl|#!/usr/bin/env perl|' ${D}${bindir}/dpkg-*
	fi

	if ${@base_contains('DISTRO_FEATURES','sysvinit','false','true',d)};then
		install -d ${D}${systemd_unitdir}/system
		install -m 0644 ${WORKDIR}/dpkg-configure.service ${D}${systemd_unitdir}/system/
		sed -i -e 's,@BASE_BINDIR@,${base_bindir},g' \
			-e 's,@SYSCONFDIR@,${sysconfdir},g' \
			-e 's,@BINDIR@,${bindir},g' \
			-e 's,@SYSTEMD_UNITDIR@,${systemd_unitdir},g' \
			${D}${systemd_unitdir}/system/dpkg-configure.service
	fi

	# Install configuration files and links follow Debian
	install -d ${D}${sysconfdir}/cron.daily
	install -d ${D}${sysconfdir}/logrotate.d
	install -m 0644 ${S}/debian/dpkg.cfg ${D}${sysconfdir}/${DPN}/
	install -m 0755 ${S}/debian/dpkg.cron.daily ${D}${sysconfdir}/cron.daily/
	install -m 0644 ${S}/debian/dpkg.logrotate ${D}${sysconfdir}/logrotate.d/

	ln -s ../bin/dpkg-divert ${D}${sbindir}/dpkg-divert
	ln -s ../bin/dpkg-statoverride ${D}${sbindir}/dpkg-statoverride
}

PACKAGES += "${PN}-perl"
FILES_${PN}-perl = "${libdir}/perl"

DEBIANNAME_${PN}-perl = "lib${PN}-perl"

repository: soderstrom-rikard/meta-debian

repo_name: soderstrom-rikard/meta-debian

branch_name: refs/heads/daisy


text:
DESCRIPTION = "Apache Portable Runtime (APR) companion library"
SECTION = "libs"
DEPENDS = "apr expat gdbm"
LICENSE = "Apache"
HOMEPAGE = "http://apr.apache.org"
PR = "r1"

SRC_URI = "${APACHE_MIRROR}/apr/${P}.tar.gz \
           file://gen_uri_delims.patch \
           file://uri_delims.h"

EXTRA_OECONF = "--with-apr=${STAGING_BINDIR_CROSS} --with-dbm=gdbm --with-gdbm=${STAGING_DIR_HOST}${layout_prefix} --with-expat=${STAGING_DIR_HOST}${layout_prefix}"

inherit autotools lib_package binconfig

do_configure() {
	cp ${S}/../uri_delims.h ${S}/uri/.
	oe_runconf
}

SRC_URI[md5sum] = "8e9cc71a1303b67b3278fbeab9799f2e"
SRC_URI[sha256sum] = "5768fcc4d38fa6f811b0a89e2ef450d0f52688ff9263e548819adb096fbfc9c3"


text:
package main

import (
	"flag"
	"fmt"
)

func main() {
	filename := flag.String("f", "", "Name of the demo file")

	flag.Parse()

	fmt.Println(*filename)

	// use DemoFileDump to open
	var demo DemoFileDump
	if demo.Open(*filename) == true {
		fmt.Println("Demo file is good")

		demo.DoDump()
	}
}

repository: mattcan/csgodem

repo_name: mattcan/csgodem


text:
@Book{xie2015,
  title = {Dynamic Documents with {R} and knitr},
  author = {Yihui Xie},
  publisher = {Chapman and Hall/CRC},
  address = {Boca Raton, Florida},
  year = {2015},
  edition = {2nd},
  note = {ISBN 978-1498716963},
  url = {http://yihui.name/knitr/},
}

@article{spence2005no,
  title={No humble pie: The origins and usage of a statistical chart},
  author={Spence, Ian},
  journal={Journal of Educational and Behavioral Statistics},
  volume={30},
  number={4},
  pages={353--368},
  year={2005},
  publisher={Sage Publications Sage CA: Los Angeles, CA}
}

@article{shanon1949mathematical,
  title={The mathematical theory of information},
  author={Shanon, CE and Weaver, W},
  journal={Urbana: University of},
  year={1949}
}


text:
TIGRE

Ander Biguri, Manjit Dosanjh, Steven Hancock and Manuchehr Soleimani
TIGRE: A MATLAB-GPU toolbox for CBCT image reconstruction
Biomedical Physics & Engineering Express, 2(5):055010 ,2016

@article{TIGRE,
  author={Ander Biguri and Manjit Dosanjh and Steven Hancock and Manuchehr Soleimani},
  title={TIGRE: a MATLAB-GPU toolbox for CBCT image reconstruction},
  journal={Biomedical Physics & Engineering Express},
  volume={2},
  number={5},
  pages={055010},
  url={http://stacks.iop.org/2057-1976/2/i=5/a=055010},
  year={2016},
  abstract={In this article the Tomographic Iterative GPU-based Reconstruction (TIGRE) Toolbox, a MATLAB/CUDA toolbox for fast and accurate 3D x-ray image reconstruction, is presented. One of the key features is the implementation of a wide variety of iterative algorithms as well as FDK, including a range of algorithms in the SART family, the Krylov subspace family and a range of methods using total variation regularization. Additionally, the toolbox has GPU-accelerated projection and back projection using the latest techniques and it has a modular design that facilitates the implementation of new algorithms. We present an overview of the structure and techniques used in the creation of the toolbox, together with two usage examples. The TIGRE Toolbox is released under an open source licence, encouraging people to contribute.}
}

ASD_POCS

E.Y. Sidky and X. Pan.
Image reconstruction in circular cone-beam computed tomography by constrained, total-variation minimization.
Physics in Medicine and Biology, 53(17):4777, 2008.
DOI: 10.1088/0031-9155/53/17/021

@article{ASD_POCS,
  author={Sidky, E.Y. and Pan, X.},
  title={Image reconstruction in circular cone-beam computed tomography by constrained, total-variation minimization},
  journal={Physics in Medicine and Biology},
  volume={53},
  number={17},
  pages={4777},
  url={http://stacks.iop.org/0031-9155/53/i=17/a=021},
  year={2008},
  abstract={An iterative algorithm, based on recent work in compressive sensing, is developed for volume image reconstruction from a circular cone-beam scan. The algorithm minimizes the total variation (TV) of the image subject to the constraint that the estimated projection data is within a specified tolerance of the available data and that the values of the volume image are non-negative. The constraints are enforced by the use of projection onto convex sets (POCS) and the TV objective is minimized by steepest descent with an adaptive step-size. The algorithm is referred to as adaptive-steepest-descent-POCS (ASD-POCS). It appears to be robust against cone-beam artifacts, and may be particularly useful when the angular range is limited or when the angular sampling rate is low. The ASD-POCS algorithm is tested with the Defrise disk and jaw computerized phantoms. Some comparisons are performed with the POCS and expectation-maximization (EM) algorithms. Although the algorithm is presented in the context of circular cone-beam image reconstruction, it can also be applied to scanning geometries involving other x-ray source trajectories.}
}

B_ASD_POCS_beta

H. Xue, L. Zhang, Z. Cheng, Y. Xing and Y. Xiao.
An improved tv minimization algorithm for incomplete data problem in computer tomography.
Nuclear Science Symposium Conference Record (NSS/MIC), 2010 IEEE, pages 2621-2624, Oct 2010
DOI: 10.1109/NSSMIC.2010.5874264

@INPROCEEDINGS{B_ASD_POCS_beta,
author={H. Xue and L. Zhang and Z. Cheng and Y. Xing and Y. Xiao},
booktitle={Nuclear Science Symposium Conference Record (NSS/MIC), 2010 IEEE},
title={An improved TV minimization algorithm for incomplete data problem in computer tomography},
year={2010},
pages={2621-2624},
keywords={computerised tomography;image reconstruction;iterative methods;medical image processing;minimisation;B-POCS-TV-$\beta$;Bregman iteration;POCS-TV method;TV minimization algorithm;computer tomography;convergence speed;image quality;incomplete data problem;reconstruction error;total variation;Computed tomography;Convergence;Image reconstruction;Minimization;Optimization;TV;B-POCS-TV-$\beta$;Computer tomography (CT);POCS-TV;TV minimization;few-view;limited-angle},
doi={10.1109/NSSMIC.2010.5874264},
ISSN={1095-7863},
month={Oct}
}

CGLS

Åke Björck
Numerical Methods for Least Squares Problems
Society for Industrial and Applied Mathematics, 1996
DOI: 10.1137/1.9781611971484

@book{doi:10.1137/1.9781611971484,
author = {Björck, Å.},
title = {Numerical Methods for Least Squares Problems},
publisher = {Society for Industrial and Applied Mathematics},
year = {1996},
doi = {10.1137/1.9781611971484},
address = {},
edition   = {},
URL = {http://epubs.siam.org/doi/abs/10.1137/1.9781611971484},
eprint = {http://epubs.siam.org/doi/pdf/10.1137/1.9781611971484}
}

FDK

L.A. Feldkamp, L.C. Davis and J.W. Kress.
Practical cone-beam algorithm.
J. Opt.Soc. Am. A, 1(6):612{619, Jun 1984.
DOI: 10.1364/JOSAA.1.000612

@article{FDK,
author = {L.A. Feldkamp and L.C. Davis and J.W. Kress},
journal = {J. Opt. Soc. Am. A},
keywords = {},
number = {6},
pages = {612--619},
publisher = {OSA},
title = {Practical cone-beam algorithm},
volume = {1},
month = {Jun},
year = {1984},
url = {http://josaa.osa.org/abstract.cfm?URI=josaa-1-6-612},
doi = {10.1364/JOSAA.1.000612},
abstract = {A convolution-backprojection formula is deduced for direct reconstruction of a three-dimensional density function from a set of two-dimensional projections. The formula is approximate but has useful properties, including errors that are relatively small in many practical instances and a form that leads to convenient computation. It reduces to the standard fan-beam formula in the plane that is perpendicular to the axis of rotation and contains the point source. The algorithm is applied to a mathematical phantom as an example of its performance.},
}

OS_SART

Y. Censor and T. Elfving.
Block-iterative algorithms with diagonally scaled oblique projections for the linear feasibility problem.
SIAM Journal on Matrix Analysis and Applications, 24(1):40-58, 2002.
DOI: 10.1137/S089547980138705X

@article{OS_SART,
author = {Y. Censor and T. Elfving},
title = {Block-Iterative Algorithms with Diagonally Scaled Oblique Projections for the Linear Feasibility Problem},
journal = {SIAM Journal on Matrix Analysis and Applications},
volume = {24},
number = {1},
pages = {40-58},
year = {2002},
doi = {10.1137/S089547980138705X},
URL = { http://dx.doi.org/10.1137/S089547980138705X},
eprint = {  http://dx.doi.org/10.1137/S089547980138705X}
}

OSC_TV

D. Matenine, Y.s Goussard and P. Despres.
GPU-accelerated regularized iterative reconstruction for few-view cone beam CT.
Medical Physics, 42(4), 2015.
DOI: 10.1118/1.4914143

	@article{Matenine2015,
   author = "Matenine, D. and Goussard, Y.s and Despr\'es, P.",
   title = "{GPU}-accelerated regularized iterative reconstruction for few-view cone beam {CT}",
   journal = "Medical Physics",
   year = "2015",
   volume = "42",
   number = "4",
   eid = ,
   pages = "1505-1517",
   url = "http://scitation.aip.org/content/aapm/journal/medphys/42/4/10.1118/1.4914143",
   doi = "http://dx.doi.org/10.1118/1.4914143"
}

SART

A. H. Andersen and A. C. Kak.
Simultaneous algebraic reconstruction technique(SART): a superior implementation of the ART algorithm.
Ultrasonic imaging, 6(1):81-94, 1984
DOI: 10.1016/0161-7346(84)90008-7
@article{SART,
  title={Simultaneous algebraic reconstruction technique ({SART}): a superior implementation of the {ART} algorithm},
  author={Andersen, A.H. and Kak, A.C.},
  journal={Ultrasonic imaging},
  volume={6},
  number={1},
  pages={81--94},
  year={1984},
  publisher={SAGE Publications}
}

SART_TV

X. Jia, Y. Lou, J. Lewis, R. Li, X. Gu, C. Men, W.Y. Song and S.B. Jiang.
GPU based fast low-dose cone beam CT reconstruction via total variation.
Journal of X-ray Science and Technology, 19(2):139-154, 2011
DOI: 10.3233/XST-2011-0283
@article{SART_TV,
  title={{GPU}-based fast low-dose cone beam {CT} reconstruction via total variation},
  author={Jia, X. and Lou, Y. and Lewis, J. and Li, R. and Gu, X. and Men, C. and Song, W.Y. and Jiang, S.B.},
  journal={Journal of X-ray Science and Technology},
  volume={19},
  number={2},
  pages={139--154},
  year={2011},
  publisher={IOS Press}
}

SIRT

A. C. Kak and Malcolm Slaney
Principles of Computerized Tomographic Imaging
Society of Industrial and Applied Mathematics, 2001.
DOI: 10.1137/1.9780898719277

@book{SIRT,
   title = "Principles of computerized tomographic imaging",
   author = "Kak, Avinash C. and Slaney, Malcolm and IEEE Engineering in Medicine and Biology Society",
   publisher = "IEEE Press",
   address = "New York",
   url = "http://opac.inria.fr/record=b1086573",
   isbn = "0-87942-198-3",
   note = "Published under the sponsorship of the IEEE Engineering in Medicine and Biology Society.",
   year = 1988
}

sheppLogan3D

If the 'yu-ye-wang' option is used:

Hengyong Yu, Yangbo Ye and Ge Wang
Katsevich-type algorithms for variable radius spiral cone-beam CT
Proceedings of SPIE - The International Society for Optical Engineering. 10/2004; 5535:550-557.
DOI: 10.1117/12.559300

@inproceedings{sheppLogan3D,
  title={Katsevich-type algorithims for variable radius spiral cone-beam CT},
  author={Yu, Hengyong and Ye, Yangbo and Wang, Ge},
  booktitle={Optical Science and Technology, the SPIE 49th Annual Meeting},
  pages={550--557},
  year={2004},
  organization={International Society for Optics and Photonics}
}

phantom3dAniso

If the 'yu-ye-wang' option is used:

Hengyong Yu, Yangbo Ye and Ge Wang
Katsevich-type algorithms for variable radius spiral cone-beam CT
Proceedings of SPIE - The International Society for Optical Engineering. 10/2004; 5535:550-557.
DOI: 10.1117/12.559300

@inproceedings{sheppLogan3D,
  title={Katsevich-type algorithims for variable radius spiral cone-beam CT},
  author={Yu, Hengyong and Ye, Yangbo and Wang, Ge},
  booktitle={Optical Science and Technology, the SPIE 49th Annual Meeting},
  pages={550--557},
  year={2004},
  organization={International Society for Optics and Photonics}
}

Measure_Quality

Please refer to the individual parameters used instead of the function itself

@notabib{
Please refer to the individual parameters used instead of the function itself
}

RMSE

J-H Kim,J Nuyts,A Kyme,Z Kuncic and R Fulton
A rigid motion correction method for helical computed tomography (CT)
Physics in Medicine & Biology, Phys. Med. Biol. 60 (2015) 2047–2073
DOI:10.1088/0031-9155/60/5/2047

@article{kim2015rigid,
  title={A rigid motion correction method for helical computed tomography (CT)},
  author={Kim, JH and Nuyts, Johan and Kyme, A and Kuncic, Z and Fulton, R},
  journal={Physics in medicine and biology},
  volume={60},
  number={5},
  pages={2047},
  year={2015},
  publisher={IOP Publishing}
}

CC

J-H Kim,J Nuyts,A Kyme,Z Kuncic and R Fulton
A rigid motion correction method for helical computed tomography (CT)
Physics in Medicine & Biology, Phys. Med. Biol. 60 (2015) 2047–2073
DOI:10.1088/0031-9155/60/5/2047

@article{kim2015rigid,
  title={A rigid motion correction method for helical computed tomography (CT)},
  author={Kim, JH and Nuyts, Johan and Kyme, A and Kuncic, Z and Fulton, R},
  journal={Physics in medicine and biology},
  volume={60},
  number={5},
  pages={2047},
  year={2015},
  publisher={IOP Publishing}
}

MSSIM

J-H Kim,J Nuyts,A Kyme,Z Kuncic and R Fulton
A rigid motion correction method for helical computed tomography (CT)
Physics in Medicine & Biology, Phys. Med. Biol. 60 (2015) 2047–2073
DOI:10.1088/0031-9155/60/5/2047

@article{kim2015rigid,
  title={A rigid motion correction method for helical computed tomography (CT)},
  author={Kim, JH and Nuyts, Johan and Kyme, A and Kuncic, Z and Fulton, R},
  journal={Physics in medicine and biology},
  volume={60},
  number={5},
  pages={2047},
  year={2015},
  publisher={IOP Publishing}
}

UQI

Wang, Zhou, and Alan C. Bovik.
A universal image quality index.
IEEE signal processing letters 9, no. 3 (2002): 81-84.
DOI:

@article{wang2002universal,
  title={A universal image quality index},
  author={Wang, Zhou and Bovik, Alan C},
  journal={IEEE signal processing letters},
  volume={9},
  number={3},
  pages={81--84},
  year={2002},
  publisher={IEEE}
}

SophiaBeads data

S. B. Coban and S. A. McDonald
SophiaBeads Dataset Project.
Zenodo (2015)
DOI: http://dx.doi.org/10.5281/zenodo.16474.

@misc{coban_2015_16474,
  author       = {Coban, S. B. and
                  McDonald, S. A.},
  title        = {SophiaBeads Dataset Project},
  month        = mar,
  year         = 2015,
  doi          = {10.5281/zenodo.16474},
  url          = {http://dx.doi.org/10.5281/zenodo.16474}
}

SophiaBeads code

S. B. Coban
SophiaBeads Dataset Project Codes
Zenodo (2015)
DOI: http://dx.doi.org/10.5281/zenodo.16539

@misc{coban_2015_16539,
  author       = {Coban, S. B.},
  title        = {SophiaBeads Dataset Project Codes},
  month        = apr,
  year         = 2015,
  doi          = {10.5281/zenodo.16539},
  url          = {http://dx.doi.org/10.5281/zenodo.16539}
}

MLEM

J. M. Ollinger
Maximum-likelihood reconstruction of transmission images in emission computed tomography via the EM algorithm
IEEE Transactions on Medical Imaging, 12 (1994) p89-101
DOI: 10.1109/42.276147

@article{ollinger1994maximum,
  title={Maximum-likelihood reconstruction of transmission images in emission computed tomography via the EM algorithm},
  author={Ollinger, John M},
  journal={IEEE transactions on medical imaging},
  volume={13},
  number={1},
  pages={89--101},
  year={1994},
  publisher={IEEE}
}

headPhantom

A. Aichert, M. Manhart, B. Navalpakkam, R. Grimm, J. Hutter, A. Maier, J. Hornegger, A. Doerfler
A Realistic Digital Phantom for Perfusion C-Arm CT Based on MRI Data
2013 IEEE Nuclear Science Symposium and Medical Imaging Conference Record (NSS/MIC), Seoul, Korea, 2013.

@inproceedings{aichert2013realistic,
  title={A realistic digital phantom for perfusion C-arm CT based on MRI data},
  author={Aichert, Andr{\'e} and Manhart, Michael T and Navalpakkam, Bharath K and Grimm, Robert and Hutter, Jana and Maier, Andreas and Hornegger, Joachim and Doerfler, Arnd},
  booktitle={2013 IEEE Nuclear Science Symposium and Medical Imaging Conference (2013 NSS/MIC)},
  pages={1--2},
  year={2013},
  organization={IEEE}
}

End of Bib (leave this here)

repository: CERN/TIGRE

repo_name: CERN/TIGRE

gha_language: MATLAB


text:
@article{qin2003survey,
  title={A survey of industrial model predictive control technology},
  author={Qin, S Joe and Badgwell, Thomas A},
  journal={Control engineering practice},
  volume={11},
  number={7},
  pages={733--764},
  year={2003},
  publisher={Elsevier}
}

@incollection{qin2000overview,
  title={An overview of nonlinear model predictive control applications},
  author={Qin, S Joe and Badgwell, Thomas A},
  booktitle={Nonlinear model predictive control},
  pages={369--392},
  year={2000},
  publisher={Springer}
}
@article{ohtsuka2004continuation,
  title={A continuation/GMRES method for fast computation of nonlinear receding horizon control},
  author={Ohtsuka, Toshiyuki},
  journal={Automatica},
  volume={40},
  number={4},
  pages={563--574},
  year={2004},
  publisher={Elsevier}
}

@book{boyd2004convex,
  title={Convex optimization},
  author={Boyd, S.P. and Vandenberghe, L.},
  year={2004},
  publisher={Cambridge Univ Pr}
}

@article{shimizu2009real,
  title={A real-time algorithm for nonlinear receding horizon control using multiple shooting and continuation/Krylov method},
  author={Shimizu, Yuichi and Ohtsuka, Toshiyuki and Diehl, Moritz},
  journal={International Journal of Robust and Nonlinear Control},
  volume={19},
  number={8},
  pages={919--936},
  year={2009},
  publisher={Wiley Online Library}
}

@article{seguchi2003nonlinear,
  title={Nonlinear receding horizon control of an underactuated hovercraft},
  author={Seguchi, Hiroaki and Ohtsuka, Toshiyuki},
  journal={International journal of robust and nonlinear control},
  volume={13},
  number={3-4},
  pages={381--398},
  year={2003},
  publisher={Wiley Online Library}
}

@incollection{diehl2009efficient,
  title={Efficient numerical methods for nonlinear MPC and moving horizon estimation},
  author={Diehl, Moritz and Ferreau, Hans Joachim and Haverbeke, Niels},
  booktitle={Nonlinear model predictive control},
  pages={391--417},
  year={2009},
  publisher={Springer}
}

@inproceedings{verschueren2014towards,
  title={Towards time-optimal race car driving using nonlinear MPC in real-time},
  author={Verschueren, Robin and De Bruyne, Stijn and Zanon, Mario and Frasch, Janick V and Diehl, Moritz},
  booktitle={Decision and Control (CDC), 2014 IEEE 53rd Annual Conference on},
  pages={2505--2510},
  year={2014},
  organization={IEEE}
}

repository: SymbolicNMPC/NMPC-Toolkit

repo_name: SymbolicNMPC/NMPC-Toolkit


text:
@Book{latexbook,
  edition =	 {2nd},
  publisher =	 {Addison-Wesley},
  year =	 1994,
  title =	 {{\LaTeX, a document preparation system}},
  shorttitle =	 {{\LaTeX book}},
  author =	 {Leslie Lamport},
  shortauthor =	 {Lamport},
  address =	 {Reading, MA},
  key =		 {0-201-52983-1}
}

@Book{companion,
  key =		 {0-201-36299-6},
  year =	 1994,
  author =	 {Frank Mittelbach and Michel Goossens and Johannes
                  Braams and David Carlisle and Chris Rowley},
  shortauthor =	 {Mittelbach \textit{et al}.},
  edition =	 {2nd},
  publisher =	 {Addison-Wesley},
  title =	 {{The \LaTeX\ Companion}},
  shorttitle =	 {{Companion}},
  address =	 {Reading, MA}
}

@Book{texbook,
  title =	 {The {\TeX book}},
  shorttitle =	 {{\TeX book}},
  address =	 {Reading, MA},
  year =	 1986,
  author =	 {Donald Knuth},
  shortauthor =	 {Knuth},
  publisher =	 {Addison-Wesley}
}

@TechReport{bibtex,
  author =	 {Oren Patashnik},
  shortauthor =	 {Patashnik},
  title =	 {{BIB\TeX ing}},
  shorttitle =	 {{BIB\TeX ing}},
  institution =	 {\TeX\ Users Group},
  address =	 {Portland, OR},
  year =	 1988,
  month =	 {Feb}
}

@Book{graphics,
  author =	 {Michel Goossens and Sebastian Rahtz and Frank
                  Mittelbach},
  title =	 {The {\LaTeX} Graphics Companion},
  shorttitle =	 {Graphics Companion},
  publisher =	 {Addison-Wesley},
  address =	 {Reading, MA},
  pages =	 554,
  year =	 1997,
  isbn =	 {0-201-85469-4},
  bibdate =	 {Fri Jul 11 07:51:47 1997},
  series =	 {Tools and Techniques for Computer Typesetting},
  keywords =	 {LaTeX (Computer file); Computerized typesetting.;
                  PostScript (Computer program language); Scientific
                  illustration -- Computer programs.; Mathematics
                  printing -- Computer programs.; Technical publishing
                  -- Computer programs.}
}

@Book{web,
  author =	 {Michel Goossens and Sebastian Rahtz},
  title =	 {The {\LaTeX} {Web} companion},
  shorttitle =	 {Web Companion},
  publisher =	 {Addison-Wesley Longman},
  address =	 {Reading, MA},
  pages =	 522,
  year =	 1999,
  isbn =	 {0-201-43311-7},
  bibdate =	 {Thu Jun 03 09:32:08 1999},
  note =	 {With Eitan M. Gurari and Ross Moore and Robert
                  S. Sutor.},
  series =	 {Tools and Techniques for Computer Typesetting}
}

@TechReport{lshort,
  author =	 {Tobias Oetiker and Hubert Partl and Irene Hyna and
                  Elisabeth Schlegl},
  title =	 {The (Not So) Short Introduction to {\LaTeXe}},
  shorttitle =	 {`Short Introduction'},
  institution =	 {Comprehensive {\TeX} Archive Network},
  year =	 1999,
  number =	 {3.7},
  month =	 {Apr},
  address =	 {\texttt{http://www.ctan.org/}}
}

@Book{beginguide,
  author =	 {Peter Flynn},
  title =	 {Formatting Information --- a Beginner's Guide to
                  {\LaTeXe}},
  shorttitle =	 {`Beginner's Guide'},
  publisher =	 {Silmaril Consultants},
  year =	 2005,
  edition =	 {3.6},
  month =	 {April},
  address = 	 {\texttt{http://www.ctan.org/tex-archive/info/beginlatex/}}
}

repository: edwardtoday/latex-templates

repo_name: edwardtoday/latex-templates


text:
@MISC{cpuUtili,
	HOWPUBLISHED = "\url{http://www.brendangregg.com/blog/2017-05-09/cpu-utilization-is-wrong.html}",
	TITLE = "CPU Utilization is Wrong",
	AUTHOR = "Brendan Gregg",
	NOTE = "Access in 01/06/2019"
}
%https://apps2.mdp.ac.id/perpustakaan/ebook/Karya%20Umum/Portable_Shared_Memory_Parallel_Programming.pdf
@book{lumzLimitProcs,
author = {Barbara Chapman and Gabriele Jost and Ruud van der Pas},
year = {2008},
title = {Using OpenMP}
}


text:
@InProceedings{liu-gardner-belinkov-peters-smith:2019:NAACL,
  author    = {Liu, Nelson F.  and  Gardner, Matt  and  Belinkov, Yonatan  and  Peters, Matthew E.  and  Smith, Noah A.},
  title     = {Linguistic Knowledge and Transferability of Contextual Representations},
  booktitle = {Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies},
  year      = {2019}
}

repository: nelson-liu/website

repo_name: nelson-liu/website


text:
func canPartition(nums []int) bool {
    sum := 0
    for _, v := range nums {
    	sum += v
    }

    if sum % 2 != 0 {
    	return false
    }

   	target, n := sum/2, len(nums)
    f := make([]bool, target+1)
    f[0] = true

    for i := 0; i < n; i++ {
    	if nums[i] > target {
    		continue
    	}

    	if f[target - nums[i]] {
    		return true
    	}

    	for j := target-1; j >= nums[i]; j-- {
    		if f[j - nums[i]] {
    			f[j] = true
    		}
    	}
    }

    return f[target]
}


text:
@Article{Agrawal2018,
author="Agrawal, Vishal
and Gautam, Sachin S.",
title="IGA: A Simplified Introduction and Implementation Details for Finite Element Users",
journal="Journal of The Institution of Engineers (India): Series C",
year="2018",
month="May",
day="14",
abstract="Isogeometric analysis (IGA) is a recently introduced technique that employs the Computer Aided Design (CAD) concept of Non-uniform Rational B-splines (NURBS) tool to bridge the substantial bottleneck between the CAD and finite element analysis (FEA) fields. The simplified transition of exact CAD models into the analysis alleviates the issues originating from geometrical discontinuities and thus, significantly reduces the design-to-analysis time in comparison to traditional FEA technique. Since its origination, the research in the field of IGA is accelerating and has been applied to various problems. However, the employment of CAD tools in the area of FEA invokes the need of adapting the existing implementation procedure for the framework of IGA. Also, the usage of IGA requires the in-depth knowledge of both the CAD and FEA fields. This can be overwhelming for a beginner in IGA. Hence, in this paper, a simplified introduction and implementation details for the incorporation of NURBS based IGA technique within the existing FEA code is presented. It is shown that with little modifications, the available standard code structure of FEA can be adapted for IGA. For the clear and concise explanation of these modifications, step-by-step implementation of a benchmark plate with a circular hole under the action of in-plane tension is included.",
issn="2250-0553",
doi="10.1007/s40032-018-0462-6",
url="https://doi.org/10.1007/s40032-018-0462-6"
}

@book{Piegl:NurbsBook,
 author = {Piegl, Les and Tiller, Wayne},
 title = {The NURBS Book (2Nd Ed.)},
 year = {1997},
 isbn = {3-540-61545-8},
 publisher = {Springer-Verlag},
 address = {Berlin, Heidelberg},
}

@article{Milic2013,
 author = {Predrag Mili{\'c}, Dragan Marinkovi{\'c}},
 title = {Isogeometric Structural Analysis based on NURBS shape functions},
 journal = {FACTA UNIVERSITATIS},
 volume = "{11, No. 2}",
 year = {2013}
}

@article{HUGHES20054135,
title = "Isogeometric analysis: CAD, finite elements, NURBS, exact geometry and mesh refinement",
journal = "Computer Methods in Applied Mechanics and Engineering",
volume = "194",
number = "39",
pages = "4135 - 4195",
year = "2005",
issn = "0045-7825",
doi = "https://doi.org/10.1016/j.cma.2004.10.008",
url = "http://www.sciencedirect.com/science/article/pii/S0045782504005171",
author = "T.J.R. Hughes and J.A. Cottrell and Y. Bazilevs",
keywords = "NURBS, Finite element analysis, CAD, Structural analysis, Fluid dynamics, Mesh refinement, Convergence, Boundary layers, Internal layers, Geometry, Shells, -refinement, -refinement, -refinement",
abstract = "The concept of isogeometric analysis is proposed. Basis functions generated from NURBS (Non-Uniform Rational B-Splines) are employed to construct an exact geometric model. For purposes of analysis, the basis is refined and/or its order elevated without changing the geometry or its parameterization. Analogues of finite element h- and p-refinement schemes are presented and a new, more efficient, higher-order concept, k-refinement, is introduced. Refinements are easily implemented and exact geometry is maintained at all levels without the necessity of subsequent communication with a CAD (Computer Aided Design) description. In the context of structural mechanics, it is established that the basis functions are complete with respect to affine transformations, meaning that all rigid body motions and constant strain states are exactly represented. Standard patch tests are likewise satisfied. Numerical examples exhibit optimal rates of convergence for linear elasticity problems and convergence to thin elastic shell solutions. A k-refinement strategy is shown to converge toward monotone solutions for advection–diffusion processes with sharp internal and boundary layers, a very surprising result. It is argued that isogeometric analysis is a viable alternative to standard, polynomial-based, finite element analysis and possesses several advantages."
}

@article{NGUYEN201589,
title = "Isogeometric analysis: An overview and computer implementation aspects",
journal = "Mathematics and Computers in Simulation",
volume = "117",
pages = "89 - 116",
year = "2015",
issn = "0378-4754",
doi = "https://doi.org/10.1016/j.matcom.2015.05.008",
url = "http://www.sciencedirect.com/science/article/pii/S0378475415001214",
author = "Vinh Phu Nguyen and Cosmin Anitescu and Stéphane P.A. Bordas and Timon Rabczuk",
keywords = "Isogeometric analysis, NURBS, Finite elements, CAD, Isogeometric collocation",
abstract = "Isogeometric analysis (IGA) represents a recently developed technology in computational mechanics that offers the possibility of integrating methods for analysis and Computer Aided Design (CAD) into a single, unified process. The implications to practical engineering design scenarios are profound, since the time taken from design to analysis is greatly reduced, leading to dramatic gains in efficiency. In this manuscript, through a self-contained Matlab® implementation, we present an introduction to IGA applied to simple analysis problems and the related computer implementation aspects. Furthermore, implementation of the extended IGA which incorporates enrichment functions through the partition of unity method (PUM) is also presented, where several examples for both two-dimensional and three-dimensional fracture are illustrated. We also describe the use of IGA in the context of strong-form (collocation) formulations, which has been an area of research interest due to the potential for significant efficiency gains offered by these methods. The code which accompanies the present paper can be applied to one, two and three-dimensional problems for linear elasticity, linear elastic fracture mechanics, structural mechanics (beams/plates/shells including large displacements and rotations) and Poisson problems with or without enrichment. The Bézier extraction concept that allows the FE analysis to be performed efficiently on T-spline geometries is also incorporated. The article includes a summary of recent trends and developments within the field of IGA."
}

@article{bar-analysis,
title = "Isogeometric Analysis as a New FEM Formulation - Simple Problems of Steady State Thermal Analysis",
journal = "Procedia Engineering",
volume = "91",
pages = "87 - 92",
year = "2014",
note = "XXIII R-S-P Seminar, Theoretical Foundation of Civil Engineering (23RSP) (TFoCE 2014)",
issn = "1877-7058",
doi = "https://doi.org/10.1016/j.proeng.2014.12.018",
url = "http://www.sciencedirect.com/science/article/pii/S1877705814030367",
author = "Zbigniew Kacprzyk and Katarzyna Ostapska-Łuczkowska",
keywords = "Isogeometric Analysis (IGA), Finite Element Method (FEM), B-spline, NURBS, T-spline, CAD, Computer Aided Engineering ;",
abstract = "The subject of this article concerns Isogeometric Analysis as a new formulation within Finite Element Method. Motivation for this new approach was presented together with theoretical foundations of the method. The main subject of the paper is numerical implementation of the method in the Matlab environment. Special focus was put on the new concept of element and new geometry data interpretation in terms of analysis. Object oriented programming was utilized to produce more universal tool for future investigations. Several examples for Poisson's partial differential equation solution were presented. The h-refinement was utilized to show method convergence. Steady state thermal analysis was performed with temperatures and heat flux as boundary conditions. Quick geometry data transfer and mesh refinement from Rhino software with Grasshopper plug-in was also prepared and described in the paper. Finally, authors’ conclusions concerning new method were presented and comparison between FEM and IGA was made on the basis of the studied examples."
}

@article{KACPRZYK201487,
title = "A two-dimensional isogeometric boundary elemnt method for elastostatic analysis",
journal = "Comput. Methods Appl. Mech. Engg.",
volume = "91",
pages = "87 - 92",
year = "2014",
note = "XXIII R-S-P Seminar, Theoretical Foundation of Civil Engineering (23RSP) (TFoCE 2014)",
issn = "1877-7058",
doi = "https://doi.org/10.1016/j.proeng.2014.12.018",
url = "https://www.sciencedirect.com/science/article/pii/S0045782511002635",
author = "R.N. Simpson and S.P.A. Bordas and J. Trevelyan and T.Rabczuk",
keywords = "A two-dimensional isogeometric boundary elemnt method for elastostatic analysis",
}

@article{Simpson,
title = "A two-dimensional isogeometric boundary elemnt method for elastostatic analysis",
journal = "Comput. Methods Appl. Mech. Engg.",
volume = "91",
pages = "87 - 92",
year = "2011",
note = "XXIII R-S-P Seminar, Theoretical Foundation of Civil Engineering (23RSP) (TFoCE 2014)",
issn = "1877-7058",
doi = "https://doi.org/10.1016/j.proeng.2014.12.018",
url = "https://www.sciencedirect.com/science/article/pii/S0045782511002635",
author = "R.N. Simpson and S.P.A. Bordas and J. Trevelyan and T.Rabczuk",
keywords = "A two-dimensional isogeometric boundary element method for elastostatic analysis",
}

@article{1D_bar,
title = "Static Structural and Modal Analysis using Isogeometric Analysis",
journal = "Journal of Theoretical and Appl. Mechanics",
volume = "46",
pages = "36 - 75",
year = "2016",
note = "XXIII R-S-P Seminar, Theoretical Foundation of Civil Engineering (23RSP) (TFoCE 2014)",
issn = "1877-7058",
doi = "https://doi.org/10.1515/jtam-2016-0020",
url = "https://www.sciencedirect.com/science/article/pii/S0045782511002635",
author = "Sangamesh Gondegaon and Hari k Voruganti",
keywords = "Static structural modal analysis",
}

repository: komahanb/isogeometric-analysis

repo_name: komahanb/isogeometric-analysis