text:
0x3a, 0xf1, 0x6d, 0x81, 0x1e, 0x9b, 0xa6, 0x4f, 0xa3, 0x57, 0x1c, 0xc8, 0x71,
	0xf5, 0x9f, 0x42, 0x35, 0x95, 0xa8, 0xb8, 0x6d, 0x9e, 0x93, 0xa9, 0xe2, 0xc8, 0x3f, 0xd1, 0x2d,
	0x28, 0x5c, 0x70, 0xa3, 0x51, 0xd4, 0x72, 0xf1, 0x6d, 0xf6, 0x59, 0xa6, 0xf1, 0xc7, 0x2c, 0x6c,
	0x2d, 0xa9, 0xb5, 0xb8, 0x9b, 0x84, 0xd4, 0x4d, 0xdc, 0x84, 0x7f, 0x27, 0xa9, 0x3b, 0x9b, 0x4a,
	0xdd, 0xb2, 0x6c, 0xc9, 0x25, 0x65, 0xcb, 0x1d, 0x28, 0xaa, 0x37, 0xcf, 0x0b, 0x98, 0x5a, 0x71,
	0x38, 0xd7, 0x5a, 0x34, 0x55, 0xa6, 0xa3, 0x56, 0xfc, 0x15, 0xe4, 0x97, 0xe9, 0xd8, 0xa2, 0x9a,
	0xa9, 0x18, 0x65, 0x09, 0x38, 0xb2, 0xb9, 0xd8, 0xc4, 0xc3, 0x8e, 0x2b, 0xea, 0x97, 0x8a, 0x21,
	0x17, 0x9c, 0x95, 0x4d, 0xb9, 0x9e, 0xb4, 0x8a, 0x64, 0x25, 0x57, 0xa8, 0x05, 0x6b, 0x71, 0x75,
	0x14, 0x11, 0xec, 0x89, 0xf2, 0x64, 0x79, 0x59, 0xd3, 0x93, 0x68, 0x7d, 0x82, 0x3d, 0xa3, 0x1a,
	0xcc, 0x16, 0x8d, 0xdf, 0xc0, 0x76, 0xd7, 0x61, 0xd1, 0x12, 0x85, 0x30, 0x43, 0xc5, 0x69, 0xf4,
	0x02, 0x0a, 0x4e, 0x44, 0x3c, 0x76, 0xc3, 0xe2, 0x55, 0x12, 0x35, 0x7c, 0xd8, 0x9a, 0x9d, 0x30,
	0x63, 0xba, 0x3b, 0xcf, 0xf4, 0xee, 0x4a, 0xa6, 0x8a, 0x0f, 0xcf, 0x13, 0x3e, 0xf9, 0x10, 0x49,
	0x13, 0x8a, 0xe8, 0x39, 0xf1, 0xd5, 0xb3, 0xac, 0x73, 0x30, 0xb7, 0x8a, 0x3e, 0x07, 0x36, 0xfe,
	0x9d, 0x85, 0x52, 0x7b, 0x8c, 0x7d, 0x9f, 0xb8, 0xea, 0xad, 0x32, 0xc9, 0x5b, 0x7d, 0x0e, 0xd5,
	0xb8, 0xec, 0xe7, 0xda, 0x97, 0xf4, 0x10, 0x83, 0x8e, 0x6c, 0xf4, 0x00, 0xd6, 0x12, 0x84, 0x49,
	0xe8, 0xa8, 0x67, 0x4e, 0x88, 0xce, 0x42, 0x87, 0x3f, 0x91, 0x3c, 0x5d, 0x3e, 0xb7, 0x5c, 0xa0,
	0x6f, 0x01, 0xc8, 0x87, 0xc0, 0x51, 0xd5, 0x67, 0xe1, 0x4a, 0xd7, 0x4c, 0x61, 0x27, 0x01, 0xba,
	0x98, 0x0a, 0xd0, 0x1a, 0x94, 0xb0, 0x6d, 0x87, 0x84, 0x31, 0x65, 0x23, 0xf1, 0x12, 0x7d, 0x07,
	0xc5, 0x00, 0x87, 0xd8, 0x63, 0x5a, 0x79, 0xe5, 0x73, 0xa8, 0xfb, 0x37, 0x7b, 0x02, 0x51, 0x15,
	0x73, 0x92, 0x8a, 0x73, 0x0e, 0xf0, 0xd4, 0xa5, 0xd8, 0x16, 0xd6, 0x54, 0x36, 0xe2, 0x25, 0x77,
	0xaa, 0x14, 0xc1, 0x8d, 0x9c, 0x0a, 0xc3, 0x46, 0x7b, 0x4c, 0xac, 0x73, 0x36, 0xf1, 0x3c, 0x62,
	0x1f, 0xe2, 0x08, 0xf3, 0x73, 0x2c, 0xea, 0xf3, 0xc8, 0x21, 0x58, 0xac, 0x19, 0xf1, 0x12, 0x7d,
	0x03, 0x45, 0x2b, 0xb4, 0x9e, 0xee, 0x59, 0x2a, 0x5f, 0xdc, 0x5b, 0xd0, 0xd3, 0xd9, 0x91, 0x1f,
	0x3d, 0xdd, 0x53, 0x51, 0x5f, 0xe2, 0x36, 0x06, 0xb0, 0x21, 0x83, 0x64, 0x7c, 0x10, 0x4b, 0x31,
	0xca, 0x5c, 0x9f, 0x11, 0xba, 0x0b, 0x65, 0xcf, 0xde, 0x37, 0xc7, 0x98, 0x8d, 0xd5, 0x45, 0x4a,
	0x9e, 0xbd, 0xff, 0x1a, 0xb3, 0x71, 0xe3, 0xaf, 0x79, 0xa8, 0xb6, 0xa9, 0xe7, 0x51, 0xbf, 0xe3,
	0x4f, 0x3c, 0xd6, 0xf8, 0x0e, 0x40, 0x79, 0x0e, 0x7f, 0x27, 0x1d, 0xee, 0xf4, 0x8c, 0x93, 0x9f,
	0x77, 0xda, 0xfd, 0xa3, 0x93, 0x63, 0xf3, 0xec, 0xf8, 0xb4, 0xd7, 0x69, 0x1f, 0xbd, 0x3a, 0xea,
	0x1c, 0xd6, 0x7f, 0x80, 0x00, 0x8a, 0xc7, 0x27, 0x66, 0xab, 0xdd, 0xad, 0x67, 0x50, 0x19, 0xf2,
	0xaf, 0xce, 0xba, 0xdd, 0x7a, 0xb6, 0xf1, 0xcf, 0x0c, 0x6c, 0xf5, 0x42, 0x62, 0x93, 0xa1, 0xe3,
	0x13, 0x3b, 0x76, 0x12, 0x17, 0x3d, 0x84, 0x07, 0x3d, 0xa3, 0x73, 0xd8, 0x79, 0x75, 0x74, 0xdc,
	0x39, 0x34, 0x0f, 0xce, 0xda, 0x6f, 0x3a, 0x7d, 0x4e, 0x7c, 0x89, 0xe9, 0x03, 0xf8, 0x2c, 0xb5,
	0xd7, 0x3a, 0xeb, 0xbf, 0xee, 0x1c, 0xf7, 0x8f, 0xda, 0xad, 0x7e, 0xe7, 0xd0, 0x34, 0x3a, 0xad,
	0xc3, 0x7a, 0x06, 0xdd, 0x01, 0x94, 0x42, 0xe9, 0x19, 0x47, 0x6f, 0x5b, 0xfd, 0x4e, 0x3d, 0x8b,
	0xee, 0x83, 0x3e, 0x07, 0x17, 0x62, 0x27, 0xfb, 0x39, 0x7e, 0x97, 0xf4, 0xfe, 0xd9, 0x41, 0xf7,
	0xa8, 0x2d, 0x79, 0xe6, 0xd1, 0x36, 0xdc, 0x5b, 0xbe, 0x67, 0xbe, 0x33, 0x8e, 0xfa, 0x9d, 0x7a,
	0xa1, 0xf1, 0x9f, 0xb9, 0x7b, 0xcd, 0x9a, 0xca, 0xf9, 0x7b, 0x9d, 0x1c, 0x88, 0x43, 0x97, 0xde,
	0x2b, 0xb5, 0xb7, 0xf4, 0x5e, 0x3b, 0xf0, 0x65, 0x0a, 0x45, 0x89, 0x73, 0xf2, 0xee, 0xb8, 0x63,
	0x98, 0x5c, 0xb7, 0x66, 0xfb, 0xe4, 0xb8, 0x6f, 0x9c, 0x74, 0xeb, 0x59, 0x2e, 0xed, 0x2a, 0x4c,
	0xc1, 0x2b, 0xc7, 0x75, 0x94, 0xc2, 0x88, 0x75, 0x90, 0xe7, 0x3a, 0x9a, 0x83, 0xcf, 0xeb, 0xa8,
	0xc0, 0x75, 0x94, 0xde, 0x4f, 0xe9, 0xa8, 0xd8, 0x30, 0x61, 0xad, 0x2d, 0xcd, 0xd9, 0xc0, 0xfe,
	0x88, 0x70, 0xd7, 0x60, 0x11, 0x0e, 0xa5, 0xad, 0xe7, 0x0c, 0xb9, 0xe0, 0x2e, 0x44, 0x7c, 0x19,
	0x67, 0x72, 0x06, 0xff, 0xe4, 0x95, 0x85, 0x45, 0xbd, 0xc0, 0x25, 0x11, 0x31, 0x5d, 0xe2, 0x8f,
	0xa2, 0xb1, 0xca, 0xb2, 0xb5, 0x18, 0xdc, 0x15, 0xd0, 0xc6, 0xbf, 0xb2, 0xb0, 0x76, 0x4c, 0x23,
	0x67, 0xe8, 0xa8, 0x5e, 0x53, 0xc4, 0x9d, 0xc0, 0xb1, 0x94, 0x43, 0xca, 0x05, 0x8f, 0x68, 0xb2,
	0x15, 0xe4, 0x51, 0x83, 0xa9, 0x1a, 0x1c, 0x04, 0xa8, 0xcf, 0x21, 0x68, 0x00, 0x9b, 0xd6, 0x84,
	0x45, 0xd4, 0x33, 0x71, 0x14, 0x85, 0xce, 0x60, 0x12, 0x11, 0x26, 0x2a, 0xf1, 0xea, 0xde, 0xfe,
	0x92, 0xc8, 0x91, 0x3e, 0xb2, 0xd9, 0x16, 0x84, 0xad, 0x84, 0x4e, 0x06, 0x92, 0xba, 0x75, 0x09,
	0x9c, 0xa4, 0xc9, 0x7c, 0x2a, 0x4d, 0x3e, 0x06, 0xa4, 0x6a, 0x1d, 0x5e, 0x97, 0xc7, 0x05, 0x8f,
	0xec, 0xf6, 0xeb, 0x72, 0x87, 0xd7, 0xe5, 0xb2, 0xe2, 0x11, 0x7d, 0xbe, 0x8c, 0x42, 0xe6, 0x90,
	0x86, 0x1e, 0x8e, 0x54, 0x30, 0x5c, 0x57, 0xd0, 0x57, 0x02, 0xa8, 0xe2, 0x79, 0x29, 0x8e, 0xe7,
	0x7a, 0x1b, 0x6e, 0x2f, 0x95, 0xf1, 0x46, 0xb1, 0xcb, 0x80, 0xbb, 0x3c, 0x41, 0xa5, 0x6f, 0x3e,
	0x4b, 0x53, 0xfb, 0xf3, 0x69, 0xea, 0xf3, 0x2b, 0x54, 0x16, 0x27, 0xbd, 0xbf, 0x57, 0xa1, 0x28,
	0xdd, 0x82, 0x17, 0x56, 0x2a, 0xf0, 0x99, 0xc4, 0xb7, 0xa8, 0xcd, 0xfb, 0x41, 0x29, 0xd7, 0x86,
	0x82, 0x77, 0x14, 0x18, 0xed, 0xc2, 0x56, 0x8c, 0x6a, 0x3b, 0x2c, 0xa0, 0x6c, 0xd6, 0x0f, 0x54,
	0x0c, 0xa4, 0xb6, 0x0e, 0x67, 0x3b, 0xbc, 0x8c, 0xb7, 0xb0, 0x35, 0x26, 0xa6, 0x25, 0x73, 0xae,
	0xca, 0x57, 0x6b, 0x02, 0x18, 0x17, 0x36, 0x6a, 0xf2, 0x94, 0xbf, 0xd1, 0xc0, 0x48, 0x4c, 0x9e,
	0x52, 0xa2, 0xbb, 0xd8, 0x1f, 0x4d, 0x78, 0x35, 0x56, 0x98, 0x13, 0xbd, 0xab, 0xc0, 0x4b, 0x26,
	0x30, 0xc5, 0xa5, 0x13, 0x98, 0x78, 0x66, 0x64, 0x13, 0x6e, 0xeb, 0xf2, 0x2d, 0xaf, 0x31, 0x33,
	0x3a, 0x94, 0xe8, 0x3c, 0x3f, 0xc7, 0x12, 0x89, 0x94, 0x29, 0xcb, 0xa4, 0xaa, 0x82, 0x71, 0x8b,
	0xe7, 0xc6, 0xc8, 0x9c, 0xdf, 0x13, 0x91, 0xdc, 0x72, 0x86, 0xf8, 0x5e, 0x98, 0x54, 0xc1, 0xcd,
	0x26, 0x55, 0xb3, 0x3c, 0x53, 0xbd, 0x41, 0x9e, 0x51, 0xae, 0x4e, 0x7d, 0x2e, 0xad, 0x45, 0x27,
	0x7e, 0x24, 0x46, 0x40, 0x05, 0xe9, 0xea, 0x02, 0xdc, 0xe6, 0xd0, 0xb9, 0x84, 0xb4, 0x3e, 0x97,
	0x90, 0x12, 0xcf, 0xaa, 0x2d, 0x9f, 0x1d, 0x6d, 0x5c, 0x7f, 0x76, 0xb4, 0xd0, 0xf1, 0xd5, 0x97,
	0x8c, 0xaa, 0xb6, 0x61, 0x6d, 0xae, 0x9b, 0xde, 0x94, 0x05, 0xd2, 0x79, 0xd2, 0x46, 0xa3, 0x77,
	0xa0, 0x0b, 0x4d, 0xce, 0xf1, 0x32, 0x63, 0x79, 0xd0, 0x95, 0xf2, 0x7c, 0xc2, 0xa9, 0xd3, 0xbd,
	0xd6, 0x99, 0x92, 0xef, 0x21, 0xd4, 0x22, 0xe2, 0x05, 0x34, 0xc4, 0xe1, 0x54, 0x4e, 0xb4, 0xb6,
	0xe4, 0x3c, 0x22, 0x81, 0x8a, 0x49, 0xd6, 0x5b, 0xb8, 0x3b, 0x6b, 0x53, 0x66, 0x35, 0x94, 0xec,
	0x88, 0x6e, 0x5d, 0x7d, 0x7c, 0x42, 0xdc, 0x49, 0x68, 0x45, 0x6f, 0xd4, 0x86, 0x32, 0xb7, 0x54,
	0x1b, 0x47, 0x58, 0xbb, 0x2d, 0x3c, 0xe5, 0xab, 0x95, 0x9e, 0xd2, 0xfc, 0x85, 0xc2, 0x94, 0xf1,
	0x30, 0x21, 0x44, 0x87, 0x50, 0x5f, 0x98, 0xcb, 0x7d, 0x76, 0x65, 0x5b, 0x5b, 0x23, 0xf3, 0xc3,
	0xba, 0x78, 0x0e, 0xfa, 0x49, 0x6a, 0x0e, 0x2a, 0x03, 0x9f, 0xb6, 0xa4, 0xe9, 0xb8, 0x3b, 0xd7,
	0x74, 0xdc, 0x07, 0x48, 0xb9, 0xa0, 0x2e, 0x5c, 0x20, 0x05, 0x99, 0x4d, 0xc2, 0x3e, 0xbd, 0xde,
	0x24, 0xec, 0xd7, 0xb0, 0x25, 0xa3, 0x3d, 0x09, 0xcd, 0xd4, 0x48, 0xec, 0x9e, 0xa0, 0x7e, 0xbc,
	0x5a, 0x43, 0x6d, 0x45, 0x94, 0x1a, 0x8d, 0x21, 0x6b, 0x01, 0xa6, 0x0f, 0x01, 0x2d, 0x62, 0xa2,
	0x27, 0x70, 0x6b, 0x76, 0x96, 0x89, 0xdd, 0x11, 0x0d, 0x9d, 0x68, 0xec, 0xa9, 0xa8, 0xb9, 0x35,
	0xdb, 0x6b, 0xc5, 0x5b, 0xbc, 0xf9, 0xe6, 0x46, 0xcb, 0xc6, 0x78, 0x6f, 0xff, 0xc7, 0x2a, 0x60,
	0x56, 0xce, 0xc9, 0xf4, 0x54, 0x00, 0xf4, 0xe7, 0xb0, 0x3e, 0xf7, 0x66, 0x37, 0xca, 0x0f, 0x7f,
	0xcb, 0xc2, 0xd6, 0x92, 0x10, 0xf9, 0xff, 0x68, 0x18, 0x65, 0x5e, 0x54, 0x31, 0x56, 0xad, 0x2e,
	0xbd, 0x69, 0x71, 0xe1, 0x4d, 0x67, 0x8d, 0x66, 0x69, 0x75, 0xa3, 0x59, 0x5e, 0xd5, 0x68, 0x56,
	0x96, 0x37, 0x9a, 0xf0, 0xd1, 0x46, 0xb3, 0xfa, 0x3f, 0x37, 0x9a, 0x4b, 0x14, 0x79, 0xa3, 0x46,
	0x73, 0x59, 0xae, 0x52, 0x39, 0xf7, 0x0f, 0x19, 0xd9, 0x69, 0x4a, 0x94, 0x19, 0x57, 0x1d, 0xca,
	0xb2, 0xfa, 0x20, 0x4c, 0xcd, 0x2e, 0x93, 0xf5, 0xac, 0x0b, 0xcd, 0xae, 0xec, 0x42, 0x25, 0xbb,
	0x8f, 0x74, 0xa1, 0xb9, 0x65, 0x5d, 0xe8, 0x6b, 0xa8, 0xa6, 0x54, 0xb1, 0xe4, 0x3f, 0x46, 0x46,
	0xd5, 0x37, 0x73, 0xff, 0x31, 0x78, 0x27, 0xc8, 0xf5, 0xab, 0xcc, 0x87, 0x7f, 0x37, 0xf6, 0xa1,
	0x76, 0x4a, 0xc2, 0x0b, 0xc7, 0x22, 0x2d, 0x4b, 0x64, 0x11, 0x1e, 0xca, 0xc5, 0x73, 0x99, 0x71,
	0x87, 0x28, 0x79, 0xad, 0x09, 0x60, 0x4b, 0xc2, 0x1a, 0x2f, 0xa0, 0x20, 0x3c, 0x39, 0x65, 0x1e,
	0x99, 0xd5, 0xe6, 0x91, 0x9d, 0x37, 0x8f, 0x83, 0x0b, 0xb8, 0x67, 0x51, 0x2f, 0xd6, 0xc6, 0x82,
	0x52, 0x0e, 0xf4, 0xb6, 0x4b, 0x27, 0xb6, 0x8a, 0xe3, 0x46, 0xfc, 0x27, 0xad, 0xc7, 0x83, 0x5b,
	0x2f, 0xf3, 0xab, 0x67, 0x09, 0x1d, 0x2f, 0x1b, 0x9a, 0x34, 0x1c, 0xed, 0x8e, 0x88, 0x2f, 0x42,
	0xdf, 0xae, 0xdc, 0xc2, 0x81, 0xc3, 0x52, 0x3f, 0xe5, 0x9e, 0xab, 0xcf, 0x41, 0x51, 0x20, 0x3d,
	0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x43, 0x62, 0xd1, 0xd7, 0xb8, 0x1b, 0x00, 0x00,
}

license_type: permissive

branch_name: refs/heads/main

gha_language: Go

extension: go


text:
@proceedings{DBLP:conf/birws/2020,
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/2020.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/CabanacFM20,
  author    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Preface to the 10th Workshop on Bibliometric-enhanced Information
               Retrieval at {ECIR} 2020},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {1--4},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-01.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/CabanacFM20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Tsatsaronis20,
  author    = {George Tsatsaronis},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Metrics and Trends in Assessing the Scientific Impact},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {5--15},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-02.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Tsatsaronis20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/BrochierGGV20,
  author    = {Robin Brochier and
               Antoine Gourru and
               Adrien Guille and
               Julien Velcin},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {New Datasets and a Benchmark of Document Network Embedding Methods
               for Scientific Expert Finding},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {16--29},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-03.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/BrochierGGV20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/MichelsNSS20,
  author    = {Christopher Michels and
               Mandy Neumann and
               Philipp Schaer and
               Ralf Schenkel},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Conference Indexing in Digital Libraries: {A} Ranking Model and Case
               Study on dblp},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {30--41},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-04.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/MichelsNSS20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/WiggersV20,
  author    = {Gineke Wiggers and
               Suzan Verberne},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Usage and Citation Metrics for Ranking Algorithms in Legal Information
               Retrieval Systems},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {42--52},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-05.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/WiggersV20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/BascurVEW20,
  author    = {Juan Pablo Bascur and
               Suzan Verberne and
               Nees Jan van Eck and
               Ludo Waltman},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Browsing Citation Clusters for Academic Literature Search: {A} Simulation
               Study with Systematic Reviews},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {53--65},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-06.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/BascurVEW20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/FarberKS20,
  author    = {Michael F{\"{a}}rber and
               Timo Klein and
               Joan Sigloch},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Neural Citation Recommendation: {A} Reproducibility Study},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {66--74},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-07.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/FarberKS20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/KershawPHJ20,
  author    = {Daniel Kershaw and
               Benjamin Pettit and
               Maya Hristakeva and
               Kris Jack},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Learning to Rank Research Articles: {A} Case Study of Collaborative
               Filtering and Learning to Rank in ScienceDirect},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {75--88},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-08.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/KershawPHJ20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/NogueiraJCL20,
  author    = {Rodrigo Nogueira and
               Zhiying Jiang and
               Kyunghyun Cho and
               Jimmy Lin},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Evaluating Pretrained Transformer Models for Citation Recommendation},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {89--100},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-09.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/NogueiraJCL20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/BreuerST20,
  author    = {Timo Breuer and
               Philipp Schaer and
               Dirk Tunger},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Relations Between Relevance Assessments, Bibliometrics and Altmetrics},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {101--112},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-10.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/BreuerST20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Scharnhorst20,
  author    = {Andrea Scharnhorst},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Building Bridges},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {113},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-11.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Scharnhorst20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Thelwall20,
  author    = {Mike Thelwall},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Why we Need Another Ten Years of Bibliometric-enhanced Information
               Retrieval},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {114--115},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-12.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Thelwall20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/BertinA20,
  author    = {Marc Bertin and
               Iana Atanassova},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {{BIR:} {A} Time and a Place to Envision Concepts and Tools around
               Bibliometrics},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {116--117},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-13.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/BertinA20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Small20,
  author    = {Henry Small},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Some Questions for Information Science Arising from the History and
               Philosophy of Science},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {118--120},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-14.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Small20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Basu20,
  author    = {Aparna Basu},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Remembering Don Swanson: Link to Bibliometric-enhanced Information
               Retrieval},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {121--123},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-15.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Basu20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Glanzel20,
  author    = {Wolfgang Gl{\"{a}}nzel},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Bibliometrics-aided Retrieval: {A} Success Story},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {124--125},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-16.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Glanzel20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Chandrasekaran20,
  author    = {Muthu Kumar Chandrasekaran},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {{BIR} and {BIRNDL:} {A} Marathon towards a Congregation of Scientific
               Document Processing Community},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {126},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-17.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Chandrasekaran20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/White20,
  author    = {Howard D. White},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Anniversary Statement},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {127--128},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-18.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/White20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{DBLP:conf/birws/Zitt20,
  author    = {Michel Zitt},
  editor    = {Guillaume Cabanac and
               Ingo Frommholz and
               Philipp Mayr},
  title     = {Intrication between Information Retrieval and Bibliometrics: the Case
               of Scientific Domain Delineation},
  booktitle = {Proceedings of the 10th International Workshop on Bibliometric-enhanced
               Information Retrieval co-located with 42nd European Conference on
               Information Retrieval, BIR@ECIR 2020, Lisbon, Portugal, April 14th,
               2020 [online only]},
  series    = {{CEUR} Workshop Proceedings},
  volume    = {2591},
  pages     = {129--133},
  publisher = {CEUR-WS.org},
  year      = {2020},
  url       = {http://ceur-ws.org/Vol-2591/paper-19.pdf},
  timestamp = {Tue, 14 Apr 2020 17:42:07 +0200},
  biburl    = {https://dblp.org/rec/conf/birws/Zitt20.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

branch_name: refs/heads/master

extension: bib


text:
require recipes-core/images/core-image-minimal-xfce.bb
require recipes-core/images/dealcore-base.bb

DESCRIPTION = "DealCore XFCE image."

export IMAGE_BASENAME = "dealcore-xfce"

SYSTEMD_DEFAULT_TARGET = "graphical.target"

license: MIT

repository: ponmadasamy/meta-dealcore

repo_name: ponmadasamy/meta-dealcore

extension: bb


text:
/*-
 *
 * Hedera Mirror Node
 *
 * Copyright (C) 2019 - 2021 Hedera Hashgraph, LLC
 *
 * 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 transaction

import (
	"testing"

	rTypes "github.com/coinbase/rosetta-sdk-go/types"
	entityid "github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/app/domain/services/encoding"
	"github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/app/domain/types"
	"github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/app/errors"
	dbTypes "github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/app/persistence/types"
	"github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/test"
	"github.com/hashgraph/hedera-mirror-node/hedera-mirror-rosetta/test/domain"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
)

const (
	consensusStart int64 = 1000
	consensusEnd   int64 = 1100
	resultSuccess        = "SUCCESS"
)

var (
	firstAccount, _          = types.NewAccountFromEncodedID(12345)
	secondAccount, _         = types.NewAccountFromEncodedID(54321)
	nodeAccount, _           = types.NewAccountFromEncodedID(3)
	treasuryAccount, _       = types.NewAccountFromEncodedID(98)
	tokenId1, _              = entityid.Decode(25636)
	tokenId2, _              = entityid.Decode(26700)
	tokenDecimals      int64 = 10
	tokenInitialSupply int64 = 50000
)

func TestShouldSuccessReturnTransactionTypesTableName(t *testing.T) {
	assert.Equal(t, tableNameTransactionTypes, transactionType{}.TableName())
}

func TestShouldSuccessReturnTransactionResultsTableName(t *testing.T) {
	assert.Equal(t, tableNameTransactionResults, transactionResult{}.TableName())
}

func TestTransactionGetHashString(t *testing.T) {
	tx := transaction{Hash: []byte{1, 2, 3, 0xaa, 0xff}}
	assert.Equal(t, "0x010203aaff", tx.getHashString())
}

func TestHbarTransferGetAccount(t *testing.T) {
	hbarTransfer := hbarTransfer{AccountId: entityid.EntityId{EntityNum: 1, EncodedId: 1}}
	assert.Equal(t, types.Account{EntityId: entityid.EntityId{EntityNum: 1, EncodedId: 1}}, hbarTransfer.getAccount())
}

func TestHbarTransferGetAmount(t *testing.T) {
	hbarTransfer := hbarTransfer{Amount: 10}
	assert.Equal(t, &types.HbarAmount{Value: 10}, hbarTransfer.getAmount())
}

func TestTokenTransferGetAccount(t *testing.T) {
	tokenTransfer := tokenTransfer{AccountId: entityid.EntityId{EntityNum: 1, EncodedId: 1}}
	assert.Equal(t, types.Account{EntityId: entityid.EntityId{EntityNum: 1, EncodedId: 1}}, tokenTransfer.getAccount())
}

func TestTokenTransferGetAmount(t *testing.T) {
	tokenId := entityid.EntityId{EntityNum: 123, EncodedId: 123}
	tokenTransfer := tokenTransfer{Amount: 10, Decimals: 3, TokenId: tokenId}
	assert.Equal(t, &types.TokenAmount{Decimals: 3, Value: 10, TokenId: tokenId}, tokenTransfer.getAmount())
}

func TestTokenGetAmount(t *testing.T) {
	tokenId := entityid.EntityId{EntityNum: 123, EncodedId: 123}
	token := token{Decimals: 5, TokenId: tokenId}
	assert.Equal(t, &types.TokenAmount{Decimals: 5, TokenId: tokenId}, token.getAmount())
}

func TestShouldFailConstructAccount(t *testing.T) {
	data := int64(-1)
	expected := errors.ErrInternalServerError

	result, err := constructAccount(data)

	assert.Equal(t, types.Account{}, result)
	assert.Equal(t, expected, err)
}

func TestShouldSuccessConstructAccount(t *testing.T) {
	// given
	data := int64(5)
	expected, _ := types.NewAccountFromEncodedID(5)

	// when
	result, err := constructAccount(data)

	// then
	assert.Nil(t, err)
	assert.Equal(t, expected, result)
}

func assertOperationIndexes(t *testing.T, operations []*types.Operation) {
	makeRange := func(len int) []int64 {
		result := make([]int64, len)
		for i := range result {
			result[i] = int64(i)
		}
		return result
	}

	expected := makeRange(len(operations))
	actual := make([]int64, len(operations))
	for i, operation := range operations {
		actual[i] = operation.Index
		// side effect, clear operation's index
		operation.Index = 0
	}

	assert.Equal(t, expected, actual)
}

func assertTransactions(t *testing.T, expected, actual []*types.Transaction) {
	getTransactionMap := func(transactions []*types.Transaction) map[string]*types.Transaction {
		result := make(map[string]*types.Transaction)
		for _, tx := range transactions {
			result[tx.Hash] = tx
		}
		return result
	}

	assert.Len(t, actual, len(expected))

	for _, tx := range actual {
		// assert the 0-based, unique, contiguous operations indexes
		assertOperationIndexes(t, tx.Operations)
	}

	actualTransactionMap := getTransactionMap(actual)
	expectedTransactionMap := getTransactionMap(expected)

	assert.Len(t, actualTransactionMap, len(expectedTransactionMap))

	for txHash, actualTx := range actualTransactionMap {
		assert.Contains(t, expectedTransactionMap, txHash)
		expectedTx := expectedTransactionMap[txHash]
		assert.ElementsMatch(t, actualTx.Operations, expectedTx.Operations)
	}
}

func TestTransactionRepositorySuite(t *testing.T) {
	suite.Run(t, new(transactionRepositorySuite))
}

type transactionRepositorySuite struct {
	test.IntegrationTest
	suite.Suite
}

func (suite *transactionRepositorySuite) SetupSuite() {
	suite.Setup()
}

func (suite *transactionRepositorySuite) TearDownSuite() {
	suite.TearDown()
}

func (suite *transactionRepositorySuite) SetupTest() {
	suite.CleanupDb()
}

func (suite *transactionRepositorySuite) TestNewTransactionRepository() {
	t := NewTransactionRepository(suite.DbResource.GetGormDb())
	assert.NotNil(suite.T(), t)
}

func (suite *transactionRepositorySuite) TestTypes() {
	t := NewTransactionRepository(suite.DbResource.GetGormDb())
	actual, err := t.Types()
	assert.Nil(suite.T(), err)
	assert.NotEmpty(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestTypesDbConnectionError() {
	t := NewTransactionRepository(suite.InvalidDbClient)
	actual, err := t.Types()
	assert.Equal(suite.T(), errors.ErrDatabaseError, err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestResults() {
	t := NewTransactionRepository(suite.DbResource.GetGormDb())
	actual, err := t.Results()
	assert.Nil(suite.T(), err)
	assert.NotEmpty(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestResultsDbConnectionError() {
	t := NewTransactionRepository(suite.InvalidDbClient)
	actual, err := t.Results()
	assert.Equal(suite.T(), errors.ErrDatabaseError, err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestTypesAsArray() {
	t := NewTransactionRepository(suite.DbResource.GetGormDb())
	actual, err := t.TypesAsArray()
	assert.Nil(suite.T(), err)
	assert.NotEmpty(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestTypesAsArrayDbConnectionError() {
	t := NewTransactionRepository(suite.InvalidDbClient)
	actual, err := t.TypesAsArray()
	assert.Equal(suite.T(), errors.ErrDatabaseError, err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestFindBetween() {
	// given
	expected := suite.setupDb(true)
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindBetween(consensusStart, consensusEnd)

	// then
	assert.Nil(suite.T(), err)
	assertTransactions(suite.T(), expected, actual)
}

func (suite *transactionRepositorySuite) TestFindBetweenNoTokenEntity() {
	// given
	expected := suite.setupDb(false)
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindBetween(consensusStart, consensusEnd)

	// then
	assert.Nil(suite.T(), err)
	assertTransactions(suite.T(), expected, actual)
}

func (suite *transactionRepositorySuite) TestFindBetweenThrowsWhenStartAfterEnd() {
	// given
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindBetween(consensusStart, consensusStart-1)

	// then
	assert.NotNil(suite.T(), err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestFindBetweenDbConnectionError() {
	// given
	t := NewTransactionRepository(suite.InvalidDbClient)

	// when
	actual, err := t.FindBetween(consensusStart, consensusEnd)

	// then
	assert.Equal(suite.T(), errors.ErrDatabaseError, err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestFindByHashInBlock() {
	// given
	expected := suite.setupDb(true)
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindByHashInBlock(expected[0].Hash, consensusStart, consensusEnd)

	// then
	assert.Nil(suite.T(), err)
	assertTransactions(suite.T(), []*types.Transaction{expected[0]}, []*types.Transaction{actual})
}

func (suite *transactionRepositorySuite) TestFindByHashInBlockNoTokenEntity() {
	// given
	expected := suite.setupDb(false)
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindByHashInBlock(expected[1].Hash, consensusStart, consensusEnd)

	// then
	assert.Nil(suite.T(), err)
	assertTransactions(suite.T(), []*types.Transaction{expected[1]}, []*types.Transaction{actual})
}

func (suite *transactionRepositorySuite) TestFindByHashInBlockThrowsInvalidHash() {
	// given
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindByHashInBlock("invalid hash", consensusStart, consensusEnd)

	// then
	assert.NotNil(suite.T(), err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestFindByHashInBlockThrowsNotFound() {
	// given
	t := NewTransactionRepository(suite.DbResource.GetGormDb())

	// when
	actual, err := t.FindByHashInBlock("0x123456", consensusStart, consensusEnd)

	// then
	assert.NotNil(suite.T(), err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) TestFindByHashInBlockDbConnectionError() {
	// given
	t := NewTransactionRepository(suite.InvalidDbClient)

	// when
	actual, err := t.FindByHashInBlock("0x123456", consensusStart, consensusEnd)

	// then
	assert.Equal(suite.T(), errors.ErrDatabaseError, err)
	assert.Nil(suite.T(), actual)
}

func (suite *transactionRepositorySuite) setupDb(createTokenEntity bool) []*types.Transaction {
	dbClient := suite.DbResource.GetGormDb()

	// successful crypto transfer transaction
	consensusTimestamp := consensusStart + 1
	validStartNs := consensusStart - 10
	cryptoTransfers := []dbTypes.CryptoTransfer{
		{Amount: -150, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 135, ConsensusTimestamp: consensusTimestamp, EntityId: secondAccount.EncodedId},
		{Amount: 5, ConsensusTimestamp: consensusTimestamp, EntityId: nodeAccount.EncodedId},
		{Amount: 10, ConsensusTimestamp: consensusTimestamp, EntityId: treasuryAccount.EncodedId},
	}
	nonFeeTransfers := []dbTypes.CryptoTransfer{
		{Amount: -135, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 135, ConsensusTimestamp: consensusTimestamp, EntityId: secondAccount.EncodedId},
	}
	domain.AddTransaction(dbClient, consensusTimestamp, 0, nodeAccount.EncodedId, firstAccount.EncodedId, 22,
		[]byte{0x1, 0x2, 0x3}, 14, validStartNs, cryptoTransfers, nonFeeTransfers, nil)

	// duplicate transaction
	consensusTimestamp += 1
	cryptoTransfers = []dbTypes.CryptoTransfer{
		{Amount: -15, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 5, ConsensusTimestamp: consensusTimestamp, EntityId: nodeAccount.EncodedId},
		{Amount: 10, ConsensusTimestamp: consensusTimestamp, EntityId: treasuryAccount.EncodedId},
	}
	domain.AddTransaction(dbClient, consensusTimestamp, 0, nodeAccount.EncodedId, firstAccount.EncodedId, 11,
		[]byte{0x1, 0x2, 0x3}, 14, validStartNs, cryptoTransfers, nil, nil)
	operations1 := []*types.Operation{
		{Account: firstAccount, Amount: &types.HbarAmount{Value: -135}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: secondAccount, Amount: &types.HbarAmount{Value: 135}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: firstAccount, Amount: &types.HbarAmount{Value: -15}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: nodeAccount, Amount: &types.HbarAmount{Value: 5}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: treasuryAccount, Amount: &types.HbarAmount{Value: 10}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: firstAccount, Amount: &types.HbarAmount{Value: -15}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: nodeAccount, Amount: &types.HbarAmount{Value: 5}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: treasuryAccount, Amount: &types.HbarAmount{Value: 10}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
	}
	expectedTransaction1 := &types.Transaction{Hash: "0x010203", Operations: operations1}

	// a successful crypto transfer + token transfer transaction
	consensusTimestamp += 1
	validStartNs += 2

	if createTokenEntity {
		domain.AddToken(dbClient, tokenId1.EncodedId, tokenDecimals, false, tokenInitialSupply, treasuryAccount.EncodedId)
	}

	cryptoTransfers = []dbTypes.CryptoTransfer{
		{Amount: -230, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 215, ConsensusTimestamp: consensusTimestamp, EntityId: secondAccount.EncodedId},
		{Amount: 5, ConsensusTimestamp: consensusTimestamp, EntityId: nodeAccount.EncodedId},
		{Amount: 10, ConsensusTimestamp: consensusTimestamp, EntityId: treasuryAccount.EncodedId},
	}
	nonFeeTransfers = []dbTypes.CryptoTransfer{
		{Amount: -215, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 215, ConsensusTimestamp: consensusTimestamp, EntityId: secondAccount.EncodedId},
	}
	tokenTransfers := []dbTypes.TokenTransfer{
		{AccountId: firstAccount.EncodedId, Amount: -160, ConsensusTimestamp: consensusTimestamp, TokenId: tokenId1.EncodedId},
		{AccountId: secondAccount.EncodedId, Amount: 160, ConsensusTimestamp: consensusTimestamp, TokenId: tokenId1.EncodedId},
	}
	domain.AddTransaction(dbClient, consensusTimestamp, 0, nodeAccount.EncodedId, firstAccount.EncodedId, 22,
		[]byte{0xa, 0xb, 0xc}, 14, validStartNs, cryptoTransfers, nonFeeTransfers, tokenTransfers)
	operations2 := []*types.Operation{
		{Account: firstAccount, Amount: &types.HbarAmount{Value: -215}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: secondAccount, Amount: &types.HbarAmount{Value: 215}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: firstAccount, Amount: &types.HbarAmount{Value: -15}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: nodeAccount, Amount: &types.HbarAmount{Value: 5}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
		{Account: treasuryAccount, Amount: &types.HbarAmount{Value: 10}, Type: "CRYPTOTRANSFER", Status: resultSuccess},
	}
	if createTokenEntity {
		operations2 = append(
			operations2,
			&types.Operation{
				Account: firstAccount,
				Amount:  &types.TokenAmount{Value: -160, Decimals: tokenDecimals, TokenId: tokenId1},
				Type:    "CRYPTOTRANSFER",
				Status:  resultSuccess,
			},
			&types.Operation{
				Account: secondAccount,
				Amount:  &types.TokenAmount{Value: 160, Decimals: tokenDecimals, TokenId: tokenId1},
				Type:    "CRYPTOTRANSFER",
				Status:  resultSuccess,
			},
		)
	}
	expectedTransaction2 := &types.Transaction{Hash: "0x0a0b0c", Operations: operations2}

	// token create transaction
	domain.AddToken(dbClient, tokenId2.EncodedId, tokenDecimals, false, tokenInitialSupply, firstAccount.EncodedId)
	// add tokencreate transaction
	consensusTimestamp += 1
	validStartNs += 1
	cryptoTransfers = []dbTypes.CryptoTransfer{
		{Amount: -15, ConsensusTimestamp: consensusTimestamp, EntityId: firstAccount.EncodedId},
		{Amount: 5, ConsensusTimestamp: consensusTimestamp, EntityId: nodeAccount.EncodedId},
		{Amount: 10, ConsensusTimestamp: consensusTimestamp, EntityId: treasuryAccount.EncodedId},
	}
	tokenTransfers = []dbTypes.TokenTransfer{
		{AccountId: firstAccount.EncodedId, Amount: tokenInitialSupply, ConsensusTimestamp: consensusTimestamp, TokenId: tokenId2.EncodedId},
	}
	domain.AddTransaction(dbClient, consensusTimestamp, tokenId2.EncodedId, nodeAccount.EncodedId, firstAccount.EncodedId, 22,
		[]byte{0xaa, 0xcc, 0xdd}, dbTypes.TransactionTypeTokenCreation, validStartNs, cryptoTransfers, nil, tokenTransfers)
	metadata := map[string]interface{}{
		"currency": &rTypes.Currency{
			Symbol:   tokenId2.String(),
			Decimals: int32(tokenDecimals),
		},
		"freeze_default": false,
		"initial_supply": tokenInitialSupply,
	}
	expectedTransaction3 := &types.Transaction{
		Hash: "0xaaccdd",
		Operations: []*types.Operation{
			{Account: firstAccount, Amount: &types.HbarAmount{Value: -15}, Type: "TOKENCREATION", Status: resultSuccess},
			{Account: nodeAccount, Amount: &types.HbarAmount{Value: 5}, Type: "TOKENCREATION", Status: resultSuccess},
			{Account: treasuryAccount, Amount: &types.HbarAmount{Value: 10}, Type: "TOKENCREATION", Status: resultSuccess},
			{Account: firstAccount, Type: "TOKENCREATION", Status: resultSuccess, Metadata: metadata},
			{
				Account: firstAccount,
				Amount:  &types.TokenAmount{Value: tokenInitialSupply, TokenId: tokenId2, Decimals: tokenDecimals},
				Type:    "TOKENCREATION",
				Status:  resultSuccess,
			},
		},
	}

	return []*types.Transaction{expectedTransaction1, expectedTransaction2, expectedTransaction3}
}


text:
DESCRIPTION = "Task for a GNOME based image"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/LICENSE;md5=3f40d7994397109285ec7b81fdeb3b58"

PR = "r3"

inherit task

# Most of these tasks are arch independant
PACKAGE_ARCH = "all"

PACKAGES += "task-gnome3-apps task-gnome3-fonts task-gnome3 task-gnome3-gstreamer task-gnome3-perl task-gnome3-cups task-gnome3-pulseaudio task-gnome3-themes task-gnome3-totem task-gnome3-xserver-base "

RDEPENDS_task-gnome3-apps = " \
  x11vnc \
  matchbox-terminal \
  epiphany \
 "

RDEPENDS_task-gnome3-fonts = " \
  fontconfig fontconfig-utils font-util \
  ttf-liberation-sans \
  ttf-liberation-serif \
  ttf-liberation-mono \
 "

RDEPENDS_task-gnome3 = " \
  gnome-settings-daemon gnome-control-center \
  gnome-keyring \
  gdm-systemd angstrom-gdm-autologin-hack \
  gnome-power-manager3 \
  gnome-bluetooth \
  connman-gnome connman-plugin-ntpd \
  gnome-panel3 \
  gtk-engine-clearlooks gtk-theme-clearlooks \
  upower udisks \
  gnome-disk-utility \
  nautilus3 \
  gpe-scap \
  bash \
  tzdata \
"

DEPENDS_task-gnome3-gstreamer = " \
  gst-plugins-base \
  gst-plugins-good \
  gst-plugins-bad \
  gst-plugins-ugly \
"

RDEPENDS_task-gnome3-gstreamer = " \
  gst-ffmpeg \
  gst-plugins-base-meta \
"

RDEPENDS_task-gnome3-perl = " \
  perl \
  libxml-parser-perl \
"

RDEPENDS_task-gnome3-themes = " \
  angstrom-gnome-icon-theme-enable \
  gnome-icon-theme \
  gnome-themes \
  gnome-theme-crux \
  gnome-theme-highcontrast \
  gnome-theme-highcontrastinverse \
  gnome-theme-highcontrastlargeprint \
  gnome-theme-highcontrastlargeprintinverse \
  gnome-theme-largeprint \
  gnome-theme-mist \
  gtk-engine-clearlooks \
  gtk-engine-crux-engine \
  gtk-engine-glide \
  gtk-engine-hcengine \
  gtk-engine-thinice \
  gtk-engine-redmond95 \
  gtk-theme-clearlooks \
  gtk-theme-crux \
  gtk-theme-mist \
  gtk-theme-thinice \
  gtk-theme-redmond \
  hicolor-icon-theme \
 "

RDEPENDS_task-gnome3-xserver-base = " \
  dbus-x11 \
  iso-codes \
  mime-support \
  xauth \
  xdg-utils \
  xhost \
  xinetd \
  xinit \
  xrandr \
  xrdb \
  xset \
  xvinfo \
 "

RDEPENDS_${PN} = " \
  task-gnome3-fonts \
  task-gnome3 \
  task-gnome3-gstreamer \
  task-gnome3-perl \
  task-gnome3-themes \
  task-gnome3-xserver-base \
"

RRECOMMENDS_${PN} = " \
   task-xserver \
"

repository: joelagnel/meta-angstrom

repo_name: joelagnel/meta-angstrom


text:
@article{Zygote.jl-2018,
  author    = {Michael Innes},
  title     = {Don't Unroll Adjoint: Differentiating SSA-Form Programs},
  journal   = {CoRR},
  volume    = {abs/1810.07951},
  year      = {2018},
  url       = {http://arxiv.org/abs/1810.07951},
  archivePrefix = {arXiv},
  eprint    = {1810.07951},
  timestamp = {Tue, 30 Oct 2018 20:39:56 +0100},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1810-07951},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

gha_license_id: NOASSERTION

gha_language: Julia


text:
package leaky_test

import (
	"testing"

	"github.com/jhunt/go-leaks"

	"github.com/jhunt/go-leaks/examples/leaky"
)

func TestPing(t *testing.T) {
	if !leaky.Ping() {
		t.Errorf("failed to ping!")
	}
	if leaks.Files(func() { leaky.Ping() }) {
		t.Errorf("Ping() leaked one or more file descriptors!")
	}
}

repository: jhunt/go-leaks

repo_name: jhunt/go-leaks


text:
@article{melymcb-0177,
 author = {Kuz, V.A.},
 document_type = {Article},
 doi = {10.1021/la00047a040},
 journal = {Langmuir},
 note = {cited By 7},
 number = {11},
 pages = {2829-2831},
 source = {Scopus},
 title = {Fluid Dynamic Analysis of Droplet Evaporation},
 url = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-26544435460&doi=10.1021%2fla00047a040&partnerID=40&md5=675caec8350a512059e71754047a5881},
 volume = {8},
 year = {1992}
}


text:
@article{pinskiCitationInfluenceJournal1976,
  title = {Citation Influence for Journal Aggregates of Scientific Publications: {{Theory}}, with Application to the Literature of Physics},
  volume = {12},
  issn = {0306-4573},
  shorttitle = {Citation Influence for Journal Aggregates of Scientific Publications},
  abstract = {A self-consistent methodology is developed for determining citation based influence measures for scientific journals, subfields and fields. Starting with the cross citing matrix between journals or between aggregates of journals, an eigenvalue problem is formulated leading to a size independent influence weight for each journal or aggregate. Two other measures, the influence per publication and the total influence are then defined. Hierarchical influence diagrams and numerical data are presented to display journal interrelationships for journals within the subfields of physics. A wide range in influence is found between the most influential and least influential or peripheral journals.},
  number = {5},
  journal = {Information Processing \& Management},
  doi = {10.1016/0306-4573(76)90048-0},
  author = {Pinski, Gabriel and Narin, Francis},
  month = jan,
  year = {1976},
  pages = {297-312},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\2DWY754M\\Pinski and Narin - 1976 - Citation influence for journal aggregates of scien.pdf;C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\Y2H25Y7K\\0306457376900480.html}
}

@article{brinAnatomyLargescaleHypertextual1998,
  title = {The Anatomy of a Large-Scale Hypertextual {{Web}} Search Engine},
  volume = {30},
  issn = {01697552},
  abstract = {In this paper, we present Google, a prototype of a large-scale search engine which makes heavy use of the structure present in hypertext. Google is designed to crawl and index the Web efficiently and produce much more satisfying search results than existing systems. The prototype with a full text and hyperlink database of at least 24 million pages is available at http://google.stanford.edu/ To engineer a search engine is a challenging task. Search engines index tens to hundreds of millions of web pages involving a comparable number of distinct terms. They answer tens of millions of queries every day. Despite the importance of large-scale search engines on the web, very little academic research has been done on them. Furthermore, due to rapid advance in technology and web proliferation, creating a web search engine today is very different from three years ago. This paper provides an in-depth description of our large-scale web search engine -- the first such detailed public description we know of to date. Apart from the problems of scaling traditional search techniques to data of this magnitude, there are new technical challenges involved with using the additional information present in hypertext to produce better search results. This paper addresses this question of how to build a practical large-scale system which can exploit the additional information present in hypertext. Also we look at the problem of how to effectively deal with uncontrolled hypertext collections where anyone can publish anything they want.},
  language = {en},
  number = {1-7},
  journal = {Computer Networks and ISDN Systems},
  doi = {10.1016/S0169-7552(98)00110-X},
  author = {Brin, Sergey and Page, Lawrence},
  month = apr,
  year = {1998},
  pages = {107-117},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\ENWS35HJ\\Brin and Page - 1998 - The anatomy of a large-scale hypertextual Web sear.pdf}
}

@article{berkhinSurveyPageRankComputing2005,
  title = {A {{Survey}} on {{PageRank Computing}}},
  volume = {2},
  issn = {1542-7951, 1944-9488},
  abstract = {This survey reviews the research related to PageRank computing. Components of a PageRank vector serve as authority weights for web pages independent of their textual content, solely based on the hyperlink structure of the web. PageRank is typically used as a web search ranking component. This defines the importance of the model and the data structures that underly PageRank processing. Computing even a single PageRank is a difficult computational task. Computing many PageRanks is a much more complex challenge. Recently, significant effort has been invested in building sets of personalized PageRank vectors. PageRank is also used in many diverse applications other than ranking.},
  language = {en},
  number = {1},
  journal = {Internet Mathematics},
  doi = {10.1080/15427951.2005.10129098},
  author = {Berkhin, Pavel},
  month = jan,
  year = {2005},
  pages = {73-120},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\IKDHYQVU\\Berkhin - 2005 - A Survey on PageRank Computing.pdf}
}

@article{brinkmeierPageRankRevisited2006,
  title = {{{PageRank}} Revisited},
  volume = {6},
  issn = {15335399},
  language = {en},
  number = {3},
  journal = {ACM Transactions on Internet Technology},
  doi = {10.1145/1151087.1151090},
  author = {Brinkmeier, Michael},
  month = aug,
  year = {2006},
  pages = {282-301},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\N53DCY7C\\Brinkmeier - 2006 - PageRank revisited.pdf}
}

@article{brinPageRankCitationRanking1998,
  title = {The {{PageRank Citation Ranking}}: {{Bringing Order}} to the {{Web}}},
  doi = {http://ilpubs.stanford.edu:8090/422/},
  author = {Brin, Sergey and Page, Larry},
  month = jan,
  year = {1998},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\SZDQGU9Y\\1999-66.pdf}
}

@book{rigoAdvancedGraphTheory2016,
  title = {Advanced Graph Theory and Combinatorics},
  isbn = {978-1-119-00898-9 978-1-119-05864-9 978-1-119-05861-8},
  abstract = {Advanced Graph Theory focuses on some of the main notions arising in graph theory with an emphasis from the very start of the book on the possible applications of the theory and the fruitful links existing with linear algebra. The second part of the book covers basic material related to linear recurrence relations with application to counting and the asymptotic estimate of the rate of growth of a sequence satisfying a recurrence relation.},
  language = {English},
  author = {Rigo, Michel},
  year = {2016},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\6LWV6X58\\Rigo - 2016 - Advanced graph theory and combinatorics.pdf},
  note = {OCLC: 1035508878}
}

@book{langvilleGooglePageRankScience2006,
  address = {Princeton, N.J},
  title = {Google's {{PageRank}} and beyond: The Science of Search Engine Rankings},
  isbn = {978-0-691-12202-1},
  lccn = {TK5105.885.G66 L36 2006},
  shorttitle = {Google's {{PageRank}} and Beyond},
  publisher = {{Princeton University Press}},
  author = {Langville, Amy N. and Meyer, C. D.},
  year = {2006},
  keywords = {Mathematics,Google,Internet searching,Ratings and rankings Mathematics,Subject access Mathematics,Web search engines,Web sites,World Wide Web},
  note = {OCLC: ocm70663456}
}

@book{berryUnderstandingSearchEngines2005,
  address = {Philadelphia},
  edition = {2nd},
  title = {Understanding {{Search Engines}}: {{Mathematical Modeling}} and {{Text Retrieval}}},
  publisher = {{Society for Industrial and Applied Mathematics}},
  author = {Berry, Michael W. and Browne, Murray},
  year = {2005},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\LFKC66Q9\\Berry and Browne - 2005 - Understanding Search Engines Mathematical Modelin.pdf}
}

@article{vignaSpectralRanking2009,
  archivePrefix = {arXiv},
  eprinttype = {arxiv},
  eprint = {0912.0238},
  primaryClass = {physics},
  title = {Spectral {{Ranking}}},
  abstract = {We sketch the history of spectral ranking\textemdash{}a general umbrella name for techniques that apply the theory of linear maps (in particular, eigenvalues and eigenvectors) to matrices that do not represent geometric transformations, but rather some kind of relationship between entities. Albeit recently made famous by the ample press coverage of Google's PageRank algorithm, spectral ranking was devised more than a century ago, and has been studied in tournament ranking, psychology, social sciences, bibliometrics, economy and choice theory. We describe the contribution given by previous scholars in precise and modern mathematical terms: along the way, we show how to express in a general way damped rankings, such as Katz's index, as dominant eigenvectors of perturbed matrices, and then use results on the Drazin inverse to go back to the dominant eigenvectors by a limit process. The result suggests a regularized definition of spectral ranking that yields for a general matrix a unique vector depending on a boundary condition.},
  language = {en},
  journal = {arXiv:0912.0238 [physics]},
  author = {Vigna, Sebastiano},
  month = dec,
  year = {2009},
  keywords = {Computer Science - Information Retrieval,Computer Science - Social and Information Networks,Physics - Physics and Society},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\JZFEAPP2\\Vigna - 2009 - Spectral Ranking.pdf}
}

@article{langvilleDeeperPageRank2004,
  title = {Deeper {{Inside PageRank}}},
  volume = {1},
  issn = {1542-7951},
  abstract = {This paper serves as a companion or extension to the ``Inside PageRank'' paper by Bianchini et al. [Bianchini et al. 03]. It is a comprehensive survey of all issues associated with PageRank, covering the basic PageRank model, available and recommended solution methods, storage issues, existence, uniqueness, and convergence properties, possible alterations to the basic model, suggested alternatives to the traditional solution methods, sensitivity and conditioning, and finally the updating problem. We introduce a few new results, provide an extensive reference list, and speculate about exciting areas of future research.},
  language = {en},
  number = {3},
  journal = {Internet Mathematics},
  doi = {10.1080/15427951.2004.10129091},
  author = {Langville, Amy and Meyer, Carl},
  month = jan,
  year = {2004},
  pages = {335-380},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\WY5AQZMG\\Langville and Meyer - 2004 - Deeper Inside PageRank.pdf}
}

@article{stewartSensitivityNearlyUncoupled1989,
  title = {On the {{Sensitivity}} of {{Nearly Uncoupled Markov Chains}}},
  language = {en},
  author = {Stewart, G W},
  year = {1989},
  pages = {8},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\JPQA7BJ9\\Stewart - 1989 - On the Sensitivity of Nearly Uncoupled Markov Chai.pdf}
}

@book{stewartIntroductionNumericalSolution1994,
  address = {Princeton, N.J},
  title = {Introduction to the Numerical Solution of {{Markov}} Chains},
  isbn = {978-0-691-03699-1},
  lccn = {QA274.7 .S74 1994},
  publisher = {{Princeton University Press}},
  author = {Stewart, William J.},
  year = {1994},
  keywords = {Markov processes,Numerical solutions}
}

@book{meyerMatrixAnalysisApplied2000,
  address = {Philadelphia},
  title = {Matrix Analysis and Applied Linear Algebra},
  isbn = {978-0-89871-454-8},
  lccn = {QA188 .M495 2000},
  language = {en},
  publisher = {{Society for Industrial and Applied Mathematics}},
  author = {Meyer, C. D.},
  year = {2000},
  keywords = {Algebras; Linear,Matrices},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\QSEPF822\\Meyer - 2000 - Matrix analysis and applied linear algebra.pdf}
}

@article{friedbergConvergenceMatrixPowers1992,
  title = {Convergence of Matrix Powers},
  volume = {23},
  issn = {0020-739X, 1464-5211},
  language = {en},
  number = {5},
  journal = {International Journal of Mathematical Education in Science and Technology},
  doi = {10.1080/0020739920230516},
  author = {Friedberg, Stephen H. and Insel, Arnold J.},
  month = sep,
  year = {1992},
  pages = {765-769},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\NHACTLYN\\Friedberg and Insel - 1992 - Convergence of matrix powers.pdf}
}

@book{levinMarkovChainsMixing,
  title = {Markov {{Chains}} and {{Mixing Times}}},
  language = {en},
  author = {Levin, David A and Peres, Yuval and Wilmer, Elizabeth L},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\GXR5RZ28\\Levin et al. - Markov Chains and Mixing Times.pdf}
}

@inproceedings{freedmanConvergenceTheoremFinite,
  title = {Convergence {{Theorem}} for {{Finite Markov Chains}}},
  abstract = {In this expository paper, I will give an overview of the necessary conditions for convergence in Markov chains on finite state spaces. In doing so, I will prove the existence and uniqueness of a stationary distribution for irreducible Markov chains, and finally the Convergence Theorem when aperiodicity is also satisfied.},
  language = {en},
  author = {Freedman, Ari},
  pages = {13},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\P7VRMEV5\\Freedman - CONVERGENCE THEOREM FOR FINITE MARKOV CHAINS.pdf}
}

@misc{InternetMappingProject,
  title = {The {{Internet Mapping Project}}},
  howpublished = {http://www.cheswick.com/ches/map/index.html},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\W8RL642G\\index.html}
}

@article{hartfielStructureStochasticMatrices1998,
  title = {On the Structure of Stochastic Matrices with a Subdominant Eigenvalue near 1},
  volume = {272},
  issn = {00243795},
  abstract = {An n \texttimes{} n irreducible stochastic matrix P can possess a subdominant eigenvalue, say {$\lambda$}2(P), near {$\lambda$} = 1. In this article we clarify the relationship between the nearness of these eigenvalues and the nearly uncoupling (some authors say ``nearly completely decomposable'') of P. We prove that for fixed n, if {$\lambda$}2(P) is sufficiently close to {$\lambda$} = 1, then P is nearly uncoupled. We then provide examples which show that {$\lambda$}2(P) must, in general, be remarkable close to 1 before such uncoupling occurs.},
  language = {en},
  number = {1-3},
  journal = {Linear Algebra and its Applications},
  doi = {10.1016/S0024-3795(97)00333-9},
  author = {Hartfiel, D.J. and Meyer, Carl D.},
  month = mar,
  year = {1998},
  pages = {193-203},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\DLZXSNLS\\Hartfiel and Meyer - 1998 - On the structure of stochastic matrices with a sub.pdf}
}

@misc{noutsosPerronFrobeniusTheory,
  title = {Perron {{Frobenius}} Theory and Some Extensions},
  language = {en},
  author = {Noutsos, Dimitrios},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\DS2MEYAN\\Noutsos - Perron Frobenius theory and some extensions.pdf}
}

@article{meyerDerivativesPerturbationsEigenvectors1988,
  title = {Derivatives and {{Perturbations}} of {{Eigenvectors}}},
  volume = {25},
  abstract = {For a matrixA(z) whoseentriesare complexvalued functionosfa complexvariablez,results are presentedconcerningderivativesof an eigenvectorx(z) of A(z) associated witha simpleeigenvalue A(z) when x(z) is restrictedto satisfya constraintof the forma(x(z))= 1 where a is a ratherarbitrary scalingfunction.The differentiatiofnormulaslead to a new approach foranalyzingthe sensitivityof an eigenvectorunder small perturbationsin the underlyingmatrix.Finally,an application is given which concernsthe analysisof a finiteMarkovchain subjectto perturbationisn thetransitionprobabilities.},
  language = {en},
  number = {3},
  journal = {SIAM Journal on Numerical Analysis},
  author = {Meyer, Carl D. and Stewart, G. W.},
  year = {1988},
  pages = {679-691},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\BA9PIHC7\\Meyer and Stewart - 1988 - Derivatives and Perturbations of Eigenvectors.pdf}
}

@article{deyConvergencePeriodicMarkov,
  title = {Convergence for Periodic {{Markov}} Chains},
  language = {en},
  author = {Dey, Partha S and Song, Yanglei},
  pages = {5},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\68RQMIIL\\Dey and Song - Convergence for periodic Markov chains.pdf}
}

@article{bryan250000002006,
  title = {The \$25,000,000,000 {{Eigenvector}}: {{The Linear Algebra}} behind {{Google}}},
  volume = {48},
  issn = {0036-1445, 1095-7200},
  shorttitle = {The \$25,000,000,000 {{Eigenvector}}},
  abstract = {Google's success derives in large part from its PageRank algorithm, which ranks the importance of webpages according to an eigenvector of a weighted link matrix. Analysis of the PageRank formula provides a wonderful applied topic for a linear algebra course. Instructors may assign this article as a project to more advanced students, or spend one or two lectures presenting the material with assigned homework from the exercises. This material also complements the discussion of Markov chains in matrix algebra. Maple and Mathematica files supporting this material can be found at www.rose-hulman.edu/{$\sim$}bryan.},
  language = {en},
  number = {3},
  journal = {SIAM Review},
  doi = {10.1137/050623280},
  author = {Bryan, Kurt and Leise, Tanya},
  month = jan,
  year = {2006},
  pages = {569-581},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\N4T49NGH\\Bryan and Leise - 2006 - The $25,000,000,000 Eigenvector The Linear Algebr.pdf}
}

@article{zhukovStructuralAnalysisVisualization,
  title = {Structural {{Analysis}} and {{Visualization}} of {{Networks}}},
  language = {en},
  author = {Zhukov, Leonid E},
  pages = {31},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\WCL46QTL\\Zhukov - Structural Analysis and Visualization of Networks.pdf}
}

@inproceedings{barabasiScaleFreeNetworks,
  title = {Scale-{{Free Networks}}},
  author = {Barabasi},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\K2YEC2ST\\124.pdf}
}

@article{haveliwalaSecondEigenvalueGoogle,
  title = {The {{Second Eigenvalue}} of the {{Google Matrix}}},
  abstract = {We determine analytically the modulus of the second eigenvalue for the web hyperlink matrix used by Google for computing PageRank. Specifically, we prove the following statement: ``For any matrix A = [cP + (1 - c)E]T , where P is an n \texttimes{} n row-stochastic matrix, E is a nonnegative n \texttimes{} n rank-one row-stochastic matrix, and 0 {$\leq$} c {$\leq$} 1, the second eigenvalue of A has modulus |{$\lambda$}2| {$\leq$} c. Furthermore, if P has at least two irreducible closed subsets, the second eigenvalue {$\lambda$}2 = c.'' This statement has implications for the convergence rate of the standard PageRank algorithm as the web scales, for the stability of PageRank to perturbations to the link structure of the web, for the detection of Google spammers, and for the design of algorithms to speed up PageRank.},
  language = {en},
  author = {Haveliwala, Taher H and Kamvar, Sepandar D},
  pages = {8},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\727GZAUS\\Haveliwala and Kamvar - The Second Eigenvalue of the Google Matrix.pdf}
}

@article{stewartDirectMethodSolution1991,
  title = {On a Direct Method for the Solution of Nearly Uncoupled {{Markov}} Chains},
  volume = {59},
  issn = {0029-599X, 0945-3245},
  abstract = {This note is concerned with the accuracy of the solution of nearly uncoupled Markov chains by a direct method based on the LU decomposition. It is shown that plain Gaussian elimination may fail in the presence of rounding errors. A modi cation of Gaussian elimination with diagonal pivoting as well as corrections of small pivots by sums of o -diagonal elements in the pivoting columns is proposed and analyzed. It is shown that the accuracy of the solution is a ected by two condition numbers associate with the aggregate and the coupling respectively.},
  language = {en},
  number = {1},
  journal = {Numerische Mathematik},
  doi = {10.1007/BF01385767},
  author = {Stewart, G. W. and Zhang, G.},
  month = dec,
  year = {1991},
  pages = {1-11},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\57D9EVGR\\Stewart and Zhang - 1991 - On a direct method for the solution of nearly unco.pdf}
}

@article{bianchiniPageRank,
  title = {Inside {{PageRank}}},
  author = {Bianchini, Monica},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\4LUCEME4\\p92-bianchini.pdf}
}

@article{fasinoNonnegativeSpectralMatrix,
  title = {Nonnegative and Spectral Matrix Theory {{Lecture}} Notes},
  language = {en},
  author = {Fasino, Dario},
  pages = {6},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\VIHYNXFC\\Fasino - Nonnegative and spectral matrix theory Lecture not.pdf}
}

@article{meyerStochasticComplementationUncoupling1989,
  title = {Stochastic {{Complementation}}, {{Uncoupling Markov Chains}}, and the {{Theory}} of {{Nearly Reducible Systems}}},
  volume = {31},
  copyright = {[Copyright] \textcopyright{} 1989 \textcopyright{} Society for Industrial and Applied Mathematics},
  issn = {00361445},
  abstract = {A concept called stochastic complementation is an idea which occurs naturally, although not always explicitly, in the theory and application of finite Markov chains. This paper brings this idea to the forefront with an explicit definition and a development of some of its properties. Applications of stochastic complementation are explored with respect to problems involving uncoupling procedures in the theory of Markov chains. Furthermore, the role of stochastic complementation in the development of the classical Simon-Ando theory of nearly reducible system is presented},
  language = {English},
  number = {2},
  journal = {SIAM Review; Philadelphia},
  doi = {http://dx.doi.org/10.1137/1031050},
  author = {Meyer, Carl D.},
  month = jun,
  year = {1989},
  keywords = {Mathematics,Technology: Comprehensive Works},
  pages = {33},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\PIR8LY6U\\Meyer - 1989 - Stochastic Complementation, Uncoupling Markov Chai.pdf}
}

@article{maccluerManyProofsApplications2000,
  title = {The {{Many Proofs}} and {{Applications}} of {{Perron}}'s {{Theorem}}},
  volume = {42},
  issn = {0036-1445, 1095-7200},
  abstract = {This paper chronicles the wide dispersal of Perron's 1907 result on positive matrices into many fields of science. The many proofs given during the last 93 years are categorized and critiqued (including Perron's original two proofs), and a more natural proof is presented. This simple-to-understand result of Perron provides a unequaled vehicle for taking students on a tour of many applied areas with some depth.},
  language = {en},
  number = {3},
  journal = {SIAM Review},
  doi = {10.1137/S0036144599359449},
  author = {MacCluer, C. R.},
  month = jan,
  year = {2000},
  pages = {487-498},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\S3FKAYZT\\MacCluer - 2000 - The Many Proofs and Applications of Perron's Theor.pdf}
}

@misc{PhysicsWeb2001,
  title = {The Physics of the {{Web}}},
  abstract = {The internet appears to have taken on a life of its own ever since the National Science Foundation in the US gave up stewardship of the network in 1995. New lines and routers are added continually by thousands of companies, none of which require permission from anybody to do so, and none of which are \ldots{}},
  language = {en-GB},
  journal = {Physics World},
  howpublished = {https://physicsworld.com/a/the-physics-of-the-web/},
  month = jul,
  year = {2001},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\8NLCQKTD\\the-physics-of-the-web.html}
}

@incollection{LinkAnalysis,
  title = {Link {{Analysis}}},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\IYJ5J78R\\ch5.pdf}
}

@misc{JessicaSu,
  title = {Jessica {{Su}}},
  howpublished = {http://snap.stanford.edu/class/cs224w-2017/slides/handout-page\_rank.pdf},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\GPUUDZFL\\handout-page_rank.pdf}
}

@misc{AsishGoel,
  title = {Asish {{Goel}}},
  howpublished = {https://web.stanford.edu/\textasciitilde{}ashishg/msande235/spr08\_09/Lecture10.pdf},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\YPY6TDWX\\Lecture10.pdf}
}

@article{boccardLandauLegacyChess2017,
  title = {The {{Landau Legacy}}: {{From Chess}} to {{Pagerank}}},
  issn = {1556-5068},
  shorttitle = {The {{Landau Legacy}}},
  abstract = {Social sciences routinely use pairwise comparisons to rank or classify multidimensional items. A century ago, German mathematician Edmund Landau contributed the ranking rule underlying Google's celebrated PageRank algorithm. We show how this method flows naturally from the most intuitive classification that arose with chess tournaments. Next, we recast a number of ranking theories within Landau's framework, thereby showing similarities and the ease with which each may be deduced from the previous one. The fields covered are sports, sociology, social choice, bibliometrics, internet ranking, learning, network economics and management. We show that the Landau method is close to the Leontief inputoutput model and how the former is a limit of the latter. Lastly, we give self-contained proofs of the Perron and Frobenius theorems whose use in the social sciences Landau pioneered.},
  language = {en},
  journal = {SSRN Electronic Journal},
  doi = {10.2139/ssrn.2945389},
  author = {Boccard, Nicolas},
  year = {2017},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\YIW69W7B\\Boccard - 2017 - The Landau Legacy From Chess to Pagerank.pdf}
}

@article{broderGraphStructureWeb,
  title = {Graph Structure in the Web},
  abstract = {The study of the web as a graph is not only fascinating in its own right, but also yields valuable insight into web algorithms for crawling, searching and community discovery, and the sociological phenomena which characterize its evolution. We report on experiments on local and global properties of the web graph using two Altavista crawls each with over 200 million pages and 1.5 billion links. Our study indicates that the macroscopic structure of the web is considerably more intricate than suggested by earlier experiments on a smaller scale.},
  language = {en},
  author = {Broder, Andrei and Kumar, Ravi and Maghoul, Farzin and Raghavan, Prabhakar and Rajagopalan, Sridhar and Stata, Raymie and Tomkins, Andrew and Wiener, Janet},
  pages = {15},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\IV8N8NKH\\Broder et al. - Graph structure in the web.pdf}
}

@article{meerbachEigenvalueBoundsRestrictions2005,
  title = {Eigenvalue Bounds on Restrictions of Reversible Nearly Uncoupled {{Markov}} Chains},
  volume = {398},
  issn = {00243795},
  abstract = {In this paper we analyze decompositions of reversible nearly uncoupled Markov chains into rapidly mixing subchains. We state upper bounds on the 2nd eigenvalue for restriction and stochastic complementation chains of reversible Markov chains, as well as a relation between them. We illustrate the obtained bounds analytically for bunkbed graphs, and furthermore apply them to restricted Markov chains that arise when analyzing conformation dynamics of a small biomolecule.},
  language = {en},
  journal = {Linear Algebra and its Applications},
  doi = {10.1016/j.laa.2004.10.018},
  author = {Meerbach, Eike and Sch\"utte, Christof and Fischer, Alexander},
  month = mar,
  year = {2005},
  pages = {141-160},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\XM6TYJ7X\\Meerbach et al. - 2005 - Eigenvalue bounds on restrictions of reversible ne.pdf}
}

@article{boyleBasicPerronFrobeniusTheory,
  title = {Basic {{Perron}}-{{Frobenius Theory}} and {{Spectral Problems}}},
  language = {en},
  author = {Boyle, Mike},
  pages = {12},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\295M3KRD\\Boyle - I. BASIC PERRON FROBENIUS THEORY AND INVERSE SPECT.pdf}
}

@misc{RandomGeometricGraph,
  title = {Random Geometric Graph},
  language = {en},
  howpublished = {https://www.wikidata.org/wiki/Q7291969},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\VF89VYDU\\Q7291969.html}
}

@misc{wangKineticConformationalCharacterization,
  title = {Kinetic and {{Conformational Characterization}} of {{Transcriptional Activator}}-{{Coactivator Interactions}}},
  abstract = {ResearchGate is a network dedicated to science and research. Connect, collaborate and discover scientific publications, jobs and conferences. All for free.},
  language = {en},
  journal = {ResearchGate},
  howpublished = {https://deepblue.lib.umich.edu/handle/2027.42/100048},
  author = {Wang, Ningkun},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\32SUV6BB\\figures.html}
}

@misc{InternetMap,
  title = {Internet Map},
  language = {en},
  howpublished = {https://www.wikidata.org/wiki/Q910404},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\NARGZ6MD\\Q910404.html}
}

@misc{zotero-1716,
  howpublished = {https://upload.wikimedia.org/wikipedia/commons/6/66/Random\_geometric\_graph.svg},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\U7EEMVQN\\Random_geometric_graph.html}
}

@article{barabasiNETWORKSCIENCESCALEFREE,
  title = {{{NETWORK SCIENCE THE SCALE}}-{{FREE PROPERTY}}},
  language = {en},
  author = {Barab\'asi, Albert-L\'aszl\'o},
  pages = {57},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\WB2XRJ3K\\Barabási - NETWORK SCIENCE THE SCALE-FREE PROPERTY.pdf}
}

@article{kamvarAdaptiveMethodsComputation2004,
  title = {Adaptive Methods for the Computation of {{PageRank}}},
  volume = {386},
  issn = {00243795},
  abstract = {We observe that the convergence patterns of pages in the PageRank algorithm have a nonuniform distribution. Specifically, many pages converge to their true PageRank quickly, while relatively few pages take a much longer time to converge. Furthermore, we observe that these slow-converging pages are generally those pages with high PageRank. We use this observation to devise a simple algorithm to speed up the computation of PageRank, in which the PageRank of pages that have converged are not recomputed at each iteration after convergence. This algorithm, which we call Adaptive PageRank, speeds up the computation of PageRank by nearly 30\%.},
  language = {en},
  journal = {Linear Algebra and its Applications},
  doi = {10.1016/j.laa.2003.12.008},
  author = {Kamvar, Sepandar and Haveliwala, Taher and Golub, Gene},
  month = jul,
  year = {2004},
  pages = {51-65},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\49GUTNAF\\Kamvar et al. - 2004 - Adaptive methods for the computation of PageRank.pdf}
}

@article{kamvarExploitingBlockStructure2003,
  title = {Exploiting the {{Block Structure}} of the {{Web}} for {{Computing PageRank}}},
  abstract = {The web link graph has a nested block structure: the vast majority of hyperlinks link pages on a host to other pages on the same host, and many of those that do not link pages within the same domain. We show how to exploit this structure to speed up the computation of PageRank by a 3-stage algorithm whereby (1)\textasciitilde{}the local PageRanks of pages for each host are computed independently using the link structure of that host, (2)\textasciitilde{}these local PageRanks are then weighted by the ``importance'' of the corresponding host, and (3)\textasciitilde{}the standard PageRank algorithm is then run using as its starting vector the weighted aggregate of the local PageRanks.  Empirically, this algorithm speeds up the computation of PageRank by a factor of 2 in realistic scenarios.  Further, we develop a variant of this algorithm that efficiently computes many different ``personalized'' PageRanks, and a variant that efficiently recomputes PageRank after node updates.},
  journal = {Stanford University Technical Report},
  author = {Kamvar, Sepandar and Haveliwala, Taher and Manning, Christopher and Golub, Gene},
  year = {2003},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\FEV3E4KZ\\Kamvar et al. - 2003 - Exploiting the Block Structure of the Web for Comp.pdf;C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\Z3MPF2VV\\579.html}
}

@article{haveliwalaAnalyticalComparisonApproaches2003,
  title = {An {{Analytical Comparison}} of {{Approaches}} to {{Personalizing PageRank}}},
  abstract = {PageRank, the popular link-analysis algorithm for ranking web pages, assigns a query and user independent estimate of "importance" to web pages.  Query and user sensitive extensions of PageRank, which use a basis set of biased PageRank vectors, have been proposed in order to personalize the ranking function in a tractable way.  We analytically compare three recent approaches to personalizing PageRank and discuss the tradeoffs of each one.},
  author = {Haveliwala, Taher and Kamvar, Sepandar and Jeh, Glen},
  month = jun,
  year = {2003},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\G7K5MU2M\\Haveliwala et al. - 2003 - An Analytical Comparison of Approaches to Personal.pdf;C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\5W6347XV\\596.html}
}

@misc{TotalNumberWebsites,
  title = {Total Number of {{Websites}}},
  abstract = {How many websites are there on the Web? Number of websites by year and growth from 1991 to 2016. Historical count and popular websites starting from the first website until today. Charts, real time counter, and interesting info.},
  language = {en},
  howpublished = {https://www.internetlivestats.com/total-number-of-websites/},
  file = {C:\\Users\\Nathanael Gentry\\OneDrive - Liberty University\\documents\\zotero\\storage\\I6Z9L28T\\total-number-of-websites.html}
}

repository: npjg/exploring-pagerank

repo_name: npjg/exploring-pagerank


text:
SUMMARY = "PC-Engine emulator"
DESCRIPTION = "PCEngine emu - Mednafen PCE Fast port for libretro"

LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=6e233eda45c807aa29aeaa6d94bc48a2"

inherit libretro

LIBRETRO_CORE = "mednafen_pce_fast"
LIBRETRO_GIT_REPO = "github.com/libretro/beetle-pce-fast-libretro.git"

gha_license_id: MIT

gha_language: BitBake


text:
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/opencars/edrmvs/pkg/domain (interfaces: FullRegistrationStore)

// Package mockstore is a generated GoMock package.
package mockstore

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"

	model "github.com/opencars/edrmvs/pkg/domain/model"
)

// MockFullRegistrationStore is a mock of FullRegistrationStore interface.
type MockFullRegistrationStore struct {
	ctrl     *gomock.Controller
	recorder *MockFullRegistrationStoreMockRecorder
}

// MockFullRegistrationStoreMockRecorder is the mock recorder for MockFullRegistrationStore.
type MockFullRegistrationStoreMockRecorder struct {
	mock *MockFullRegistrationStore
}

// NewMockFullRegistrationStore creates a new mock instance.
func NewMockFullRegistrationStore(ctrl *gomock.Controller) *MockFullRegistrationStore {
	mock := &MockFullRegistrationStore{ctrl: ctrl}
	mock.recorder = &MockFullRegistrationStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFullRegistrationStore) EXPECT() *MockFullRegistrationStoreMockRecorder {
	return m.recorder
}

// AllSeries mocks base method.
func (m *MockFullRegistrationStore) AllSeries(arg0 context.Context) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSeries", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSeries indicates an expected call of AllSeries.
func (mr *MockFullRegistrationStoreMockRecorder) AllSeries(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSeries", reflect.TypeOf((*MockFullRegistrationStore)(nil).AllSeries), arg0)
}

// Create mocks base method.
func (m *MockFullRegistrationStore) Create(arg0 context.Context, arg1 *model.Registration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockFullRegistrationStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFullRegistrationStore)(nil).Create), arg0, arg1)
}

// FindByCode mocks base method.
func (m *MockFullRegistrationStore) FindByCode(arg0 context.Context, arg1 string) (*model.Registration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByCode", arg0, arg1)
	ret0, _ := ret[0].(*model.Registration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByCode indicates an expected call of FindByCode.
func (mr *MockFullRegistrationStoreMockRecorder) FindByCode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByCode", reflect.TypeOf((*MockFullRegistrationStore)(nil).FindByCode), arg0, arg1)
}

// FindByNumber mocks base method.
func (m *MockFullRegistrationStore) FindByNumber(arg0 context.Context, arg1 string) ([]model.Registration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByNumber", arg0, arg1)
	ret0, _ := ret[0].([]model.Registration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByNumber indicates an expected call of FindByNumber.
func (mr *MockFullRegistrationStoreMockRecorder) FindByNumber(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByNumber", reflect.TypeOf((*MockFullRegistrationStore)(nil).FindByNumber), arg0, arg1)
}

// FindByVIN mocks base method.
func (m *MockFullRegistrationStore) FindByVIN(arg0 context.Context, arg1 string) ([]model.Registration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByVIN", arg0, arg1)
	ret0, _ := ret[0].([]model.Registration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByVIN indicates an expected call of FindByVIN.
func (mr *MockFullRegistrationStoreMockRecorder) FindByVIN(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByVIN", reflect.TypeOf((*MockFullRegistrationStore)(nil).FindByVIN), arg0, arg1)
}

// FindLastBySeries mocks base method.
func (m *MockFullRegistrationStore) FindLastBySeries(arg0 context.Context, arg1 string) (*model.Registration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindLastBySeries", arg0, arg1)
	ret0, _ := ret[0].(*model.Registration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindLastBySeries indicates an expected call of FindLastBySeries.
func (mr *MockFullRegistrationStoreMockRecorder) FindLastBySeries(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLastBySeries", reflect.TypeOf((*MockFullRegistrationStore)(nil).FindLastBySeries), arg0, arg1)
}

// Health mocks base method.
func (m *MockFullRegistrationStore) Health(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Health", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Health indicates an expected call of Health.
func (mr *MockFullRegistrationStoreMockRecorder) Health(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockFullRegistrationStore)(nil).Health), arg0)
}

repository: opencars/edrmvs

repo_name: opencars/edrmvs


text:
// Code generated by MockGen. DO NOT EDIT.
// Source: golang.org/x/crypto/sha3 (interfaces: ShakeHash)

// Package crypto is a generated GoMock package.
package crypto

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	sha3 "golang.org/x/crypto/sha3"
)

// MockShakeHash is a mock of ShakeHash interface.
type MockShakeHash struct {
	ctrl     *gomock.Controller
	recorder *MockShakeHashMockRecorder
}

// MockShakeHashMockRecorder is the mock recorder for MockShakeHash.
type MockShakeHashMockRecorder struct {
	mock *MockShakeHash
}

// NewMockShakeHash creates a new mock instance.
func NewMockShakeHash(ctrl *gomock.Controller) *MockShakeHash {
	mock := &MockShakeHash{ctrl: ctrl}
	mock.recorder = &MockShakeHashMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockShakeHash) EXPECT() *MockShakeHashMockRecorder {
	return m.recorder
}

// Clone mocks base method.
func (m *MockShakeHash) Clone() sha3.ShakeHash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone")
	ret0, _ := ret[0].(sha3.ShakeHash)
	return ret0
}

// Clone indicates an expected call of Clone.
func (mr *MockShakeHashMockRecorder) Clone() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockShakeHash)(nil).Clone))
}

// Read mocks base method.
func (m *MockShakeHash) Read(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockShakeHashMockRecorder) Read(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockShakeHash)(nil).Read), arg0)
}

// Reset mocks base method.
func (m *MockShakeHash) Reset() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset")
}

// Reset indicates an expected call of Reset.
func (mr *MockShakeHashMockRecorder) Reset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockShakeHash)(nil).Reset))
}

// Write mocks base method.
func (m *MockShakeHash) Write(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockShakeHashMockRecorder) Write(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockShakeHash)(nil).Write), arg0)
}


text:
@book{144,
	title = "The art of computer programming /",
	address = "Reading, Mass. :",
	publisher = "Addison-Wesley Pub. Co.,",
	year = "c1973-c1981."
}

extension: bibtex


text:
require dnsmasq.inc

SRC_URI += "\
    file://lua.patch \
"

SRC_URI[dnsmasq-2.76.md5sum] = "6610f8233ca89b15a1bb47c788ffb84f"
SRC_URI[dnsmasq-2.76.sha256sum] = "777c4762d2fee3738a0380401f2d087b47faa41db2317c60660d69ad10a76c32"

repository: nedap/meta-openembedded

repo_name: nedap/meta-openembedded


text:
@InProceedings{xua15,
  supplementary = {Supplementary:xua15-supp.pdf},
  title = {CUR Algorithm for Partially Observed Matrices},
  author = {Miao Xu and Rong Jin and Zhi-Hua Zhou},
  pages = {1412-1421},
  abstract = {CUR matrix decomposition computes the low rank approximation of a given matrix by using the actual rows and columns of the matrix. It has been a very useful tool for handling large matrices. One limitation with the existing algorithms for CUR matrix decomposition is that they cannot deal with entries in a {\it partially observed} matrix, while incomplete matrices are found in many real world applications. In this work, we alleviate this limitation by developing a CUR decomposition algorithm for partially observed matrices. In particular, the proposed algorithm computes the low rank approximation of the target matrix based on (i) the randomly sampled rows and columns, and (ii) a subset of observed entries that are randomly sampled from the matrix. Our analysis shows the relative error bound, measured by spectral norm, for the proposed algorithm when the target matrix is of full rank. We also show that only $O(n r\ln r)$ observed entries are needed by the proposed algorithm to perfectly recover a rank $r$ matrix of size $n\times n$, which improves the sample complexity of the existing algorithms for matrix completion. Empirical studies on both synthetic and real-world datasets verify our theoretical claims and demonstrate the effectiveness of the proposed algorithm.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
// Copyright 2019 tsuru authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"log"

	"github.com/google/gops/agent"
	"github.com/spf13/viper"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"

	"github.com/tsuru/rpaas-operator/api/v1alpha1"
	"github.com/tsuru/rpaas-operator/internal/config"
	"github.com/tsuru/rpaas-operator/pkg/web"
	"github.com/tsuru/rpaas-operator/pkg/web/target"
)

func main() {
	if err := config.Init(); err != nil {
		log.Fatalf("could not initialize RPaaS configurations: %v", err)
	}

	if err := agent.Listen(agent.Options{}); err != nil {
		log.Fatalf("could not initialize gops agent: %v", err)
	}
	defer agent.Close()

	cfg := config.Get()
	isFakeServerAPI := viper.GetBool("fake-api")

	var targetFactory target.Factory
	var err error
	if cfg.MultiCluster {
		targetFactory = target.NewMultiClustersFactory(cfg.Clusters)
	} else if isFakeServerAPI {
		log.Println("Starting a Fake API Server (without K8s)...")
		targetFactory, err = target.NewFakeServerFactory(fakeRuntimeObjects())
		if err != nil {
			log.Fatalf("could not initialize fake cluster target: %v", err)
		}
	} else {
		targetFactory, err = target.NewKubeConfigFactory()
		if err != nil {
			log.Fatalf("could not initialize cluster target: %v", err)
		}
	}

	a, err := web.NewWithTargetFactoryWithDefaults(targetFactory)
	if err != nil {
		log.Fatalf("could not create RPaaS API: %v", err)
	}

	if err := a.Start(); err != nil {
		log.Fatalf("could not start the RPaaS API server: %v", err)
	}
}

func fakeRuntimeObjects() []runtime.Object {
	return []runtime.Object{
		&v1alpha1.RpaasPlan{
			ObjectMeta: metav1.ObjectMeta{
				Name:      "my-plan",
				Namespace: "rpaasv2",
			},
		},
		&v1alpha1.RpaasInstance{
			ObjectMeta: metav1.ObjectMeta{
				Name:      "my-rpaas",
				Namespace: "rpaasv2",
			},
		},
	}
}

repository: tsuru/rpaas-operator

repo_name: tsuru/rpaas-operator


text:
// Copyright (c) 2019 Uber Technologies, Inc.
//
// 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 adminsvc

import (
	"github.com/uber/peloton/.gen/peloton/api/v1alpha/admin/svc"
	"github.com/uber/peloton/pkg/jobmgr/task/lifecyclemgr"
)

type killLockComponent struct {
	lockable lifecyclemgr.Lockable
}

func (c *killLockComponent) lock() error {
	c.lockable.LockKill()
	return nil
}

func (c *killLockComponent) unlock() error {
	c.lockable.UnlockKill()
	return nil
}

func (c *killLockComponent) component() svc.Component {
	return svc.Component_Kill
}

type launchLockComponent struct {
	lockable lifecyclemgr.Lockable
}

func (c *launchLockComponent) lock() error {
	c.lockable.LockLaunch()
	return nil
}

func (c *launchLockComponent) unlock() error {
	c.lockable.UnlockLaunch()
	return nil
}

func (c *launchLockComponent) component() svc.Component {
	return svc.Component_Launch
}

repository: fakeNetflix/uber-repo-peloton

repo_name: fakeNetflix/uber-repo-peloton