text:
. While the mean pathways are known, the contribution to the mixing and transport of the water from mesoscale eddies has not been comprehensively investigated. In this research, satellite altimetry data, combined with an eddy detection and tracking algorithm is used to investigate the distribution and surface characteristics of mesoscale eddies in this region of complex bathymetry (10°S?30°S, 140°E?190°E). Detected eddies are then colocalized with in situ data from Argo floats to determine their vertical structure and the effect of eddies on the water masses. The numerous islands affect the eddy behavior as most eddies are formed in the lee of islands, propagate westward and decay when encountering shallow bathymetry. Eddies are sparse and short-lived in the tropical area north of Fiji, impacting only the top 200 meters of water. They do not appear to be able to trap and transport waters in this region. In the Coral Sea, a region of lateral shear between currents transporting waters of different origins, eddies are more numerous and energetic. They affect the water properties down to at least 500 m depth, and anticyclonic eddies trap water to ?200 m, contributing to the upper thermocline waters mixing and transport. South of New Caledonia, mesoscale eddies are ubiquitous, with typical lifetimes longer than 5 months. They affect the temperature, salinity, and velocities down to ?1,000 m depth, and weakly contribute to the mixing of lower thermocline waters.},
	number = {4},
	urldate = {2019-06-26},
	journal = {Journal of Geophysical Research: Oceans},
	author = {Keppler, L. and Cravatte, S. and Chaigneau, A. and Pegliasco, C. and Gourdeau, L. and Singh, A.},
	month = apr,
	year = {2018},
	keywords = {mesoscale eddies, argo floats, satellite altimetry, southwest Pacific},
	pages = {2731--2756},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/SFYEERDT/Keppler et al. - 2018 - Observed Characteristics and Vertical Structure of.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/BNKKU939/2017JC013712.html:text/html}
}

@article{dovidio_frontiers_2019,
	title = {Frontiers in {Fine}-{Scale} in situ {Studies}: {Opportunities} {During} the {SWOT} {Fast} {Sampling} {Phase}},
	volume = {6},
	issn = {2296-7745},
	shorttitle = {Frontiers in {Fine}-{Scale} in situ {Studies}},
	doi = {10.3389/fmars.2019.00168},
	abstract = {Conceived as a major new tool for climate studies, the Surface Water and Ocean Topography (SWOT) satellite mission will launch in late 2021 and can retrieve the dynamics of the ocean upper layer at an unprecedented resolution of a few kilometers. During the calibration and validation (CalVal) phase in 2022, the satellite will be in a 1-day-repeat fast sampling orbit with enhanced temporal resolution but sacrificing the spatial coverage. This is an ideal opportunity - unique for many years to come - for coordinating in-situ experiments during the same period for a focused study of the find scale dynamics and their broader rolesin the Earth system. Key questions to be addressed include the role of the fine scales on the ocean energy budget, the connection between their surface and internal dynamics, their impact on plankton diversity, and their biophysical dynamics at the ice margin.},
	language = {English},
	urldate = {2019-07-05},
	journal = {Frontiers in Marine Science},
	author = {d’Ovidio, F. and Pascual, A. and Wang, J. and Doglioli, A. M. and Jing, Z. and Moreau, S. and Grégori, G. and Swart, S. and Speich, S. and Cyr, F. and Legresy, B. and Chao, Y. and Fu, L. and Morrow, R.},
	year = {2019},
	keywords = {mesoscale, biogeochemial processes, Energy cascade, ocean dynamics, remote sensing, Submesoscale},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/7M2F35YN/d’Ovidio et al. - 2019 - Frontiers in Fine-Scale in situ Studies Opportuni.pdf:application/pdf}
}

@article{marchesiello_coastal_2010,
	series = {New {Caledonia} tropical lagoons: an overview of multidisciplinary investigations},
	title = {Coastal upwelling, circulation and heat balance around {New} {Caledonia}’s barrier reef},
	volume = {61},
	issn = {0025-326X},
	doi = {10.1016/j.marpolbul.2010.06.043},
	abstract = {An outstanding characteristic of New Caledonia upwelling is that most events appear limited to the southern half of the western barrier reef. This north–south difference cannot be explained by alongshore variability of the projected wind stress and no strong evidence for alternative explanations has been proposed. A major objective of this paper is to provide the first dynamical analysis of New Caledonia upwelling and its regional environment, based on numerical simulations. Coastal upwelling around New Caledonia is shown to be modulated by a system of geostrophic currents interacting with the island mass. Upwelling velocities are weaker than expected from the two-dimensional Ekman theory, as Ekman divergence is balanced by “coastal geostrophic convergence”. The cooling effect of upwelling is also attenuated by alongshore transport of warm water by the Alis current, reminiscent of the Leeuwin current off Western Australia. Nevertheless, coastal upwelling can locally modify the large-scale surface water heat budget, dominated by meridional advection warming and surface cooling. The upwelled waters appear to be mostly of western origin and are transported below the surface by the Subtropical Counter Current before upwelling off New Caledonia. This appears in sharp contrast with the eastern barrier reef where the general warming by meridional advection of tropical surface waters is accentuated by the vigorous western boundary type Vauban current.},
	number = {7},
	urldate = {2019-07-05},
	journal = {Marine Pollution Bulletin},
	author = {Marchesiello, P. and Lefèvre, J. and Vega, A. and Couvelard, X. and Menkes, C.},
	month = jan,
	year = {2010},
	keywords = {Coastal upwelling, New Caledonia, Regional ocean circulation},
	pages = {432--448},
	file = {ScienceDirect Snapshot:/Users/serazin/Zotero/storage/AM6Q7RTE/S0025326X10002869.html:text/html}
}

@article{henin_circulation_1984,
	title = {Circulation superficielle autour de la {Nouvelle}-{Calédonie}},
	volume = {19},
	issn = {0245-9418},
	language = {fre},
	number = {2},
	urldate = {2019-07-05},
	journal = {Océanographie Tropicale},
	author = {Hénin, C. and Guillerm, J.-M. and Chabert, L.},
	year = {1984},
	keywords = {CIRCULATION OCEANIQUE, COURANT COTIER, COURANT DE DERIVE, COURANT DE PENTE, COURANT GEOSTROPHIQUE, COURANT SUPERFICIEL, HYDROLOGIE MARINE},
	pages = {113--126}
}

@article{srinivasan_submesoscale_2019,
	title = {Submesoscale {Vortical} {Wakes} in the {Lee} of {Topography}},
	volume = {49},
	issn = {0022-3670},
	doi = {10.1175/JPO-D-18-0042.1},
	abstract = {An idealized framework of steady barotropic flow past an isolated seamount in a background of constant stratification (with frequency N) and rotation (with Coriolis parameter f) is used to examine the formation, separation, instability of the turbulent bottom boundary layers (BBLs), and ultimately, the genesis of submesoscale coherent vortices (SCVs) in the ocean interior. The BBLs generate vertical vorticity ζ and potential vorticity q on slopes; the flow separates and spawns shear layers; barotropic and centrifugal shear instabilities form submesoscale vortical filaments and induce a high rate of local energy dissipation; the filaments organize into vortices that then horizontally merge and vertically align to form SCVs. These SCVs have O(1) Rossby numbers () and horizontal and vertical scales that are much larger than those of the separated shear layers and associated vortical filaments. Although the upstream flow is barotropic, downstream baroclinicity manifests in the wake, depending on the value of the nondimensional height , which is the ratio of the seamount height  to that of the Taylor height , where L is the seamount half-width. When , SCVs span the vertical extent of the seamount itself. However, for , there is greater range of variation in the sizes of the SCVs in the wake, reflecting the wake baroclinicity caused by the topographic interaction. The aspect ratio of the wake SCVs has the scaling , instead of the quasigeostrophic scaling .},
	number = {7},
	urldate = {2019-07-16},
	journal = {Journal of Physical Oceanography},
	author = {Srinivasan, K. and McWilliams, J. C. and Molemaker, M. J. and Barkan, R.},
	month = mar,
	year = {2019},
	pages = {1949--1971},
	file = {Snapshot:/Users/serazin/Zotero/storage/TQSN5WIF/JPO-D-18-0042.html:text/html}
}

@article{srinivasan_topographic_2017,
	title = {Topographic and {Mixed} {Layer} {Submesoscale} {Currents} in the {Near}-{Surface} {Southwestern} {Tropical} {Pacific}},
	volume = {47},
	issn = {0022-3670},
	doi = {10.1175/JPO-D-16-0216.1},
	abstract = {The distribution and strength of submesoscale (SM) surface layer fronts and filaments generated through mixed layer baroclinic energy conversion and submesoscale coherent vortices (SCVs) generated by topographic drag are analyzed in numerical simulations of the near-surface southwestern Pacific, north of 16°S. In the Coral Sea a strong seasonal cycle in the surface heat flux leads to a winter SM “soup” consisting of baroclinic mixed layer eddies (MLEs), fronts, and filaments similar to those seen in other regions farther away from the equator. However, a strong wind stress seasonal cycle, largely in sync with the surface heat flux cycle, is also a source of SM processes. SM restratification fluxes show distinctive signatures corresponding to both surface cooling and wind stress. The winter peak in SM activity in the Coral Sea is not in phase with the summer dominance of the mesoscale eddy kinetic energy in the region, implying that local surface layer forcing effects are more important for SM generation than the nonlocal eddy deformation field. In the topographically complex Solomon and Bismarck Seas, a combination of equatorial proximity and boundary drag generates SCVs with large-vorticity Rossby numbers (Ro {\textasciitilde} 10). River outflows in the Bismarck and Solomon Seas make a contribution to SM generation, although they are considerably weaker than the topographic effects. Mean to eddy kinetic energy conversions implicate barotropic instability in SM topographic wakes, with the strongest values seen north of the Vitiaz Strait along the coast of Papua New Guinea.},
	number = {6},
	urldate = {2019-07-16},
	journal = {Journal of Physical Oceanography},
	author = {Srinivasan, K. and McWilliams, J. C. and Renault, L. and Hristova, H. G. and Molemaker, J. and Kessler, William S.},
	month = may,
	year = {2017},
	pages = {1221--1242},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/C73FND5X/Srinivasan et al. - 2017 - Topographic and Mixed Layer Submesoscale Currents .pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/SSCHWQZF/JPO-D-16-0216.html:text/html}
}

@article{lahaye_sea_2019,
	title = {Sea {Surface} {Signature} of {Internal} {Tides}},
	volume = {46},
	copyright = {©2019. American Geophysical Union. All Rights Reserved.},
	issn = {1944-8007},
	doi = {10.1029/2018GL081848},
	abstract = {The upper ocean is energetic at scales below the Rossby deformation radius owing to the existence of internal waves and submesoscale fronts and vortices. These contribute significantly to energy dissipation, tracer mixing, and exchanges between the ocean surface layer, the ocean interior, and the atmospheric boundary layer. Internal waves and submesoscale motions both undergo strong spatial and seasonal variations, driven by different mechanisms. Here, we investigate the sea surface signature of internal waves and its seasonality using linear wave theory and a high-resolution realistic simulation. In summer, internal waves are greatly amplified near the surface mostly due to a thin mixed layer bounded by a seasonal pycnocline. This surface amplification is well captured by linear theory, provided that the stratification at the base of the mixed layer is accurately represented. In winter, the superinertial motions are not fully explained by linear theory, reflecting impacts of the more energetic submesoscale motions.},
	language = {en},
	number = {7},
	urldate = {2019-08-01},
	journal = {Geophysical Research Letters},
	author = {Lahaye, N. and Gula, J. and Roullet, G.},
	year = {2019},
	keywords = {internal tide, seasonality, submesosacle dynamics},
	pages = {3880--3890},
	file = {Snapshot:/Users/serazin/Zotero/storage/I54NTANH/2018GL081848.html:text/html}
}

@article{rocha_seasonality_2016,
	title = {Seasonality of submesoscale dynamics in the {Kuroshio} {Extension}},
	volume = {43},
	copyright = {©2016. American Geophysical Union. All Rights Reserved.},
	issn = {1944-8007},
	doi = {10.1002/2016GL071349},
	abstract = {Recent studies show that the vigorous seasonal cycle of the mixed layer modulates upper ocean submesoscale turbulence. Here we provide model-based evidence that the seasonally changing upper ocean stratification in the Kuroshio Extension also modulates submesoscale (here 10–100 km) inertia-gravity waves. Summertime restratification weakens submesoscale turbulence but enhances inertia-gravity waves near the surface. Thus, submesoscale turbulence and inertia-gravity waves undergo vigorous out-of-phase seasonal cycles. These results imply a strong seasonal modulation of the accuracy of geostrophic velocity diagnosed from submesoscale sea surface height delivered by the Surface Water and Ocean Topography satellite mission.},
	language = {en},
	number = {21},
	urldate = {2019-08-01},
	journal = {Geophysical Research Letters},
	author = {Rocha, C. B. and Gille, S. T. and Chereskin, T. K. and Menemenlis, D.},
	year = {2016},
	keywords = {Kuroshio Extension, SWOT, COMPIRA, inertia-gravity waves, submesoscale dynamics, submesoscale turbulence},
	pages = {11,304--11,311},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/C2E5X55A/Rocha et al. - 2016 - Seasonality of submesoscale dynamics in the Kurosh.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/XS7MXB6T/2016GL071349.html:text/html}
}

@article{callies_seasonality_2015,
	title = {Seasonality in submesoscale turbulence},
	volume = {6},
	copyright = {2015 Nature Publishing Group},
	issn = {2041-1723},
	doi = {10.1038/ncomms7862},
	abstract = {Although the strongest ocean surface currents occur at horizontal scales of order 100 km, recent numerical simulations suggest that flows smaller than these mesoscale eddies can achieve important vertical transports in the upper ocean. These submesoscale flows, 1–100 km in horizontal extent, take heat and atmospheric gases down into the interior ocean, accelerating air–sea fluxes, and bring deep nutrients up into the sunlit surface layer, fueling primary production. Here we present observational evidence that submesoscale flows undergo a seasonal cycle in the surface mixed layer: they are much stronger in winter than in summer. Submesoscale flows are energized by baroclinic instabilities that develop around geostrophic eddies in the deep winter mixed layer at a horizontal scale of order 1–10 km. Flows larger than this instability scale are energized by turbulent scale interactions. Enhanced submesoscale activity in the winter mixed layer is expected to achieve efficient exchanges with the permanent thermocline below.},
	language = {en},
	urldate = {2019-08-01},
	journal = {Nature Communications},
	author = {Callies, J. and Ferrari, R. and Klymak, J. M. and Gula, J.},
	month = apr,
	year = {2015},
	pages = {6862},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/QV9LTH7F/Callies et al. - 2015 - Seasonality in submesoscale turbulence.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/6GRCSNIZ/ncomms7862.html:text/html}
}

@article{vic_deep-ocean_2019,
	title = {Deep-ocean mixing driven by small-scale internal tides},
	volume = {10},
	copyright = {2019 The Author(s)},
	issn = {2041-1723},
	doi = {10.1038/s41467-019-10149-5},
	abstract = {The geography of deep-ocean mixing driven by internal tides is poorly constrained in ocean models. Here the authors unveil the global variability of energetic small-scale internal tides, combining an analytical model with satellite and in situ observations, paving the way to future parameterisations.},
	language = {En},
	number = {1},
	urldate = {2019-07-31},
	journal = {Nature Communications},
	author = {Vic, C. and Naveira Garabato, A. C. and Green, J. A. M. and Waterhouse, A. F. and Zhao, Z. and Melet, A. and de Lavergne, C. and Buijsman, M. C. and Stephenson, G. R.},
	month = may,
	year = {2019},
	pages = {2099},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/342GVIYZ/Vic et al. - 2019 - Deep-ocean mixing driven by small-scale internal t.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/WLLHFJNK/s41467-019-10149-5.html:text/html}
}

@article{de_lavergne_toward_2019,
	title = {Toward global maps of internal tide energy sinks},
	volume = {137},
	issn = {1463-5003},
	doi = {10.1016/j.ocemod.2019.03.010},
	abstract = {Internal tides power much of the observed small-scale turbulence in the ocean interior. To represent mixing induced by this turbulence in ocean climate models, the cascade of internal tide energy to dissipation scales must be understood and mapped. Here, we present a framework for estimating the geography of internal tide energy sinks. The mapping relies on the following ingredients: (i) a global observational climatology of stratification; (ii) maps of the generation of M2, S2 and K1 internal tides decomposed into vertical normal modes; (iii) simplified representations of the dissipation of low-mode internal tides due to wave-wave interactions, scattering by small-scale topography, interaction with critical slopes and shoaling; (iv) Lagrangian tracking of low-mode energy beams through observed stratification, including refraction and reflection. We thus obtain a global map of the column-integrated energy dissipation for each of the four considered dissipative processes, each of the three tidal constituents and each of the first five modes. Modes ≥6 are inferred to dissipate within the local water column at the employed half-degree horizontal resolution. Combining all processes, modes and constituents, we construct a map of the total internal tide energy dissipation, which compares well with observational inferences of internal wave energy dissipation. This result suggests that tides largely shape observed spatial contrasts of dissipation, and that the framework has potential in improving understanding and modelling of ocean mixing. However, sensitivity to poorly constrained parameters and simplifying assumptions entering the parameterized energy sinks calls for additional investigation. The attenuation of low-mode internal tides by wave-wave interactions needs particular attention.},
	urldate = {2019-07-31},
	journal = {Ocean Modelling},
	author = {de Lavergne, C. and Falahat, S. and Madec, G. and Roquet, F. and Nycander, J. and Vic, C.},
	month = may,
	year = {2019},
	keywords = {Internal tides, Parameterization, Energy dissipation, Ocean mixing},
	pages = {52--75},
	file = {ScienceDirect Full Text PDF:/Users/serazin/Zotero/storage/XQWPLITH/de Lavergne et al. - 2019 - Toward global maps of internal tide energy sinks.pdf:application/pdf;ScienceDirect Snapshot:/Users/serazin/Zotero/storage/6GDGG8LC/S1463500318302890.html:text/html}
}

@article{zhao_global_2018,
	title = {The {Global} {Mode}-2 {M}2 {Internal} {Tide}},
	volume = {123},
	issn = {2169-9275},
	doi = {10.1029/2018JC014475},
	abstract = {Abstract The mode-2 M2 internal tide is observed from satellite altimetry. It is extracted in two steps: First, the mode-2 component is separated from modes 1 and 3 by a bandpass filter with cutoff wavelengths of [0.85 1.35]??2, where ?2 is the mode-2 wavelength; and second, three mode-2 internal tidal waves are extracted by fitting plane waves in each 120 km by 120 km window. The satellite-observed mode-2 M2 internal tide underestimates its strength: It contains the phase-locked component only, missing the time-varying component; it contains the southbound/northbound component only, missing the eastbound/westbound component. The satellite results provide rich information on the global mode-2 M2 internal tide. The results show that the mode-2 M2 internal tide is ubiquitous in the ocean, and its sea surface height amplitudes are O (1 mm). The spatial patterns of mode-1 and mode-2 internal tides are very different. Mode 1 mainly originates at steep topographic features such as submarine ridges, but mode 2 is also generated at gentler topographic features such as abyssal seamounts and fracture zones. Mode-1 beams propagate O (1,000 km), while mode-2 beams can be tracked for O (100 km). Depth-integrated energy and flux are calculated using sea surface height amplitudes and conversion functions built from the World Ocean Atlas 2013. The globally integrated energy of the mode-2 M2 internal tide approximates to 8 PJ, about 22\% of mode 1 (36.4 PJ). This work suggests that higher-mode internal tides play an important role in the tidal energetics, in particular, over abyssal seamounts and fracture zones.},
	number = {11},
	urldate = {2019-08-02},
	journal = {Journal of Geophysical Research: Oceans},
	author = {Zhao, Z.},
	month = nov,
	year = {2018},
	keywords = {internal tide, satellite altimetry, baroclinic mode, fracture zone, Hawaiian Ridge, plane wave analysis},
	pages = {7725--7746},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/UBWTWMX7/Zhao - 2018 - The Global Mode-2 M2 Internal Tide.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/76UIB7RC/2018JC014475.html:text/html}
}

@article{delcroix_observed_1998,
	title = {Observed surface oceanic and atmospheric variability in the tropical {Pacific} at seasonal and {ENSO} timescales: {A} tentative overview},
	volume = {103},
	copyright = {Copyright 1998 by the American Geophysical Union.},
	issn = {2156-2202},
	shorttitle = {Observed surface oceanic and atmospheric variability in the tropical {Pacific} at seasonal and {ENSO} timescales},
	doi = {10.1029/98JC00814},
	abstract = {Seasonal and El Niño-Southern Oscillation (ENSO)-related variations of sea surface temperature (SST) and salinity (SSS), 0/450-dbar dynamic height anomalies (η, an alias for sea level), zonal (τx) and meridional (τy) wind stress, wind stress curl (curl (τ)), and precipitation (P) are examined in the tropical Pacific during 1961–1995. In the equatorial band the El Niño (La Niña) events are chiefly concerned (1) in the east and center, with warmer (colder) than average SST and a η increase (decrease), and (2) in the west, with fresher (saltier) than average SSS, westerly (easterly) wind anomalies, above (below) average P limited to the east of about 150°E, and a η decrease (increase); Much smaller ENSO changes occur away from the equatorial band except in the convergence zones for SSS, P, arid τy changes and in two patches centered around 7°N and 7°S in the west for curl (τ). The ENSO-related η changes are schematically concerned with a zonal “seesaw” in phase with the Southern Oscillation Index (SOI) in the equatorial band and a meridional seesaw between the regions situated north and south of about 5°N, which lags by about 1 year behind the SOI. The double seesaws result in a longitudinal mean η rise (drop) within about 5°N–20°S up to the mature phase of El Niño (La Niña), and not just until its beginning, partly compensated by a longitudinal mean η drop (rise) within about 5°–20°N. Aside from its intrinsic substance, this paper offers a novel and concise observational basis for testing theoretical studies and model simulations.},
	language = {en},
	number = {C9},
	urldate = {2019-08-23},
	journal = {Journal of Geophysical Research: Oceans},
	author = {Delcroix, T.},
	year = {1998},
	pages = {18611--18633},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/8XK8BV6X/Delcroix - 1998 - Observed surface oceanic and atmospheric variabili.pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/ICIUQBR7/98JC00814.html:text/html}
}

@article{batchelor_small-scale_1959,
	title = {Small-scale variation of convected quantities like temperature in turbulent fluid {Part} 1. {General} discussion and the case of small conductivity},
	volume = {5},
	issn = {1469-7645, 0022-1120},
	doi = {10.1017/S002211205900009X},
	abstract = {When some external agency imposes on a fluid large-scale variations of some dynamically passive, conserved, scalar quantity θ like temperature or concentration of solute, turbulent motion of the fluid generates small-scale variations of θ. This paper describes a theoretical investigation of the form of the spectrum of θ at large wave-numbers, taking into account the two effects of convection with the fluid and molecular diffusion with diffusivity k. Hypotheses of the kind made by Kolmogoroff for the small-scale variations of velocity in a turbulent motion at high Reynolds number are assumed to apply also to small-scale variations of θ.Previous contributions to the problem are reviewed. These have established that the spectrum of θ varies as n−53 n{\textasciicircum}\{- {\textbackslash}frac \{5\} \{3\}\} (n being wave-number) at the low wave-number end of the equilibrium range, but there has been some confusion about the wave-number marking the upper end of the range of validity of this relation. The existence of a conduction ‘cut-off’ near n={\textbackslash}isin{\textbackslash}solk3)14 n = {\textbackslash}isin\{{\textbackslash}sol\}k \{{\textasciicircum}3\}) \{{\textasciicircum}{\textbackslash}frac \{1\} \{4\}\} as put forward by Obukhoff and Corrsin is shown to hold only when ν [Lt ] κ, and that near n = (ε/νκ2) 14 {\textasciicircum}\{{\textbackslash}frac \{1\} \{4\}\} put forward by Batchelor is shown to apply only when ν [Gt ] κ. In the case ν [Lt ] κ, the remaining problem is to determine the form of the spectrum of θ beyond the conduction cut-off; this is done in Part 2. In the case ν [Gt ] κ, the conduction cut-off occurs at wave-numbers much higher than (ε/ν3)14 {\textasciicircum}\{{\textbackslash}frac \{1\} \{4\}\}, which is where the energy spectrum is cut off by viscosity, and where the spectrum of θ ceases to vary as n−53 n{\textasciicircum}\{- {\textbackslash}frac \{5\} \{3\}\}.The form of the spectrum of θ in this latter case is determined over the range n {\textgreater} (ε/ν3)14 {\textasciicircum}\{{\textbackslash}frac \{1\} \{4\}\} by analysing the effect of the velocity field, regarded as effectively a persistent uniform straining motion for these small-scale variations of θ, and of molecular diffusion on a single Fourier component of θ. The wave-number of this sinusoidal variation of θ is changed (and generally increased in magnitude) by the straining motion and the amplitude is diminished by diffusion. By supposing that the level of the spectrum of θ is kept steady at wave-numbers near (ε/ν3)14 {\textasciicircum}\{{\textbackslash}frac \{1\} \{4\}\} by some mechanism of transfer from lower wave-numbers, the linearity of the equation for θ then allows the determination of the spectrum for n {\textgreater} (ε/ν3) 14 {\textasciicircum}\{{\textbackslash}frac \{1\} \{4\}\}, the result being given by (4.8). The same result is obtained, using essentially the same approximation about the velocity field, from a different kind of analysis in terms of velocity and θ correlations. Finally, the relation between this work and Townsend's model of the small-scale variations of vorticity in a turbulent fluid is discussed.},
	language = {en},
	number = {1},
	urldate = {2019-08-23},
	journal = {Journal of Fluid Mechanics},
	author = {Batchelor, G. K.},
	month = jan,
	year = {1959},
	pages = {113--133},
	file = {Snapshot:/Users/serazin/Zotero/storage/IDUXUEEB/A8AEA175A906F98CDDB0F9ED146BB9FE.html:text/html}
}

@article{shcherbina_latmix_2014,
	title = {The {LatMix} {Summer} {Campaign}: {Submesoscale} {Stirring} in the {Upper} {Ocean}},
	volume = {96},
	issn = {0003-0007},
	shorttitle = {The {LatMix} {Summer} {Campaign}},
	doi = {10.1175/BAMS-D-14-00015.1},
	abstract = {Lateral stirring is a basic oceanographic phenomenon affecting the distribution of physical, chemical, and biological fields. Eddy stirring at scales on the order of 100 km (the mesoscale) is fairly well understood and explicitly represented in modern eddy-resolving numerical models of global ocean circulation. The same cannot be said for smaller-scale stirring processes. Here, the authors describe a major oceanographic field experiment aimed at observing and understanding the processes responsible for stirring at scales of 0.1–10 km. Stirring processes of varying intensity were studied in the Sargasso Sea eddy field approximately 250 km southeast of Cape Hatteras. Lateral variability of water-mass properties, the distribution of microscale turbulence, and the evolution of several patches of inert dye were studied with an array of shipboard, autonomous, and airborne instruments. Observations were made at two sites, characterized by weak and moderate background mesoscale straining, to contrast different regimes of lateral stirring. Analyses to date suggest that, in both cases, the lateral dispersion of natural and deliberately released tracers was O(1) m2 s–1 as found elsewhere, which is faster than might be expected from traditional shear dispersion by persistent mesoscale flow and linear internal waves. These findings point to the possible importance of kilometer-scale stirring by submesoscale eddies and nonlinear internal-wave processes or the need to modify the traditional shear-dispersion paradigm to include higher-order effects. A unique aspect of the Scalable Lateral Mixing and Coherent Turbulence (LatMix) field experiment is the combination of direct measurements of dye dispersion with the concurrent multiscale hydrographic and turbulence observations, enabling evaluation of the underlying mechanisms responsible for the observed dispersion at a new level.},
	number = {8},
	urldate = {2019-08-23},
	journal = {Bulletin of the American Meteorological Society},
	author = {Shcherbina, A. Y. and Sundermeyer, M. A. and Kunze, E. and D’Asaro, E. and Badin, G. and Birch, D. and Brunner-Suzuki, A.-M. E. G. and Callies, J. and Kuebel Cervantes, B. T. and Claret, M. and Concannon, B. and Early, J. and Ferrari, R. and Goodman, L. and Harcourt, R. R. and Klymak, J. M. and Lee, C. M. and Lelong, M.-P. and Levine, M. D. and Lien, R.-C. and Mahadevan, A. and McWilliams, J. C. and Molemaker, M. J. and Mukherjee, S. and Nash, J. D. and Özgökmen, T. and Pierce, S. D. and Ramachandran, S. and Samelson, R. M. and Sanford, T. B. and Shearman, R. K. and Skyllingstad, E. D. and Smith, K. S. and Tandon, A. and Taylor, J. R. and Terray, E. A. and Thomas, L. N. and Ledwell, J. R.},
	month = dec,
	year = {2014},
	pages = {1257--1279},
	file = {Full Text PDF:/Users/serazin/Zotero/storage/X68VIJ3C/Shcherbina et al. - 2014 - The LatMix Summer Campaign Submesoscale Stirring .pdf:application/pdf;Snapshot:/Users/serazin/Zotero/storage/Q6EGGBUT/BAMS-D-14-00015.html:text/html}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bib


text:
SECTION = "devel/chicken"
DESCRIPTION = "ISBN lib for handling book identifier numbers and public isbn databases"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://isbn.meta;md5=2c82f69744383462dffe6f703e95d05f"
DEPENDS_append_class-cross = " chicken-egg-json-cross chicken-egg-sxml-transforms-cross chicken-egg-sxpath-cross chicken-egg-intarweb-cross chicken-egg-http-client-cross chicken-egg-ssax-cross chicken-egg-uri-common-cross"
DEPENDS_append_class-crosssdk = " chicken-egg-json-crosssdk chicken-egg-sxml-transforms-crosssdk chicken-egg-sxpath-crosssdk chicken-egg-intarweb-crosssdk chicken-egg-http-client-crosssdk chicken-egg-ssax-crosssdk chicken-egg-uri-common-crosssdk"
DEPENDS_append_class-nativesdk = " nativesdk-chicken-egg-json nativesdk-chicken-egg-sxml-transforms nativesdk-chicken-egg-sxpath nativesdk-chicken-egg-intarweb nativesdk-chicken-egg-http-client nativesdk-chicken-egg-ssax nativesdk-chicken-egg-uri-common chicken-egg-json-crosssdk chicken-egg-sxml-transforms-crosssdk chicken-egg-sxpath-crosssdk chicken-egg-intarweb-crosssdk chicken-egg-http-client-crosssdk chicken-egg-ssax-crosssdk chicken-egg-uri-common-crosssdk"
DEPENDS = " chicken-egg-json chicken-egg-sxml-transforms chicken-egg-sxpath chicken-egg-intarweb chicken-egg-http-client chicken-egg-ssax chicken-egg-uri-common chicken-egg-json-cross chicken-egg-sxml-transforms-cross chicken-egg-sxpath-cross chicken-egg-intarweb-cross chicken-egg-http-client-cross chicken-egg-ssax-cross chicken-egg-uri-common-cross"
RDEPENDS_${PN} = " chicken-egg-json chicken-egg-sxml-transforms chicken-egg-sxpath chicken-egg-intarweb chicken-egg-http-client chicken-egg-ssax chicken-egg-uri-common"

SRC_URI = "http://code.call-cc.org/egg-tarballs/4/isbn/isbn-${PV}.tar.gz"

SRC_URI[md5sum] = "abd791f57fedf64234c44f4286d6c8fb"
SRC_URI[sha256sum] = "61cd1401ee948473cde60ab4221ac4101f276e3c213c87d6842405fef31b7aa0"

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

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: OSSystems/meta-chicken

repo_name: OSSystems/meta-chicken

extension: bb


text:
VIMVER = "64"

require vim.inc

PR = "${INC_PR}.1"

EXTRA_OECONF = "--enable-gui=none --disable-gtktest \
		--disable-xim --with-features=normal \
		--disable-gpm --without-x --disable-netbeans \
		--with-tlib=ncurses"

repository: demsey/openembedded

repo_name: demsey/openembedded

branch_name: HEAD


text:
@inproceedings{vazirizade2021learning,
 abstract = {Principled decision making in emergency response management necessitates the use of statistical models that predict the spatial-temporal likelihood of incident occurrence. These statistical models are then used for proactive stationing which allocates first responders across the spatial area in order to reduce overall response time. Traditional methods that simply aggregate past incidents over space and time fail to make useful short-term predictions when the spatial region is large and focused on fine-grained spatial entities like interstate highway networks. This is partially due to the sparsity of incidents with respect to the area in consideration. Further, accidents are affected by several covariates, and collecting, cleaning, and managing multiple streams of data from various sources is challenging for large spatial areas. In this paper, we highlight how this problem is being solved for the state of Tennessee, a state in the USA with a total area of over 100,000 sq. km. Our pipeline, based on a combination of synthetic resampling, non-spatial clustering, and learning from data can efficiently forecast the spatial and temporal dynamics of accident occurrence, even under sparse conditions. In the paper, we describe our pipeline that uses data related to roadway geometry, weather, historical accidents, and real-time traffic congestion to aid accident forecasting. To understand how our forecasting model can affect allocation and dispatch, we improve upon a classical resource allocation approach. Experimental results show that our approach can significantly reduce response times in the field in comparison with current approaches followed by first responders.},
 archiveprefix = {arXiv},
 author = {Sayyed Mohsen Vazirizade and Ayan Mukhopadhyay and Geoffrey Pettet and Said El Said and Hiba Baroud and Abhishek Dubey},
 eprint = {2106.08307},
 preprint = {https://arxiv.org/abs/2106.08307},
 primaryclass = {cs.LG},
 tag = {ai4cps,incident},
 title = {Learning Incident Prediction Models Over Large Geographical Areas for Emergency Response Systems},
 year = {2021}
}


text:
@inproceedings{RN1205,
 author = {Boroojerdi, M. T. and Menard, M. and Kirk, A. G.},
 booktitle = {2017 Conference on Lasers and Electro-Optics (Cleo)},
 isbn = {2160-9020},
 title = {Bandwidth Tunable SOI Add-Drop Filter},
 type = {Conference Proceedings},
 url = {<Go to ISI>://WOS:000427296201168},
 year = {2017}
}

repository: andrewgkirk/website

repo_name: andrewgkirk/website

gha_license_id: MIT

gha_language: Jupyter Notebook


text:
package serie_test

import (
	"fmt"
	"math"
	"sort"
	"testing"

	"github.com/datasweet/datatable/serie"
	"github.com/stretchr/testify/assert"
	"gonum.org/v1/gonum/stat"
)

func TestAvg(t *testing.T) {
	xs := []float64{
		32.32, 56.98, 21.52, 44.32,
		55.63, 13.75, 43.47, 43.34,
		12.34,
	}

	s := serie.Float64(xs)
	assert.NotNil(t, s)
	assert.Equal(t, 9, s.Len())
	assert.Equal(t, stat.Mean(xs, nil), s.Avg())

	s = serie.Float64N(xs, "teemo", "nil")
	assert.NotNil(t, s)
	assert.Equal(t, 11, s.Len())
	assert.Equal(t, stat.Mean(xs, nil), s.Avg())
	assert.Greater(t, stat.Mean(xs, nil), s.Avg(serie.Missing(0)))
}

func TestCount(t *testing.T) {
	xs := []float64{
		32.32, 56.98, 21.52, 44.32,
		55.63, 13.75, 43.47, 43.34,
		12.34,
	}

	s := serie.Float64(xs)
	assert.NotNil(t, s)
	assert.Equal(t, 9, s.Len())
	assert.Equal(t, int64(9), s.Count())

	s = serie.Float64N(xs, "teemo", "nil")
	assert.NotNil(t, s)
	assert.Equal(t, 11, s.Len())
	assert.Equal(t, int64(9), s.Count())
}

func TestSum(t *testing.T) {
	s := serie.Float64N(1, "23", 3.14, "teemo", true, nil)
	assert.NotNil(t, s)
	assertSerieEq(t, s, float64(1), float64(23), float64(3.14), nil, float64(1), nil)
	assert.Equal(t, 28.14, s.Sum())
}

func TestMedian(t *testing.T) {
	xs := []float64{
		32.32, 56.98, 21.52, 44.32,
		55.63, 13.75, 43.47, 43.34,
		12.34,
	}

	fmt.Printf("data: %v\n", xs)

	// computes the weighted mean of the dataset.
	// we don't have any weights (ie: all weights are 1)
	// so we just pass a nil slice.
	mean := stat.Mean(xs, nil)
	variance := stat.Variance(xs, nil)
	stddev := math.Sqrt(variance)

	// stat.Quantile needs the input slice to be sorted.
	sort.Float64s(xs)
	fmt.Printf("data: %v (sorted)\n", xs)

	// computes the median of the dataset.
	// here as well, we pass a nil slice as weights.
	median := stat.Quantile(0.5, stat.Empirical, xs, nil)

	fmt.Printf("mean=     %v\n", mean)
	fmt.Printf("median=   %v\n", median)
	fmt.Printf("variance= %v\n", variance)
	fmt.Printf("std-dev=  %v\n", stddev)

}

repository: datasweet/datatable

repo_name: datasweet/datatable

gha_language: Go

extension: go


text:
/*
Copyright 2023 The Vitess Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package endtoend

import (
	"context"
	"testing"
	"time"

	"github.com/stretchr/testify/require"

	"vitess.io/vitess/go/vt/callerid"
	querypb "vitess.io/vitess/go/vt/proto/query"
	vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc"
	"vitess.io/vitess/go/vt/vttablet/endtoend/framework"
)

// TestGetSchemaRPC will validate GetSchema RPC.
func TestGetSchemaRPC(t *testing.T) {
	testcases := []struct {
		name               string
		queries            []string
		deferQueries       []string
		getSchemaQueryType querypb.SchemaTableType
		getSchemaTables    []string
		mapToExpect        map[string]string
	}{
		{
			name: "All views",
			queries: []string{
				"create view vitess_view1 as select id from vitess_a",
				"create view vitess_view2 as select id from vitess_b",
			},
			deferQueries: []string{
				"drop view vitess_view1",
				"drop view vitess_view2",
			},
			mapToExpect: map[string]string{
				"vitess_view1": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view1` AS select `vitess_a`.`id` AS `id` from `vitess_a`",
				"vitess_view2": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view2` AS select `vitess_b`.`id` AS `id` from `vitess_b`",
			},
			getSchemaQueryType: querypb.SchemaTableType_VIEWS,
		}, {
			name: "Views listed",
			queries: []string{
				"create view vitess_view1 as select eid from vitess_a",
				"create view vitess_view2 as select eid from vitess_b",
				"create view vitess_view3 as select eid from vitess_c",
			},
			deferQueries: []string{
				"drop view vitess_view1",
				"drop view vitess_view2",
				"drop view vitess_view3",
			},
			mapToExpect: map[string]string{
				"vitess_view3": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view3` AS select `vitess_c`.`eid` AS `eid` from `vitess_c`",
				"vitess_view2": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view2` AS select `vitess_b`.`eid` AS `eid` from `vitess_b`",
				// These shouldn't be part of the result so we verify it is empty.
				"vitess_view1": "",
				"unknown_view": "",
			},
			getSchemaTables:    []string{"vitess_view3", "vitess_view2", "unknown_view"},
			getSchemaQueryType: querypb.SchemaTableType_VIEWS,
		}, {
			name: "All tables",
			queries: []string{
				"create table vitess_temp1 (id int);",
				"create table vitess_temp2 (id int);",
				"create table vitess_temp3 (id int);",
			},
			deferQueries: []string{
				"drop table vitess_temp1",
				"drop table vitess_temp2",
				"drop table vitess_temp3",
			},
			mapToExpect: map[string]string{
				"vitess_temp1": "CREATE TABLE `vitess_temp1` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp2": "CREATE TABLE `vitess_temp2` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp3": "CREATE TABLE `vitess_temp3` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
			},
			getSchemaQueryType: querypb.SchemaTableType_TABLES,
		}, {
			name: "Tables listed",
			queries: []string{
				"create table vitess_temp1 (eid int);",
				"create table vitess_temp2 (eid int);",
				"create table vitess_temp3 (eid int);",
			},
			deferQueries: []string{
				"drop table vitess_temp1",
				"drop table vitess_temp2",
				"drop table vitess_temp3",
			},
			mapToExpect: map[string]string{
				"vitess_temp1": "CREATE TABLE `vitess_temp1` (\n  `eid` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp3": "CREATE TABLE `vitess_temp3` (\n  `eid` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				// These shouldn't be part of the result so we verify it is empty.
				"vitess_temp2":  "",
				"unknown_table": "",
			},
			getSchemaQueryType: querypb.SchemaTableType_TABLES,
			getSchemaTables:    []string{"vitess_temp1", "vitess_temp3", "unknown_table"},
		}, {
			name: "All tables and views",
			queries: []string{
				"create table vitess_temp1 (id int);",
				"create table vitess_temp2 (id int);",
				"create table vitess_temp3 (id int);",
				"create view vitess_view1 as select id from vitess_a",
				"create view vitess_view2 as select id from vitess_b",
			},
			deferQueries: []string{
				"drop table vitess_temp1",
				"drop table vitess_temp2",
				"drop table vitess_temp3",
				"drop view vitess_view1",
				"drop view vitess_view2",
			},
			mapToExpect: map[string]string{
				"vitess_view1": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view1` AS select `vitess_a`.`id` AS `id` from `vitess_a`",
				"vitess_view2": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view2` AS select `vitess_b`.`id` AS `id` from `vitess_b`",
				"vitess_temp1": "CREATE TABLE `vitess_temp1` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp2": "CREATE TABLE `vitess_temp2` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp3": "CREATE TABLE `vitess_temp3` (\n  `id` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
			},
			getSchemaQueryType: querypb.SchemaTableType_ALL,
		}, {
			name: "Listed tables and views",
			queries: []string{
				"create table vitess_temp1 (eid int);",
				"create table vitess_temp2 (eid int);",
				"create table vitess_temp3 (eid int);",
				"create view vitess_view1 as select eid from vitess_a",
				"create view vitess_view2 as select eid from vitess_b",
				"create view vitess_view3 as select eid from vitess_c",
			},
			deferQueries: []string{
				"drop table vitess_temp1",
				"drop table vitess_temp2",
				"drop table vitess_temp3",
				"drop view vitess_view1",
				"drop view vitess_view2",
				"drop view vitess_view3",
			},
			mapToExpect: map[string]string{
				"vitess_view1": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view1` AS select `vitess_a`.`eid` AS `eid` from `vitess_a`",
				"vitess_view3": "CREATE ALGORITHM=UNDEFINED DEFINER=`vt_dba`@`localhost` SQL SECURITY DEFINER VIEW `vitess_view3` AS select `vitess_c`.`eid` AS `eid` from `vitess_c`",
				"vitess_temp1": "CREATE TABLE `vitess_temp1` (\n  `eid` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				"vitess_temp3": "CREATE TABLE `vitess_temp3` (\n  `eid` int DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci",
				// These shouldn't be part of the result so we verify it is empty.
				"vitess_temp2":  "",
				"vitess_view2":  "",
				"unknown_view":  "",
				"unknown_table": "",
			},
			getSchemaQueryType: querypb.SchemaTableType_ALL,
			getSchemaTables:    []string{"vitess_temp1", "vitess_temp3", "unknown_table", "vitess_view3", "vitess_view1", "unknown_view"},
		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.name, func(t *testing.T) {
			client := framework.NewClient()
			client.UpdateContext(callerid.NewContext(
				context.Background(),
				&vtrpcpb.CallerID{},
				&querypb.VTGateCallerID{Username: "dev"}))

			for _, query := range testcase.queries {
				_, err := client.Execute(query, nil)
				require.NoError(t, err)
			}
			defer func() {
				for _, query := range testcase.deferQueries {
					_, err := client.Execute(query, nil)
					require.NoError(t, err)
				}
			}()

			timeout := 1 * time.Minute
			wait := time.After(timeout)
			for {
				select {
				case <-wait:
					t.Errorf("Schema tracking hasn't caught up")
					return
				case <-time.After(1 * time.Second):
					schemaDefs, err := client.GetSchema(testcase.getSchemaQueryType, testcase.getSchemaTables...)
					require.NoError(t, err)
					success := true
					for tableName, expectedCreateStatement := range testcase.mapToExpect {
						if schemaDefs[tableName] != expectedCreateStatement {
							success = false
							break
						}
					}
					if success {
						return
					}
				}
			}
		})
	}
}

repository: vitessio/vitess

repo_name: vitessio/vitess

branch_name: refs/heads/main


text:
SUMMARY = "AVRDUDE is a utility to download/upload/manipulate the ROM and EEPROM contents of AVR microcontrollers using the in-system programming technique (ISP)."

LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=4f51bb496ef8872ccff73f440f2464a8"

DEPENDS = "libusb elfutils hidapi libftdi"

inherit autotools

PV = "6.3+svn${SRCPV}"
SRC_URI = "svn://svn.savannah.nongnu.org/svn/avrdude/;protocol=http;module=trunk;rev=1425"

S = "${WORKDIR}/trunk/avrdude"

EXTRA_OECONF = "--enable-linuxgpio"

repository: koenkooi/meta-maker

repo_name: koenkooi/meta-maker

gha_language: BitBake


text:
package types

type Attribute struct {
	Name       string
	Type       string
	List       bool
	Optional   bool
	Deprecated bool
}

type InheritedAttribute struct {
	Owner string
	Attribute
}

repository: FINTLabs/fint-graphql-cli

repo_name: FINTLabs/fint-graphql-cli


text:
@article{cole_empirical_2017,
 author = {Cole, Veronica T and Bauer, Daniel J and Hussong, Andrea M and Giordano, Michael L},
 journal = {Structural equation modeling: a multidisciplinary journal},
 note = {Publisher: Routledge},
 number = {2},
 pages = {159--179},
 title = {An empirical assessment of the sensitivity of mixture models to changes in measurement},
 volume = {24},
 year = {2017}
}


text:
package model

import (
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/utils"

	"strings"
)

// ListBackupRecordsRequest Request Object
type ListBackupRecordsRequest struct {

	// 实例ID。
	InstanceId string `json:"instance_id"`

	// 查询开始时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20170718235959。
	BeginTime *string `json:"begin_time,omitempty"`

	// 查询结束时间，时间为UTC时间。格式：yyyyMMddHHmmss，如：20170718235959。
	EndTime *string `json:"end_time,omitempty"`

	// 每页显示的条目数量。
	Limit *int32 `json:"limit,omitempty"`

	// 偏移量，表示从此偏移量开始查询， offset大于等于0。
	Offset *int32 `json:"offset,omitempty"`
}

func (o ListBackupRecordsRequest) String() string {
	data, err := utils.Marshal(o)
	if err != nil {
		return "ListBackupRecordsRequest struct{}"
	}

	return strings.Join([]string{"ListBackupRecordsRequest", string(data)}, " ")
}

gha_license_id: NOASSERTION


text:
require cuda-shared-binaries.inc

MAINSUM = "87f2161d58e3766f4d1ac695dae673ad6bad0e0e8a5f9866506dccae6c72219f"
MAINSUM:x86-64 = "1974a8b35f3006bc477a74c86a05a0126fde949fb56d986a224d2f48781a2cd2"
DEVSUM = "79bbf5a42f606b22e3d89a09abb6dffc353d3cd8cc083b8c9fdb71e39a968236"
DEVSUM:x86-64 = "b491bf0737ac1a70a56893262a74873c8bfb1708117c4d4768bb1d5b2c6ed55e"

BBCLASSEXTEND = "native nativesdk"

repository: lfdmn/meta-tegra

repo_name: lfdmn/meta-tegra


text:
@InProceedings{vladymyrov14,
  supplementary = {Supplementary:vladymyrov14-supp.tgz},
  title = {{Linear-time training of nonlinear low-dimensional embeddings}},
  author = {Vladymyrov, Max and Carreira-Perpinan, Miguel},
  pages = {968-977},
  abstract = {Nonlinear embeddings such as stochastic neighbor embedding or the elastic embedding achieve better results than spectral methods but require an expensive, nonconvex optimization, where the objective function and gradient are quadratic on the sample size. We address this bottleneck by formulating the optimization as an $N$-body problem and using fast multipole methods (FMMs) to approximate the gradient in linear time. We study the effect, in theory and experiment, of approximating gradients in the optimization and show that the expected error is related to the mean curvature of the objective function, and that gradually increasing the accuracy level in the FMM over iterations leads to a faster training. When combined with standard optimizers, such as gradient descent or L-BFGS, the resulting algorithm beats the $\mathcal{O}(N \log N)$ Barnes-Hut method and achieves reasonable embeddings for one million points in around three hours' runtime.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
package main

import (
	"bufio"
	"bytes"
	"encoding/csv"
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"

	"github.com/fatih/color"
)

type Field struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type Block struct {
	Type      string   `json:"type"`
	Source    string   `json:"source"`
	Rows      []string `json:"rows"`
	Fields    []Field  `json:"fields"`
	Header    string   `json:"header"`
	completed bool     `json:"completed"`
}

func PrintBlock(block *Block) {
	fmt.Println("   [Block Definition]")
	fmt.Println("   Source: ", block.Source)
	fmt.Println("   Type  : ", block.Type)
	fmt.Println("   Rows  :")
	for i, row := range block.Rows {
		fmt.Println("  ", i, ":", row)
	}
	fmt.Println("   Fields:")
	for i, field := range block.Fields {
		fmt.Println("  ", i, ":(", field.Name, ":", field.Value, ")")
	}
}

func main() {
	version := "Version 0.002"
	var blocks []Block
	var keyValueStore [][]string

	var inputFilePath string
	var outputFilePath string
	var keyValuePath string
	var verboseOutput bool
	var outputBlocks bool
	var jsonOutFile string
	var jsonAsInput bool
	var jsonInputPath string

	// flags declaration using flag package
	flag.StringVar(&inputFilePath, "i", "source.txt", "path of the input file. Default is source.txt")
	flag.StringVar(&outputFilePath, "o", "output.txt", "path of the output file. Default is output.txt")
	flag.StringVar(&keyValuePath, "k", "keyvalue.csv", "path of the key-value store file as comma seperated file with two columns. Default is keyvalue.csv")
	flag.BoolVar(&verboseOutput, "v", false, "activate verbose output to console")
	flag.BoolVar(&outputBlocks, "outputjson", false, "activate output block definitions as JSON")
	flag.StringVar(&jsonOutFile, "jsonoutfile", "blocksDefinitions.json", "set the output filepath of the block definitions JSON file")
	flag.BoolVar(&jsonAsInput, "jsoninput", false, "activate using a JSON block definition from a file as input source")
	flag.StringVar(&jsonInputPath, "jsoninfile", "blocksDefinitions.json", "use this file path if -jsoninput is set")

	c := color.New(color.FgWhite).Add(color.Bold)
	flag.Usage = func() {
		fmt.Println("cst - the command shell template parser - ALPHA version", version, "\n") // redundant newline ok
		fmt.Println("   cst -i <input filepath> -o <output filepath> [-k <key-value file path>] [-v]\n")
		c.Println("DESCRIPTION")
		fmt.Println("cst is a command line template parser that uses comma seperated files (csv) as it's data source.")
		fmt.Println("It is being used to transform data, present in csv files, into structured text files,")
		fmt.Println("such as HTML, JSON, XML or yaml files or any other structured file format.")
		c.Println("ARGUMENTS")
		fmt.Println("The program needs an input and an output file path.")
		fmt.Println("All needed data file paths are being defined in the template file itself in so called block definitions")
		fmt.Println("The input file defines the template for the output file.")
		fmt.Println("All parsed template definitions are processed and written to the output file.\n")
		fmt.Println("-i specifies the path of the input file")
		fmt.Println("-o specifies the path of the output file")
		c.Println("OPTIONS")
		fmt.Println("-k if specified, cst uses the specified file path as the key value store file")
		fmt.Println("   The key value store file is a csv file with two columns, where the first column")
		fmt.Println("   defines the key and the second the value. Everything is a string.")
		fmt.Println("   if -k is not specified, cst uses the definition in the source file. It has the following format:")
		fmt.Println("   (store;source:<filepath>)")
		fmt.Println("   This needs to be defined in its own text line with opening and closing brackets and the keyword 'store'")
		fmt.Println("-v Activate verbose output to the console.")
		fmt.Println("   This prints out all actions of the parser and the templating engine so that you can debug your template.")
	}
	flag.Parse()

	// TODO: make all variables available through command arguments
	//       verbosity
	//       Optional: token delimiter like '{{}}'

	if !jsonAsInput {
		// the blocks structure will be created using the parser
		file, err := os.Open(inputFilePath)
		if err != nil {
			fmt.Println("Error opening source file", inputFilePath, " Error Description: ", err)
			os.Exit(1)
		}
		defer file.Close()
		if verboseOutput {
			c.Println("[Parser] Start on input file: ", inputFilePath)
		}

		var currentBlock *Block
		var rowIndex int32 = 0
		scanner := bufio.NewScanner(file)
		// optionally, resize scanner's capacity for lines over 64K, see next example
		for scanner.Scan() {
			if verboseOutput {
				fmt.Println("Scanning row index ", rowIndex)
			}
			row := scanner.Text()

			if strings.HasPrefix(row, "(block-start;") {
				if strings.HasSuffix(row, ")") { // found header of a block
					if currentBlock != nil && currentBlock.completed == false {
						fmt.Println("Error (block-start) without closing current block definition. Row[", rowIndex, "]:", row)
						panic(1)
					}

					block := Block{}
					block.Header = row

					strHeader := strings.TrimPrefix(row, "(block-start;")
					strHeader = strings.TrimSuffix(strHeader, ")")
					fields := strings.Split(strHeader, ";")
					for i, strField := range fields { // range over name:value definitions and add them to the structs Fields array
						fieldTokens := strings.Split(strField, ":")
						if len(fieldTokens) == 2 {
							field := Field{Name: fieldTokens[0], Value: fieldTokens[1]}
							if field.Name == "source" {
								block.Source = field.Value
							} else if field.Name == "type" {
								block.Type = field.Value
							}
							block.Fields = append(block.Fields, field)
						} else {
							fmt.Println("Error in block header definition. Cannot read field definition, field index [", i, "] Row[", rowIndex, "]:", row)
							panic(1)
						}
					}
					blocks = append(blocks, block)
					currentBlock = &blocks[len(blocks)-1]
				} else {
					// error in defining a block header, report error and panic
					fmt.Println("Error in defining a blocks header. Row[", rowIndex, "]:", row)
					panic(1)
				}
			} else if strings.Compare(row, "(block-end)") == 0 { // found block-end
				if currentBlock != nil {
					currentBlock.completed = true
					if verboseOutput {
						PrintBlock(currentBlock)
					}
					currentBlock = nil
				} else {
					fmt.Println("Error (block-end) without (block-start). Row[", rowIndex, "]:", row)
					panic(1)
				}
			} else if strings.HasPrefix(row, "(store;") {
				if strings.HasSuffix(row, ")") {
					if currentBlock != nil && currentBlock.completed == false {
						fmt.Println("Error (store) definition started without closing current block definition. Row[", rowIndex, "]:", row)
						panic(1)
					}
					// key-value store definition found
					block := Block{}
					block.Header = row
					block.Type = "store"

					strHeader := strings.TrimPrefix(row, "(store;") // Todo: DUPLICATE CODE - MAKE FUNCTION!!
					strHeader = strings.TrimSuffix(strHeader, ")")
					fields := strings.Split(strHeader, ";")
					for i, strField := range fields { // range over name:value definitions and add them to the structs Fields array
						fieldTokens := strings.Split(strField, ":")
						if len(fieldTokens) == 2 {
							field := Field{Name: fieldTokens[0], Value: fieldTokens[1]}
							if field.Name == "source" {
								block.Source = field.Value
							}
							block.Fields = append(block.Fields, field)
						} else {
							fmt.Println("Error in block header definition. Cannot read field definition, field index [", i, "] Row[", rowIndex, "]:", row)
							panic(1)
						}
					}
					blocks = append(blocks, block)
					if verboseOutput {
						PrintBlock(&block)
					}
					currentBlock = nil
					// finished with store block
				} else {
					fmt.Println("Error (store) definition started but not closed. Closing bracket is needed! Row[", rowIndex, "]:", row)
					panic(1)
				}
			} else {
				// anything else is a template definition of the block
				// it will be added to the Rows array of the currentBlock
				if currentBlock == nil {
					block := Block{}
					block.Rows = append(block.Rows, row)
					block.Type = "string"
					block.completed = true
					blocks = append(blocks, block)
					currentBlock = &blocks[len(blocks)-1]
					if verboseOutput {
						PrintBlock(currentBlock)
					}
					currentBlock = nil
				} else {
					currentBlock.Rows = append(currentBlock.Rows, row)
				}
			}
			rowIndex++
		}
		file.Close()
		if verboseOutput {
			c.Println("[Parser] Done\n")
		}

		// write the blocks definition structure out to a JSON file for further use
		if outputBlocks {

			var buffer bytes.Buffer
			e := json.NewEncoder(&buffer)
			e.SetEscapeHTML(false)
			e.SetIndent("", " ")
			e.Encode(blocks)

			_ = ioutil.WriteFile(jsonOutFile, buffer.Bytes(), 0644)
		}

	} else {
		// the blocks structure will be created using unmarshalling JSON from a file
		jsonInputBuffer, err := ioutil.ReadFile(jsonInputPath)
		if err != nil {
			fmt.Println("Error while reading JSON file ", jsonInputPath)
			os.Exit(1)
		}
		err = json.Unmarshal(jsonInputBuffer, &blocks)
		if err != nil {
			fmt.Println("Error while unmarshalling JSON block definition from ", jsonInputPath)
			os.Exit(1)
		}
	}

	// Now loop over the blocks and work them out
	// write into a buffer that then is going to be appended to an output file

	outputFile, err := os.Create(outputFilePath)
	if err != nil {
		log.Fatal(err)
	}

	if verboseOutput {
		c.Println("[Template Engine] Start on output file: ", outputFilePath)
	}

	for i := 0; i < len(blocks); i++ {
		// verbose output
		if verboseOutput {
			fmt.Print("Parsing block #", i, " type=", blocks[i].Type, " rows=", blocks[i].Rows)
		}

		if blocks[i].Type == "string" {
			// 1.) basic string from row in source file
			outputStr := blocks[i].Rows[0] + "\n"

			// 2.) Key-Value Templating
			//     {{key}}
			for _, key := range keyValueStore {
				// really dumb method now to loop over all keys but it will do for the first implementation
				// Todo: Performance enhancement here!!
				token := "{{" + key[0] + "}}"
				outputStr = strings.Replace(outputStr, token, key[1], -1) // replace {index} with the column nr=index
			}

			outputFile.WriteString(outputStr)
			if verboseOutput {
				fmt.Println(" -> written to output file.")
			}
		} else if blocks[i].Type == "store" {
			// key-store definition
			// read the csv file and use it as a key value store for all tokens
			if blocks[i].Source != "" {
				sourceFile, err := os.Open(blocks[i].Source)
				if err != nil {
					fmt.Println("Error while opening the source file: ", err)
					panic(1)
				}
				reader := csv.NewReader(sourceFile)
				reader.Comma = ','
				reader.Comment = '#'

				keyValueStore, err = reader.ReadAll()
				if err != nil {
					fmt.Println("Error: Could not read the csv file. Description: ", err)
					panic(1)
				}
				// key value store is present in the variable keyValueStore

				// verbose output
				if verboseOutput {
					fmt.Println(" -> Key-Value store successfully read: ", keyValueStore)
				}
			} else {
				fmt.Println("Error: Cannot read key value store fields as the source definition is not set. Check the (store ..) definition in the defintiion file..")
				panic(1)
			}

		} else if blocks[i].Type == "foreach" {
			// foreach block definition
			// 1.) open source file
			if verboseOutput {
				fmt.Println("")
			}

			block := &blocks[i]
			if block.Source != "" {
				sourceFile, err := os.Open(block.Source)
				if err != nil {
					fmt.Println("Error while opening the source file: ", err)
					panic(1)
				}
				reader := csv.NewReader(sourceFile)
				reader.Comma = ','
				reader.Comment = '#'

				records, _ := reader.ReadAll()
				//fmt.Println("Records in file ", block.Source, ": ", records)

				for recordIndex, record := range records {
					// per record ...
					// loop over all Rows of the current definition block
					for rowIndex, blockRow := range block.Rows {
						// 1.) column-index Templating
						//     {column-index}

						// replace in Row string all occurrences of columns in the current csv record
						outputStr := blockRow
						for indexColumn, column := range record {
							// for every column, replace the {column-index} with its content in the current record
							token := "{" + strconv.Itoa(indexColumn) + "}"
							outputStr = strings.Replace(outputStr, token, column, -1) // replace {index} with the column nr=index
							if indexColumn == (len(record) - 1) {
								// verbose output
								if verboseOutput {
									fmt.Println("   Replacing for record #", recordIndex, " with record='", record, "' in row #", rowIndex, "='"+blockRow, " output='", outputStr, "'")
								}
								// last column, add newline character
								outputStr = outputStr + "\n"
							}
						}

						// 2.) Key-Value Templating
						//     {{key}}
						for _, key := range keyValueStore {
							// really dumb method, currently, to loop over all keys but it will do for the first implementation
							// Todo: Performance enhancement here!!
							token := "{{" + key[0] + "}}"
							outputStr = strings.Replace(outputStr, token, key[1], -1) // replace {index} with the column nr=index
						}

						// write the Row to the output file
						outputFile.WriteString(outputStr)
					}
				}
				if verboseOutput {
					fmt.Println("   -> written to output file.")
				}
				sourceFile.Close()
			} else {
				fmt.Println("Error: Foreach block does not have a source definition. Please add the source of the csv file in the \"source\" field. Definition:", block.Fields)
				panic(1)
			}
		}
	}
}

repository: Nonlinearsound/cst

repo_name: Nonlinearsound/cst


text:
/*
 * Copyright (c) 2019 QLC Chain Team
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

package commands

import (
	"fmt"

	"github.com/abiosoft/ishell"
	rpc "github.com/qlcchain/jsonrpc2"
	"github.com/spf13/cobra"

	"github.com/qlcchain/go-qlc/cmd/util"
	"github.com/qlcchain/go-qlc/common/types"
)

func addLedgerBalanceByIshell(parentCmd *ishell.Cmd) {
	address := util.Flag{
		Name:  "address",
		Must:  true,
		Usage: "address for account",
		Value: "",
	}
	args := []util.Flag{address}
	c := &ishell.Cmd{
		Name:                "balance",
		Help:                "balance for accounts",
		CompleterWithPrefix: util.OptsCompleter(args),
		Func: func(c *ishell.Context) {
			if util.HelpText(c, args) {
				return
			}
			if err := util.CheckArgs(c, args); err != nil {
				util.Warn(err)
				return
			}
			addresses := util.StringSliceVar(c.Args, address)
			err := accountBalance(addresses)
			if err != nil {
				util.Warn(err)
				return
			}
		},
	}
	parentCmd.AddCmd(c)
}

func addLedgerBalanceByCobra(parentCmd *cobra.Command) {
	var addresses []string
	var balanceCmd = &cobra.Command{
		Use:   "balance",
		Short: " balance for accounts",
		Run: func(cmd *cobra.Command, args []string) {
			if len(addresses) < 1 {
				cmd.Println("err account")
				return
			}
			err := accountBalance(addresses)
			if err != nil {
				cmd.Println(err)
				return
			}
		},
	}
	balanceCmd.Flags().StringSliceVar(&addresses, "address", addresses, "address for accounts")
	parentCmd.AddCommand(balanceCmd)
}

func accountBalance(addresses []string) error {
	client, err := rpc.Dial(endpointP)
	if err != nil {
		return err
	}
	defer client.Close()
	var resp map[types.Address]map[string]map[string]types.Balance
	err = client.Call(&resp, "ledger_accountsBalance", addresses)
	if err != nil {
		return err
	}

	for _, a := range addresses {
		addr, err := types.HexToAddress(a)
		if err != nil {
			return err
		}
		if value, ok := resp[addr]; ok {
			if interactive {
				util.Info(a, ":")
			} else {
				fmt.Println(a, ":")
			}
			for k, v := range value {
				fmt.Printf("    %s: balance is %s, pending is %s", k, v["balance"], v["pending"])
				fmt.Println()
			}
		} else {
			if interactive {
				util.Info(a, " not found")
			} else {
				fmt.Println(a, " not found")
			}
		}
	}
	return nil
}

repository: qlcchain/go-qlc

repo_name: qlcchain/go-qlc


text:
---
---

@string{aps = {American Physical Society,}}

@phdthesis{tese,
    author        = {Longen, L.},
    title         = {Interação entre Dissipação Fracionária e Memória Não-Linear na Existência de Soluções para a Equação de Placas},
    journaltitle  = {Ph.D. Thesis, Department of Mathematics, UFSC},
    year          = {2021},
    pdf           = {tese.pdf},
    selected      ={true}
}

@article{LuisDab,
  title={The interplay between fractional damping and nonlinear memory for the plate equation},
  author={D'Abbicco, M. and Longen, L.},
  journal={Manuscript submitted for publication},
  pdf={example_pdf.pdf},
  selected={true}
}

@mastersthesis{dissertacao,
  title={Boa-Colocação e Soluções Assintoticamente Autossimilares para as Equações de Navier-Stokes em Espaços de Herz Fracos (in Portuguese)},
  author={Longen, L.},
  journal={Masters Thesis, Institute of Mathematics, Statistics and Scientific Computing, UNICAMP},
  year={2016},
  pdf={dissertacao.pdf},
  selected={true}
}


text:
@article{chertkov_inference_2010,
 abstract = {Methods to extract information from the tracking of mobile objects/particles have broad interest in biological and physical sciences. Techniques based on simple criteria of proximity in time-consecutive snapshots are useful to identify the trajectories of the particles. However, they become problematic as the motility and/or the density of the particles increases due to uncertainties on the trajectories that particles followed during the images’ acquisition time. Here, we report an efficient method for learning parameters of the dynamics of the particles from their positions in time-consecutive images. Our algorithm belongs to the class of message-passing algorithms, known in computer science, information theory, and statistical physics as belief propagation (BP). The algorithm is distributed, thus allowing parallel implementation suitable for computations on multiple machines without significant intermachine overhead. We test our method on the model example of particle tracking in turbulent flows, which is particularly challenging due to the strong transport that those flows produce. Our numerical experiments show that the BP algorithm compares in quality with exact Markov Chain Monte Carlo algorithms, yet BP is far superior in speed. We also suggest and analyze a random distance model that provides theoretical justification for BP accuracy. Methods developed here systematically formulate the problem of particle tracking and provide fast and reliable tools for the model’s extensive range of applications.},
 author = {Chertkov, M. and Kroc, L. and Krzakala, F. and Vergassola, M. and Zdeborová, L.},
 doi = {10.1073/pnas.0910994107},
 file = {Full Text PDF:/Users/florentkrzakala/Zotero/storage/RIZ54AZM/Chertkov et al. - 2010 - Inference in particle tracking experiments by pass.pdf:application/pdf;Snapshot:/Users/florentkrzakala/Zotero/storage/SM8KHLN7/7663.html:text/html},
 issn = {0027-8424, 1091-6490},
 journal = {PNAS},
 keywords = {belief propagation, message passing, particle image velocimetry, statistical inference, turbulence},
 language = {en},
 month = {April},
 number = {17},
 pages = {7663--7668},
 pmid = {20368454},
 title = {Inference in particle tracking experiments by passing messages between images},
 url = {https://www.pnas.org/content/107/17/7663},
 urldate = {2019-07-01},
 volume = {107},
 year = {2010}
}

repository: krzakala/academic-kickstart

repo_name: krzakala/academic-kickstart


text:
SUMMARY = "A C implementation of the Constrained Application Protocol"
DESCRIPTION = "libcoap implements a lightweight application-protocol for \
devices that are constrained their resources such as computing power, \
RF range, memory, bandwith, or network packet sizes."
HOMEPAGE ="https://libcoap.net/"

LICENSE = "BSD-2-Clause & BSD-1-Clause"
LIC_FILES_CHKSUM = "file://LICENSE;md5=0fbe4435d52b2d27a16f980ffc8ffc80"

SRC_URI = "git://github.com/obgm/libcoap.git;branch=main;protocol=https \
           file://run-ptest \
           "
SRCREV = "02b76470ab9168947152c78ad50835bf043d7c84"

S = "${WORKDIR}/git"

inherit autotools manpages pkgconfig ptest

DEPENDS += "ctags-native"

PACKAGECONFIG ?= "\
    async openssl tcp \
    ${@bb.utils.contains('PTEST_ENABLED', '1', 'tests', '', d)} \
"
PACKAGECONFIG[async] = "--enable-async,--disable-async"
PACKAGECONFIG[gnutls] = "--with-gnutls,--without-gnutls,gnutls,,,openssl mbedtls"
PACKAGECONFIG[manpages] = "--enable-documentation --enable-doxygen --enable-manpages,--disable-documentation,asciidoc-native doxygen-native graphviz-native"
PACKAGECONFIG[mbedtls] = "--with-mbedtls,--without-mbedtls,mbedtls,,,gnutls openssl"
PACKAGECONFIG[openssl] = "--with-openssl,--without-openssl,openssl,,,gnutls mbedtls"
PACKAGECONFIG[small-stack] = "--enable-small-stack,--disable-small-stack"
PACKAGECONFIG[tcp] = "--enable-tcp,--disable-tcp"
PACKAGECONFIG[tests] = "--enable-tests,--disable-tests,cunit"

EXTRA_OECONF = "\
    --with-epoll --enable-add-default-names \
    --without-tinydtls --without-submodule-tinydtls \
    ${@bb.utils.contains_any('PACKAGECONFIG', 'gnutls openssl mbedtls', '--enable-dtls', '--disable-dtls', d)} \
"

python () {
    if d.getVar('PTEST_ENABLED') == "1":
        d.setVar('DISABLE_STATIC', '')
}

export SGML_CATALOG_FILES="file://${STAGING_ETCDIR_NATIVE}/xml/catalog"

do_compile:prepend() {
    oe_runmake update-map-file
}

do_install_ptest () {
	install -d ${D}${PTEST_PATH}
	install -m 0755 ${WORKDIR}/run-ptest ${D}${PTEST_PATH}/run-ptest
	install -m 0755 ${B}/tests/testdriver ${D}${PTEST_PATH}/testdriver
}

PACKAGE_BEFORE_PN += "\
    ${PN}-bin \
"

FILES:${PN}-bin = "${bindir}"
FILES:${PN}-dev += "${datadir}/${BPN}/examples"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
package tmallhk

// ClearanceUnitDo
type ClearanceUnitDo struct {

    // 第一数量，最多4位小数

    FirstQuantity   string `json:"first_quantity,omitempty" xml:"first_quantity,omitempty"`

    // 第一单位，单位编码

    FirstUnit   string `json:"first_unit,omitempty" xml:"first_unit,omitempty"`

    // 第二数量，最多4位小数

    SecondQuantity   string `json:"second_quantity,omitempty" xml:"second_quantity,omitempty"`

    // 第二单位，单位编码

    SecondUnit   string `json:"second_unit,omitempty" xml:"second_unit,omitempty"`

}

repository: phpyandong/opentaobao

repo_name: phpyandong/opentaobao


text:
SUMMARY = "/etc/pulse/client.conf tailored for Qt5 Radio Car (based on Sato Pulse configuration)"
SECTION = "multimedia"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420"

SRC_URI = "file://50-radio.conf"
S = "${WORKDIR}"

inherit allarch

do_install() {
	install -d ${D}${sysconfdir}/pulse/client.conf.d
	install -m 0644 ${S}/50-radio.conf ${D}${sysconfdir}/pulse/client.conf.d/50-radio.conf
}

FILES_${PN} = "${sysconfdir}/pulse/client.conf.d/50-radio.conf"
CONFFILES_${PN} = "${sysconfdir}/pulse/client.conf.d/50-radio.conf"


text:
DESCRIPTION = "Manipulating stashes (Perl's symbol tables) is occasionally necessary, but \
incredibly messy, and easy to get wrong. This module hides all of that \
behind a simple API."

SECTION = "libs"
LICENSE = "Artisticv1 | GPLv1+"
PR = "r0"

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

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0;md5=e9e36a9de734199567a4d769498f743d"

SRC_URI = "https://cpan.metacpan.org/authors/id/D/DO/DOY/Package-Stash-0.37.tar.gz"

SRC_URI[md5sum] = "7e47a8261312e1cf3d12bd2007916b66"
SRC_URI[sha256sum] = "06ab05388f9130cd377c0e1d3e3bafeed6ef6a1e22104571a9e1d7bfac787b2c"
RDEPENDS_${PN} += "dist-checkconflicts-perl"
RDEPENDS_${PN} += "module-implementation-perl"
RRECOMMENDS_${PN} += "package-stash-xs-perl"
DEPENDS += "test-fatal-perl-native"
DEPENDS += "test-requires-perl-native"

S = "${WORKDIR}/Package-Stash-${PV}"

inherit cpan allarch

BBCLASSEXTEND = "native"

repository: CELLINKAB/meta-cpan

repo_name: CELLINKAB/meta-cpan


text:
package builder

import (
	"database/sql"
	"os"
	"testing"

	"github.com/IacopoMelani/Go-Starter-Project/pkg/manager/db"
	"github.com/subosito/gotenv"
)

type testStruct struct {
	recordID int64
	name     sql.NullString
	lastname sql.NullString
	gender   sql.NullBool
	Builder
}

func TestQueryBuilder(t *testing.T) {

	if err := gotenv.Load("./../../../../.env"); err != nil {
		t.Fatal("Errore caricamento configurazione")
	}
	db.InitConnection(os.Getenv("SQL_DRIVER"), os.Getenv("STRING_CONNECTION"))

	db := db.GetConnection()

	ts := new(testStruct)

	_, err := db.Exec("INSERT INTO users(name, lastname, gender) VALUES(?, ?, ?)", []interface{}{"Mario", "Rossi", nil}...)
	if err != nil {
		t.Fatalf("Errore durante salvataggio record da ricercare, errore %s", err.Error())
	}

	ts.SelectField("*").WhereEqual("name", "Mario").WhereEqual("lastname", "Rossi").WhereNull("gender", true).WhereOperator("record_id", ">=", 1).WhereOperator("record_id", "<", "99999").OrderByAsc("record_id").OrderByDesc("name")

	query := ts.BuildQuery("users")

	stmt, err := db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la costruzione della query: %s", query)
	}
	defer stmt.Close()

	rows, err := stmt.Query(ts.Params...)
	if err != nil {
		t.Fatalf("Errore durante l'esecuzione della query: %s parametri %v", query, ts.Params)
	}
	defer rows.Close()

	if rows.Next() {

		err := rows.Scan(&ts.recordID, &ts.name, &ts.lastname, &ts.gender)
		if err != nil {
			t.Fatalf("Errore durante prelievo valori, errore restituito: %s", err.Error())
		}
	}

	if ts.name.String != "Mario" {
		t.Fatal("Errore: prelevata riga errata")
	}

	ts.ResetStmt()

	query = ts.BuildQuery("users")
	stmt, err = db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la costruzione della query: %s", query)
	}
	defer stmt.Close()

	ts.ResetStmt()

	ts.SelectField("name").SelectField("lastname").GroupByField("name").GroupByField("lastname")

	query = ts.BuildQuery("users")

	stmt, err = db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la query %s parametri %v", query, ts.Params)
	}
	defer stmt.Close()

	ts.ResetStmt()

	ts.WhereOperator("name", "=", "Mario").WhereNull("gender", false)

	query = ts.BuildQuery("users")

	stmt, err = db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la query %s parametri %v", query, ts.Params)
	}
	defer stmt.Close()

	ts.ResetStmt()

	ts.WhereNull("gender", false)

	query = ts.BuildQuery("users")

	stmt, err = db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la query %s parametri %v", query, ts.Params)
	}
	defer stmt.Close()

	ts.ResetStmt()

	ts.WhereNull("gender", true)

	query = ts.BuildQuery("users")

	stmt, err = db.Prepare(query)
	if err != nil {
		t.Fatalf("Errore durante la query %s parametri %v", query, ts.Params)
	}
	defer stmt.Close()
}

repository: IacopoMelani/Go-Starter-Project

repo_name: IacopoMelani/Go-Starter-Project


text:
//go:build !windows && !darwin
// +build !windows,!darwin

package byteexec

func renameExecutable(orig string) string {
	return orig
}

func pathForRelativeFiles() (string, error) {
	return inHomeDir(".byteexec")
}

repository: getlantern/byteexec

repo_name: getlantern/byteexec


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

IMAGE_BASENAME = "cryptopuck"

IMAGE_INSTALL_append = " wpa-supplicant"
IMAGE_INSTALL_append = " cryptopuck"

repository: platisd/meta-dimitriOS

repo_name: platisd/meta-dimitriOS


text:
require ti-framework-components.inc

PV = "2_25_03_07"

SRC_URI[fctarball.md5sum] = "2b89d86098fd99dfc99b546da4251eb2"
SRC_URI[fctarball.sha256sum] = "bc5834ccfddb14cf1cca47e07bcc4993733785825962583747d8f6b5a4372940"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty


text:
package dovetail

import (
	"bytes"
	"testing"

	"gotest.tools/assert"
)

func TestTailwind(t *testing.T) {
	t.Run("Func with padding and text styles", func(t *testing.T) {
		s := subjectAsString(Div(Tailwind(Pt8, Pb8, Text2XL, FontBold)))

		t.Run(`it renders <div> with class "pt-8 pb-8 text-2xl font-bold"`, func(t *testing.T) {
			assert.Equal(t, s, `<div class="pt-8 pb-8 text-2xl font-bold"></div>`)
		})
	})

	t.Run("Method with padding and text styles", func(t *testing.T) {
		s := subjectAsString(Div().Tailwind(Pt8, Pb8, Text2XL, FontBold))

		t.Run(`it renders <div> with class "pt-8 pb-8 text-2xl font-bold"`, func(t *testing.T) {
			assert.Equal(t, s, `<div class="pt-8 pb-8 text-2xl font-bold"></div>`)
		})
	})

	t.Run("Method with md styles", func(t *testing.T) {
		s := subjectAsString(Div().Tailwind(Pt8, Pb8, TextBase, FontBold).Md(Pt1, Text2XL))

		t.Run(`it renders <div> with class "pt-8 pb-8 text-base font-bold md:pt-1 md:text-2xl"`, func(t *testing.T) {
			assert.Equal(t, s, `<div class="pt-8 pb-8 text-base font-bold md:pt-1 md:text-2xl"></div>`)
		})
	})
}

func BenchmarkTailwindJustDiv(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div())
	}

	result = buf
}

func BenchmarkTailwind0Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().Tailwind())
	}

	result = buf
}

func BenchmarkTailwind2Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().Tailwind(Text2XL, FontBold))
	}

	result = buf
}

func BenchmarkTailwind4Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().Tailwind(Pt8, Pb8, Text2XL, FontBold))
	}

	result = buf
}

func BenchmarkTailwind8Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().Tailwind(Pt8, Pb8, Mb8, Text2XL, FontBold, TextBlue300, BgBlue800, RoundedFull))
	}

	result = buf
}

func BenchmarkTailwindAddClasses2Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().AddClasses(TailwindToClass(Text2XL, FontBold)))
	}

	result = buf
}

func BenchmarkTailwindAddClasses4Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().AddClasses(TailwindToClass(Pt8, Pb8, Text2XL, FontBold)))
	}

	result = buf
}

func BenchmarkTailwindAddClasses8Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().AddClasses(TailwindToClass(Pt8, Pb8, Mb8, Text2XL, FontBold, TextBlue300, BgBlue800, RoundedFull)))
	}

	result = buf
}

func BenchmarkTailwindDivWithClasses8Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, DivWithClasses(TailwindToClass(Pt8, Pb8, Mb8, Text2XL, FontBold, TextBlue300, BgBlue800, RoundedFull)))
	}

	result = buf
}

func BenchmarkTailwindChangeClasses2Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().ChangeClasses(TailwindChanger(Text2XL, FontBold)))
	}

	result = buf
}

func BenchmarkTailwindChangeClasses4Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().ChangeClasses(TailwindChanger(Pt8, Pb8, Text2XL, FontBold)))
	}

	result = buf
}

func BenchmarkTailwindChangeClasses8Classes(b *testing.B) {
	buf := new(bytes.Buffer)

	for n := 0; n < b.N; n++ {
		buf.Reset()
		Render(buf, Div().ChangeClasses(TailwindChanger(Pt8, Pb8, Mb8, Text2XL, FontBold, TextBlue300, BgBlue800, RoundedFull)))
	}

	result = buf
}

repository: RoyalIcing/dovetail

repo_name: RoyalIcing/dovetail


text:
@article{junker2014seasonality,
 author = {J R Junker and W F Cross},
 cites = {18},
 journal = {Limnology and Oceanography},
 number = {2},
 pages = {507--518},
 title = {Seasonality in the trophic basis of a temperate stream invertebrate assemblage: Importance of temperature and food quality},
 volume = {59},
 year = {2014}
}


text:
DESCRIPTION = "Set of i2c tools for linux"
SECTION = "base"
LICENSE = "GPL"

SRC_URI = "http://dl.lm-sensors.org/i2c-tools/releases/i2c-tools-${PV}.tar.bz2"

inherit autotools

do_compile_prepend() {
        sed -i 's_/usr/local_/usr_' Makefile
        sed -i 's_CC\t:= gcc_CC\t:= ${CC}_' Makefile
}


text:
package ping

import (
	"time"

	"github.com/antongulenko/RTP/protocols"
)

const (
	default_ping_check_duration = 200 * time.Millisecond
)

type FaultDetector struct {
	*protocols.FaultDetectorBase
	client *Client
}

func NewFaultDetector(client protocols.Client, server string) (*FaultDetector, error) {
	pingClient, err := NewClient(client)
	if err != nil {
		return nil, err
	}
	err = pingClient.SetServer(server)
	if err != nil {
		_ = pingClient.Close()
		return nil, err
	}
	return &FaultDetector{
		FaultDetectorBase: protocols.NewFaultDetectorBase(client.Protocol(), pingClient.Server()),
		client:            pingClient,
	}, nil
}

func DialNewFaultDetector(endpoint string) (*FaultDetector, error) {
	client := protocols.NewClient(MiniProtocol)
	return NewFaultDetector(client, endpoint)
}

func (detector *FaultDetector) Start() {
	go detector.LoopCheck(detector.Check, default_ping_check_duration)
}

func (detector *FaultDetector) Close() (err error) {
	detector.Closed.Enable(func() {
		err = detector.client.Close()
	})
	return
}

func (detector *FaultDetector) Check() {
	detector.PerformCheck(detector.doPing)
}

func (detector *FaultDetector) doPing() error {
	err := detector.client.Ping()
	// Next ping with fresh connection
	detector.client.ResetConnection()
	return err
}


text:
package loghistogram

import (
	"math"
	"testing"
)

func TestWindowedAccumulate(t *testing.T) {
	h := NewWindowed(0, 100, 1000)
	for i := float64(0); i <= 100; i++ {
		h.Accumulate(i)
	}

	lo, hi := h.Outliers()
	if (lo | hi) != 0 {
		t.Errorf("h.Outliers() %d,%d != 0", lo, hi)
	}
	if h.Count() != 101 {
		t.Errorf("h.Count %d != 11", h.Count())
	}

	pers := []float64{0, 50, 90, 99, 100}
	vals := h.Percentiles(pers...)
	t.Logf("vals = %f\n", vals)
	for i, e := range []float64{0, 50, 90, 99, 100} {
		if pers[i] != e {
			t.Errorf("percentile[%v (%v%%)] %v != %v", i, pers[i], vals[i], e)
		}
	}
}

func TestWindowedOutliers(t *testing.T) {
	h := NewWindowed(-10, 10, 10)
	h.Accumulate(-10.0001)
	h.Accumulate(-99)
	h.Accumulate(10.0001)
	if h.Count() != 3 {
		t.Error("Count", h.Count())
	}
	lo, hi := h.Outliers()
	if lo != 2 || hi != 1 {
		t.Error("Outliers", lo, hi)
	}
}

func TestWindowedEmptyHistogram(t *testing.T) {
	h := NewWindowed(0, 1, 10)
	p := h.Percentile(50)
	if !math.IsNaN(p) {
		t.Error("Percentile() of empty histogram != NaN")
	}
	ps := h.Percentiles(0, 100)
	for _, p := range ps {
		if !math.IsNaN(p) {
			t.Error("Percentiles() of empty histogram != NaN")
		}
	}
}

func BenchmarkWindowedAccumulate(b *testing.B) {
	h := NewWindowed(0, 10000000, 1000)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Accumulate(float64(i))
	}
}

func BenchmarkWindowedRaceyAccumulate(b *testing.B) {
	h := NewWindowed(0, 10000000, 1000)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.raceyAccumulate(float64(i))
	}
}

func BenchmarkWindowedSingle10thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentile(10)
	}
}

func BenchmarkWindowedSingle25thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentile(25)
	}
}

func BenchmarkWindowedSingle50thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentile(50)
	}
}

func BenchmarkWindowedSingle75thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentile(75)
	}
}

func BenchmarkWindowed2Percentiles(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentiles(25, 50)
	}
}

func BenchmarkWindowed3Percentiles(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentiles(25, 33, 50)
	}
}

func BenchmarkWindowed4Percentiles(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentiles(10, 25, 33, 50)
	}
}

func BenchmarkWindowed75thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentiles(75)
	}
}

func BenchmarkWindowed99thPercentile(b *testing.B) {
	h := NewWindowed(0, 10000, 1000)
	for i := 0; i < 10000; i += 10 {
		h.Accumulate(float64(i))
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		h.Percentiles(99)
	}
}


text:
# Using relative path here causes bitbake to search in
# BBPATH for the first instance of x-load.inc rather
# than just within the current directory.
require recipes/x-load/x-load.inc

COMPATIBLE_MACHINE = "am37x-evm|dm37x-evm|am3517-evm"

SRCREV = "fc6d5be15c703d21aef0ae0b8c02177721f0445f"

PR = "r0"

# Added ECC patch
SRC_URI = "git://arago-project.org/git/projects/x-load-omap3.git;protocol=git \
           file://0001-Xloader-BCH-4b8b-Error-Correction.patch \
          "

XVER = "1.46"
PSPREL = "03.00.01.06.sdk"

S = "${WORKDIR}/git"

# Add FOUR_BIT_ERROR_CORRECTION flag to the flags passed to the compile
EXTRA_OEMAKE += "PLATFORM_RELFLAGS=-DFOUR_BIT_ERROR_CORRECT"

PACKAGE_ARCH = "${MACHINE_ARCH}"


text:
@article{konu2020role,
  title={A role for ventromedial prefrontal cortex in self-generated episodic social cognition},
  author={Konu, Delali and Turnbull, Adam and Karapanagiotidis, Theodoros and Wang, Hao-ting and Brown, Lydia and Jefferies, Elizabeth and Smallwood, Jonathan},
  journal={NeuroImage},
  pages={116977},
  year={2020},
  publisher={Elsevier}
}

repository: tkarapan/academic-kickstart

repo_name: tkarapan/academic-kickstart