text
stringlengths 1
22.8M
|
|---|
The BMW Welt is a combined exhibition, delivery, adventure museum, and event venue located in Munich's district Am Riesenfeld, next to the Olympic Park, in the immediate vicinity of the BMW Headquarters and factory. It was built from August 2003 to summer 2007. A solar system with 800 kW of power is installed on the roof of the main building. The opening took place on 17 October 2007. The BMW Welt is the most visited tourist attraction in Bavaria.
Operations
BMW Welt operations are coordinated with the other local BMW facilities, the BMW Museum and BMW Headquarters. It has a showroom with the current model lineup of BMW cars and motorcycles, and the other two BMW Group brands, Mini and Rolls-Royce.
Customers picking up special ordered cars are given a dramatic "staged experience" in which they await their new car in an enormous glass-walled hall, and their cars are lifted up from lower levels on round elevator platforms to their respective delivery area. BMW Welt also has shops selling BMW-branded promotional merchandise and accessories, and a restaurant.
Design and construction
In 2001, an international architectural design competition was sponsored by BMW. Twenty-seven offices participated in the competition four of which were awarded prizes. The jury awarded two offices Sauerbruch Hutton and COOP HIMMELB(L)AU first prize and made the recommendation for the competitors to rework their design submissions in a third design phase in order for BMW to determine which office would be awarded the contract.
The contract was awarded to the Vienna-based architects COOP HIMMELB(L)AU and the facility was constructed from August 2003 through summer 2007 at a cost of US$200 million. Originally conceived to be open and ready for World Cup 2006, it eventually opened on 17 October 2007, and deliveries commenced on 23 October 2007. The first customer to take European delivery of a new BMW at the Welt was Jonathan Spira.
There were 2,200,000 visitors during the first 12 months of operation. The number of visitors increased to 2,930,000 in 2013, of which 60% came from Germany.
Designed with an 800 kW solar plant on its roof, "the building does not have the boredom of an exhibition hall, it is not only a temple but also a market place and communication center, and a meeting point for knowledge transfer", said architect Wolf D. Prix at the opening ceremony.
COOP HIMMELB(L)AU's BMW Welt project records are archived at the Canadian Centre for Architecture in Montreal, Quebec, Canada.
Gallery
See also
World Architecture Survey
References
External links
BMW-Welt on www.muenchenarchitektur.com
BMW European Delivery wiki, on the Bimmerfest.com site
Buildings and structures in Munich
Coop Himmelblau
Museums in Munich
BMW
Automobile museums in Germany
Milbertshofen-Am Hart
|
Topatali is a village in Kamrup Metropolitan district, situated in south bank of river Brahmaputra.
Transport
The village is near National Highway 37 and connected to nearby towns and cities with regular buses and other modes of transportation.
Nearest Railway Station is Jagiroad (5 KM) and the nearest airport is Lokpriya Gopinath Bordoloi International Airport (70 KM).
See also
Tupamari
Tukrapara
References
Villages in Kamrup district
|
Myloplus arnoldi is a medium to large omnivorous fish of the family Serrasalmidae from South America, where it is found in the Amazon, Xingu and Tocantins River basins.
It can grow to a length of .
They are also called the silver dollar and are one of the fish referred to as "silver dollars".
These fish are capable of delivering serious bites to humans.
Etymology
The fish is named in honor of German aquarist Johann Paul Arnold (1869-1952), who donated the type specimens to the Zoological Museum of Berlin.
References
Jégu, M., 2003. Serrasalminae (Pacus and piranhas). p. 182-196. In R.E. Reis, S.O. Kullander and C.J. Ferraris, Jr. (eds.) Checklist of the Freshwater Fishes of South and Central America. Porto Alegre: EDIPUCRS, Brasil.
Serrasalmidae
Freshwater fish of Brazil
Fish of the Amazon basin
Taxa named by Ernst Ahl
Fish described in 1936
|
```makefile
xcl2_SRCS:=${COMMON_REPO}/common/includes/xcl2/xcl2.cpp
xcl2_HDRS:=${COMMON_REPO}/common/includes/xcl2/xcl2.hpp
xcl2_CXXFLAGS:=-I${COMMON_REPO}/common/includes/xcl2
```
|
```c++
///////////////////////////////////////////////////////////////////////////////
// LICENSE_1_0.txt or copy at path_to_url
#ifndef BOOST_MP_NO_ET_OPS_HPP
#define BOOST_MP_NO_ET_OPS_HPP
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4714)
#endif
namespace boost {
namespace multiprecision {
//
// Operators for non-expression template enabled number.
// NOTE: this is not a complete header - really just a suffix to default_ops.hpp.
// NOTE: these operators have to be defined after the methods in default_ops.hpp.
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& v)
{
static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
number<B, et_off> result(v);
result.backend().negate();
return result;
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator~(const number<B, et_off>& v)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
number<B, et_off> result;
eval_complement(result.backend(), v.backend());
return result;
}
//
// Addition:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator+(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator+(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Subtraction:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator-(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator-(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// Multiply:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator*(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator*(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// divide:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator/(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator/(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// modulus:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator%(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator%(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// Bitwise or:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator|(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator|(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Bitwise xor:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator^(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator^(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Bitwise and:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator&(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator&(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// shifts:
//
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator<<(const number<B, et_off>& a, const I& b)
{
number<B, et_off> result(a);
using default_ops::eval_left_shift;
detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
eval_left_shift(result.backend(), b);
return result;
}
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator>>(const number<B, et_off>& a, const I& b)
{
number<B, et_off> result(a);
using default_ops::eval_right_shift;
detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
eval_right_shift(result.backend(), b);
return result;
}
//
// If we have rvalue references go all over again with rvalue ref overloads and move semantics.
// Note that while it would be tempting to implement these so they return an rvalue reference
// (and indeed this would be optimally efficient), this is unsafe due to users propensity to
// write:
//
// const T& t = a * b;
//
// which would lead to a dangling reference if we didn't return by value. Of course move
// semantics help a great deal in return by value, so performance is still pretty good...
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& v)
{
static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
v.backend().negate();
return std::move(v);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator~(number<B, et_off>&& v)
{
eval_complement(v.backend(), v.backend());
return std::move(v);
}
//
// Addition:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator+(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator+(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Subtraction:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_signed_number<B>::value, number<B, et_off> >::type operator-(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(b.backend(), a.backend());
b.backend().negate();
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator-(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(is_compatible_arithmetic_type<V, number<B, et_off> >::value && is_signed_number<B>::value) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator-(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(b.backend(), number<B, et_off>::canonical_value(a));
b.backend().negate();
return std::move(b);
}
//
// Multiply:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator*(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator*(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// divide:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_divide;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_divide(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator/(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_divide;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_divide(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
//
// modulus:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_modulus;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_modulus(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator%(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_modulus;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_modulus(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
//
// Bitwise or:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator|(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator|(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Bitwise xor:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator^(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator^(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Bitwise and:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator&(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator&(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// shifts:
//
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator<<(number<B, et_off>&& a, const I& b)
{
using default_ops::eval_left_shift;
eval_left_shift(a.backend(), b);
return std::move(a);
}
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator>>(number<B, et_off>&& a, const I& b)
{
using default_ops::eval_right_shift;
eval_right_shift(a.backend(), b);
return std::move(a);
}
}
} // namespace boost::multiprecision
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#endif // BOOST_MP_NO_ET_OPS_HPP
```
|
```swift
// swift-tools-version:5.9
import PackageDescription
let package = Package(
name: "fluent",
platforms: [
.macOS(.v10_15),
.iOS(.v13),
.watchOS(.v6),
.tvOS(.v13),
],
products: [
.library(name: "Fluent", targets: ["Fluent"]),
],
dependencies: [
.package(url: "path_to_url", from: "1.48.4"),
.package(url: "path_to_url", from: "4.101.0"),
],
targets: [
.target(
name: "Fluent",
dependencies: [
.product(name: "FluentKit", package: "fluent-kit"),
.product(name: "Vapor", package: "vapor"),
],
swiftSettings: swiftSettings
),
.testTarget(
name: "FluentTests",
dependencies: [
.target(name: "Fluent"),
.product(name: "XCTFluent", package: "fluent-kit"),
.product(name: "XCTVapor", package: "vapor"),
],
swiftSettings: swiftSettings
),
]
)
var swiftSettings: [SwiftSetting] { [
.enableUpcomingFeature("ExistentialAny"),
.enableUpcomingFeature("ConciseMagicFile"),
.enableUpcomingFeature("ForwardTrailingClosures"),
.enableUpcomingFeature("ImportObjcForwardDeclarations"),
.enableUpcomingFeature("DisableOutwardActorInference"),
.enableExperimentalFeature("StrictConcurrency=complete"),
] }
```
|
```java
/*
*
*
* path_to_url
*
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
*/
package org.dartlang.vm.service.consumer;
// This file is generated by the script: pkg/vm_service/tool/generate.dart in dart-lang/sdk.
import org.dartlang.vm.service.element.ErrorObj;
import org.dartlang.vm.service.element.Success;
@SuppressWarnings({"WeakerAccess", "unused"})
public interface SetFlagConsumer extends Consumer {
void received(ErrorObj response);
void received(Success response);
}
```
|
Pauwels Casteels or Pauwel Casteels (Antwerp, c. 1625 – Antwerp, after 1677) was a Flemish painter and draughtsman. He worked in Antwerp and is known for his battle scenes and landscapes with mythological, historical and biblical scenes.
Life
Casteels was born in Antwerp around 1625. He was admitted as a ‘wijnmeester’ (‘wine master’, meaning a son of a master) in the Antwerp Guild of St. Luke in the guild year 1649–1650. In the Guild year 1656-1657 he had a pupil called Jan-Batista Marien registered at the Guild.
Casteels' works were distributed by the Antwerp art dealers Forchondt who traded artworks throughout Europe. The son of the founder of the Forchondt firm who was living in Vienna specifically requested for small and large-scale battle scenes by Paul and that of another battle painter called Alexander Casteels the Elder, possibly a family member, to be sent to Vienna as there was a strong demand for their battle scenes in Central and Eastern Europe.
It is not known when or where he died. His latest dated work is the Battle between king John Sobieski III and the Turks (At Sotheby's Milan auction, 1 June 2005 lot 48), which is signed and dated to 1677.
Work
Casteels was a versatile painter who painted cavalry battles and scenes with mythological, historical and biblical stories. His historical and mythological scenes often depicted bacchanalia and sea triumphs. He usually painted on large canvases. His works have at times been attributed to other Flemish painters, such as Jan Cossiers, Simon de Vos and Cornelis de Vos.
His battle scenes were very popular in Central Europe and one example is in the collection of the Bavarian State Painting Collections. These scenes were influenced by fellow Flemish battle painters Pieter Snayers and Pieter Meulener, of whom he adopted the colour palette. His battle scenes are often crowded compositions with many figures engaged in frenzied battle. The figures in these compositions are individualised thus luring the viewer into the details of the scene.
Due to the stylistic similarities, some of his battle paintings may have been attributed to fellow Antwerp battle painter Alexander Casteels the Elder.
References
External links
1635 births
1681 deaths
17th-century Flemish painters
Flemish Baroque painters
Flemish landscape painters
Painters from Antwerp
17th-century war artists
Flemish war artists
Flemish battle painters
|
Jack Heid (June 26, 1924 – May 27, 1987) was an American cyclist. He competed in the time trial and the sprint events at the 1948 Summer Olympics.
References
External links
1924 births
1987 deaths
American male cyclists
Olympic cyclists for the United States
Cyclists at the 1948 Summer Olympics
Cyclists from New York City
|
```python
from time import sleep
import pytest
import ray
from ray import workflow
from ray.workflow.http_event_provider import HTTPListener
from ray.tests.conftest import * # noqa
from ray import serve
from ray.workflow import common
from ray._private.test_utils import wait_for_condition
import requests
@pytest.mark.parametrize(
"workflow_start_regular_shared_serve",
[
{
"num_cpus": 4, # TODO (Alex): When we switch to the efficient event
# implementation we shouldn't need these extra cpus.
}
],
indirect=True,
)
def test_multiple_events_by_http(workflow_start_regular_shared_serve):
"""If a workflow has multiple event arguments, it should wait for them at the
same time.
"""
def send_event1():
resp = requests.post(
"path_to_url"
+ "workflow_test_multiple_event_by_http",
json={"event_key": "e1", "event_payload": "hello"},
)
return resp
def send_event2():
sleep(0.5)
resp = requests.post(
"path_to_url"
+ "workflow_test_multiple_event_by_http",
json={"event_key": "e2", "event_payload": "world"},
)
return resp
@ray.remote
def trivial_task(arg1, arg2):
return f"{arg1[1]} {arg2[1]}"
event1_promise = workflow.wait_for_event(HTTPListener, event_key="e1")
event2_promise = workflow.wait_for_event(HTTPListener, event_key="e2")
workflow.run_async(
trivial_task.bind(event1_promise, event2_promise),
workflow_id="workflow_test_multiple_event_by_http",
)
# wait until HTTPEventProvider is ready
def check_app_running():
status = serve.status().applications[common.HTTP_EVENT_PROVIDER_NAME]
assert status.status == "RUNNING"
return True
wait_for_condition(check_app_running)
# repeat send_event1() until the returned status code is not 404
while True:
res = send_event1()
if res.status_code == 404:
sleep(0.5)
else:
break
while True:
res = send_event2()
if res.status_code == 404:
sleep(0.5)
else:
break
event_msg = workflow.get_output(workflow_id="workflow_test_multiple_event_by_http")
assert event_msg == "hello world"
if __name__ == "__main__":
import sys
sys.exit(pytest.main(["-v", __file__]))
```
|
Michael Elias Baroody (born September 14, 1946) is an American lobbyist.
Life and career
Baroody was born in Washington, D.C. and graduated from the University of Notre Dame (B.A., 1968). He served in the United States Navy in 1968 - 1970. In 1970 he began his career in the Washington office of Nebraska Senator Roman Hruska. From 1977 to 1980 he was research director and later director of public affairs at the Republican National Committee. In 1980 he served as Editor-in-Chief for Republican Platform.
From 1981 to 1985 Baroody served as Deputy Assistant to the President and Director of Public Affairs at the White House under Ronald Reagan. From 1985 to 1990 he was assistant secretary for policy at the United States Department of Labor during the Ronald Reagan and George H. W. Bush administrations.
From 1990 to 1993 he was senior vice president for policy and communications and later president of the Republican-oriented National Policy Forum. He also served as Bob Dole's Speechwriter and Executive Assistant. In 1994 he returned to the National Association of Manufacturers (NAM) to help build the Association's public affairs program, emphasizing greater involvement by NAM members in lobbying, policy and political activities inside and outside of Washington. These involvement activities grew into a "third branch" of NAM's advocacy efforts, co-equal with the traditional lobbying and media-relations "branches" in Policy and Communications. From 1997 to 2002 he was board member of the National Center for Neighborhood Enterprise.
Since 1998, Baroody has been senior lobbyist for the National Association of Manufacturers, one of industry's most powerful lobbies. He oversees all of the NAM's advocacy efforts and represents the NAM on the Executive Committee of BIPAC, the influential Business-Industry Political Action Committee. In March 2007 President George W. Bush raised controversy after nominating Baroody as the new chairman of the Consumer Product Safety Commission. Baroody withdrew his name from consideration on May 23.
References
External links
Bush expected to nominate Baroody to head CPSC
Baroody resigns from National Policy Forum
List of people passing between gov't and private sector - Baroody
A protest site to Baroody's nomination to the CSA
1946 births
Living people
American lobbyists
Washington, D.C., Republicans
Reagan administration personnel
|
```python
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import unittest
import numpy as np
from get_test_cover_info import (
XPUOpTestWrapper,
create_test_class,
get_xpu_op_support_types,
)
from op_test_xpu import XPUOpTest
import paddle
paddle.enable_static()
class XPUTestBmmOp(XPUOpTestWrapper):
"""
func desc:: path_to_url#bmm
"""
def __init__(self):
self.op_name = 'bmm'
self.use_dynamic_create_class = False
class TestBmmOp(XPUOpTest):
def setUp(self):
self.init_dtype()
self.set_xpu()
self.op_type = "bmm"
self.place = paddle.XPUPlace(0)
self.set_shape()
X = np.random.random(self.Xshape).astype(self.dtype)
Y = np.random.random(self.Yshape).astype(self.dtype)
self.inputs = {'X': X, 'Y': Y}
Out = np.matmul(X, Y)
self.outputs = {'Out': Out}
def init_dtype(self):
self.dtype = self.in_type
def set_shape(self):
self.Xshape = (10, 3, 4)
self.Yshape = (10, 4, 5)
def set_xpu(self):
self.__class__.use_xpu = True
self.__class__.no_need_check_grad = False
self.__class__.op_type = self.in_type
def test_check_output(self):
self.check_output_with_place(self.place)
def test_check_grad_normal(self):
self.check_grad_with_place(self.place, ['X', 'Y'], 'Out')
class TestBmmOp1(TestBmmOp):
def set_shape(self):
self.Xshape = (3, 3, 3)
self.Yshape = (3, 3, 3)
class TestBmmOp2(TestBmmOp):
def set_shape(self):
self.Xshape = (128, 3, 16)
self.Yshape = (128, 16, 3)
class TestBmmOp3(TestBmmOp):
def set_shape(self):
self.Xshape = (2048, 16, 27)
self.Yshape = (2048, 27, 16)
class TestBmmOp4(TestBmmOp):
def set_shape(self):
self.Xshape = (2, 27, 27)
self.Yshape = (2, 27, 27)
class TestBmmOp5(TestBmmOp):
def set_shape(self):
self.Xshape = (2, 1, 1)
self.Yshape = (2, 1, 1)
support_types = get_xpu_op_support_types('bmm')
for stype in support_types:
create_test_class(globals(), XPUTestBmmOp, stype)
if __name__ == '__main__':
unittest.main()
```
|
Caeculia is a genus of moths in the family Lasiocampidae. The genus was erected by Gottlieb August Wilhelm Herrich-Schäffer in 1854.
External links
Lasiocampidae
|
```yaml
apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
spec:
profile: empty
components:
ingressGateways:
- name: istio-ingressgateway
enabled: true
label:
aaa: aaa-val
bbb: bbb-val
version: "21"
k8s:
resources:
requests:
cpu: 111m
memory: 111Mi
- name: user-ingressgateway
enabled: true
label:
ccc: ccc-val
ddd: ddd-val
k8s:
resources:
requests:
cpu: 222m
memory: 888Mi
- namespace: user-ingressgateway-ns
name: ilb-gateway
enabled: true
k8s:
resources:
requests:
cpu: 333m
serviceAnnotations:
cloud.google.com/load-balancer-type: "internal"
service:
ports:
## You can add custom gateway ports - google ILB default quota is 5 ports,
- port: 15011
name: grpc-pilot-mtls
- port: 8060
targetPort: 8060
name: tcp-citadel-grpc-tls
# Port 5353 is forwarded to kube-dns
- port: 5353
name: tcp-dns
overlays:
- kind: Deployment
name: ilb-gateway
patches:
- path: spec.template.spec.containers.[name:istio-proxy].env.[name:PILOT_CERT_PROVIDER].value
value: foobar # OVERRIDDEN
```
|
```java
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package google.registry.tools.params;
import static com.google.common.truth.Truth.assertThat;
import static google.registry.tools.params.NameserversParameter.splitNameservers;
import static org.junit.jupiter.api.Assertions.assertThrows;
import com.beust.jcommander.ParameterException;
import org.junit.jupiter.api.Test;
/** Unit tests for {@link NameserversParameter}. */
class NameserversParameterTest {
private final NameserversParameter instance = new NameserversParameter();
@Test
void testConvert_singleBasicNameserver() {
assertThat(instance.convert("ns11.goes.to")).containsExactly("ns11.goes.to");
}
@Test
void testConvert_multipleBasicNameservers() {
assertThat(instance.convert("ns1.tim.buktu, ns2.tim.buktu, ns3.tim.buktu"))
.containsExactly("ns1.tim.buktu", "ns2.tim.buktu", "ns3.tim.buktu");
}
@Test
void testConvert_kitchenSink() {
assertThat(instance.convert(" ns1.foo.bar, ,ns2.foo.bar,, ns[1-3].range.baz "))
.containsExactly(
"ns1.foo.bar", "ns2.foo.bar", "ns1.range.baz", "ns2.range.baz", "ns3.range.baz");
}
@Test
void testConvert_invalid() {
assertThat(instance.convert("ns1.foo.bar,ns2.foo.baz,ns3.foo.bar"))
.containsExactly("ns1.foo.bar", "ns3.foo.bar", "ns2.foo.baz");
}
@Test
void testValidate_sillyString_throws() {
ParameterException thrown =
assertThrows(ParameterException.class, () -> instance.validate("nameservers", "[[ns]]"));
assertThat(thrown).hasMessageThat().contains("Must be a comma-delimited list of nameservers");
assertThat(thrown).hasCauseThat().hasMessageThat().contains("Could not parse square brackets");
}
@Test
void testConvert_empty_returnsEmpty() {
assertThat(instance.convert("")).isEmpty();
}
@Test
void testConvert_nullString_returnsNull() {
assertThat(instance.convert(null)).isEmpty();
}
@Test
void testSplitNameservers_noopWithNoBrackets() {
assertThat(splitNameservers("ns9.fake.example")).containsExactly("ns9.fake.example");
}
@Test
void testSplitNameservers_worksWithBrackets() {
assertThat(splitNameservers("ns[1-4].zan.zibar"))
.containsExactly("ns1.zan.zibar", "ns2.zan.zibar", "ns3.zan.zibar", "ns4.zan.zibar");
}
@Test
void testSplitNameservers_worksWithBrackets_soloRange() {
assertThat(splitNameservers("ns[1-1].zan.zibar")).containsExactly("ns1.zan.zibar");
}
@Test
void testSplitNameservers_throwsOnInvalidRange() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("ns[9-2].foo.bar"));
assertThat(thrown).hasMessageThat().isEqualTo("Number range [9-2] is invalid");
}
@Test
void testSplitNameservers_throwsOnInvalidHostname_missingPrefix() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("[1-4].foo.bar"));
assertThat(thrown)
.hasMessageThat()
.isEqualTo("Could not parse square brackets in [1-4].foo.bar");
}
@Test
void testSplitNameservers_throwsOnInvalidHostname_missingDomainName() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("this.is.ns[1-5]"));
assertThat(thrown)
.hasMessageThat()
.isEqualTo("Could not parse square brackets in this.is.ns[1-5]");
}
@Test
void testSplitNameservers_throwsOnInvalidRangeSyntax() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("ns[1-4[.foo.bar"));
assertThat(thrown).hasMessageThat().contains("Could not parse square brackets");
}
}
```
|
Lilium superbum is a species of true lily native to the eastern and central regions of North America. Common names include Turk's cap lily, turban lily, swamp lily, lily royal, or American tiger lily. The native range of the species extends from southern New Hampshire, Massachusetts, and New York, west to Illinois, Missouri, and Arkansas, and south to Georgia, Alabama, Mississippi, and Florida.
Description
Lilium superbum grows from high with typically three to seven blooms, but exceptional specimens have been observed with up to 40 flowers on each stem. It is capable of growing in wet conditions. It is fairly variable in size, form, and color. The color is known to range from a deep yellow to orange to a reddish-orange "flame" coloring with reddish petal tips. The flowers have a green star at their center that can be used to distinguish L. superbum from the Asiatic "tigerlilies" that frequently escape from cultivation. It grows in swamps, woods, and wet meadows.
Uses
The roots were a food source for Native Americans, and the flowers provide nectar for hummingbirds and larger insects.
Status
It is listed as endangered in Florida, New Hampshire, Alberta and Saskatchewan and threatened in Kentucky, and exploitably vulnerable in New York.
Etymology
The Turk's cap common name is derived from the reflexed shape of the flower petals, which presumably resemble a type of hat worn by early Turkish people.
Toxicity
Cats
Cats are extremely sensitive to lily toxicity and ingestion is often fatal; households and gardens that are visited by cats are strongly advised against keeping this plant or placing dried flowers where a cat may brush against them and become dusted with pollen that they then consume while cleaning. Suspected cases require urgent veterinary attention. Rapid treatment with activated charcoal and/or induced vomiting can reduce the amount of toxin absorbed (this is time-sensitive so in some cases vets may advise doing it at home), and large amounts of fluid by IV can reduce damage to kidneys to increase the chances of survival.
Traditional uses
The bulbs were made into soups by some Native Americans.
References
External links
USDA Plants Profile for Lilium superbum (turk's-cap lily)
Missouri Botanical Garden, Kemper Center for Home Gardening: Turkscap lily (Lilium superbum)
Lady Bird Johnson Wildflower Center Native Plant Information Network−NPIN: Lilium superbum (Turk's-cap lily) — with horticultural info.
superbum
Flora of the Eastern United States
Flora of the Northeastern United States
Flora of the Southeastern United States
Flora of the Appalachian Mountains
Plants described in 1753
Taxa named by Carl Linnaeus
Endangered flora of the United States
|
Bo is a mainly Swedish/Danish masculine given name, derived from the Old Norse verb búa ("to reside"). A variant of Bo is the Swedish Bosse. Bo is uncommon as a surname. Bo is also short for names including Beaufort, Beauregard, Bonita, or Bonnie; it is also a less common shortening of the name Robert, which is usually shortened to Bob. It can also be a shortening of the name James, which is usually shortened to Jimmy, Jim, or Jimbo.
Notable people
Given name
Bo Anderson, birth name of American Brazilian DJ and producer Maga Bo
Bo Bergman (1869–1967), Swedish poet
Bo van Leijden (born 1997), Dutch Scharrel
Bo Bichette (born 1998), Major League Baseball player
Bo Boustedt (1868–1939), Swedish Army lieutenant general
Bo Bowling (born 1987), American football player
Bo Carpelan (1926–2011), Finnish poet and author
Bo Danske, 13th-century Danish philosopher
Bo Ehnbom (1899–1985), Swedish military engineer
Bo Ericson (athlete) (1919–1970), Swedish hammer thrower
Bo Goldman (born 1932), American writer, Broadway playwright, and screenwriter
Bo Hamburger (born 1970), Danish former cyclist
Bo Hansson (1943–2010), Swedish musician
Bo Holmberg (1942–2010), Swedish politician
Bo Horvat (1995), Current Captain of the Vancouver Canucks of the National Hockey League
Bo Johansson (born 1942), Swedish former football player and current football coach
Bo Larsson (born 1944), former Swedish football midfielder/striker
Bo Ljungberg (1911–1984), Swedish pole vaulter
Bo Melton (born 1999), American football player
Bo Levi Mitchell (born 1990), Canadian football quarterback
Bo Mossberg, Swedish author and illustrator of Den nya nordiska floran
Bo Nix (born 2000), American football quarterback
Bo Persson (table tennis), former Swedish table tennis player
Bo Petersson, (born 1946), Swedish football manager and former football player
Bo Randall, (1909 – 1989), American knifemaker
Bo Johan Renck, (born 1966), Swedish director of music videos, TV and film
Bo Rybeck (1935–2019), Swedish physician
Bo Scarbrough (born 1996), American football player
Bo Svenson (born 1941), Swedish-born American actor
Bo Svensson (born 1979), Danish football player
Bo Toresson (born 1939), Swedish politician
Bo Varenius (1918–1996), Swedish major general
Bo Vestergaard (born 1965), Danish lightweight rower
Bo Widerberg (1930–1997), Swedish film director
Nickname
Bo Belinsky (1936–2001), American Major League Baseball pitcher
Bo Bice (born 1975), American singer who placed second on the fourth season of American Idol
Bo Bruce (born 25 November 1984), English singer-songwriter
Gudmundur S. (Bo) Bodvarsson (1952–2006), Icelandic hydrogeologist
Bo Bolinger (1932–2011), American football player
Jérôme Napoléon Bonaparte (1805–1870), American farmer, son of Napoleon Bonaparte's brother Jérôme and Elizabeth Patterson
Bo Brown (1906–1996), American cartoonist
Bo Burnham (born 1990), American singer songwriter/comedian
Bo Burris (born 1944), American retired National Football League player
Bo Callaway (April 2, 1927 – March 15, 2014), American politician and businessman
Bo Cornell (born 1949), American retired National Football League player
Israel "Bo" Curtis (1932-2012), African-American educator and politician
Bo Derek (born 1956), American actress
Bo Diddley (1928–2008), American R&B and Chicago blues musician
Bo Goldman (born September 10, 1932), American writer, Broadway playwright, and screenwriter
Bo Gritz (born January 18, 1939), American former US Army officer and perennial candidate
Bo Halldórsson (born 16 April 1951), Icelandic pop singer
Bo Hines (born 1995), American football player and politician
Bo Hopkins (1938–2022), American actor
Bo Horvat (born 1995), Canadian hockey player
Bo Jackson (born 1962), American former National Football League and Major League Baseball player
Bo Kimble (born 1966), American basketball player
Bo Lamar (born 1951), American former basketball player
Bo McCalebb (born May 4, 1985), American-Macedonian professional basketball player
Bo Mitchell (born September 5, 1970), representative in the Tennessee House of Representatives
Bo Outlaw (born 1971), American former National Basketball Association player
Bo Pelini (born 1967), American college football head coach
Bo Rein (July 20, 1945 – January 10, 1980), American, football player, baseball player, and football coach
Bo Roberson (July 23, 1935 – April 15, 2001), American, track and field athlete, and football player
Bo Robinson (born 1956), American retired National Football League player
Bo Ryan (born 1947), American college basketball coach and former player
Bo Schembechler (1929–2006), American football player, college head coach and administrator
Bo Snerdley, pseudonym of James Golden (radio personality)
Bo Songvisava (born 1979/1980), Thai chef
Bo Welch (born November 30, 1951), American production designer, art director, film and TV director, actor
Fictional characters
Bo Adams, main character in the Believe TV series
Bo Abobo from the video game Double Dragon
Bo, a character from the video game Brawl Stars
Bo Brady, in the soap opera Days of Our Lives
Bo Buchanan, in the soap opera One Life to Live
Bo Callahan, main draft prospect in the movie Draft Day
Bo Cocky, the main protagonist in the 2006 film Supertwink
Bo (Lost Girl) (Bo Dennis), protagonist of the Canadian TV series Lost Girl
Bo Duke, one of the main characters in The Dukes of Hazzard TV series
Bo Monkey, a main character in the Nickelodeon TV series Fresh Beat Band of Spies
Bo Orlov, a character in the Netflix series Grand Army
Little Bo Peep, from a nursery rhyme
Bo Peep, in the Toy Story animated film
Bo' Rai Cho, in the Mortal Kombat video game series
Bo Sheep, in the U.S. Acres comic strip
Bo Sinclair, in the 2005 film House of WaxBo, a cheetah from the British animated TV series Mama Mirabelle's Home MoviesBo, a cartoon character in Muse magazine
Bo, an orphan named "Boniface" in the Cornelia Funke novel The Thief LordBo, the main protagonist of the 2017 animated film The Star''
Bo Hess from the movie Signs
See also
Beau (name), given name and surname
References
Danish masculine given names
Swedish masculine given names
English masculine given names
Masculine given names
Nicknames
|
```smalltalk
// This file is part of Core WF which is licensed under the MIT license.
// See LICENSE file in the project root for full license information.
using System.Threading;
namespace System.Activities.Runtime.DurableInstancing;
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
internal class SignalGate
{
[Fx.Tag.SynchronizationObject(Blocking = false, Kind = Fx.Tag.SynchronizationKind.InterlockedNoSpin)]
private int _state;
public SignalGate() { }
internal bool IsLocked => _state == GateState.Locked;
internal bool IsSignalled => _state == GateState.Signalled;
// Returns true if this brings the gate to the Signalled state.
// Transitions - Locked -> SignalPending | Completed before it was unlocked
// Unlocked -> Signaled
public bool Signal()
{
int lastState = _state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref _state, GateState.SignalPending, GateState.Locked);
}
if (lastState == GateState.Unlocked)
{
_state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// Returns true if this brings the gate to the Signalled state.
// Transitions - SignalPending -> Signaled | return the AsyncResult since the callback already
// | completed and provided the result on its thread
// Locked -> Unlocked
public bool Unlock()
{
int lastState = _state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref _state, GateState.Unlocked, GateState.Locked);
}
if (lastState == GateState.SignalPending)
{
_state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// This is factored out to allow Signal and Unlock to be inlined.
private static void ThrowInvalidSignalGateState() => throw Fx.Exception.AsError(new InvalidOperationException(SR.InvalidSemaphoreExit));
private static class GateState
{
public const int Locked = 0;
public const int SignalPending = 1;
public const int Unlocked = 2;
public const int Signalled = 3;
}
}
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
internal class SignalGate<T> : SignalGate
{
private T _result;
public SignalGate()
: base() { }
public bool Signal(T result)
{
_result = result;
return Signal();
}
public bool Unlock(out T result)
{
if (Unlock())
{
result = _result;
return true;
}
result = default;
return false;
}
}
```
|
```shell
How to unstage a staged file
How to set your username and email
Use `short` status to make output more compact
Intent to add
Ignore files in git
```
|
```java
package com.nytimes.android.sample.data.model;
import org.immutables.value.Value;
import java.util.List;
@Value.Immutable
@Value.Style(allParameters = true)
public abstract class Preview {
@Value.Parameter(false)
public abstract List<Images> images();
}
```
|
A pontifical () is a Christian liturgical book containing the liturgies that only a bishop may perform. Among the liturgies are those of the ordinal for the ordination and consecration of deacons, priests, and bishops to Holy Orders. While the Roman Pontifical and closely related Ceremonial of Bishops of the Roman Rite are the most common, pontificals exist in other liturgical traditions.
History
Pontificals in Latin Christianity first developed from sacramentaries by the 8th century. Besides containing the texts of exclusively episcopal liturgies such as the Pontifical High Mass, liturgies that other clergymen could celebrate were also present. The contents varied throughout the Middle Ages, but eventually a pontifical only contained those liturgies a bishop could perform. The Pontificale Egberti, a pontifical that once belonged to and was perhaps authored by Ecgbert of York, is regarded as one of the most notable early pontificals and may be the oldest to survive.
The ordination liturgies of the Sarum Use pontifical was adapted by Thomas Cranmer into his 1550 ordinal for the Church of England following the English Reformation. Among the complaints lodged by Anglicans against the medieval Catholic pontificals was that the laying on of hands during the conferral of Holy Orders was "obscured by ceremonies."
A pontifical was printed in Rome in 1485 but the first authoritative Roman Pontifical was not printed until 1596 under Clement VIII. Revisions of the Roman Pontifical () continued over the next centuries, though was largely replaced by the Ceremonial of Bishops () that had been developing alongside it, with the rubrics for the celebration of a Pontifical High Mass deleted from the pontifical and celebrated from the ceremonial. Among the contents of both these texts during the 17th century was the inclusion of illustrations depicting the relevant pontifical vestments to be worn during the celebration of the liturgies. The 1961 Roman Pontifical modified the blessings for these vestments, adding the cope and humeral veil to the list of articles that might be blessed.
The Union of Utrecht, a communion of Old Catholic denominations, adapted and translated the Roman Pontifical into German at Bern in 1899. The pontifical was later translated into Dutch and Polish. This was just one of several liturgical books of the Roman Rite translated by the Union of Utrecht in its early years. An English translation of this pontifical, executed by Arnold Mathew and including the Old Catholic missal, was published in 1909. In 1985, this pontifical was replaced by a new text that incorporated a rite for ordaining deaconesses.
Within the Maronite Church–an Eastern Catholic church–the term "pontifical" was applied to texts of a similar purpose as their Latin counterparts by the 18th century. During the 17th century, such a text was approved by the Maronite clergy and submitted for review in Rome, though went unpublished. The manuscript, labelled as a pontifical, was translated into Latin in 1723 at the Maronite College. In 2008, a revised Maronite pontifical by Stephen Youssef Doueihi was published and approved for English-language use.
Byzantine Rite
In the Eastern Orthodox Church and Byzantine Rite Eastern Catholic churches, the equivalent of a pontifical is the Archieratikon (Greek: Ἀρχηιερατικόν; Slavonic: Чиновникъ, Chinovnik). This book is often in a large format and contains only those portions of Vespers, Matins, and the Divine Liturgy which pertain to the bishop (hierarch). It also contains those rites (ordination, the consecration of a church or altar, etc.) which are normally performed only by a bishop. The Euchologion combines some features present in Latin missals, rituals, and pontificals into a single text.
See also
Book of Common Prayer
Customary (liturgy)
Pontificale Romano-Germanicum
Primer (prayer book)
References
Anglican liturgical books
Eastern Orthodox liturgical books
Christian ordination
Latin liturgical rites
Old Catholicism
|
Augustino de Cazalla (1510-1559), or Dr. Agustín Cazalla, was a Spanish clergyman, with humanist and Erasmist tendencies, who was prosecuted for founding a Protestant sect in Valladolid.
The son of a royal accountant, Pedro de Cazalla, and Leonor de Vibero (or Vivero) - both were of 'converso' families - the nephew of Bishop Juan de Cazalla and the brother of María de Cazalla (of the group of illuminati in Guadalajara in 1525), he studied at the University of Valladolid with Bartolomé Carranza (who was also tried by the Spanish Inquisition) and at the University of Alcalá de Henares, where his uncle Juan was the former chaplain to Cardinal Cisneros and was also a renowned humanist and Erasmist. His classmate in Alcalá, Diego Laínez, was a founding member of the Society of Jesus.
Augustino was a canon in the cathedral of Salamanca and became chaplain to the Emperor Charles V, accompanying him throughout Europe. On his return to Valladolid in 1552, he joined a conventicle considered heretical. Among this group of religious elites was the corregidor of Toro, Carlos de Seso with whom he had been in contact Juan de Valdés in Italy. Despite the strict rules and secrecy practiced within the circle they were discovered.
Trial and conviction
Cazalla was subjected to a carefully managed trial by the Inquisitor General, Fernando de Valdés, who communicated his findings to King Philip II. Upon a confession of heresy, the penalty was burning at the stake at a religious ceremonial auto-da-fé held in Valladolid on 21 May 1559. Those who recanted, were granted the mercy of strangulation before burning. His siblings Francisco de Buiero, Beatriz and Pedro were also prosecuted and sentenced to the stake. Two more, Costanza de Buiero and Juan Buiero, were condemned to wear the Sanbenito and perpetual imprisonment (in all, they were ten brothers). The corpse of his mother Doña Leonora de Buiero was disinterred and thrown into the fire and as the "heretical" Lutheran conventicles had taken place in her home, the house was razed to the ground. A marble 'column of infamy' erected in its place, bore an inscription prohibiting the rebuilding of the house, or removal of plaque under penalty of excommunication and banishment from the Spanish realms.
Scabrous details emerged excoriating Cazalla and the activities of the conventicle:
"A cleric named José Cazalia [sic] lives in a certain city of Castile; He had planted a false and diabolical doctrine among the ignorant, and he summoned them to his house at dusk, a porter opened the door to each caller, who man or woman alike, on giving the name 'Cazuela', was admitted; being assembled he would give his lecture, and extinguishing the lights he would say: "Hallelujah, each with his own". And so each man would grab the woman that chance, or malice, placed next to him."
... there was a case of a boy of 13 or 14 years, whose mother, each night after he had gone to bed, would leave the home. Unable to discover where she would go, one night he followed her, and on seeing that she came to the house, and that calling and giving the name she entered it... he decided to call and give the same name as the others and enter. Having entered he had seen everything that happened, and when it came to the extinguishing of the lights, he did as the others; moved by curiosity he had cut a piece of the "basquine" (tight-fitting bodice) of the woman who he had touched, to see if he could come to know one day where he had been that night; the boy went home understanding nothing of what he had seen, but noticing that the basquine of his mother was missing the piece he had cut in the house of Cazalla, he understood that his mother was the woman he had known carnally. The next day he had confessed his guilt, and so the King's doctor came to be discovered, imprisoned and punished by the Holy Office of the Inquisition, the house was sown with salt, and a stone plaque erected as an example and lesson to others for centuries to come.
An anecdote collected in a moralizing sermon of the 17th or 18th century:
Given the alternative that was offered (being burned alive), the sincerity of Cazalla's retraction, although vehemently expressed, was considered questionable by a good many of the critical bibliographers, especially by Juan Antonio Llorente, and those present, such as his confessor, Antonio de la Carrera and the chronicler Antonio de Illescas take it for granted. He urged his companions in torture and execution, to recant. All, except Antonio Herrezuelo, recanted. Although he was known as "The Bachelor", he had a wife Leonor de Cisneros, who was among those who "reconciled" to the Roman Catholic faith. Upon discovering this on his way to the ceremonial cremation, he rebuked her harshly in passing. Herrezuelo's response to Augustino Cazalla was: "Doctor, I desire my soul now, not for a later time; and I never judged myself less than this judge." Hearing him speak in such manner a halberdier silenced him by wounding him with his weapon. He was burned alive.
One account attributed Cazalla's "heresy" to:
ambition and malice that so corrupted him, he was intent on disturbing the peace and tranquility of the realm with such novelties, and he believed he would be worshiped by all as another Lutheran in Saxony and that his disciples would continue the name of Cazalla.
In one of the various accounts of Cazalla's last words he addresses Princess Juana of Austria (sister of Philip II, regent in his name) who had presided over the Auto-da-fé, saying: "I gave you good doctrine; I preached well to you but for myself I chose the worst, I thought that this corruption was a golden mitre; and because of my evil works, I deserve what I get. Merciful Lady, remember my nephews, the children of the accountant Hernando Ortiz."
After crying out to the executioner, "Oh brother, I believe, I believe," he kissed the cross and died.
Memorial
Augustino Cazalla is considered a Protestant martyr and especially as a precursor for Spanish Protestants.
In Valladolid, the site of his house and the column of infamy was preserved until 1776, when it was replaced (the original presumably had deteriorated) by a tombstone with a rectangle surmounted by a triangle, or semicircle, and the inscription:
Paul IV presiding over the Church of Rome and Philip II reigning in Spain, The Holy Office of the Inquisition condemned to demolition and razing of this house of Pedro Cazalla and Dona Leonor Vibero, his wife, as Lutheran heretics who met to conspire against our Sta. Fe ch. and Church of Rome in the year 1559 on 21 May.
With the arrival of the Liberal Regime in 1820 the house was rebuilt on its original site, and the street was renamed 'Doctor Cazalla street'. His reputation was re-evaluated as an opponent of the Inquisition. Although the tombstone has not been preserved and no drawings exist, several copies of the text survive, some from the plate when it was dismantled and others from the City Council archives. Preserved texts attest the sign was replaced in 1776 due to deterioration. One text describes "a stone wall containing a sign manifesting his crime and his grief." A description thought to have been by an eyewitness, relates; "The first paragraph is written in a triangle and the second in a rectangle, so it is assumed that the plate had a semicircular shape at the top. Sangrador who wrote in Gothic script, says the sign was in a small hollow and closed by a wall." Leonor de Vivero, Cazalla's mother was erroneously named as his wife, due to a confusion of Pedro the father with Agustín the son of Pedro and Leonor.
Citations
References
1510 births
1559 deaths
16th-century Christian theologians
16th-century Protestant martyrs
16th-century Spanish people
People executed by strangulation
People executed by the Spanish Inquisition
People executed for heresy
University of Alcalá alumni
University of Valladolid alumni
16th-century Spanish theologians
Conversos
|
```go
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/genomics/v1alpha2/pipelines.proto
package genomics
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
duration "github.com/golang/protobuf/ptypes/duration"
empty "github.com/golang/protobuf/ptypes/empty"
timestamp "github.com/golang/protobuf/ptypes/timestamp"
_ "google.golang.org/genproto/googleapis/api/annotations"
longrunning "google.golang.org/genproto/googleapis/longrunning"
code "google.golang.org/genproto/googleapis/rpc/code"
math "math"
)
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// The types of disks that may be attached to VMs.
type PipelineResources_Disk_Type int32
const (
// Default disk type. Use one of the other options below.
PipelineResources_Disk_TYPE_UNSPECIFIED PipelineResources_Disk_Type = 0
// Specifies a Google Compute Engine persistent hard disk. See
// path_to_url#pdspecs for details.
PipelineResources_Disk_PERSISTENT_HDD PipelineResources_Disk_Type = 1
// Specifies a Google Compute Engine persistent solid-state disk. See
// path_to_url#pdspecs for details.
PipelineResources_Disk_PERSISTENT_SSD PipelineResources_Disk_Type = 2
// Specifies a Google Compute Engine local SSD.
// See path_to_url for details.
PipelineResources_Disk_LOCAL_SSD PipelineResources_Disk_Type = 3
)
var PipelineResources_Disk_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "PERSISTENT_HDD",
2: "PERSISTENT_SSD",
3: "LOCAL_SSD",
}
var PipelineResources_Disk_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"PERSISTENT_HDD": 1,
"PERSISTENT_SSD": 2,
"LOCAL_SSD": 3,
}
func (x PipelineResources_Disk_Type) String() string {
return proto.EnumName(PipelineResources_Disk_Type_name, int32(x))
}
func (PipelineResources_Disk_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16, 0, 0}
}
// Describes a Compute Engine resource that is being managed by a running
// [pipeline][google.genomics.v1alpha2.Pipeline].
type ComputeEngine struct {
// The instance on which the operation is running.
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
// The availability zone in which the instance resides.
Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
// The machine type of the instance.
MachineType string `protobuf:"bytes,3,opt,name=machine_type,json=machineType,proto3" json:"machine_type,omitempty"`
// The names of the disks that were created for this pipeline.
DiskNames []string `protobuf:"bytes,4,rep,name=disk_names,json=diskNames,proto3" json:"disk_names,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ComputeEngine) Reset() { *m = ComputeEngine{} }
func (m *ComputeEngine) String() string { return proto.CompactTextString(m) }
func (*ComputeEngine) ProtoMessage() {}
func (*ComputeEngine) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{0}
}
func (m *ComputeEngine) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ComputeEngine.Unmarshal(m, b)
}
func (m *ComputeEngine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ComputeEngine.Marshal(b, m, deterministic)
}
func (m *ComputeEngine) XXX_Merge(src proto.Message) {
xxx_messageInfo_ComputeEngine.Merge(m, src)
}
func (m *ComputeEngine) XXX_Size() int {
return xxx_messageInfo_ComputeEngine.Size(m)
}
func (m *ComputeEngine) XXX_DiscardUnknown() {
xxx_messageInfo_ComputeEngine.DiscardUnknown(m)
}
var xxx_messageInfo_ComputeEngine proto.InternalMessageInfo
func (m *ComputeEngine) GetInstanceName() string {
if m != nil {
return m.InstanceName
}
return ""
}
func (m *ComputeEngine) GetZone() string {
if m != nil {
return m.Zone
}
return ""
}
func (m *ComputeEngine) GetMachineType() string {
if m != nil {
return m.MachineType
}
return ""
}
func (m *ComputeEngine) GetDiskNames() []string {
if m != nil {
return m.DiskNames
}
return nil
}
// Runtime metadata that will be populated in the
// [runtimeMetadata][google.genomics.v1.OperationMetadata.runtime_metadata]
// field of the Operation associated with a RunPipeline execution.
type RuntimeMetadata struct {
// Execution information specific to Google Compute Engine.
ComputeEngine *ComputeEngine `protobuf:"bytes,1,opt,name=compute_engine,json=computeEngine,proto3" json:"compute_engine,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RuntimeMetadata) Reset() { *m = RuntimeMetadata{} }
func (m *RuntimeMetadata) String() string { return proto.CompactTextString(m) }
func (*RuntimeMetadata) ProtoMessage() {}
func (*RuntimeMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{1}
}
func (m *RuntimeMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RuntimeMetadata.Unmarshal(m, b)
}
func (m *RuntimeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RuntimeMetadata.Marshal(b, m, deterministic)
}
func (m *RuntimeMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_RuntimeMetadata.Merge(m, src)
}
func (m *RuntimeMetadata) XXX_Size() int {
return xxx_messageInfo_RuntimeMetadata.Size(m)
}
func (m *RuntimeMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_RuntimeMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_RuntimeMetadata proto.InternalMessageInfo
func (m *RuntimeMetadata) GetComputeEngine() *ComputeEngine {
if m != nil {
return m.ComputeEngine
}
return nil
}
// The pipeline object. Represents a transformation from a set of input
// parameters to a set of output parameters. The transformation is defined
// as a docker image and command to run within that image. Each pipeline
// is run on a Google Compute Engine VM. A pipeline can be created with the
// `create` method and then later run with the `run` method, or a pipeline can
// be defined and run all at once with the `run` method.
type Pipeline struct {
// Required. The project in which to create the pipeline. The caller must have
// WRITE access.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Required. A user specified pipeline name that does not have to be unique.
// This name can be used for filtering Pipelines in ListPipelines.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// User-specified description.
Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
// Input parameters of the pipeline.
InputParameters []*PipelineParameter `protobuf:"bytes,8,rep,name=input_parameters,json=inputParameters,proto3" json:"input_parameters,omitempty"`
// Output parameters of the pipeline.
OutputParameters []*PipelineParameter `protobuf:"bytes,9,rep,name=output_parameters,json=outputParameters,proto3" json:"output_parameters,omitempty"`
// Required. The executor indicates in which environment the pipeline runs.
//
// Types that are valid to be assigned to Executor:
// *Pipeline_Docker
Executor isPipeline_Executor `protobuf_oneof:"executor"`
// Required. Specifies resource requirements for the pipeline run.
// Required fields:
//
// *
// [minimumCpuCores][google.genomics.v1alpha2.PipelineResources.minimum_cpu_cores]
//
// *
// [minimumRamGb][google.genomics.v1alpha2.PipelineResources.minimum_ram_gb]
Resources *PipelineResources `protobuf:"bytes,6,opt,name=resources,proto3" json:"resources,omitempty"`
// Unique pipeline id that is generated by the service when CreatePipeline
// is called. Cannot be specified in the Pipeline used in the
// CreatePipelineRequest, and will be populated in the response to
// CreatePipeline and all subsequent Get and List calls. Indicates that the
// service has registered this pipeline.
PipelineId string `protobuf:"bytes,7,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Pipeline) Reset() { *m = Pipeline{} }
func (m *Pipeline) String() string { return proto.CompactTextString(m) }
func (*Pipeline) ProtoMessage() {}
func (*Pipeline) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{2}
}
func (m *Pipeline) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Pipeline.Unmarshal(m, b)
}
func (m *Pipeline) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Pipeline.Marshal(b, m, deterministic)
}
func (m *Pipeline) XXX_Merge(src proto.Message) {
xxx_messageInfo_Pipeline.Merge(m, src)
}
func (m *Pipeline) XXX_Size() int {
return xxx_messageInfo_Pipeline.Size(m)
}
func (m *Pipeline) XXX_DiscardUnknown() {
xxx_messageInfo_Pipeline.DiscardUnknown(m)
}
var xxx_messageInfo_Pipeline proto.InternalMessageInfo
func (m *Pipeline) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *Pipeline) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Pipeline) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Pipeline) GetInputParameters() []*PipelineParameter {
if m != nil {
return m.InputParameters
}
return nil
}
func (m *Pipeline) GetOutputParameters() []*PipelineParameter {
if m != nil {
return m.OutputParameters
}
return nil
}
type isPipeline_Executor interface {
isPipeline_Executor()
}
type Pipeline_Docker struct {
Docker *DockerExecutor `protobuf:"bytes,5,opt,name=docker,proto3,oneof"`
}
func (*Pipeline_Docker) isPipeline_Executor() {}
func (m *Pipeline) GetExecutor() isPipeline_Executor {
if m != nil {
return m.Executor
}
return nil
}
func (m *Pipeline) GetDocker() *DockerExecutor {
if x, ok := m.GetExecutor().(*Pipeline_Docker); ok {
return x.Docker
}
return nil
}
func (m *Pipeline) GetResources() *PipelineResources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Pipeline) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Pipeline) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Pipeline_OneofMarshaler, _Pipeline_OneofUnmarshaler, _Pipeline_OneofSizer, []interface{}{
(*Pipeline_Docker)(nil),
}
}
func _Pipeline_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Pipeline)
// executor
switch x := m.Executor.(type) {
case *Pipeline_Docker:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Docker); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Pipeline.Executor has unexpected type %T", x)
}
return nil
}
func _Pipeline_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Pipeline)
switch tag {
case 5: // executor.docker
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(DockerExecutor)
err := b.DecodeMessage(msg)
m.Executor = &Pipeline_Docker{msg}
return true, err
default:
return false, nil
}
}
func _Pipeline_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Pipeline)
// executor
switch x := m.Executor.(type) {
case *Pipeline_Docker:
s := proto.Size(x.Docker)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// The request to create a pipeline. The pipeline field here should not have
// `pipelineId` populated, as that will be populated by the server.
type CreatePipelineRequest struct {
// The pipeline to create. Should not have `pipelineId` populated.
Pipeline *Pipeline `protobuf:"bytes,1,opt,name=pipeline,proto3" json:"pipeline,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreatePipelineRequest) Reset() { *m = CreatePipelineRequest{} }
func (m *CreatePipelineRequest) String() string { return proto.CompactTextString(m) }
func (*CreatePipelineRequest) ProtoMessage() {}
func (*CreatePipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{3}
}
func (m *CreatePipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreatePipelineRequest.Unmarshal(m, b)
}
func (m *CreatePipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreatePipelineRequest.Marshal(b, m, deterministic)
}
func (m *CreatePipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreatePipelineRequest.Merge(m, src)
}
func (m *CreatePipelineRequest) XXX_Size() int {
return xxx_messageInfo_CreatePipelineRequest.Size(m)
}
func (m *CreatePipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreatePipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreatePipelineRequest proto.InternalMessageInfo
func (m *CreatePipelineRequest) GetPipeline() *Pipeline {
if m != nil {
return m.Pipeline
}
return nil
}
// The pipeline run arguments.
type RunPipelineArgs struct {
// Required. The project in which to run the pipeline. The caller must have
// WRITER access to all Google Cloud services and resources (e.g. Google
// Compute Engine) will be used.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Pipeline input arguments; keys are defined in the pipeline documentation.
// All input parameters that do not have default values must be specified.
// If parameters with defaults are specified here, the defaults will be
// overridden.
Inputs map[string]string `protobuf:"bytes,2,rep,name=inputs,proto3" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Pipeline output arguments; keys are defined in the pipeline
// documentation. All output parameters of without default values
// must be specified. If parameters with defaults are specified
// here, the defaults will be overridden.
Outputs map[string]string `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The Google Cloud Service Account that will be used to access data and
// services. By default, the compute service account associated with
// `projectId` is used.
ServiceAccount *ServiceAccount `protobuf:"bytes,4,opt,name=service_account,json=serviceAccount,proto3" json:"service_account,omitempty"`
// This field is deprecated. Use `labels` instead. Client-specified pipeline
// operation identifier.
ClientId string `protobuf:"bytes,5,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
// Specifies resource requirements/overrides for the pipeline run.
Resources *PipelineResources `protobuf:"bytes,6,opt,name=resources,proto3" json:"resources,omitempty"`
// Required. Logging options. Used by the service to communicate results
// to the user.
Logging *LoggingOptions `protobuf:"bytes,7,opt,name=logging,proto3" json:"logging,omitempty"`
// How long to keep the VM up after a failure (for example docker command
// failed, copying input or output files failed, etc). While the VM is up, one
// can ssh into the VM to debug. Default is 0; maximum allowed value is 1 day.
KeepVmAliveOnFailureDuration *duration.Duration `protobuf:"bytes,8,opt,name=keep_vm_alive_on_failure_duration,json=keepVmAliveOnFailureDuration,proto3" json:"keep_vm_alive_on_failure_duration,omitempty"`
// Labels to apply to this pipeline run. Labels will also be applied to
// compute resources (VM, disks) created by this pipeline run. When listing
// operations, operations can [filtered by labels]
// [google.longrunning.ListOperationsRequest.filter].
// Label keys may not be empty; label values may be empty. Non-empty labels
// must be 1-63 characters long, and comply with [RFC1035]
// (path_to_url
// Specifically, the name must be 1-63 characters long and match the regular
// expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first
// character must be a lowercase letter, and all following characters must be
// a dash, lowercase letter, or digit, except the last character, which cannot
// be a dash.
Labels map[string]string `protobuf:"bytes,9,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RunPipelineArgs) Reset() { *m = RunPipelineArgs{} }
func (m *RunPipelineArgs) String() string { return proto.CompactTextString(m) }
func (*RunPipelineArgs) ProtoMessage() {}
func (*RunPipelineArgs) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{4}
}
func (m *RunPipelineArgs) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RunPipelineArgs.Unmarshal(m, b)
}
func (m *RunPipelineArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RunPipelineArgs.Marshal(b, m, deterministic)
}
func (m *RunPipelineArgs) XXX_Merge(src proto.Message) {
xxx_messageInfo_RunPipelineArgs.Merge(m, src)
}
func (m *RunPipelineArgs) XXX_Size() int {
return xxx_messageInfo_RunPipelineArgs.Size(m)
}
func (m *RunPipelineArgs) XXX_DiscardUnknown() {
xxx_messageInfo_RunPipelineArgs.DiscardUnknown(m)
}
var xxx_messageInfo_RunPipelineArgs proto.InternalMessageInfo
func (m *RunPipelineArgs) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *RunPipelineArgs) GetInputs() map[string]string {
if m != nil {
return m.Inputs
}
return nil
}
func (m *RunPipelineArgs) GetOutputs() map[string]string {
if m != nil {
return m.Outputs
}
return nil
}
func (m *RunPipelineArgs) GetServiceAccount() *ServiceAccount {
if m != nil {
return m.ServiceAccount
}
return nil
}
func (m *RunPipelineArgs) GetClientId() string {
if m != nil {
return m.ClientId
}
return ""
}
func (m *RunPipelineArgs) GetResources() *PipelineResources {
if m != nil {
return m.Resources
}
return nil
}
func (m *RunPipelineArgs) GetLogging() *LoggingOptions {
if m != nil {
return m.Logging
}
return nil
}
func (m *RunPipelineArgs) GetKeepVmAliveOnFailureDuration() *duration.Duration {
if m != nil {
return m.KeepVmAliveOnFailureDuration
}
return nil
}
func (m *RunPipelineArgs) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
// The request to run a pipeline. If `pipelineId` is specified, it
// refers to a saved pipeline created with CreatePipeline and set as
// the `pipelineId` of the returned Pipeline object. If
// `ephemeralPipeline` is specified, that pipeline is run once
// with the given args and not saved. It is an error to specify both
// `pipelineId` and `ephemeralPipeline`. `pipelineArgs`
// must be specified.
type RunPipelineRequest struct {
// Types that are valid to be assigned to Pipeline:
// *RunPipelineRequest_PipelineId
// *RunPipelineRequest_EphemeralPipeline
Pipeline isRunPipelineRequest_Pipeline `protobuf_oneof:"pipeline"`
// The arguments to use when running this pipeline.
PipelineArgs *RunPipelineArgs `protobuf:"bytes,3,opt,name=pipeline_args,json=pipelineArgs,proto3" json:"pipeline_args,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RunPipelineRequest) Reset() { *m = RunPipelineRequest{} }
func (m *RunPipelineRequest) String() string { return proto.CompactTextString(m) }
func (*RunPipelineRequest) ProtoMessage() {}
func (*RunPipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{5}
}
func (m *RunPipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RunPipelineRequest.Unmarshal(m, b)
}
func (m *RunPipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RunPipelineRequest.Marshal(b, m, deterministic)
}
func (m *RunPipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_RunPipelineRequest.Merge(m, src)
}
func (m *RunPipelineRequest) XXX_Size() int {
return xxx_messageInfo_RunPipelineRequest.Size(m)
}
func (m *RunPipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_RunPipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_RunPipelineRequest proto.InternalMessageInfo
type isRunPipelineRequest_Pipeline interface {
isRunPipelineRequest_Pipeline()
}
type RunPipelineRequest_PipelineId struct {
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3,oneof"`
}
type RunPipelineRequest_EphemeralPipeline struct {
EphemeralPipeline *Pipeline `protobuf:"bytes,2,opt,name=ephemeral_pipeline,json=ephemeralPipeline,proto3,oneof"`
}
func (*RunPipelineRequest_PipelineId) isRunPipelineRequest_Pipeline() {}
func (*RunPipelineRequest_EphemeralPipeline) isRunPipelineRequest_Pipeline() {}
func (m *RunPipelineRequest) GetPipeline() isRunPipelineRequest_Pipeline {
if m != nil {
return m.Pipeline
}
return nil
}
func (m *RunPipelineRequest) GetPipelineId() string {
if x, ok := m.GetPipeline().(*RunPipelineRequest_PipelineId); ok {
return x.PipelineId
}
return ""
}
func (m *RunPipelineRequest) GetEphemeralPipeline() *Pipeline {
if x, ok := m.GetPipeline().(*RunPipelineRequest_EphemeralPipeline); ok {
return x.EphemeralPipeline
}
return nil
}
func (m *RunPipelineRequest) GetPipelineArgs() *RunPipelineArgs {
if m != nil {
return m.PipelineArgs
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*RunPipelineRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _RunPipelineRequest_OneofMarshaler, _RunPipelineRequest_OneofUnmarshaler, _RunPipelineRequest_OneofSizer, []interface{}{
(*RunPipelineRequest_PipelineId)(nil),
(*RunPipelineRequest_EphemeralPipeline)(nil),
}
}
func _RunPipelineRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RunPipelineRequest)
// pipeline
switch x := m.Pipeline.(type) {
case *RunPipelineRequest_PipelineId:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.PipelineId)
case *RunPipelineRequest_EphemeralPipeline:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.EphemeralPipeline); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("RunPipelineRequest.Pipeline has unexpected type %T", x)
}
return nil
}
func _RunPipelineRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*RunPipelineRequest)
switch tag {
case 1: // pipeline.pipeline_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pipeline = &RunPipelineRequest_PipelineId{x}
return true, err
case 2: // pipeline.ephemeral_pipeline
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Pipeline)
err := b.DecodeMessage(msg)
m.Pipeline = &RunPipelineRequest_EphemeralPipeline{msg}
return true, err
default:
return false, nil
}
}
func _RunPipelineRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*RunPipelineRequest)
// pipeline
switch x := m.Pipeline.(type) {
case *RunPipelineRequest_PipelineId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.PipelineId)))
n += len(x.PipelineId)
case *RunPipelineRequest_EphemeralPipeline:
s := proto.Size(x.EphemeralPipeline)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A request to get a saved pipeline by id.
type GetPipelineRequest struct {
// Caller must have READ access to the project in which this pipeline
// is defined.
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetPipelineRequest) Reset() { *m = GetPipelineRequest{} }
func (m *GetPipelineRequest) String() string { return proto.CompactTextString(m) }
func (*GetPipelineRequest) ProtoMessage() {}
func (*GetPipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{6}
}
func (m *GetPipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetPipelineRequest.Unmarshal(m, b)
}
func (m *GetPipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetPipelineRequest.Marshal(b, m, deterministic)
}
func (m *GetPipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetPipelineRequest.Merge(m, src)
}
func (m *GetPipelineRequest) XXX_Size() int {
return xxx_messageInfo_GetPipelineRequest.Size(m)
}
func (m *GetPipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetPipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetPipelineRequest proto.InternalMessageInfo
func (m *GetPipelineRequest) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// A request to list pipelines in a given project. Pipelines can be
// filtered by name using `namePrefix`: all pipelines with names that
// begin with `namePrefix` will be returned. Uses standard pagination:
// `pageSize` indicates how many pipelines to return, and
// `pageToken` comes from a previous ListPipelinesResponse to
// indicate offset.
type ListPipelinesRequest struct {
// Required. The name of the project to search for pipelines. Caller
// must have READ access to this project.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Pipelines with names that match this prefix should be
// returned. If unspecified, all pipelines in the project, up to
// `pageSize`, will be returned.
NamePrefix string `protobuf:"bytes,2,opt,name=name_prefix,json=namePrefix,proto3" json:"name_prefix,omitempty"`
// Number of pipelines to return at once. Defaults to 256, and max
// is 2048.
PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Token to use to indicate where to start getting results.
// If unspecified, returns the first page of results.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListPipelinesRequest) Reset() { *m = ListPipelinesRequest{} }
func (m *ListPipelinesRequest) String() string { return proto.CompactTextString(m) }
func (*ListPipelinesRequest) ProtoMessage() {}
func (*ListPipelinesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{7}
}
func (m *ListPipelinesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListPipelinesRequest.Unmarshal(m, b)
}
func (m *ListPipelinesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListPipelinesRequest.Marshal(b, m, deterministic)
}
func (m *ListPipelinesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListPipelinesRequest.Merge(m, src)
}
func (m *ListPipelinesRequest) XXX_Size() int {
return xxx_messageInfo_ListPipelinesRequest.Size(m)
}
func (m *ListPipelinesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListPipelinesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListPipelinesRequest proto.InternalMessageInfo
func (m *ListPipelinesRequest) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *ListPipelinesRequest) GetNamePrefix() string {
if m != nil {
return m.NamePrefix
}
return ""
}
func (m *ListPipelinesRequest) GetPageSize() int32 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListPipelinesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
// The response of ListPipelines. Contains at most `pageSize`
// pipelines. If it contains `pageSize` pipelines, and more pipelines
// exist, then `nextPageToken` will be populated and should be
// used as the `pageToken` argument to a subsequent ListPipelines
// request.
type ListPipelinesResponse struct {
// The matched pipelines.
Pipelines []*Pipeline `protobuf:"bytes,1,rep,name=pipelines,proto3" json:"pipelines,omitempty"`
// The token to use to get the next page of results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListPipelinesResponse) Reset() { *m = ListPipelinesResponse{} }
func (m *ListPipelinesResponse) String() string { return proto.CompactTextString(m) }
func (*ListPipelinesResponse) ProtoMessage() {}
func (*ListPipelinesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{8}
}
func (m *ListPipelinesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListPipelinesResponse.Unmarshal(m, b)
}
func (m *ListPipelinesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListPipelinesResponse.Marshal(b, m, deterministic)
}
func (m *ListPipelinesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListPipelinesResponse.Merge(m, src)
}
func (m *ListPipelinesResponse) XXX_Size() int {
return xxx_messageInfo_ListPipelinesResponse.Size(m)
}
func (m *ListPipelinesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListPipelinesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListPipelinesResponse proto.InternalMessageInfo
func (m *ListPipelinesResponse) GetPipelines() []*Pipeline {
if m != nil {
return m.Pipelines
}
return nil
}
func (m *ListPipelinesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
// The request to delete a saved pipeline by ID.
type DeletePipelineRequest struct {
// Caller must have WRITE access to the project in which this pipeline
// is defined.
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeletePipelineRequest) Reset() { *m = DeletePipelineRequest{} }
func (m *DeletePipelineRequest) String() string { return proto.CompactTextString(m) }
func (*DeletePipelineRequest) ProtoMessage() {}
func (*DeletePipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{9}
}
func (m *DeletePipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeletePipelineRequest.Unmarshal(m, b)
}
func (m *DeletePipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeletePipelineRequest.Marshal(b, m, deterministic)
}
func (m *DeletePipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeletePipelineRequest.Merge(m, src)
}
func (m *DeletePipelineRequest) XXX_Size() int {
return xxx_messageInfo_DeletePipelineRequest.Size(m)
}
func (m *DeletePipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeletePipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeletePipelineRequest proto.InternalMessageInfo
func (m *DeletePipelineRequest) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// Request to get controller configuation. Should only be used
// by VMs created by the Pipelines Service and not by end users.
type GetControllerConfigRequest struct {
// The operation to retrieve controller configuration for.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"`
ValidationToken uint64 `protobuf:"varint,2,opt,name=validation_token,json=validationToken,proto3" json:"validation_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetControllerConfigRequest) Reset() { *m = GetControllerConfigRequest{} }
func (m *GetControllerConfigRequest) String() string { return proto.CompactTextString(m) }
func (*GetControllerConfigRequest) ProtoMessage() {}
func (*GetControllerConfigRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{10}
}
func (m *GetControllerConfigRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetControllerConfigRequest.Unmarshal(m, b)
}
func (m *GetControllerConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetControllerConfigRequest.Marshal(b, m, deterministic)
}
func (m *GetControllerConfigRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetControllerConfigRequest.Merge(m, src)
}
func (m *GetControllerConfigRequest) XXX_Size() int {
return xxx_messageInfo_GetControllerConfigRequest.Size(m)
}
func (m *GetControllerConfigRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetControllerConfigRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetControllerConfigRequest proto.InternalMessageInfo
func (m *GetControllerConfigRequest) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *GetControllerConfigRequest) GetValidationToken() uint64 {
if m != nil {
return m.ValidationToken
}
return 0
}
// Stores the information that the controller will fetch from the
// server in order to run. Should only be used by VMs created by the
// Pipelines Service and not by end users.
type ControllerConfig struct {
Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
Cmd string `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
GcsLogPath string `protobuf:"bytes,3,opt,name=gcs_log_path,json=gcsLogPath,proto3" json:"gcs_log_path,omitempty"`
MachineType string `protobuf:"bytes,4,opt,name=machine_type,json=machineType,proto3" json:"machine_type,omitempty"`
Vars map[string]string `protobuf:"bytes,5,rep,name=vars,proto3" json:"vars,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Disks map[string]string `protobuf:"bytes,6,rep,name=disks,proto3" json:"disks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
GcsSources map[string]*ControllerConfig_RepeatedString `protobuf:"bytes,7,rep,name=gcs_sources,json=gcsSources,proto3" json:"gcs_sources,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
GcsSinks map[string]*ControllerConfig_RepeatedString `protobuf:"bytes,8,rep,name=gcs_sinks,json=gcsSinks,proto3" json:"gcs_sinks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ControllerConfig) Reset() { *m = ControllerConfig{} }
func (m *ControllerConfig) String() string { return proto.CompactTextString(m) }
func (*ControllerConfig) ProtoMessage() {}
func (*ControllerConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{11}
}
func (m *ControllerConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ControllerConfig.Unmarshal(m, b)
}
func (m *ControllerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ControllerConfig.Marshal(b, m, deterministic)
}
func (m *ControllerConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_ControllerConfig.Merge(m, src)
}
func (m *ControllerConfig) XXX_Size() int {
return xxx_messageInfo_ControllerConfig.Size(m)
}
func (m *ControllerConfig) XXX_DiscardUnknown() {
xxx_messageInfo_ControllerConfig.DiscardUnknown(m)
}
var xxx_messageInfo_ControllerConfig proto.InternalMessageInfo
func (m *ControllerConfig) GetImage() string {
if m != nil {
return m.Image
}
return ""
}
func (m *ControllerConfig) GetCmd() string {
if m != nil {
return m.Cmd
}
return ""
}
func (m *ControllerConfig) GetGcsLogPath() string {
if m != nil {
return m.GcsLogPath
}
return ""
}
func (m *ControllerConfig) GetMachineType() string {
if m != nil {
return m.MachineType
}
return ""
}
func (m *ControllerConfig) GetVars() map[string]string {
if m != nil {
return m.Vars
}
return nil
}
func (m *ControllerConfig) GetDisks() map[string]string {
if m != nil {
return m.Disks
}
return nil
}
func (m *ControllerConfig) GetGcsSources() map[string]*ControllerConfig_RepeatedString {
if m != nil {
return m.GcsSources
}
return nil
}
func (m *ControllerConfig) GetGcsSinks() map[string]*ControllerConfig_RepeatedString {
if m != nil {
return m.GcsSinks
}
return nil
}
type ControllerConfig_RepeatedString struct {
Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ControllerConfig_RepeatedString) Reset() { *m = ControllerConfig_RepeatedString{} }
func (m *ControllerConfig_RepeatedString) String() string { return proto.CompactTextString(m) }
func (*ControllerConfig_RepeatedString) ProtoMessage() {}
func (*ControllerConfig_RepeatedString) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{11, 0}
}
func (m *ControllerConfig_RepeatedString) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ControllerConfig_RepeatedString.Unmarshal(m, b)
}
func (m *ControllerConfig_RepeatedString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ControllerConfig_RepeatedString.Marshal(b, m, deterministic)
}
func (m *ControllerConfig_RepeatedString) XXX_Merge(src proto.Message) {
xxx_messageInfo_ControllerConfig_RepeatedString.Merge(m, src)
}
func (m *ControllerConfig_RepeatedString) XXX_Size() int {
return xxx_messageInfo_ControllerConfig_RepeatedString.Size(m)
}
func (m *ControllerConfig_RepeatedString) XXX_DiscardUnknown() {
xxx_messageInfo_ControllerConfig_RepeatedString.DiscardUnknown(m)
}
var xxx_messageInfo_ControllerConfig_RepeatedString proto.InternalMessageInfo
func (m *ControllerConfig_RepeatedString) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
// Stores the list of events and times they occured for major events in job
// execution.
type TimestampEvent struct {
// String indicating the type of event
Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
// The time this event occured.
Timestamp *timestamp.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TimestampEvent) Reset() { *m = TimestampEvent{} }
func (m *TimestampEvent) String() string { return proto.CompactTextString(m) }
func (*TimestampEvent) ProtoMessage() {}
func (*TimestampEvent) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{12}
}
func (m *TimestampEvent) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TimestampEvent.Unmarshal(m, b)
}
func (m *TimestampEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TimestampEvent.Marshal(b, m, deterministic)
}
func (m *TimestampEvent) XXX_Merge(src proto.Message) {
xxx_messageInfo_TimestampEvent.Merge(m, src)
}
func (m *TimestampEvent) XXX_Size() int {
return xxx_messageInfo_TimestampEvent.Size(m)
}
func (m *TimestampEvent) XXX_DiscardUnknown() {
xxx_messageInfo_TimestampEvent.DiscardUnknown(m)
}
var xxx_messageInfo_TimestampEvent proto.InternalMessageInfo
func (m *TimestampEvent) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *TimestampEvent) GetTimestamp() *timestamp.Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
// Request to set operation status. Should only be used by VMs
// created by the Pipelines Service and not by end users.
type SetOperationStatusRequest struct {
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"`
TimestampEvents []*TimestampEvent `protobuf:"bytes,2,rep,name=timestamp_events,json=timestampEvents,proto3" json:"timestamp_events,omitempty"`
ErrorCode code.Code `protobuf:"varint,3,opt,name=error_code,json=errorCode,proto3,enum=google.rpc.Code" json:"error_code,omitempty"`
ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
ValidationToken uint64 `protobuf:"varint,5,opt,name=validation_token,json=validationToken,proto3" json:"validation_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetOperationStatusRequest) Reset() { *m = SetOperationStatusRequest{} }
func (m *SetOperationStatusRequest) String() string { return proto.CompactTextString(m) }
func (*SetOperationStatusRequest) ProtoMessage() {}
func (*SetOperationStatusRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{13}
}
func (m *SetOperationStatusRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetOperationStatusRequest.Unmarshal(m, b)
}
func (m *SetOperationStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetOperationStatusRequest.Marshal(b, m, deterministic)
}
func (m *SetOperationStatusRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetOperationStatusRequest.Merge(m, src)
}
func (m *SetOperationStatusRequest) XXX_Size() int {
return xxx_messageInfo_SetOperationStatusRequest.Size(m)
}
func (m *SetOperationStatusRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetOperationStatusRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetOperationStatusRequest proto.InternalMessageInfo
func (m *SetOperationStatusRequest) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *SetOperationStatusRequest) GetTimestampEvents() []*TimestampEvent {
if m != nil {
return m.TimestampEvents
}
return nil
}
func (m *SetOperationStatusRequest) GetErrorCode() code.Code {
if m != nil {
return m.ErrorCode
}
return code.Code_OK
}
func (m *SetOperationStatusRequest) GetErrorMessage() string {
if m != nil {
return m.ErrorMessage
}
return ""
}
func (m *SetOperationStatusRequest) GetValidationToken() uint64 {
if m != nil {
return m.ValidationToken
}
return 0
}
// A Google Cloud Service Account.
type ServiceAccount struct {
// Email address of the service account. Defaults to `default`,
// which uses the compute service account associated with the project.
Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"`
// List of scopes to be enabled for this service account on the VM.
// The following scopes are automatically included:
//
// * path_to_url
// * path_to_url
// * path_to_url
// * path_to_url
// * path_to_url
Scopes []string `protobuf:"bytes,2,rep,name=scopes,proto3" json:"scopes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ServiceAccount) Reset() { *m = ServiceAccount{} }
func (m *ServiceAccount) String() string { return proto.CompactTextString(m) }
func (*ServiceAccount) ProtoMessage() {}
func (*ServiceAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{14}
}
func (m *ServiceAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ServiceAccount.Unmarshal(m, b)
}
func (m *ServiceAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ServiceAccount.Marshal(b, m, deterministic)
}
func (m *ServiceAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_ServiceAccount.Merge(m, src)
}
func (m *ServiceAccount) XXX_Size() int {
return xxx_messageInfo_ServiceAccount.Size(m)
}
func (m *ServiceAccount) XXX_DiscardUnknown() {
xxx_messageInfo_ServiceAccount.DiscardUnknown(m)
}
var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo
func (m *ServiceAccount) GetEmail() string {
if m != nil {
return m.Email
}
return ""
}
func (m *ServiceAccount) GetScopes() []string {
if m != nil {
return m.Scopes
}
return nil
}
// The logging options for the pipeline run.
type LoggingOptions struct {
// The location in Google Cloud Storage to which the pipeline logs
// will be copied. Can be specified as a fully qualified directory
// path, in which case logs will be output with a unique identifier
// as the filename in that directory, or as a fully specified path,
// which must end in `.log`, in which case that path will be
// used, and the user must ensure that logs are not
// overwritten. Stdout and stderr logs from the run are also
// generated and output as `-stdout.log` and `-stderr.log`.
GcsPath string `protobuf:"bytes,1,opt,name=gcs_path,json=gcsPath,proto3" json:"gcs_path,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoggingOptions) Reset() { *m = LoggingOptions{} }
func (m *LoggingOptions) String() string { return proto.CompactTextString(m) }
func (*LoggingOptions) ProtoMessage() {}
func (*LoggingOptions) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{15}
}
func (m *LoggingOptions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LoggingOptions.Unmarshal(m, b)
}
func (m *LoggingOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LoggingOptions.Marshal(b, m, deterministic)
}
func (m *LoggingOptions) XXX_Merge(src proto.Message) {
xxx_messageInfo_LoggingOptions.Merge(m, src)
}
func (m *LoggingOptions) XXX_Size() int {
return xxx_messageInfo_LoggingOptions.Size(m)
}
func (m *LoggingOptions) XXX_DiscardUnknown() {
xxx_messageInfo_LoggingOptions.DiscardUnknown(m)
}
var xxx_messageInfo_LoggingOptions proto.InternalMessageInfo
func (m *LoggingOptions) GetGcsPath() string {
if m != nil {
return m.GcsPath
}
return ""
}
// The system resources for the pipeline run.
type PipelineResources struct {
// The minimum number of cores to use. Defaults to 1.
MinimumCpuCores int32 `protobuf:"varint,1,opt,name=minimum_cpu_cores,json=minimumCpuCores,proto3" json:"minimum_cpu_cores,omitempty"`
// Whether to use preemptible VMs. Defaults to `false`. In order to use this,
// must be true for both create time and run time. Cannot be true at run time
// if false at create time.
Preemptible bool `protobuf:"varint,2,opt,name=preemptible,proto3" json:"preemptible,omitempty"`
// The minimum amount of RAM to use. Defaults to 3.75 (GB)
MinimumRamGb float64 `protobuf:"fixed64,3,opt,name=minimum_ram_gb,json=minimumRamGb,proto3" json:"minimum_ram_gb,omitempty"`
// Disks to attach.
Disks []*PipelineResources_Disk `protobuf:"bytes,4,rep,name=disks,proto3" json:"disks,omitempty"`
// List of Google Compute Engine availability zones to which resource
// creation will restricted. If empty, any zone may be chosen.
Zones []string `protobuf:"bytes,5,rep,name=zones,proto3" json:"zones,omitempty"`
// The size of the boot disk. Defaults to 10 (GB).
BootDiskSizeGb int32 `protobuf:"varint,6,opt,name=boot_disk_size_gb,json=bootDiskSizeGb,proto3" json:"boot_disk_size_gb,omitempty"`
// Whether to assign an external IP to the instance. This is an experimental
// feature that may go away. Defaults to false.
// Corresponds to `--no_address` flag for [gcloud compute instances create]
// (path_to_url
// In order to use this, must be true for both create time and run time.
// Cannot be true at run time if false at create time. If you need to ssh into
// a private IP VM for debugging, you can ssh to a public VM and then ssh into
// the private VM's Internal IP. If noAddress is set, this pipeline run may
// only load docker images from Google Container Registry and not Docker Hub.
// ** Note: To use this option, your project must be in Google Access for
// Private IPs Early Access Program.**
NoAddress bool `protobuf:"varint,7,opt,name=no_address,json=noAddress,proto3" json:"no_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineResources) Reset() { *m = PipelineResources{} }
func (m *PipelineResources) String() string { return proto.CompactTextString(m) }
func (*PipelineResources) ProtoMessage() {}
func (*PipelineResources) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16}
}
func (m *PipelineResources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineResources.Unmarshal(m, b)
}
func (m *PipelineResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineResources.Marshal(b, m, deterministic)
}
func (m *PipelineResources) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineResources.Merge(m, src)
}
func (m *PipelineResources) XXX_Size() int {
return xxx_messageInfo_PipelineResources.Size(m)
}
func (m *PipelineResources) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineResources.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineResources proto.InternalMessageInfo
func (m *PipelineResources) GetMinimumCpuCores() int32 {
if m != nil {
return m.MinimumCpuCores
}
return 0
}
func (m *PipelineResources) GetPreemptible() bool {
if m != nil {
return m.Preemptible
}
return false
}
func (m *PipelineResources) GetMinimumRamGb() float64 {
if m != nil {
return m.MinimumRamGb
}
return 0
}
func (m *PipelineResources) GetDisks() []*PipelineResources_Disk {
if m != nil {
return m.Disks
}
return nil
}
func (m *PipelineResources) GetZones() []string {
if m != nil {
return m.Zones
}
return nil
}
func (m *PipelineResources) GetBootDiskSizeGb() int32 {
if m != nil {
return m.BootDiskSizeGb
}
return 0
}
func (m *PipelineResources) GetNoAddress() bool {
if m != nil {
return m.NoAddress
}
return false
}
// A Google Compute Engine disk resource specification.
type PipelineResources_Disk struct {
// Required. The name of the disk that can be used in the pipeline
// parameters. Must be 1 - 63 characters.
// The name "boot" is reserved for system use.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Required. The type of the disk to create.
Type PipelineResources_Disk_Type `protobuf:"varint,2,opt,name=type,proto3,enum=google.genomics.v1alpha2.PipelineResources_Disk_Type" json:"type,omitempty"`
// The size of the disk. Defaults to 500 (GB).
// This field is not applicable for local SSD.
SizeGb int32 `protobuf:"varint,3,opt,name=size_gb,json=sizeGb,proto3" json:"size_gb,omitempty"`
// The full or partial URL of the persistent disk to attach. See
// path_to_url#resource
// and
// path_to_url#snapshots
// for more details.
Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
// Deprecated. Disks created by the Pipelines API will be deleted at the end
// of the pipeline run, regardless of what this field is set to.
AutoDelete bool `protobuf:"varint,6,opt,name=auto_delete,json=autoDelete,proto3" json:"auto_delete,omitempty"`
// Required at create time and cannot be overridden at run time.
// Specifies the path in the docker container where files on
// this disk should be located. For example, if `mountPoint`
// is `/mnt/disk`, and the parameter has `localPath`
// `inputs/file.txt`, the docker container can access the data at
// `/mnt/disk/inputs/file.txt`.
MountPoint string `protobuf:"bytes,8,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineResources_Disk) Reset() { *m = PipelineResources_Disk{} }
func (m *PipelineResources_Disk) String() string { return proto.CompactTextString(m) }
func (*PipelineResources_Disk) ProtoMessage() {}
func (*PipelineResources_Disk) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16, 0}
}
func (m *PipelineResources_Disk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineResources_Disk.Unmarshal(m, b)
}
func (m *PipelineResources_Disk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineResources_Disk.Marshal(b, m, deterministic)
}
func (m *PipelineResources_Disk) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineResources_Disk.Merge(m, src)
}
func (m *PipelineResources_Disk) XXX_Size() int {
return xxx_messageInfo_PipelineResources_Disk.Size(m)
}
func (m *PipelineResources_Disk) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineResources_Disk.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineResources_Disk proto.InternalMessageInfo
func (m *PipelineResources_Disk) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PipelineResources_Disk) GetType() PipelineResources_Disk_Type {
if m != nil {
return m.Type
}
return PipelineResources_Disk_TYPE_UNSPECIFIED
}
func (m *PipelineResources_Disk) GetSizeGb() int32 {
if m != nil {
return m.SizeGb
}
return 0
}
func (m *PipelineResources_Disk) GetSource() string {
if m != nil {
return m.Source
}
return ""
}
func (m *PipelineResources_Disk) GetAutoDelete() bool {
if m != nil {
return m.AutoDelete
}
return false
}
func (m *PipelineResources_Disk) GetMountPoint() string {
if m != nil {
return m.MountPoint
}
return ""
}
// Parameters facilitate setting and delivering data into the
// pipeline's execution environment. They are defined at create time,
// with optional defaults, and can be overridden at run time.
//
// If `localCopy` is unset, then the parameter specifies a string that
// is passed as-is into the pipeline, as the value of the environment
// variable with the given name. A default value can be optionally
// specified at create time. The default can be overridden at run time
// using the inputs map. If no default is given, a value must be
// supplied at runtime.
//
// If `localCopy` is defined, then the parameter specifies a data
// source or sink, both in Google Cloud Storage and on the Docker container
// where the pipeline computation is run. The [service account associated with
// the Pipeline][google.genomics.v1alpha2.RunPipelineArgs.service_account] (by
// default the project's Compute Engine service account) must have access to the
// Google Cloud Storage paths.
//
// At run time, the Google Cloud Storage paths can be overridden if a default
// was provided at create time, or must be set otherwise. The pipeline runner
// should add a key/value pair to either the inputs or outputs map. The
// indicated data copies will be carried out before/after pipeline execution,
// just as if the corresponding arguments were provided to `gsutil cp`.
//
// For example: Given the following `PipelineParameter`, specified
// in the `inputParameters` list:
//
// ```
// {name: "input_file", localCopy: {path: "file.txt", disk: "pd1"}}
// ```
//
// where `disk` is defined in the `PipelineResources` object as:
//
// ```
// {name: "pd1", mountPoint: "/mnt/disk/"}
// ```
//
// We create a disk named `pd1`, mount it on the host VM, and map
// `/mnt/pd1` to `/mnt/disk` in the docker container. At
// runtime, an entry for `input_file` would be required in the inputs
// map, such as:
//
// ```
// inputs["input_file"] = "gs://my-bucket/bar.txt"
// ```
//
// This would generate the following gsutil call:
//
// ```
// gsutil cp gs://my-bucket/bar.txt /mnt/pd1/file.txt
// ```
//
// The file `/mnt/pd1/file.txt` maps to `/mnt/disk/file.txt` in the
// Docker container. Acceptable paths are:
//
// <table>
// <thead>
// <tr><th>Google Cloud storage path</th><th>Local path</th></tr>
// </thead>
// <tbody>
// <tr><td>file</td><td>file</td></tr>
// <tr><td>glob</td><td>directory</td></tr>
// </tbody>
// </table>
//
// For outputs, the direction of the copy is reversed:
//
// ```
// gsutil cp /mnt/disk/file.txt gs://my-bucket/bar.txt
// ```
//
// Acceptable paths are:
//
// <table>
// <thead>
// <tr><th>Local path</th><th>Google Cloud Storage path</th></tr>
// </thead>
// <tbody>
// <tr><td>file</td><td>file</td></tr>
// <tr>
// <td>file</td>
// <td>directory - directory must already exist</td>
// </tr>
// <tr>
// <td>glob</td>
// <td>directory - directory will be created if it doesn't exist</td></tr>
// </tbody>
// </table>
//
// One restriction due to docker limitations, is that for outputs that are found
// on the boot disk, the local path cannot be a glob and must be a file.
type PipelineParameter struct {
// Required. Name of the parameter - the pipeline runner uses this string
// as the key to the input and output maps in RunPipeline.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Human-readable description.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// The default value for this parameter. Can be overridden at runtime.
// If `localCopy` is present, then this must be a Google Cloud Storage path
// beginning with `gs://`.
DefaultValue string `protobuf:"bytes,5,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
// If present, this parameter is marked for copying to and from the VM.
// `LocalCopy` indicates where on the VM the file should be. The value
// given to this parameter (either at runtime or using `defaultValue`)
// must be the remote path where the file should be.
LocalCopy *PipelineParameter_LocalCopy `protobuf:"bytes,6,opt,name=local_copy,json=localCopy,proto3" json:"local_copy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineParameter) Reset() { *m = PipelineParameter{} }
func (m *PipelineParameter) String() string { return proto.CompactTextString(m) }
func (*PipelineParameter) ProtoMessage() {}
func (*PipelineParameter) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{17}
}
func (m *PipelineParameter) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineParameter.Unmarshal(m, b)
}
func (m *PipelineParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineParameter.Marshal(b, m, deterministic)
}
func (m *PipelineParameter) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineParameter.Merge(m, src)
}
func (m *PipelineParameter) XXX_Size() int {
return xxx_messageInfo_PipelineParameter.Size(m)
}
func (m *PipelineParameter) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineParameter.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineParameter proto.InternalMessageInfo
func (m *PipelineParameter) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PipelineParameter) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *PipelineParameter) GetDefaultValue() string {
if m != nil {
return m.DefaultValue
}
return ""
}
func (m *PipelineParameter) GetLocalCopy() *PipelineParameter_LocalCopy {
if m != nil {
return m.LocalCopy
}
return nil
}
// LocalCopy defines how a remote file should be copied to and from the VM.
type PipelineParameter_LocalCopy struct {
// Required. The path within the user's docker container where
// this input should be localized to and from, relative to the specified
// disk's mount point. For example: file.txt,
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
// Required. The name of the disk where this parameter is
// located. Can be the name of one of the disks specified in the
// Resources field, or "boot", which represents the Docker
// instance's boot disk and has a mount point of `/`.
Disk string `protobuf:"bytes,2,opt,name=disk,proto3" json:"disk,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineParameter_LocalCopy) Reset() { *m = PipelineParameter_LocalCopy{} }
func (m *PipelineParameter_LocalCopy) String() string { return proto.CompactTextString(m) }
func (*PipelineParameter_LocalCopy) ProtoMessage() {}
func (*PipelineParameter_LocalCopy) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{17, 0}
}
func (m *PipelineParameter_LocalCopy) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineParameter_LocalCopy.Unmarshal(m, b)
}
func (m *PipelineParameter_LocalCopy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineParameter_LocalCopy.Marshal(b, m, deterministic)
}
func (m *PipelineParameter_LocalCopy) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineParameter_LocalCopy.Merge(m, src)
}
func (m *PipelineParameter_LocalCopy) XXX_Size() int {
return xxx_messageInfo_PipelineParameter_LocalCopy.Size(m)
}
func (m *PipelineParameter_LocalCopy) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineParameter_LocalCopy.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineParameter_LocalCopy proto.InternalMessageInfo
func (m *PipelineParameter_LocalCopy) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *PipelineParameter_LocalCopy) GetDisk() string {
if m != nil {
return m.Disk
}
return ""
}
// The Docker execuctor specification.
type DockerExecutor struct {
// Required. Image name from either Docker Hub or Google Container Registry.
// Users that run pipelines must have READ access to the image.
ImageName string `protobuf:"bytes,1,opt,name=image_name,json=imageName,proto3" json:"image_name,omitempty"`
// Required. The command or newline delimited script to run. The command
// string will be executed within a bash shell.
//
// If the command exits with a non-zero exit code, output parameter
// de-localization will be skipped and the pipeline operation's
// [`error`][google.longrunning.Operation.error] field will be populated.
//
// Maximum command string length is 16384.
Cmd string `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DockerExecutor) Reset() { *m = DockerExecutor{} }
func (m *DockerExecutor) String() string { return proto.CompactTextString(m) }
func (*DockerExecutor) ProtoMessage() {}
func (*DockerExecutor) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{18}
}
func (m *DockerExecutor) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DockerExecutor.Unmarshal(m, b)
}
func (m *DockerExecutor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DockerExecutor.Marshal(b, m, deterministic)
}
func (m *DockerExecutor) XXX_Merge(src proto.Message) {
xxx_messageInfo_DockerExecutor.Merge(m, src)
}
func (m *DockerExecutor) XXX_Size() int {
return xxx_messageInfo_DockerExecutor.Size(m)
}
func (m *DockerExecutor) XXX_DiscardUnknown() {
xxx_messageInfo_DockerExecutor.DiscardUnknown(m)
}
var xxx_messageInfo_DockerExecutor proto.InternalMessageInfo
func (m *DockerExecutor) GetImageName() string {
if m != nil {
return m.ImageName
}
return ""
}
func (m *DockerExecutor) GetCmd() string {
if m != nil {
return m.Cmd
}
return ""
}
func init() {
proto.RegisterEnum("google.genomics.v1alpha2.PipelineResources_Disk_Type", PipelineResources_Disk_Type_name, PipelineResources_Disk_Type_value)
proto.RegisterType((*ComputeEngine)(nil), "google.genomics.v1alpha2.ComputeEngine")
proto.RegisterType((*RuntimeMetadata)(nil), "google.genomics.v1alpha2.RuntimeMetadata")
proto.RegisterType((*Pipeline)(nil), "google.genomics.v1alpha2.Pipeline")
proto.RegisterType((*CreatePipelineRequest)(nil), "google.genomics.v1alpha2.CreatePipelineRequest")
proto.RegisterType((*RunPipelineArgs)(nil), "google.genomics.v1alpha2.RunPipelineArgs")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.InputsEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.LabelsEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.OutputsEntry")
proto.RegisterType((*RunPipelineRequest)(nil), "google.genomics.v1alpha2.RunPipelineRequest")
proto.RegisterType((*GetPipelineRequest)(nil), "google.genomics.v1alpha2.GetPipelineRequest")
proto.RegisterType((*ListPipelinesRequest)(nil), "google.genomics.v1alpha2.ListPipelinesRequest")
proto.RegisterType((*ListPipelinesResponse)(nil), "google.genomics.v1alpha2.ListPipelinesResponse")
proto.RegisterType((*DeletePipelineRequest)(nil), "google.genomics.v1alpha2.DeletePipelineRequest")
proto.RegisterType((*GetControllerConfigRequest)(nil), "google.genomics.v1alpha2.GetControllerConfigRequest")
proto.RegisterType((*ControllerConfig)(nil), "google.genomics.v1alpha2.ControllerConfig")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.ControllerConfig.DisksEntry")
proto.RegisterMapType((map[string]*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.GcsSinksEntry")
proto.RegisterMapType((map[string]*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.GcsSourcesEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.ControllerConfig.VarsEntry")
proto.RegisterType((*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.RepeatedString")
proto.RegisterType((*TimestampEvent)(nil), "google.genomics.v1alpha2.TimestampEvent")
proto.RegisterType((*SetOperationStatusRequest)(nil), "google.genomics.v1alpha2.SetOperationStatusRequest")
proto.RegisterType((*ServiceAccount)(nil), "google.genomics.v1alpha2.ServiceAccount")
proto.RegisterType((*LoggingOptions)(nil), "google.genomics.v1alpha2.LoggingOptions")
proto.RegisterType((*PipelineResources)(nil), "google.genomics.v1alpha2.PipelineResources")
proto.RegisterType((*PipelineResources_Disk)(nil), "google.genomics.v1alpha2.PipelineResources.Disk")
proto.RegisterType((*PipelineParameter)(nil), "google.genomics.v1alpha2.PipelineParameter")
proto.RegisterType((*PipelineParameter_LocalCopy)(nil), "google.genomics.v1alpha2.PipelineParameter.LocalCopy")
proto.RegisterType((*DockerExecutor)(nil), "google.genomics.v1alpha2.DockerExecutor")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// PipelinesV1Alpha2Client is the client API for PipelinesV1Alpha2 service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to path_to_url#ClientConn.NewStream.
type PipelinesV1Alpha2Client interface {
// Creates a pipeline that can be run later. Create takes a Pipeline that
// has all fields other than `pipelineId` populated, and then returns
// the same pipeline with `pipelineId` populated. This id can be used
// to run the pipeline.
//
// Caller must have WRITE permission to the project.
CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*Pipeline, error)
// Runs a pipeline. If `pipelineId` is specified in the request, then
// run a saved pipeline. If `ephemeralPipeline` is specified, then run
// that pipeline once without saving a copy.
//
// The caller must have READ permission to the project where the pipeline
// is stored and WRITE permission to the project where the pipeline will be
// run, as VMs will be created and storage will be used.
RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
// Retrieves a pipeline based on ID.
//
// Caller must have READ permission to the project.
GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*Pipeline, error)
// Lists pipelines.
//
// Caller must have READ permission to the project.
ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error)
// Deletes a pipeline based on ID.
//
// Caller must have WRITE permission to the project.
DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*empty.Empty, error)
// Gets controller configuration information. Should only be called
// by VMs created by the Pipelines Service and not by end users.
GetControllerConfig(ctx context.Context, in *GetControllerConfigRequest, opts ...grpc.CallOption) (*ControllerConfig, error)
// Sets status of a given operation. Any new timestamps (as determined by
// description) are appended to TimestampEvents. Should only be called by VMs
// created by the Pipelines Service and not by end users.
SetOperationStatus(ctx context.Context, in *SetOperationStatusRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type pipelinesV1Alpha2Client struct {
cc *grpc.ClientConn
}
func NewPipelinesV1Alpha2Client(cc *grpc.ClientConn) PipelinesV1Alpha2Client {
return &pipelinesV1Alpha2Client{cc}
}
func (c *pipelinesV1Alpha2Client) CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*Pipeline, error) {
out := new(Pipeline)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/CreatePipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) {
out := new(longrunning.Operation)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/RunPipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*Pipeline, error) {
out := new(Pipeline)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetPipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error) {
out := new(ListPipelinesResponse)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/ListPipelines", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/DeletePipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) GetControllerConfig(ctx context.Context, in *GetControllerConfigRequest, opts ...grpc.CallOption) (*ControllerConfig, error) {
out := new(ControllerConfig)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetControllerConfig", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) SetOperationStatus(ctx context.Context, in *SetOperationStatusRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/SetOperationStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// PipelinesV1Alpha2Server is the server API for PipelinesV1Alpha2 service.
type PipelinesV1Alpha2Server interface {
// Creates a pipeline that can be run later. Create takes a Pipeline that
// has all fields other than `pipelineId` populated, and then returns
// the same pipeline with `pipelineId` populated. This id can be used
// to run the pipeline.
//
// Caller must have WRITE permission to the project.
CreatePipeline(context.Context, *CreatePipelineRequest) (*Pipeline, error)
// Runs a pipeline. If `pipelineId` is specified in the request, then
// run a saved pipeline. If `ephemeralPipeline` is specified, then run
// that pipeline once without saving a copy.
//
// The caller must have READ permission to the project where the pipeline
// is stored and WRITE permission to the project where the pipeline will be
// run, as VMs will be created and storage will be used.
RunPipeline(context.Context, *RunPipelineRequest) (*longrunning.Operation, error)
// Retrieves a pipeline based on ID.
//
// Caller must have READ permission to the project.
GetPipeline(context.Context, *GetPipelineRequest) (*Pipeline, error)
// Lists pipelines.
//
// Caller must have READ permission to the project.
ListPipelines(context.Context, *ListPipelinesRequest) (*ListPipelinesResponse, error)
// Deletes a pipeline based on ID.
//
// Caller must have WRITE permission to the project.
DeletePipeline(context.Context, *DeletePipelineRequest) (*empty.Empty, error)
// Gets controller configuration information. Should only be called
// by VMs created by the Pipelines Service and not by end users.
GetControllerConfig(context.Context, *GetControllerConfigRequest) (*ControllerConfig, error)
// Sets status of a given operation. Any new timestamps (as determined by
// description) are appended to TimestampEvents. Should only be called by VMs
// created by the Pipelines Service and not by end users.
SetOperationStatus(context.Context, *SetOperationStatusRequest) (*empty.Empty, error)
}
func RegisterPipelinesV1Alpha2Server(s *grpc.Server, srv PipelinesV1Alpha2Server) {
s.RegisterService(&_PipelinesV1Alpha2_serviceDesc, srv)
}
func _PipelinesV1Alpha2_CreatePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreatePipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).CreatePipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/CreatePipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).CreatePipeline(ctx, req.(*CreatePipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_RunPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RunPipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).RunPipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/RunPipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).RunPipeline(ctx, req.(*RunPipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_GetPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetPipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).GetPipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetPipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).GetPipeline(ctx, req.(*GetPipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_ListPipelines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListPipelinesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).ListPipelines(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/ListPipelines",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).ListPipelines(ctx, req.(*ListPipelinesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_DeletePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeletePipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).DeletePipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/DeletePipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).DeletePipeline(ctx, req.(*DeletePipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_GetControllerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetControllerConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).GetControllerConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetControllerConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).GetControllerConfig(ctx, req.(*GetControllerConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_SetOperationStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetOperationStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).SetOperationStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/SetOperationStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).SetOperationStatus(ctx, req.(*SetOperationStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
var _PipelinesV1Alpha2_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.genomics.v1alpha2.PipelinesV1Alpha2",
HandlerType: (*PipelinesV1Alpha2Server)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CreatePipeline",
Handler: _PipelinesV1Alpha2_CreatePipeline_Handler,
},
{
MethodName: "RunPipeline",
Handler: _PipelinesV1Alpha2_RunPipeline_Handler,
},
{
MethodName: "GetPipeline",
Handler: _PipelinesV1Alpha2_GetPipeline_Handler,
},
{
MethodName: "ListPipelines",
Handler: _PipelinesV1Alpha2_ListPipelines_Handler,
},
{
MethodName: "DeletePipeline",
Handler: _PipelinesV1Alpha2_DeletePipeline_Handler,
},
{
MethodName: "GetControllerConfig",
Handler: _PipelinesV1Alpha2_GetControllerConfig_Handler,
},
{
MethodName: "SetOperationStatus",
Handler: _PipelinesV1Alpha2_SetOperationStatus_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/genomics/v1alpha2/pipelines.proto",
}
func init() {
proto.RegisterFile("google/genomics/v1alpha2/pipelines.proto", fileDescriptor_72a0789107b705b0)
}
var fileDescriptor_72a0789107b705b0 = []byte{
// 2065 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x73, 0xdb, 0xc8,
0xd1, 0x36, 0x28, 0x4a, 0x22, 0x9a, 0x12, 0x45, 0xcf, 0xda, 0x6b, 0x9a, 0xf6, 0xbe, 0xb6, 0xe1,
0x37, 0xbb, 0xb2, 0x9c, 0x22, 0x63, 0x79, 0x9d, 0xc8, 0x4a, 0xd5, 0xd6, 0x4a, 0x14, 0x2d, 0xb1,
0x22, 0x4b, 0x0c, 0xa8, 0x55, 0xbe, 0x0e, 0xa8, 0x11, 0x38, 0x82, 0xb0, 0x02, 0x30, 0x08, 0x06,
0x50, 0x59, 0x4e, 0x25, 0x55, 0x49, 0xe5, 0x90, 0xda, 0x4a, 0x2e, 0xc9, 0xfe, 0x88, 0x5c, 0x72,
0xcc, 0xcf, 0xc8, 0x29, 0xa7, 0x9c, 0x72, 0xc9, 0x21, 0x3f, 0x21, 0xb9, 0xa5, 0x66, 0x06, 0x03,
0x82, 0x1f, 0x92, 0xc8, 0xaa, 0x54, 0x6e, 0x33, 0x3d, 0xdd, 0x0f, 0x9e, 0xe9, 0xe9, 0xe9, 0xe9,
0x06, 0xac, 0x3a, 0x94, 0x3a, 0x1e, 0x69, 0x3a, 0x24, 0xa0, 0xbe, 0x6b, 0xb3, 0xe6, 0xc5, 0x0b,
0xec, 0x85, 0x67, 0x78, 0xbd, 0x19, 0xba, 0x21, 0xf1, 0xdc, 0x80, 0xb0, 0x46, 0x18, 0xd1, 0x98,
0xa2, 0x9a, 0xd4, 0x6c, 0x28, 0xcd, 0x86, 0xd2, 0xac, 0x3f, 0x4c, 0x31, 0x70, 0xe8, 0x36, 0x71,
0x10, 0xd0, 0x18, 0xc7, 0x2e, 0x0d, 0x52, 0xbb, 0xfa, 0xd3, 0x74, 0xd5, 0xa3, 0x81, 0x13, 0x25,
0x41, 0xe0, 0x06, 0x4e, 0x93, 0x86, 0x24, 0x1a, 0x52, 0xfa, 0xbf, 0x54, 0x49, 0xcc, 0x4e, 0x92,
0xd3, 0x66, 0x3f, 0x91, 0x0a, 0xe9, 0xfa, 0x83, 0xd1, 0x75, 0xe2, 0x87, 0xf1, 0x65, 0xba, 0xf8,
0x68, 0x74, 0x31, 0x76, 0x7d, 0xc2, 0x62, 0xec, 0x87, 0xa9, 0xc2, 0xdd, 0x54, 0x21, 0x0a, 0xed,
0xa6, 0x4d, 0xfb, 0x44, 0x8a, 0x8d, 0xaf, 0x34, 0x58, 0x6e, 0x51, 0x3f, 0x4c, 0x62, 0xd2, 0x0e,
0x1c, 0x37, 0x20, 0xe8, 0x29, 0x2c, 0xbb, 0x01, 0x8b, 0x71, 0x60, 0x13, 0x2b, 0xc0, 0x3e, 0xa9,
0x69, 0x8f, 0xb5, 0x55, 0xdd, 0x5c, 0x52, 0xc2, 0x03, 0xec, 0x13, 0x84, 0xa0, 0xf8, 0x9e, 0x06,
0xa4, 0x56, 0x10, 0x6b, 0x62, 0x8c, 0x9e, 0xc0, 0x92, 0x8f, 0xed, 0x33, 0x37, 0x20, 0x56, 0x7c,
0x19, 0x92, 0xda, 0x9c, 0x58, 0x2b, 0xa7, 0xb2, 0xa3, 0xcb, 0x90, 0xa0, 0x8f, 0x00, 0xfa, 0x2e,
0x3b, 0x17, 0xb8, 0xac, 0x56, 0x7c, 0x3c, 0xb7, 0xaa, 0x9b, 0x3a, 0x97, 0x70, 0x50, 0x66, 0x60,
0x58, 0x31, 0x93, 0x80, 0x33, 0x7f, 0x4b, 0x62, 0xdc, 0xc7, 0x31, 0x46, 0x07, 0x50, 0xb1, 0x25,
0x3d, 0x8b, 0x08, 0x7e, 0x82, 0x4e, 0x79, 0xfd, 0x93, 0xc6, 0x55, 0x47, 0xd1, 0x18, 0xda, 0x8e,
0xb9, 0x6c, 0xe7, 0xa7, 0xc6, 0x5f, 0xe6, 0xa0, 0xd4, 0x4d, 0x4f, 0x95, 0xd3, 0x09, 0x23, 0xfa,
0x25, 0xb1, 0x63, 0xcb, 0xed, 0xa7, 0xfb, 0xd4, 0x53, 0x49, 0xa7, 0xcf, 0x37, 0x29, 0x1c, 0x90,
0x6e, 0x92, 0x8f, 0xd1, 0x63, 0x28, 0xf7, 0x09, 0xb3, 0x23, 0x37, 0xe4, 0x27, 0xa3, 0xf6, 0x98,
0x13, 0xa1, 0x63, 0xa8, 0xba, 0x41, 0x98, 0xc4, 0x56, 0x88, 0x23, 0xec, 0x93, 0x98, 0x44, 0xac,
0x56, 0x7a, 0x3c, 0xb7, 0x5a, 0x5e, 0x7f, 0x7e, 0x35, 0x67, 0x45, 0xa9, 0xab, 0x6c, 0xcc, 0x15,
0x01, 0x92, 0xcd, 0x19, 0xfa, 0x21, 0xdc, 0xa6, 0x49, 0x3c, 0x02, 0xac, 0xcf, 0x0e, 0x5c, 0x95,
0x28, 0x39, 0xe4, 0x6d, 0x58, 0xe8, 0x53, 0xfb, 0x9c, 0x44, 0xb5, 0x79, 0xe1, 0xdb, 0xd5, 0xab,
0xe1, 0x76, 0x84, 0x5e, 0xfb, 0x1d, 0xb1, 0x93, 0x98, 0x46, 0x7b, 0xb7, 0xcc, 0xd4, 0x12, 0x75,
0x40, 0x8f, 0x08, 0xa3, 0x49, 0x64, 0x13, 0x56, 0x5b, 0x10, 0x30, 0x53, 0xb0, 0x32, 0x95, 0x89,
0x39, 0xb0, 0x46, 0x8f, 0xa0, 0xac, 0xee, 0x1d, 0x3f, 0x96, 0x45, 0xe1, 0x62, 0x50, 0xa2, 0x4e,
0x7f, 0x1b, 0xa0, 0x44, 0x52, 0x06, 0xc6, 0x0f, 0xe0, 0x6e, 0x2b, 0x22, 0x38, 0x26, 0x03, 0xc8,
0x9f, 0x26, 0x84, 0xc5, 0xe8, 0x33, 0x28, 0x29, 0x93, 0x34, 0x64, 0x8c, 0x29, 0xf8, 0x64, 0x36,
0xc6, 0x9f, 0x17, 0x44, 0x30, 0xaa, 0x95, 0xad, 0xc8, 0x61, 0x37, 0xc5, 0xcb, 0x5b, 0x58, 0x10,
0x87, 0xc6, 0x6a, 0x05, 0x71, 0x2c, 0xaf, 0xae, 0xfe, 0xe0, 0x08, 0x72, 0xa3, 0x23, 0xec, 0xda,
0x41, 0x1c, 0x5d, 0x9a, 0x29, 0x08, 0xea, 0xc2, 0xa2, 0x3c, 0x2a, 0x56, 0x9b, 0x13, 0x78, 0xdf,
0x9e, 0x1e, 0xef, 0x50, 0x1a, 0x4a, 0x40, 0x05, 0x83, 0xbe, 0x0f, 0x2b, 0x8c, 0x44, 0x17, 0xae,
0x4d, 0x2c, 0x6c, 0xdb, 0x34, 0x09, 0xe2, 0x5a, 0xf1, 0xa6, 0x13, 0xef, 0x49, 0x83, 0x2d, 0xa9,
0x6f, 0x56, 0xd8, 0xd0, 0x1c, 0x3d, 0x00, 0xdd, 0xf6, 0x5c, 0x12, 0x08, 0x8f, 0xcc, 0x0b, 0x8f,
0x94, 0xa4, 0xa0, 0xd3, 0xff, 0x6f, 0x06, 0xc5, 0x36, 0x2c, 0x7a, 0xd4, 0x71, 0xdc, 0xc0, 0x11,
0x01, 0x71, 0x2d, 0xe5, 0x7d, 0xa9, 0x78, 0x28, 0xee, 0x23, 0x33, 0x95, 0x21, 0x3a, 0x81, 0x27,
0xe7, 0x84, 0x84, 0xd6, 0x85, 0x6f, 0x61, 0xcf, 0xbd, 0x20, 0x16, 0x0d, 0xac, 0x53, 0xec, 0x7a,
0x49, 0x44, 0x2c, 0x95, 0x6b, 0x6b, 0x25, 0x81, 0x7e, 0x5f, 0xa1, 0xab, 0x7c, 0xda, 0xd8, 0x49,
0x15, 0xcc, 0x87, 0x1c, 0xe3, 0xd8, 0xdf, 0xe2, 0x08, 0x87, 0xc1, 0x1b, 0x69, 0xaf, 0x56, 0x79,
0x0c, 0x78, 0xf8, 0x84, 0x78, 0xea, 0x6a, 0xce, 0x10, 0x03, 0xfb, 0xc2, 0x2e, 0x8d, 0x01, 0x09,
0x52, 0x7f, 0x0d, 0xe5, 0x5c, 0x68, 0xa0, 0x2a, 0xcc, 0x9d, 0x93, 0xcb, 0x34, 0xf2, 0xf8, 0x10,
0xdd, 0x81, 0xf9, 0x0b, 0xec, 0x25, 0x2a, 0x49, 0xc9, 0xc9, 0x66, 0x61, 0x43, 0xab, 0x6f, 0xc2,
0x52, 0x3e, 0x0a, 0x66, 0xb2, 0x7d, 0x0d, 0xe5, 0x1c, 0x9b, 0x59, 0x4c, 0x8d, 0x7f, 0x6a, 0x80,
0x72, 0x3b, 0x53, 0xd7, 0xf1, 0xc9, 0xf0, 0xa5, 0x16, 0x50, 0x7b, 0xb7, 0xf2, 0xd7, 0x1a, 0xf5,
0x00, 0x91, 0xf0, 0x8c, 0xf8, 0x24, 0xc2, 0x9e, 0x95, 0xdd, 0xdd, 0xc2, 0xb4, 0x77, 0x77, 0xef,
0x96, 0x79, 0x3b, 0xb3, 0xcf, 0x52, 0xfc, 0x01, 0x2c, 0x67, 0xdf, 0xc5, 0x91, 0xc3, 0x44, 0xc6,
0x2e, 0xaf, 0x3f, 0x9b, 0xfa, 0x58, 0xcc, 0xa5, 0x30, 0x37, 0xe3, 0xb9, 0x27, 0x4b, 0x11, 0xaf,
0x00, 0xed, 0x92, 0x78, 0x74, 0xa7, 0x8f, 0x26, 0xec, 0x34, 0xbf, 0x4f, 0xe3, 0xf7, 0x1a, 0xdc,
0xd9, 0x77, 0x59, 0x66, 0xc8, 0x94, 0xe5, 0x0d, 0xe9, 0xe5, 0x11, 0x94, 0xf9, 0x13, 0x64, 0x85,
0x11, 0x39, 0x75, 0xdf, 0xa5, 0x9e, 0x07, 0x2e, 0xea, 0x0a, 0x09, 0xbf, 0x8b, 0x21, 0x76, 0x88,
0xc5, 0xdc, 0xf7, 0xf2, 0xf5, 0x9d, 0x37, 0x4b, 0x5c, 0xd0, 0x73, 0xdf, 0xcb, 0xb7, 0x8e, 0x2f,
0xc6, 0xf4, 0x9c, 0x04, 0xe2, 0xda, 0x73, 0x70, 0xec, 0x90, 0x23, 0x2e, 0x30, 0x7e, 0xa9, 0xc1,
0xdd, 0x11, 0x52, 0x2c, 0xa4, 0x01, 0x23, 0xe8, 0x73, 0xd0, 0xb3, 0x32, 0xa8, 0xa6, 0x89, 0xa0,
0x9e, 0x26, 0x93, 0x0e, 0x8c, 0xd0, 0xc7, 0xb0, 0x12, 0x90, 0x77, 0xfc, 0xdd, 0xca, 0xbe, 0x2f,
0xc9, 0x2f, 0x73, 0x71, 0x37, 0xe3, 0xb0, 0x01, 0x77, 0x77, 0x88, 0x47, 0xc6, 0x73, 0xf9, 0x8d,
0x2e, 0xfd, 0x12, 0xea, 0xbb, 0x24, 0x6e, 0xd1, 0x20, 0x8e, 0xa8, 0xe7, 0x91, 0xa8, 0x45, 0x83,
0x53, 0xd7, 0x19, 0xc4, 0xde, 0x52, 0x56, 0x6c, 0x0d, 0xec, 0xcb, 0x99, 0xac, 0xd3, 0x47, 0xcf,
0xa0, 0x7a, 0x81, 0x3d, 0xb7, 0x2f, 0x75, 0x06, 0x1c, 0x8b, 0xe6, 0xca, 0x40, 0x2e, 0x59, 0xfe,
0x6d, 0x01, 0xaa, 0xa3, 0x5f, 0xe2, 0xf7, 0xc1, 0xf5, 0xb1, 0xa3, 0x8a, 0x25, 0x39, 0xe1, 0xf7,
0xc6, 0xf6, 0xfb, 0xe9, 0x66, 0xf9, 0x10, 0x3d, 0x86, 0x25, 0xc7, 0x66, 0x96, 0x47, 0x1d, 0x2b,
0xc4, 0xf1, 0x59, 0x5a, 0x3f, 0x80, 0x63, 0xb3, 0x7d, 0xea, 0x74, 0x71, 0x7c, 0x36, 0x56, 0x45,
0x15, 0xc7, 0xab, 0xa8, 0x3d, 0x28, 0x5e, 0xe0, 0x88, 0xd5, 0xe6, 0xc5, 0x61, 0x7c, 0x7a, 0x5d,
0x25, 0x34, 0x4c, 0xb3, 0x71, 0x8c, 0xa3, 0x34, 0xc1, 0x08, 0x04, 0xf4, 0x3d, 0x98, 0xe7, 0xd5,
0x17, 0x4f, 0xce, 0x37, 0x24, 0xab, 0x31, 0xa8, 0x1d, 0x6e, 0x27, 0xb1, 0x24, 0x06, 0xfa, 0x09,
0x94, 0xf9, 0xde, 0x54, 0xbe, 0x5f, 0x14, 0x90, 0x9b, 0x33, 0x40, 0xee, 0xda, 0xac, 0x27, 0x8d,
0x25, 0x2e, 0x77, 0x4b, 0x2a, 0x40, 0x5f, 0x80, 0x2e, 0xc0, 0xdd, 0xe0, 0x5c, 0x95, 0x53, 0x1b,
0x33, 0x42, 0x73, 0x53, 0x09, 0x5c, 0x72, 0xd2, 0x69, 0x7d, 0x15, 0x2a, 0x26, 0x09, 0x79, 0xfd,
0xd0, 0xef, 0xc5, 0x11, 0x7f, 0x24, 0x3e, 0x84, 0x05, 0x91, 0xcc, 0x64, 0xac, 0xeb, 0x66, 0x3a,
0xab, 0x7f, 0x07, 0xf4, 0xcc, 0x7b, 0x33, 0xe5, 0xd2, 0x0d, 0x80, 0x81, 0xaf, 0x66, 0xb2, 0x7c,
0x07, 0x2b, 0x23, 0x2e, 0x99, 0x60, 0x7e, 0x98, 0x37, 0x2f, 0xaf, 0xbf, 0x9e, 0xc1, 0x29, 0xc3,
0x3b, 0xcf, 0x7f, 0xf9, 0x02, 0x96, 0x87, 0x3c, 0xf6, 0x3f, 0xfa, 0xae, 0xe1, 0x41, 0xe5, 0x48,
0xf5, 0x2d, 0xed, 0x0b, 0x12, 0xc4, 0xa3, 0xf5, 0xb6, 0x36, 0x5e, 0x6f, 0x6f, 0x80, 0x9e, 0xf5,
0x3a, 0x29, 0x99, 0xfa, 0xd8, 0xeb, 0x9d, 0xa1, 0x9a, 0x03, 0x65, 0xe3, 0xeb, 0x02, 0xdc, 0xef,
0x91, 0xf8, 0x50, 0xe5, 0x81, 0x5e, 0x8c, 0xe3, 0x84, 0xcd, 0x90, 0x35, 0x7a, 0x50, 0xcd, 0xd0,
0x2c, 0xc2, 0xf9, 0xaa, 0xd2, 0xef, 0x9a, 0xea, 0x64, 0x78, 0x83, 0xe6, 0x4a, 0x3c, 0x34, 0x67,
0xa8, 0x09, 0x40, 0xa2, 0x88, 0x46, 0x16, 0xef, 0xd2, 0x44, 0x82, 0xa8, 0xac, 0x57, 0x15, 0x5c,
0x14, 0xda, 0x8d, 0x16, 0xed, 0x13, 0x53, 0x17, 0x3a, 0x7c, 0xc8, 0x1b, 0x36, 0x69, 0xe0, 0x13,
0xc6, 0x78, 0x0e, 0x92, 0x29, 0x63, 0x49, 0x08, 0xdf, 0x4a, 0xd9, 0xc4, 0x04, 0x37, 0x3f, 0x39,
0xc1, 0x7d, 0x06, 0x95, 0xe1, 0xa2, 0x8f, 0x87, 0x28, 0xf1, 0xb1, 0xeb, 0xa9, 0xec, 0x26, 0x26,
0xfc, 0xa6, 0x30, 0x9b, 0x86, 0x44, 0xee, 0x59, 0x37, 0xd3, 0x99, 0xf1, 0x1c, 0x2a, 0xc3, 0x15,
0x18, 0xba, 0x0f, 0xfc, 0xc6, 0xc9, 0x8c, 0x27, 0x21, 0x16, 0x1d, 0x9b, 0xf1, 0x74, 0x67, 0xfc,
0xbd, 0x08, 0xb7, 0xc7, 0x0a, 0x3f, 0xb4, 0x06, 0xb7, 0x7d, 0x37, 0x70, 0xfd, 0xc4, 0xb7, 0xec,
0x30, 0xb1, 0x6c, 0x1a, 0x89, 0xfb, 0xc8, 0x5f, 0xb4, 0x95, 0x74, 0xa1, 0x15, 0x26, 0x2d, 0x2e,
0xe6, 0x11, 0x12, 0x46, 0x84, 0xf7, 0xc2, 0xee, 0x89, 0x27, 0xc3, 0xb1, 0x64, 0xe6, 0x45, 0xe8,
0xff, 0xa1, 0xa2, 0xd0, 0x22, 0xec, 0x5b, 0xce, 0x89, 0xf0, 0xaa, 0x66, 0x2e, 0xa5, 0x52, 0x13,
0xfb, 0xbb, 0x27, 0xe8, 0x8d, 0xca, 0x85, 0x45, 0x71, 0x82, 0xdf, 0x9a, 0xa1, 0x50, 0x15, 0xc9,
0x50, 0xa5, 0xc1, 0x3b, 0x30, 0xcf, 0xdb, 0x61, 0x99, 0x9e, 0x75, 0x53, 0x4e, 0xd0, 0x33, 0xb8,
0x7d, 0x42, 0x69, 0x6c, 0x89, 0xf6, 0x97, 0x3f, 0xd0, 0x9c, 0xc6, 0x82, 0xd8, 0x51, 0x85, 0x2f,
0x70, 0x04, 0xfe, 0x4e, 0xef, 0x9e, 0xf0, 0x97, 0x3a, 0xa0, 0x16, 0xee, 0xf7, 0x23, 0xc2, 0x98,
0xa8, 0x76, 0x4b, 0xa6, 0x1e, 0xd0, 0x2d, 0x29, 0xa8, 0xff, 0xa9, 0x00, 0x45, 0xae, 0x9d, 0xb5,
0xa7, 0x5a, 0xae, 0x3d, 0xed, 0x40, 0x51, 0xbc, 0x1a, 0x05, 0x11, 0x36, 0xaf, 0x66, 0xdd, 0x43,
0x83, 0xbf, 0x2f, 0xa6, 0x80, 0x40, 0xf7, 0x60, 0x51, 0xf1, 0x94, 0xb5, 0xc4, 0x02, 0x93, 0xfc,
0xf8, 0xb9, 0x0b, 0x9b, 0x34, 0xd0, 0xd2, 0x19, 0x7f, 0xa5, 0x71, 0x12, 0x53, 0xab, 0x2f, 0xde,
0x70, 0xb1, 0xb9, 0x92, 0x09, 0x5c, 0x24, 0x5f, 0x75, 0xae, 0xe0, 0xf3, 0x78, 0xb2, 0x42, 0xea,
0x06, 0xb1, 0xa8, 0xb4, 0x75, 0x13, 0x84, 0xa8, 0xcb, 0x25, 0x46, 0x0f, 0x8a, 0xe2, 0x81, 0xbb,
0x03, 0xd5, 0xa3, 0x1f, 0x75, 0xdb, 0xd6, 0x17, 0x07, 0xbd, 0x6e, 0xbb, 0xd5, 0x79, 0xd3, 0x69,
0xef, 0x54, 0x6f, 0x21, 0x04, 0x95, 0x6e, 0xdb, 0xec, 0x75, 0x7a, 0x47, 0xed, 0x83, 0x23, 0x6b,
0x6f, 0x67, 0xa7, 0xaa, 0x8d, 0xc8, 0x7a, 0xbd, 0x9d, 0x6a, 0x01, 0x2d, 0x83, 0xbe, 0x7f, 0xd8,
0xda, 0xda, 0x17, 0xd3, 0x39, 0xe3, 0xdf, 0xda, 0x20, 0xc2, 0xb2, 0xa6, 0x77, 0xa2, 0xf3, 0x46,
0x72, 0x4d, 0x61, 0x3c, 0xd7, 0x3c, 0x85, 0xe5, 0x3e, 0x39, 0xc5, 0x89, 0x17, 0x5b, 0x32, 0xf9,
0xc9, 0x8e, 0x67, 0x29, 0x15, 0x1e, 0x73, 0x19, 0x3a, 0x02, 0xf0, 0xa8, 0x8d, 0x3d, 0xcb, 0xa6,
0xe1, 0x65, 0xda, 0xf6, 0xbc, 0x9a, 0xa1, 0x43, 0x6f, 0xec, 0x73, 0xeb, 0x16, 0x0d, 0x2f, 0x4d,
0xdd, 0x53, 0xc3, 0xfa, 0x4b, 0xd0, 0x33, 0x39, 0x67, 0x9f, 0xbb, 0x4c, 0x62, 0xcc, 0x65, 0x3c,
0xb8, 0xd4, 0xdf, 0x0a, 0x3e, 0x36, 0xb6, 0xa0, 0x32, 0xdc, 0xb1, 0xf3, 0xe0, 0x12, 0xb5, 0x49,
0xfe, 0xd7, 0x8e, 0x2e, 0x24, 0xe2, 0xbf, 0xce, 0x58, 0xc5, 0xb2, 0xfe, 0x9b, 0xd2, 0xc0, 0x7d,
0xec, 0xf8, 0xc5, 0x96, 0x20, 0x8d, 0x7e, 0xab, 0x41, 0x65, 0xb8, 0xef, 0x46, 0xcd, 0x6b, 0x5e,
0x80, 0x49, 0x1d, 0x7a, 0x7d, 0x8a, 0x2a, 0xd2, 0xf8, 0xc6, 0xaf, 0xfe, 0xfa, 0x8f, 0x3f, 0x14,
0x1e, 0x19, 0x1f, 0x4c, 0xf8, 0x27, 0xb7, 0x99, 0x55, 0xe2, 0xe8, 0x17, 0x50, 0xce, 0x95, 0xed,
0xe8, 0x9b, 0x53, 0x55, 0xf7, 0x8a, 0xc7, 0x47, 0x4a, 0x3b, 0xf7, 0x77, 0xae, 0x91, 0x3d, 0x0a,
0x86, 0x21, 0x28, 0x3c, 0x34, 0xee, 0x4d, 0xa2, 0x10, 0x25, 0xc1, 0xa6, 0xb6, 0x86, 0xbe, 0xd2,
0xa0, 0x9c, 0x6b, 0x05, 0xae, 0x23, 0x30, 0xde, 0x31, 0x4c, 0xe5, 0x88, 0x67, 0x82, 0xc5, 0x53,
0xf4, 0x64, 0x02, 0x8b, 0xe6, 0xcf, 0x72, 0xd5, 0xf1, 0xcf, 0xd1, 0xef, 0x34, 0x58, 0x1e, 0x2a,
0xe5, 0x51, 0xe3, 0x9a, 0x5e, 0x79, 0x42, 0x23, 0x52, 0x6f, 0x4e, 0xad, 0x2f, 0x7b, 0x04, 0xe3,
0x81, 0x60, 0x77, 0x17, 0x4d, 0x3a, 0x26, 0xf4, 0x6b, 0x0d, 0x2a, 0xc3, 0x75, 0xfd, 0x75, 0xb1,
0x32, 0xb1, 0x03, 0xa8, 0x7f, 0x38, 0xf6, 0xa2, 0xb7, 0xfd, 0x30, 0xbe, 0x54, 0x6e, 0x59, 0x9b,
0xc2, 0x2d, 0x7f, 0xd4, 0xe0, 0x83, 0x09, 0x4d, 0x02, 0xfa, 0xf4, 0xda, 0xb3, 0xba, 0xa2, 0xa7,
0xa8, 0xaf, 0x4d, 0x5f, 0xef, 0x18, 0x4d, 0x41, 0xf2, 0x19, 0xfa, 0x64, 0x52, 0x04, 0x39, 0x13,
0x28, 0x7d, 0xad, 0x01, 0x1a, 0x2f, 0x4c, 0xd0, 0xcb, 0xeb, 0xfe, 0xd2, 0x5c, 0x51, 0xc6, 0x5c,
0xe9, 0xb9, 0x17, 0x82, 0xd4, 0xf3, 0xfa, 0xc7, 0x93, 0x48, 0xb1, 0x31, 0xb8, 0x4d, 0x6d, 0x6d,
0x3b, 0x84, 0x7b, 0x36, 0xf5, 0x27, 0x91, 0xd8, 0xae, 0x64, 0x31, 0xd1, 0xe5, 0x9f, 0xe9, 0x6a,
0x3f, 0xfe, 0x5c, 0xa9, 0x51, 0x0f, 0x07, 0x4e, 0x83, 0x46, 0x4e, 0xd3, 0x21, 0x81, 0x20, 0xd1,
0x94, 0x4b, 0x38, 0x74, 0xd9, 0xf8, 0x3f, 0xf7, 0xef, 0x2a, 0xc9, 0xbf, 0x34, 0xed, 0x64, 0x41,
0xe8, 0xbf, 0xfc, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x13, 0x10, 0x96, 0x1d, 0xa2, 0x17, 0x00,
0x00,
}
```
|
```makefile
################################################################################
#
# sam-ba
#
################################################################################
SAM_BA_SITE = path_to_url
SAM_BA_VERSION = 2.12
SAM_BA_SOURCE = sam-ba_$(SAM_BA_VERSION).zip
SAM_BA_PATCH = sam-ba_$(SAM_BA_VERSION)_patch5.gz
SAM_BA_LICENSE = BSD-like (partly binary-only)
SAM_BA_LICENSE_FILES = doc/readme.txt
define HOST_SAM_BA_EXTRACT_CMDS
$(UNZIP) -d $(BUILD_DIR) $(DL_DIR)/$(SAM_BA_SOURCE)
mv $(BUILD_DIR)/sam-ba_cdc_cdc_linux/* $(@D)
rmdir $(BUILD_DIR)/sam-ba_cdc_cdc_linux/
endef
# Since it's a prebuilt application and it does not conform to the
# usual Unix hierarchy, we install it in $(HOST_DIR)/opt/sam-ba and
# then create a symbolic link from $(HOST_DIR)/usr/bin to the
# application binary, for easier usage.
define HOST_SAM_BA_INSTALL_CMDS
mkdir -p $(HOST_DIR)/opt/sam-ba/
cp -a $(@D)/* $(HOST_DIR)/opt/sam-ba/
ln -sf ../../opt/sam-ba/sam-ba $(HOST_DIR)/usr/bin/sam-ba
endef
$(eval $(host-generic-package))
```
|
```objective-c
/*===-- llvm-c/TargetMachine.h - Target Machine Library C Interface - C++ -*-=*\
|* *|
|* Exceptions. *|
|* See path_to_url for license information. *|
|* *|
|*===your_sha256_hash------===*|
|* *|
|* This header declares the C interface to the Target and TargetMachine *|
|* classes, which can be used to generate assembly or object files. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===your_sha256_hash------===*/
#ifndef LLVM_C_TARGETMACHINE_H
#define LLVM_C_TARGETMACHINE_H
#include "llvm-c/ExternC.h"
#include "llvm-c/Target.h"
#include "llvm-c/Types.h"
LLVM_C_EXTERN_C_BEGIN
typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
typedef struct LLVMTarget *LLVMTargetRef;
typedef enum {
LLVMCodeGenLevelNone,
LLVMCodeGenLevelLess,
LLVMCodeGenLevelDefault,
LLVMCodeGenLevelAggressive
} LLVMCodeGenOptLevel;
typedef enum {
LLVMRelocDefault,
LLVMRelocStatic,
LLVMRelocPIC,
LLVMRelocDynamicNoPic,
LLVMRelocROPI,
LLVMRelocRWPI,
LLVMRelocROPI_RWPI
} LLVMRelocMode;
typedef enum {
LLVMCodeModelDefault,
LLVMCodeModelJITDefault,
LLVMCodeModelTiny,
LLVMCodeModelSmall,
LLVMCodeModelKernel,
LLVMCodeModelMedium,
LLVMCodeModelLarge
} LLVMCodeModel;
typedef enum {
LLVMAssemblyFile,
LLVMObjectFile
} LLVMCodeGenFileType;
/** Returns the first llvm::Target in the registered targets list. */
LLVMTargetRef LLVMGetFirstTarget(void);
/** Returns the next llvm::Target given a previous one (or null if there's none) */
LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T);
/*===-- Target ------------------------------------------------------------===*/
/** Finds the target corresponding to the given name and stores it in \p T.
Returns 0 on success. */
LLVMTargetRef LLVMGetTargetFromName(const char *Name);
/** Finds the target corresponding to the given triple and stores it in \p T.
Returns 0 on success. Optionally returns any error in ErrorMessage.
Use LLVMDisposeMessage to dispose the message. */
LLVMBool LLVMGetTargetFromTriple(const char* Triple, LLVMTargetRef *T,
char **ErrorMessage);
/** Returns the name of a target. See llvm::Target::getName */
const char *LLVMGetTargetName(LLVMTargetRef T);
/** Returns the description of a target. See llvm::Target::getDescription */
const char *LLVMGetTargetDescription(LLVMTargetRef T);
/** Returns if the target has a JIT */
LLVMBool LLVMTargetHasJIT(LLVMTargetRef T);
/** Returns if the target has a TargetMachine associated */
LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T);
/** Returns if the target as an ASM backend (required for emitting output) */
LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T);
/*===-- Target Machine ----------------------------------------------------===*/
/** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */
LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
const char *Triple, const char *CPU, const char *Features,
LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel);
/** Dispose the LLVMTargetMachineRef instance generated by
LLVMCreateTargetMachine. */
void LLVMDisposeTargetMachine(LLVMTargetMachineRef T);
/** Returns the Target used in a TargetMachine */
LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T);
/** Returns the triple used creating this target machine. See
llvm::TargetMachine::getTriple. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineTriple(LLVMTargetMachineRef T);
/** Returns the cpu used creating this target machine. See
llvm::TargetMachine::getCPU. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineCPU(LLVMTargetMachineRef T);
/** Returns the feature string used creating this target machine. See
llvm::TargetMachine::getFeatureString. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T);
/** Create a DataLayout based on the targetMachine. */
LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T);
/** Set the target machine's ASM verbosity. */
void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
LLVMBool VerboseAsm);
/** Emits an asm or object file for the given module to the filename. This
wraps several c++ only classes (among them a file stream). Returns any
error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */
LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
char *Filename, LLVMCodeGenFileType codegen, char **ErrorMessage);
/** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
LLVMCodeGenFileType codegen, char** ErrorMessage, LLVMMemoryBufferRef *OutMemBuf);
/*===-- Triple ------------------------------------------------------------===*/
/** Get a triple for the host machine as a string. The result needs to be
disposed with LLVMDisposeMessage. */
char* LLVMGetDefaultTargetTriple(void);
/** Normalize a target triple. The result needs to be disposed with
LLVMDisposeMessage. */
char* LLVMNormalizeTargetTriple(const char* triple);
/** Get the host CPU as a string. The result needs to be disposed with
LLVMDisposeMessage. */
char* LLVMGetHostCPUName(void);
/** Get the host CPU's features as a string. The result needs to be disposed
with LLVMDisposeMessage. */
char* LLVMGetHostCPUFeatures(void);
/** Adds the target-specific analysis passes to the pass manager. */
void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM);
LLVM_C_EXTERN_C_END
#endif
```
|
Vici Gaming (VG) is a Chinese professional esports organization based in Shanghai. It has teams competing in Dota 2, League of Legends, StarCraft II, WarCraft III, FIFA, Hearthstone and Counter-Strike: Global Offensive. Vici Gaming's Dota 2 team has been a top contender in numerous tournaments, most notably as runners-up of The International 2014.
Dota 2
History
2012
Vici Gaming was founded on 21 September 2012 with the help of "Fengdidi", who previously played in PanDarea Gaming under the name PanPan, handpicking skilled players that were highly ranked on the Chinese DotA ladder at the time.
The players had no previous professional experience at the time with the exception of sydm who had played under the banner of TyLoo. Their mid lane player Cty had shown promise by winning a 1v1 tournament organized by 2009, in which he beat famous players like Ferrari_430, Sylar, Hao, and other top Chinese players shortly before getting recruited.
The team qualified for the 2012 G-League Season 2 by beating Noah's Ark in the preliminaries.
2013
On 28 January, Vici signed Greedy, captained by the famous YaphetS as their online/backup squad. The rest of the team consisted of xiaotuji, Maybe, nL_Ks, and CaptainGiveMeBall. They were focused on Dota, although they have since expanded to Dota 2.
On 1 March, Vici signed ZSMJ, the founder of Dota 2 squad. It was believed that ZSMJ brought some of his teammates from his project with Chisbug to Vici Gaming, of which a member is Sgua_Li. In the following weeks, Vici Gaming made some roster adjustments, dropping some players in private while sending out a public notice for interested players to contact them.
On 28 March, it was announced that carry player ZSMJ replaced mid player sydm and that former carry Cty picked up the mid role.
In June 2013, following elimination from The International 2013 qualifiers and a disappointing finish outside playoff places in DSL, Vici Gaming announced the departure of team executive, PandaPanPan, and team manager, Nada. Their replacement was mikasa, who had played as a substitute for VG.
On 31 October, Sylar joined the team as the new carry player, but would not be in the starting lineup for almost two months due to contract terms and TuTu remains to play on the ongoing 2013 WPC Ace Dota 2 League.
In December 2013, Vici Gaming traveled to Poland to compete in the Raidcall EMS Fall LAN finals, joining the ranks of teams like Alliance, Natus Vincere, and DK who were pioneers in east-west tournament participation. Vici would go on to take first place at EMS One Fall. Following this, the team also traveled to the Kingston HyperX Dota 2 League in Las Vegas., but would subsequently fall from the top of Dota 2 due to a lack of direction and poor player performances. Despite placing at many events Vici would not achieve another title in the TI3 to TI4 season.
2014
On 16 April, it was announced that former EHOME player QQQ will be joining VG as a coach.
At the end of April 2014, Vici Gaming received an invitation to The International 2014, where they would go on to place first in the group stage and second overall. They lost to NewBee in the finals 3–1.
On 17 August, rOtK announced his retirement. 26 August Sylar leaves the team, and Black^ and join. VG looked very strong with their new lineup for the rest of the year, certainly the best Chinese team.
In mid December they travelled to Los Angeles to compete in The Summit 2 and as strong favorites they defeated Cloud9 for the Championship 3–1.
2015
VG had a strong 2015 season. In February, they reached the finals of Dota 2 Asian Championships ("the biggest event outside of The International") with not too much effort, but they lost shockingly 0–3 to Evil Geniuses in the Grand Finals, especially since they defeated them 20 the day before. With the next International being months away, this definitely shook up things for VG and they must've started analyzing their future and possibilities.
On 11 March, Hao joined VG, replacing Black^ in the Carry position, after a month of speculation and rumors going on.
On 15 March, the team announced the creation of a youth squad, VG.P. On 27 April, Vici won Starladder XII after defeating Invictus Gaming 3–1.
They were one of the officially invited teams for The International 2015 with a complete prize pool of $18,377,817 and on 2 July they confirmed that they've obtained their USA visas, needed to participate in the event. They ended losing to LGD Gaming to finish 4th and securing $1,562,114.
During the first day of The International 2015, VG became the first team outside of Europe to obtain the Verified Tag on Facebook, and third after only Fnatic and Gambit Gaming. After the annual post-TI break/shuffle period, Hao returned to Newbee and VG acquired Xu "BurNIng" Zhilei and Yang "YJ" Pu. They finished 2nd in the Nanyang Championships, falling 2–3 to Secret in the Grand Finals. They would proceed to participate in the first ever Major by Valve in Frankfurt, Germany. They finished in 5th place with $205,000 in winnings.
Roster
VGJ
In September 2016, Vici Gaming signed an agreement with American basketball player Jeremy Lin and investment group China Digital Group to form another Dota 2 team, called VGJ, meant to create a celebrity brand in esports. The team later split into two branches in 2017: VGJ.Thunder, based in China, and VGJ.Storm, based in North America. In May 2018, VGJ.Storm won the GESC Thailand Dota 2 Minor tournament, while VGJ.Thunder qualified for The International 2018 with a top eight finish in the Dota Pro Circuit, with VGJ.Storm winning in the North American regional qualifiers to also gain an invite. In September 2018, the VGJ organization announced an ending to the Vici Gaming partnership due to new Dota Pro Circuit team ownership rules. As a result, it disbanded VGJ.Thunder and rebranded VGJ.Storm as J.Storm, with the team focusing on the North American esports scene.
League of Legends
History
On 1 December 2015, VG signed former SKT T1 mid laner Lee "Easyhoon" Ji-hoon to their roster.
On 2 January 2021, VG rebranded as Rare Atom.
Final roster
Other rosters
Counter-Strike: Global Offensive
Hearthstone
Minyang "Ant" Wong
Anping "Season" Tan
Jingfan "ChinaYLD" Zhu
Yan "Rosicky" Zhongshu
FIFA
Zheng "Zola" Yang
References
External links
2012 establishments in China
Companies based in Shanghai
Dota teams
Hearthstone teams
Esports teams based in China
FIFA (video game series) teams
League of Legends Pro League teams
Esports teams established in 2012
Sports clubs and teams in Shanghai
|
"Strange Kind of Woman" is a song by English rock band Deep Purple that was originally released as a follow-up single after "Black Night" in early 1971. The song also became a hit, peaking at No. 8 on the UK chart and Germany, and No. 1 in Denmark. The 1996 remix by Roger Glover later appeared on the re-release of the band's 1971 album Fireball, while the original version can be found on various Deep Purple compilations. Although not part of the Fireball recording sessions, "Strange Kind of Woman" was included on the US and Canadian editions of the album, in lieu of the track "Demon's Eye" on the UK edition.
The B-side song, "I'm Alone", was later released on The Deep Purple Singles A's and B's as well as on the 25th anniversary reissue of Fireball.
History
The song was originally called "Prostitute". Vocalist Ian Gillan introduced the song on Deep Purple in Concert: "It was about a friend of ours who got mixed up with a very evil woman and it was a sad story. They got married in the end. And a few days after they got married, the lady died." In Wordographys section Gillan gives a slightly different version of the song's history:
When Deep Purple performed the song live, Gillan and guitarist Ritchie Blackmore would play a guitar-vocal duel in the middle. This would always end with an extremely long, high-pitched scream from Gillan before the band returned to playing the original song. An example can be heard on the live album, Made in Japan, recorded in 1972.
Charts
Personnel
Ian Gillan – vocals
Ritchie Blackmore – guitars
Roger Glover – bass
Jon Lord – keyboards
Ian Paice – drums
References
Deep Purple songs
1971 songs
Songs written by Ian Gillan
Songs written by Roger Glover
Songs written by Ritchie Blackmore
Songs written by Jon Lord
Songs written by Ian Paice
Warner Records singles
Harvest Records singles
1971 singles
Songs about prostitutes
|
```ocaml
(*
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*)
exception Dns_resolve_timeout
exception Dns_resolve_error of exn list
(** The type of pluggable DNS resolver modules for request contexts and
custom metadata and wire protocols.
*)
module type CLIENT = sig
type context
val get_id : unit -> int
(** [marshal query] is a list of context-buffer pairs corresponding to the
channel contexts and request buffers with which to attempt DNS requests.
Requests are made in parallel and the first response to successfully
parse is returned as the answer. Lagging requests are kept running until
successful parse or timeout. With this behavior, it is easy to construct
low-latency but network-environment-aware DNS resolvers.
*)
val marshal : ?alloc:(unit -> Cstruct.t) -> Packet.t -> (context * Cstruct.t) list
(** [parse ctxt buf] is the potential packet extracted out of [buf]
with [ctxt]
*)
val parse : context -> Cstruct.t -> Packet.t option
(** [timeout ctxt] is the exception resulting from a context [ctxt] that has
timed-out
*)
val timeout : context -> exn
end
(** The default DNS resolver using the standard DNS protocol *)
module Client : CLIENT
(** The type of pluggable DNS server modules for request contexts and
custom metadata dn wire protocols.
*)
module type SERVER = sig
type context
(** Projects a context into its associated query *)
val query_of_context : context -> Packet.t
(** DNS wire format parser function.
@param buf message buffer
@return parsed packet and context
*)
val parse : Cstruct.t -> context option
(** DNS wire format marshal function.
@param alloc allocator
@param _q context
@param response answer packet
@return buffer to write
*)
val marshal : ?alloc:(unit -> Cstruct.t) -> context -> Packet.t -> Cstruct.t option
end
(** The default DNS server using the standard DNS protocol *)
module Server : SERVER with type context = Packet.t
val contain_exc : string -> (unit -> 'a) -> 'a option
```
|
```c++
//
// (See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
//
// See path_to_url for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/bitwise.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/test.hpp>
typedef integral_c<unsigned int, 0> _0;
typedef integral_c<unsigned int, 1> _1;
typedef integral_c<unsigned int, 2> _2;
typedef integral_c<unsigned int, 8> _8;
typedef integral_c<unsigned int, 0xffffffff> _ffffffff;
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitand_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_1,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_0,_1>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_0,_ffffffff>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_1,_ffffffff>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitand_<_8,_ffffffff>::value), ==, 8 );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitor_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitor_<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitor_<_0,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_0,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_1,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_8,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitxor_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitxor_<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitxor_<_0,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_0,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 0) );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_1,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 1) );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_8,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 8) );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (shift_right<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_right<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_right<_1,_1>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_right<_2,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_right<_8,_1>::value), ==, 4 );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (shift_left<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_left<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_left<_1,_1>::value), ==, 2 );
MPL_ASSERT_RELATION( (shift_left<_2,_1>::value), ==, 4 );
MPL_ASSERT_RELATION( (shift_left<_8,_1>::value), ==, 16 );
}
```
|
Nowe Mistrzewice is a village in the administrative district of Gmina Młodzieszyn, within Sochaczew County, Masovian Voivodeship, in east-central Poland. It lies approximately east of Młodzieszyn, north of Sochaczew, and west of Warsaw.
References
Nowe Mistrzewice
|
Welton Ivan Taylor (November 12, 1919 – November 1, 2012) was an American microbiologist, inventor and civil rights activist. He is known for his work on food-borne pathogens, notably for developing tests for Salmonella and for inventing the XLD (Xylose Lysine Deoxycholate) agar, which can be used to isolate Salmonella and Shigella bacteria.
After obtaining his PhD at the University of Illinois at Urbana-Champaign, and research relevant to infections of soldiers' wounds at the university's College of Medicine, Taylor joined the food processing company Swift & Company, developing for them an accurate test for the contamination of food with salmonella. This set the direction for his subsequent research, undertaken mostly at Microbiologist-in-Chief at Chicago's Children's Memorial Hospital, on different ways of detecting specific pathogens accurately and quickly, in a clinical setting.
Taylor was a life-long civil-rights activist, promoting racial equality and working towards de-segregation.
In 2016, Taylor was inducted into the National Inventors Hall of Fame. In 1985, a species of bacteria was named jointly after Taylor and an eponymous colleague.
Life
Taylor was born in Birmingham, Alabama on November 12, 1919. A few weeks after his birth, his family was forced to move because Taylor's mother had inadvertently discovered the identity of a local Ku Klux Klan leader. The family moved first to Chicago, then to Peoria, and eventually back to the Bronzeville neighborhood of Chicago, where Taylor attended DuSable High School. He graduated from high school in 1937 as valedictorian of his class.
With the help of local African-American businessmen active in the Kappa Alpha Psi fraternity, who had been impressed with his academic performance in high school, Taylor was able to attend the University of Illinois at Urbana-Champaign, earning a bachelor's degree in bacteriology in 1941. At the university, Taylor was a Reserve Officers' Training Corps cadet.
When World War II broke out, Taylor enlisted in the U.S. Army, serving in the South Pacific theater of operations as a liaison pilot for the Army Field Artillery, that is, using air surveillance to help direct field artillery fire. His unit was the 93rd Infantry Division, a segregated unit that had already fought in World War I.
After the war, Taylor returned to his alma mater on the G.I. Bill to complete his M.S. degree in the same subject in 1947, and a PhD degree in 1948. For his PhD, Taylor studied "The growth and toxin production of Clostridium botulinum in cottage cheese".
Throughout his career, including his service in an army that was, at the time, still subject to Jim Crow rules, Taylor was confronted with anti-black racism. He recounts a number of such confrontations in the memoirs he wrote on his time in the army, published in 2012. As a civil rights activist, Taylor promoted racial equality, including work with white veterans in Urbana-Champaign with the aim of de-segregating restaurants, movie theaters and public swimming pools. Taylor was one of the first African Americans to integrate Chicago's Chatham neighborhood, serving as president of the Chatham Avalon Park Community Council.
Taylor married Jayne Rowena Kemp in 1945, and had two daughters, whose names are Karyn and Shelley. Taylor and Jayne were married for many years until Jayne passed away in 2005.
Scientific career
In 1948, Taylor joined the faculty at the University of Illinois College of Medicine. As research subjects, he chose gas gangrene and tetanus, both of which were infections relevant to the military as complications of soldiers' wounds. Taylor and his colleague Milan Novak found that penicillin could be used as prophylaxis for both diseases.
Between 1954 and 1959, Taylor worked at the food processing company Swift & Company. When there was an outbreak of salmonella at the company, Taylor, with his colleague John Silliker, developed an accurate test that could be used to test egg yolks for salmonella. The testing method is still in use today. Taylor and Silliker jointly took out a patent on a new method of destroying food-borne bacteria using bacteriophages in 1959.
In 1959, Taylor left the company to take up a post as Microbiologist-in-Chief at Chicago's Children's Memorial Hospital.
With a Special Research Fellowship from the National Institute of Allergy and Infectious Diseases, Taylor spent 1961 at Britain's Central Public Health Laboratory in Colindale and France's Pasteur Institute in Lille, helping to develop procedures aimed at preventing salmonella poisoning caused by meat imports.
Upon his return to Children's Memorial Hospital in 1962, Taylor went on to develop rapid testing methods for two more classes of bacteria known to cause food poisoning, notably Shigellae – one of the leading bacterial causes of diarrhea worldwide – and Enterobacteriaceae, obtaining several patents. The methods he developed were adopted internationally as part of the ongoing effort to keep processed food safe. Taylor acted as a consultant for eleven Chicago-area hospitals, seven corporations, three government agencies, as well as for the Center for Disease Control on subjects ranging from toxic shock syndrome and Legionnaire's disease to sexually transmitted diseases and AIDS.
In 1965, Taylor developed the XLD agar, which can be used to isolate Salmonella and Shigella bacterial species both from clinical samples and from food. This agar remains a standard diagnostic tool of clinical microbiology, and is particularly well-suited for routine diagnostic work on Salmonella enterica.
In 1975, Taylor was one of the founders of the Journal of Clinical Microbiology, which is published by the American Society for Microbiology; he also served as one of the journal's editors from 1975 to 1983.
In pursuit of his research, Taylor set about combining different culture media in a form that would allow for easy identification of different bacteria in a clinical setting. For the resulting "Device for Use in the Identification of Microorganisms", which includes different compartments with specific culture media allowing for accurate and fast identification, a patent was issued to Taylor on March 1, 1977. The device was approved by the FDA as well as by food-safety regulatory agencies in Canada and in Europe as a means of certifying food as bacteria free. Taylor founded Micro-Palettes Inc. in order to commercialize devices of this type, but the company was dissolved in 1988.
Honors and awards
Taylor's inventions in the area of food testing eventually led to his induction into the National Inventors Hall of Fame in 2016.
In 1985, a group of researchers from the Center for Disease Control named a newly identified Enterobacter bacterium Enterobacter taylorae in honor of both the British bacteriologist Joan Taylor and Welton Taylor. The citation reads "The name also honors Welton Taylor, an American clinical microbiologist who has also made many contributions to our knowledge of the family Enterobacteriaceae, particularly the development of the XLD agar and the isolation of Shigella and other bacterial pathogens from feces.''
References
1919 births
2012 deaths
20th-century American inventors
American patent holders
American microbiologists
Academic journal editors
Academics from Chicago
Activists for African-American civil rights
American anti-racism activists
University of Illinois Urbana-Champaign alumni
People from Birmingham, Alabama
United States Army Air Forces pilots of World War II
21st-century African-American people
Military personnel from Birmingham, Alabama
United States Army personnel of World War II
United States Army soldiers
|
A laboratory notebook (colloq. lab notebook or lab book) is a primary record of research. Researchers use a lab notebook to document their hypotheses, experiments and initial analysis or interpretation of these experiments. The notebook serves as an organizational tool, a memory aid, and can also have a role in protecting any intellectual property that comes from the research.
Structure
The guidelines for lab notebooks vary widely between institution and between individual labs, but some guidelines are fairly common, for example, like those in the reference. The lab notebook is typically permanently bound and pages are numbered. Dates are given as a rule. All entries are with a permanent writing tool, e.g., a ballpoint pen (though a permanent marker may be undesirable, as the ink might bleed through multiple pages). The lab notebook is usually written as the experiments progress, rather than at a later date. In many laboratories, it is the original place of record of data (no copying is carried out from other notes) as well as any observations or insights. For data recorded by other means (e.g., on a computer), the lab notebook will record that the data was obtained and the identification of the data set will be given in the notebook. Many adhere to the concept that a lab notebook should be thought of as a diary of activities that are described in sufficient detail to allow another scientist to replicate the steps. In laboratories with several staff and a common laboratory notebook, entries in the notebook are signed by those making them.
Legal aspects
To ensure that data cannot be easily altered, notebooks with permanently bound pages are often recommended. Researchers are often encouraged to write only with unerasable pen, to sign and date each page, and to have their notebooks inspected periodically by another scientist who can read and understand it. All of these guidelines can be useful in proving exactly when a discovery was made, in the case of a patent dispute. It is worth noting however that following March 2013, lab notebooks are of limited legal use in the United States, due to a change in the law that grants patents to the first person to file, rather than the first person to invent. The lab notebook is still useful for proving that work was not stolen, but can no longer be used to dispute the patent of an unrelated party.
Electronic formats
Several companies now offer electronic lab notebooks. This format has gained some popularity, especially in large pharmaceutical companies, which have large numbers of researchers and great need to document their experiments.
Open lab notebooks
Lab notebooks kept online have started to become as transparent to the world as they are to the researcher keeping them, a trend often referred to as Open Notebook Science, after the title of a 2006 blogpost by chemist Jean-Claude Bradley. The term is frequently used to distinguish this aspect of Open Science from the related but rather independent developments commonly labeled as Open Source, Open Access, Open Data and so forth. The openness of the notebook, then, specifically refers to the set of the following points, or elements thereof:
Sharing of the researcher's laboratory notebook online in real time without password protection or limitations on the use of the data.
The raw data used by the researcher to derive observations and conclusions are made available online to anyone.
All experimental data are shared, including failed or ambiguous attempts.
Feedback and other contributions to the research effort can be integrated easily with the understanding that everything is donated to the public domain.
The use of a wiki makes it convenient to track contributions by individual authors.
See also
Exercise book
Fieldnotes
Ruled paper
Graph paper
Invention disclosure
Inventor's notebook
Laboratory information management system
References
External links
Durham University Guide on Lab Books
NIH training guide for Keeping a Lab Notebook
Scientific documents
Research
Notebooks
|
Viral Scandal is a Philippine television drama broadcast by Kapamilya Channel, A2Z and TV5. It aired from November 15, 2021 to May 13, 2022 on the channel's Primetime Bida evening block and worldwide via The Filipino Channel, replacing Huwag Kang Mangamba.
Series overview
iWantTFC shows two episodes first in advance before its television broadcast.
Episodes
Season 1
Season 2
References
Lists of Philippine drama television series episodes
|
```objective-c
/*
*
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef AOM_AOM_DSP_PROB_H_
#define AOM_AOM_DSP_PROB_H_
#include <assert.h>
#include <stdio.h>
#include "pxr/imaging/plugin/hioAvif/aom/config/aom_config.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_dsp/aom_dsp_common.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_dsp/entcode.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_ports/bitops.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_ports/mem.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef uint16_t aom_cdf_prob;
#define CDF_SIZE(x) ((x) + 1)
#define CDF_PROB_BITS 15
#define CDF_PROB_TOP (1 << CDF_PROB_BITS)
#define CDF_INIT_TOP 32768
#define CDF_SHIFT (15 - CDF_PROB_BITS)
/*The value stored in an iCDF is CDF_PROB_TOP minus the actual cumulative
probability (an "inverse" CDF).
This function converts from one representation to the other (and is its own
inverse).*/
#define AOM_ICDF(x) (CDF_PROB_TOP - (x))
#if CDF_SHIFT == 0
#define AOM_CDF2(a0) AOM_ICDF(a0), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF3(a0, a1) AOM_ICDF(a0), AOM_ICDF(a1), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF4(a0, a1, a2) \
AOM_ICDF(a0), AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF5(a0, a1, a2, a3) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF6(a0, a1, a2, a3, a4) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF7(a0, a1, a2, a3, a4, a5) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF8(a0, a1, a2, a3, a4, a5, a6) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF9(a0, a1, a2, a3, a4, a5, a6, a7) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF10(a0, a1, a2, a3, a4, a5, a6, a7, a8) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF11(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF12(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF13(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF14(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF15(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(a13), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, \
a14) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(a13), AOM_ICDF(a14), \
AOM_ICDF(CDF_PROB_TOP), 0
#else
#define AOM_CDF2(a0) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 2) + \
((CDF_INIT_TOP - 2) >> 1)) / \
((CDF_INIT_TOP - 2)) + \
1) \
, AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF3(a0, a1) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 3) + \
((CDF_INIT_TOP - 3) >> 1)) / \
((CDF_INIT_TOP - 3)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 3) + \
((CDF_INIT_TOP - 3) >> 1)) / \
((CDF_INIT_TOP - 3)) + \
2), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF4(a0, a1, a2) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
3), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF5(a0, a1, a2, a3) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
4), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF6(a0, a1, a2, a3, a4) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
5), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF7(a0, a1, a2, a3, a4, a5) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
6), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF8(a0, a1, a2, a3, a4, a5, a6) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
7), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF9(a0, a1, a2, a3, a4, a5, a6, a7) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
8), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF10(a0, a1, a2, a3, a4, a5, a6, a7, a8) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
9), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF11(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
10), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF12(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
11), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF13(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
12), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF14(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
13), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF15(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
13), \
AOM_ICDF((((a13)-14) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
14), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, \
a14) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
13), \
AOM_ICDF((((a13)-14) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
14), \
AOM_ICDF((((a14)-15) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
15), \
AOM_ICDF(CDF_PROB_TOP), 0
#endif
static INLINE uint8_t get_prob(unsigned int num, unsigned int den) {
assert(den != 0);
{
const int p = (int)(((uint64_t)num * 256 + (den >> 1)) / den);
// (p > 255) ? 255 : (p < 1) ? 1 : p;
const int clipped_prob = p | ((255 - p) >> 23) | (p == 0);
return (uint8_t)clipped_prob;
}
}
static INLINE void update_cdf(aom_cdf_prob *cdf, int8_t val, int nsymbs) {
int rate;
int i, tmp;
static const int nsymbs2speed[17] = { 0, 0, 1, 1, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2 };
assert(nsymbs < 17);
rate = 3 + (cdf[nsymbs] > 15) + (cdf[nsymbs] > 31) +
nsymbs2speed[nsymbs]; // + get_msb(nsymbs);
tmp = AOM_ICDF(0);
// Single loop (faster)
for (i = 0; i < nsymbs - 1; ++i) {
tmp = (i == val) ? 0 : tmp;
if (tmp < cdf[i]) {
cdf[i] -= ((cdf[i] - tmp) >> rate);
} else {
cdf[i] += ((tmp - cdf[i]) >> rate);
}
}
cdf[nsymbs] += (cdf[nsymbs] < 32);
}
#ifdef __cplusplus
} // extern "C"
#endif
#endif // AOM_AOM_DSP_PROB_H_
```
|
Peter Chester (1720–1799) was the last governor of the British territory of West Florida from August 1770 until 9 May 1781.
Chester focused on agricultural development in the Lower Mississippi Valley. Spain controlled the land west of the Mississippi River, Britain its east side, and the French held influence over the trading post of New Orleans.
Chester was the area's third governor (fifth if acting governors are included). He dealt with issues related to Native Americans in Florida. John Stuart was the Superintendent of Indian Affairs in the Southern District of North America. George Washington wrote to him March 25, 1773. Robert Ross also wrote a letter to Chester, on August 14, 1778.
British artist Arthur Devis (1711 – 1787) produced an oil painting of a hunting scene with Peter Chester, his brother Edward Chester who owned Cockenhatch estate manager Thomas Gorsuch, and a clergyman of Barkway.
Britain's National Archives at Kew have some of his correspondence in their collection.
See also
List of colonial governors of Florida
References
1720 births
1799 deaths
Governors of West Florida
|
```javascript
Synchronous File Write/Read in Node.js
Asynchronous File Write/Read in Node.js
Global Objects and Environment Variables in **Node**
The built-in Node debugger
Handle `JSON.parse` error in Node.js
```
|
```html
<!DOCTYPE html>
<html xmlns="path_to_url"><head><title>Conv3D (owl.Owl_neural.S.Graph.Neuron.Conv3D)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 2.4.2"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> <a href="../../../../../index.html">owl</a> » <a href="../../../../index.html">Owl_neural</a> » <a href="../../../index.html">S</a> » <a href="../../index.html">Graph</a> » <a href="../index.html">Neuron</a> » Conv3D</nav><header class="odoc-preamble"><h1>Module <code><span>Neuron.Conv3D</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-neuron_typ"><a href="#type-neuron_typ" class="anchor"></a><code><span><span class="keyword">type</span> neuron_typ</span><span> =
<a href="../../../../../../owl-base/Owl_neural_generic/Make_Embedded/Neuron/Conv3D/index.html#type-neuron_typ">Owl_neural_generic.Make_Embedded(Owl_algodiff_primal_ops.S).Neuron.Conv3D.neuron_typ</a></span><span> =
</span><span>{</span></code><ol><li id="type-neuron_typ.w" class="def record field anchored"><a href="#type-neuron_typ.w" class="anchor"></a><code><span><span class="keyword">mutable</span> w : <a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a>;</span></code></li><li id="type-neuron_typ.b" class="def record field anchored"><a href="#type-neuron_typ.b" class="anchor"></a><code><span><span class="keyword">mutable</span> b : <a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a>;</span></code></li><li id="type-neuron_typ.kernel" class="def record field anchored"><a href="#type-neuron_typ.kernel" class="anchor"></a><code><span><span class="keyword">mutable</span> kernel : <span>int array</span>;</span></code></li><li id="type-neuron_typ.stride" class="def record field anchored"><a href="#type-neuron_typ.stride" class="anchor"></a><code><span><span class="keyword">mutable</span> stride : <span>int array</span>;</span></code></li><li id="type-neuron_typ.padding" class="def record field anchored"><a href="#type-neuron_typ.padding" class="anchor"></a><code><span><span class="keyword">mutable</span> padding : <a href="../../../../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a>;</span></code></li><li id="type-neuron_typ.init_typ" class="def record field anchored"><a href="#type-neuron_typ.init_typ" class="anchor"></a><code><span><span class="keyword">mutable</span> init_typ : <a href="../Init/index.html#type-typ">Init.typ</a>;</span></code></li><li id="type-neuron_typ.in_shape" class="def record field anchored"><a href="#type-neuron_typ.in_shape" class="anchor"></a><code><span><span class="keyword">mutable</span> in_shape : <span>int array</span>;</span></code></li><li id="type-neuron_typ.out_shape" class="def record field anchored"><a href="#type-neuron_typ.out_shape" class="anchor"></a><code><span><span class="keyword">mutable</span> out_shape : <span>int array</span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create :
<span><span class="optlabel">?inputs</span>:<span>int array</span> <span class="arrow">-></span></span>
<span><a href="../../../../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="../Init/index.html#type-typ">Init.typ</a> <span class="arrow">-></span></span>
<a href="#type-neuron_typ">neuron_typ</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-connect"><a href="#val-connect" class="anchor"></a><code><span><span class="keyword">val</span> connect : <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mktag"><a href="#val-mktag" class="anchor"></a><code><span><span class="keyword">val</span> mktag : <span>int <span class="arrow">-></span></span> <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mkpar"><a href="#val-mkpar" class="anchor"></a><code><span><span class="keyword">val</span> mkpar : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <span><a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mkpri"><a href="#val-mkpri" class="anchor"></a><code><span><span class="keyword">val</span> mkpri : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <span><a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mkadj"><a href="#val-mkadj" class="anchor"></a><code><span><span class="keyword">val</span> mkadj : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <span><a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <span><span><a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a> array</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <a href="#type-neuron_typ">neuron_typ</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run"><a href="#val-run" class="anchor"></a><code><span><span class="keyword">val</span> run : <span><a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a> <span class="arrow">-></span></span> <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> <a href="../Optimise/Algodiff/index.html#type-t">Optimise.Algodiff.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-neuron_typ">neuron_typ</a> <span class="arrow">-></span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_name"><a href="#val-to_name" class="anchor"></a><code><span><span class="keyword">val</span> to_name : <span>unit <span class="arrow">-></span></span> string</span></code></div></div></div></body></html>
```
|
Vibeuf () is a commune in the Seine-Maritime department in the Normandy region in northern France.
Geography
A farming village situated in the Pays de Caux, some northwest of Rouen near the junction of the D263 with the D142 road.
Population
Places of interest
The church of St. Martin, dating from the nineteenth century.
A medieval fortified manorhouse.
See also
Communes of the Seine-Maritime department
References
External links
Official commune website
Communes of Seine-Maritime
|
```objective-c
// This file is part of libigl, a simple c++ geometry processing library.
//
//
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at path_to_url
#ifndef IGL_FRAME_TO_CROSS_FIELD_H
#define IGL_FRAME_TO_CROSS_FIELD_H
#include "igl_inline.h"
#include <Eigen/Dense>
namespace igl
{
// Convert a frame field into its closest cross field
// Inputs:
// V #V by 3 coordinates of the vertices
// F #F by 3 list of mesh faces (must be triangles)
// FF1 #F by 3 the first representative vector of the frame field (up to permutation and sign)
// FF2 #F by 3 the second representative vector of the frame field (up to permutation and sign)
//
// Outputs:
// X #F by 3 representative vector of the closest cross field
//
IGL_INLINE void frame_to_cross_field(
const Eigen::MatrixXd& V,
const Eigen::MatrixXi& F,
const Eigen::MatrixXd& FF1,
const Eigen::MatrixXd& FF2,
Eigen::MatrixXd& X);
}
#ifndef IGL_STATIC_LIBRARY
# include "frame_to_cross_field.cpp"
#endif
#endif
```
|
```hlsl
Texture2D eye : register(t0);
SamplerState EyeSampler
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Clamp;
AddressV = Clamp;
};
float4 main(in float4 pos : SV_POSITION, in float2 tex : TEXCOORD0) : SV_TARGET
{
return eye.Sample(EyeSampler, tex);
}
```
|
The Mbum or Kebi-Benue languages (also known as Lakka in narrower scope) are a group of the Mbum–Day branch of the Adamawa languages, spoken in southern Chad, northwestern Central African Republic, northern Cameroon and eastern Nigeria. Their best-known member is Mbum; other languages in the group include Tupuri and Kare.
They were labeled "G6" in Joseph Greenberg's Adamawa language-family proposal.
Languages
Southern Mbum: Mbum proper, Mbere, Gbete
South West Mbum : [Limbum of the Wimbum]
Central Mbum
Karang: Karang (Mbum, Laka), Nzakambay (Njak Mbai), Pana, Ngumi, Kare (Kãrɛ̃)
Koh: Kuo (Koh), Sakpu
Northern Mbum
Dama–Galke: Dama, Ndai (Galke, Pormi), Mono, Kali
Tupuri–Mambai: Mangbai, Mundang, Tupuri
In addition, Pondo, Gonge, Tale, Laka, Pam and To are unclassified within Mbum. To is a secret male initiation language of the Gbaya. Dek is purported in some sources but apparently unattested.
La'bi, an esoteric ritual language of male initiation among the Gbaya Kara, the Mbum, and some Sara Laka, is related to Mbum. It has substantial loans from one or more Sara languages. Other initiation languages in the Mbum family are To (Gbaya, but with partial Mbum origins), Dzel, and Ngarage.
See also
List of Proto-Lakka reconstructions (Wiktionary)
References
Roger Blench, 2004. List of Adamawa languages (ms)
External links
A sociolinguistic survey of the Mambay language of Chad and Cameroon (PDF) by Cameron Hamm, 2002. SIL Electronic Survey Reports SILESR 2002–039.
Mbum–Day languages
|
```html
<!-- Search accordion for /api/v1/hosts/<id> (filtering task results) -->
{% load datetime_formatting %}
{% if not static_generation %}
<div class="col-xl-6 offset-xl-3">
<div class="accordion" id="search_accordion">
<div class="accordion-item">
<h2 class="accordion-header">
<button class="accordion-button text-bg-ara {% if not expand_search %}collapsed{% endif %}" type="button" data-bs-toggle="collapse" data-bs-target="#search_host_results" aria-expanded="{% if expand_search %}true{% else %}false{% endif %}" aria-controls="search_host_results">
<svg xmlns="path_to_url" width="16" height="16" fill="currentColor" class="bi bi-search" viewBox="0 0 16 16">
<path d="M11.742 10.344a6.5 6.5 0 1 0-1.397 1.398h-.001c.03.04.062.078.098.115l3.85 3.85a1 1 0 0 0 1.415-1.414l-3.85-3.85a1.007 1.007 0 0 0-.115-.1zM12 6.5a5.5 5.5 0 1 1-11 0 5.5 5.5 0 0 1 11 0z"></path>
</svg>
Search and filter host results
</button>
</h2>
<div id="search_host_results" class="accordion-collapse collapse {% if expand_search %}show{% endif %}" data-bs-parent="#search_host_results">
<div class="accordion-body">
<form method="get" action="{% url 'ui:host' host.id %}#results">
<!-- task name -->
<div class="row g-2">
<div class="col-md">
<div class="form-floating">
<input type="text" class="form-control" id="task_name" name="task_name" placeholder="ex: Install httpd" value="{{ search_form.task_name.value | default_if_none:'' }}">
<label for="task_name" {% if request.GET.task_name %}style="font-weight:bold;"{% endif %}>Task name</label>
</div>
</div>
</div>
<br />
<!-- Result status -->
<div class="row g-2">
<div class="col-md">
<label for="status" {% if request.GET.status %}style="font-weight:bold;"{% endif %}>Status: </label>
{% for value, text in search_form.status.field.choices %}
{% if value != "unknown" %}
<div class="form-check form-check-inline {% if value == 'completed' %}text-success{% elif value == 'failed' %}text-danger{% elif value == 'running' %}text-info{% else %}text-warning{% endif %}">
<input class="form-check-input" type="checkbox" id="{{ value }}" value="{{ value }}" name="status" {% if value in search_form.status.data %}checked{% endif %}>
<label class="form-check-label" for="{{ value }}">
{% include "partials/result_status_icon.html" with status=value %}
</label>
</div>
{% endif %}
{% endfor %}
</div>
</div>
<br />
<!-- include only changes -->
<div class="row g-2">
<div class="col-md">
<label class="align-middle" for="changed" {% if request.GET.changed %}style="font-weight:bold;"{% endif %}>Changed: </label>
<div class="form-check form-check-inline">
<input class="form-check-input" type="checkbox" id="changed" value="true" name="changed" {% if search_form.changed.value %}checked{% endif %}/>
<label class="form-check-label" for="changed">
<span class="btn btn-warning btn-sm ara-result-status-badge" title="Search changed results">
CHANGED
</span>
</label>
</div>
</div>
</div>
<br />
<!-- submit -->
<div class="row g-2">
<div class="col-md">
<button type="submit" class="btn btn-primary">Submit</button>
</div>
</div>
</form>
<!-- reset button -->
{% if request.GET %}
<br />
<div class="row g-2">
<div class="col-md">
<a class="btn btn-outline-danger" href="{% url 'ui:host' host.id %}#results" role="button">Reset</a>
</div>
</div>
{% endif %}
</div>
</div>
</div>
</div>
</div>
{% endif %}
```
|
```javascript
'use strict';
angular.module('app')
.controller('scheduledLogController', [ '$rootScope', '$scope', '$http', '$state',
function($rootScope, $scope, $http, $state) {
$scope.title = '';
$scope.param = { };
$scope.loading = false;
$scope.search = function () {
$scope.loading = true;
$.ajax({
type: 'get',
url : '/scheduled/read/log',
data: $scope.param
}).then(function(result) {
$scope.loading = false;
if (result.code == 200) {
$scope.pageInfo = result;
} else {
$scope.msg = result.msg;
}
$scope.$apply();
});
}
$scope.search();
$scope.clearSearch = function() {
$scope.param.keyword= null;
$scope.search();
}
$scope.disableItem = function(id, enable) {
}
//
$scope.pagination = function (page) {
$scope.param.pageNum=page;
$scope.search();
};
} ]);
```
|
```go
package copy
import (
"github.com/containers/image/signature"
"github.com/containers/image/transports"
"github.com/pkg/errors"
)
// createSignature creates a new signature of manifest using keyIdentity.
func (c *copier) createSignature(manifest []byte, keyIdentity string) ([]byte, error) {
mech, err := signature.NewGPGSigningMechanism()
if err != nil {
return nil, errors.Wrap(err, "Error initializing GPG")
}
defer mech.Close()
if err := mech.SupportsSigning(); err != nil {
return nil, errors.Wrap(err, "Signing not supported")
}
dockerReference := c.dest.Reference().DockerReference()
if dockerReference == nil {
return nil, errors.Errorf("Cannot determine canonical Docker reference for destination %s", transports.ImageName(c.dest.Reference()))
}
c.Printf("Signing manifest\n")
newSig, err := signature.SignDockerManifest(manifest, dockerReference.String(), mech, keyIdentity)
if err != nil {
return nil, errors.Wrap(err, "Error creating signature")
}
return newSig, nil
}
```
|
```shell
#!/bin/sh
#
# Run this script in a directory that contains a valid SQLite makefile in
# order to verify that unintentionally exported symbols.
#
make sqlite3.c
echo '****** Exported symbols from a build including RTREE && FTS4 ******'
gcc -c -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_RTREE \
-DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
sqlite3.c
nm sqlite3.o | grep " [TD] "
echo '****** Surplus symbols from a build including RTREE & FTS4 ******'
nm sqlite3.o | grep " [TD] " | grep -v " .*sqlite3_"
echo '****** Dependencies of the core. No extensions. No OS interface *******'
gcc -c -DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
-DSQLITE_OS_OTHER -DSQLITE_THREADSAFE=0 \
sqlite3.c
nm sqlite3.o | grep " U "
echo '****** Dependencies including RTREE & FTS4 *******'
gcc -c -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_RTREE \
-DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
sqlite3.c
nm sqlite3.o | grep " U "
```
|
```javascript
import { IS_BROWSER, HAS_PROMISE_SUPPORT, HAS_MUTATION_OBSERVER_SUPPORT } from '../constants/env'
import { getNoWarn } from './env'
/**
* Log a warning message to the console with BootstrapVue formatting
* @param {string} message
*/
export const warn = (message, source = null) => /* istanbul ignore next */ {
if (!getNoWarn()) {
console.warn(`[BootstrapVue warn]: ${source ? `${source} - ` : ''}${message}`)
}
}
/**
* Warn when no Promise support is given
* @param {string} source
* @returns {boolean} warned
*/
export const warnNotClient = source => {
/* istanbul ignore else */
if (IS_BROWSER) {
return false
} else {
warn(`${source}: Can not be called during SSR.`)
return true
}
}
/**
* Warn when no Promise support is given
* @param {string} source
* @returns {boolean} warned
*/
export const warnNoPromiseSupport = source => {
/* istanbul ignore else */
if (HAS_PROMISE_SUPPORT) {
return false
} else {
warn(`${source}: Requires Promise support.`)
return true
}
}
/**
* Warn when no MutationObserver support is given
* @param {string} source
* @returns {boolean} warned
*/
export const warnNoMutationObserverSupport = source => {
/* istanbul ignore else */
if (HAS_MUTATION_OBSERVER_SUPPORT) {
return false
} else {
warn(`${source}: Requires MutationObserver support.`)
return true
}
}
```
|
```c++
//////////////////////////////////////////////////////////////////////////////
//
// Detours Test Program (sltestp.cpp of sltestp.exe)
//
// Microsoft Research Detours Package
//
//
// Test the named-pipe-based connection to the syelog system-event logger.
//
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
#include "syelog.h"
VOID MyErrExit(PCSTR pszMsg)
{
fprintf(stderr, "Error %s: %ld\n", pszMsg, GetLastError());
exit(1);
}
DWORD main(int argc, char *argv[])
{
HANDLE hPipe;
SYELOG_MESSAGE Message;
BOOL fSuccess;
DWORD cbWritten, dwMode;
// Try to open a named pipe; wait for it, if necessary.
TIME_ZONE_INFORMATION tzi;
GetTimeZoneInformation(&tzi);
for (;;) {
hPipe = CreateFileW(SYELOG_PIPE_NAMEW, // pipe name
GENERIC_WRITE, // write access only
0, // no sharing
NULL, // no security attributes
OPEN_EXISTING, // opens existing pipe
0, // default attributes
NULL); // no template file
// Break if the pipe handle is valid.
if (hPipe != INVALID_HANDLE_VALUE)
break;
// Exit if an error other than ERROR_PIPE_BUSY occurs.
if (GetLastError() != ERROR_PIPE_BUSY)
MyErrExit("Could not open pipe");
// All pipe instances are busy, so wait for 1 seconds.
if (!WaitNamedPipeW(SYELOG_PIPE_NAMEW, 1000))
MyErrExit("Could not open pipe");
}
// The pipe connected; change to message-read mode.
dwMode = PIPE_READMODE_MESSAGE;
fSuccess = SetNamedPipeHandleState(hPipe, // pipe handle
&dwMode, // new pipe mode
NULL, // don't set maximum bytes
NULL); // don't set maximum time
if (!fSuccess)
MyErrExit("SetNamedPipeHandleState");
// Send a message to the pipe server.
memset(&Message, 0, sizeof(Message));
StringCchCopyA(Message.szMessage, ARRAYSIZE(Message.szMessage),
(argc > 1) ? argv[1] : "sltestp: hello world!");
Message.nFacility = SYELOG_FACILITY_APPLICATION;
Message.nSeverity = SYELOG_SEVERITY_INFORMATION;
Message.nProcessId = GetCurrentProcessId();
GetSystemTimeAsFileTime(&Message.ftOccurance);
PCSTR pszEnd = Message.szMessage;
for (; *pszEnd; pszEnd++) {
// no internal contents.
}
Message.nBytes = (USHORT)(pszEnd - ((PCSTR)&Message) + 1);
fSuccess = WriteFile(hPipe, // pipe handle
&Message, // message
Message.nBytes, // message length
&cbWritten, // bytes written
NULL); // not overlapped
if (! fSuccess)
MyErrExit("WriteFile");
CloseHandle(hPipe);
GetTimeZoneInformation(&tzi);
return 0;
}
```
|
```objective-c
/*****************************************************************************
This program is free software; you can redistribute it and/or modify it under
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
*****************************************************************************/
/********************************************************************//**
@file include/data0types.h
Some type definitions
Created 9/21/2000 Heikki Tuuri
*************************************************************************/
#ifndef data0types_h
#define data0types_h
/* SQL data field struct */
struct dfield_t;
/* SQL data tuple struct */
struct dtuple_t;
#endif
```
|
```lua
local ngx_var = ngx.var
local ngx_unescape_uri = ngx.unescape_uri
local next_ctx = ngx.ctx.next_ctx or {}
local type = type
local ipairs = ipairs
if type(next_ctx.replace_Mod) ~= "table" then
return
end
local token_dict = ngx.shared.token_dict
local optl = require("optl")
-- ngx.re.gsub ( ngx.re.sub)
local function ngx_2(reps,str_all)
for _,v in ipairs(reps) do
local tmp3 = optl.ngx_find(v[3])
if v[2] == "" then
str_all = ngx.re.gsub(str_all,v[1],tmp3)
else
str_all = ngx.re.gsub(str_all,v[1],tmp3,v[2])
end
end
ngx.arg[1] = str_all
token_dict:delete(token_tmp)
end
-- ngx.ctx.next_ctx.request_guid
local token_tmp = next_ctx.request_guid
if ngx.arg[1] ~= '' then --
local chunk = token_dict:get(token_tmp)
if not chunk then
chunk = ngx.arg[1]
token_dict:set(token_tmp,chunk,15)
else
chunk = chunk..ngx.arg[1]
token_dict:set(token_tmp,chunk,15)
end
end
local tmp_replace_mod = next_ctx.replace_Mod
if ngx.arg[2] then
ngx_2(tmp_replace_mod.replace_list,token_dict:get(token_tmp))
else
ngx.arg[1] = nil
end
```
|
```html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>buffered_read_stream::in_avail (1 of 2 overloads)</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../boost_asio.html" title="Boost.Asio">
<link rel="up" href="../in_avail.html" title="buffered_read_stream::in_avail">
<link rel="prev" href="../in_avail.html" title="buffered_read_stream::in_avail">
<link rel="next" href="overload2.html" title="buffered_read_stream::in_avail (2 of 2 overloads)">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../in_avail.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../in_avail.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../boost_asio.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="overload2.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_asio.reference.buffered_read_stream.in_avail.overload1"></a><a class="link" href="overload1.html" title="buffered_read_stream::in_avail (1 of 2 overloads)">buffered_read_stream::in_avail
(1 of 2 overloads)</a>
</h5></div></div></div>
<p>
Determine the amount of data that may be read without blocking.
</p>
<pre class="programlisting">std::size_t in_avail();
</pre>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
file LICENSE_1_0.txt or copy at <a href="path_to_url" target="_top">path_to_url
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../in_avail.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../in_avail.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../boost_asio.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="overload2.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
Phyllonorycter viminetorum is a moth of the family Gracillariidae. It is found from Latvia to the Pyrenees and Italy and from Ireland to Ukraine.
The wingspan is 8–9 mm. The antennae with the apex
whitish. Forewings golden-brown, sprinkled with dark fuscous; a slender white median streak from base to near middle; a triangular white dorsal spot at 1/3 reaching basal streak; an angulated sometimes interrupted median fascia, three ill-defined posterior costal and two dorsal spots white, anteriorly dark margined; an elongate blackish apical dot. Hindwings are dark grey. The larva is pale yellowish; dorsal line greenish; head pale brown.
The larvae feed on Salix viminalis. They mine the leaves of their host plant. They create a lower-surface tentiform mine close to the leaf margin and normally also close to the petiole. There are often two mines in a single leaf. The mine in contracted in a tube-like fashion. The pupa yellowish brown and there is no visible cocoon. The frass is deposited in a corner of the mine.
References
viminetorum
Moths of Europe
Moths described in 1854
|
Séraphine Louis, known as Séraphine de Senlis (Séraphine of Senlis; 3 September 1864 – 11 December 1942), was a French painter in the naïve style. Self-taught, she was inspired by her religious faith and by stained-glass church windows and other religious art. The intensity of her images, both in colour and replicative design, is sometimes interpreted as a reflection of her own psyche, walking a tightrope between ecstasy and mental illness.
Early life
Louis was born in Arsy (Oise) on 3 September 1864. Her father was a manual laborer and her mother came from a farmworking background. Louis's mother died on her first birthday and her father, who remarried, also died before she was seven; at which point, she came under the charge of her eldest sister. She first worked as a shepherdess but, by 1881, she was engaged as a domestic worker at the convent of the Sisters of Providence in Clermont, Oise. Beginning in 1901, she was employed as a housekeeper for middle-class families in the town of Senlis.
Career
In addition to her arduous day jobs, Louis painted by candlelight, largely in secret isolation, until her considerable body of work was discovered in 1912 by German art collector Wilhelm Uhde. While in Senlis, Uhde saw a still-life of apples at his neighbor's house and was astonished to learn that Louis, his housecleaner, was the artist. His support had barely begun to lift her horizons when he was forced to leave France in August 1914; the war between France and Germany had made him an unwelcome outsider in Senlis, much as Louis was, given her eccentric persona. They only re-established contact in 1927 when Uhde – back in France and living in Chantilly – visited an exhibition of local artists in Senlis and, seeing Louis's work, realized that she had survived and her art had flourished. Under Uhde's patronage, Louis began painting large canvases, some of them two meters high, and she achieved prominence as the naïve painter of her day. In 1929, Uhde organized an exhibition, "Painters of the Sacred Heart," that featured Louis's art, launching her into a period of financial success she had never known – and was ill prepared to manage. Then, in 1930, with the effects of the Great Depression destroying the finances of her patrons, Uhde had no choice but to stop buying her paintings.
Death
In 1932, Louis was admitted for chronic psychosis at Clermont's lunatic asylum, where her artistry found no outlet. Although Uhde reported that she had died in 1934, some
say that Louis actually lived until 1942 in a hospital annex at Villers-sous-Erquery, where she died friendless and alone. She was buried in a common grave.
After
Uhde continued to exhibit her work: in 1932, at the exhibition "The Modern Primitives" in Paris; in 1937–38 in an exhibition titled "The Popular Masters of Reality" which showed in Paris, Zurich, and New York (at the Museum of Modern Art); in 1942, at the "Primitives of the 20th Century" exhibition in Paris, and finally, in 1945, in a solo exhibition of her work in Paris.
Works
Louis's works are predominantly rich fantasies of intensely repeated and embellished floral arrangements. She used colours and pigments that she made herself from unusual and exotic ingredients she never revealed that have stood the test of time for durable vividness. Her paintings' surfaces have a matte, almost waxy appearance. Sometimes her signature (typically "S. Louis") was carved by knife, revealing a ground of contrasting colour. In some cases, she appears to have signed her paintings before painting them.
Louis was an artist consumed by an irrepressible urge to create, "this famous internal necessity of which Kandinsky spoke", terms employed by Bertrand Lorquin, conservator of the Musée Maillol in his introduction to the exhibition "Séraphine Louis dite Séraphine de Senlis" at the Musée Maillol in Paris, which ran from 1 October 2008 to 18 May 2009.
Legacy
Louis's paintings are exhibited in the Musée d'art de Senlis, the Musée d'art naïf in Nice, and the Musée d'Art moderne Lille Métropole in Villeneuve-d'Ascq.
In 2009, the French biographical film Séraphine by director Martin Provost won seven César Awards, including Best Film and Best Actress for Yolande Moreau who starred in the title role. The film explores the relationship between Louis and Wilhelm Uhde from their first encounter in 1912 until her days in the Clermont Asylum.
References
Bibliography
Wilhelm Uhde, Cinq Maitres Primitifs, pp. 127–139, Librairie Palmes (3, place Saint-Sulpice, Paris), Philippe Daudy Editeur, Paris, 1949
H M Gallot Séraphine, bouquetiére 'sans rivale' des fleurs maudites de l'instinct in L'Information artistique, N° 40, Etude de, pp 32, mai 1957
Jean-Pierre Foucher, Séraphine de Senlis, Éditions du Temps, coll., Paris, 1968, pp 124.
Alain Vircondelet, Séraphine de Senlis, Albin Michel, coll., Une Vie, Paris, 1986, pp 217, 8 p. de planches illustrées.
Alain Vircondelet, Séraphine : de la peinture à la folie, éditions Albin Michel, Paris, 2008, pp 211.
Françoise Cloarec, Séraphine : la vie rêvée de Séraphine de Senlis, Éditions Phébus, Paris, 2008, pp 172, 8 p. de planches illustrées .
Marie-Jo Bonnet, Séraphine Louis, un génie singulier, LM, Lesbia mag, N° 265, décembre 2008.
Catalogue de l'exposition Séraphine de Senlis, présentée à Paris, du 1st octobre 2008 au 5 janvier 2009, par la Fondation Dina Vierny et le Musée Maillol, avec la collaboration de la ville de Senlis. Textes de Bertrand Lorquin, Wilhelm Uhde et Jean-Louis Derenne. Publication : éditions Gallimard, Fondation Dina Vierny et Musée Maillol, Paris, 2008, pp 55, (Gallimard) ou (Fondation Dina Vierny et Musée Maillol).
External links
Exhibition "Séraphine de Senlis, de l'ombre à la lumière" au musée d'Art et d'Archéologie de Senlis, from 25 June 2014 to 26 January 2015
Musée d'Art et d'Archéologie de Senlis
Musée d'art naïf (M.A.N.) Beraut (near Toulouse) Biography
The Artists Photographie
Artnet
Her work at Musée Maillol
1864 births
1942 deaths
Outsider artists
Naïve painters
19th-century French painters
20th-century French painters
French women painters
People from Oise
20th-century French women artists
19th-century French women artists
Women outsider artists
|
```c
/**
******************************************************************************
* @file stm32f4xx_hal_flash.c
* @author MCD Application Team
* @brief FLASH HAL module driver.
* This file provides firmware functions to manage the following
* functionalities of the internal FLASH memory:
* + Program operations functions
* + Memory Control functions
* + Peripheral Errors functions
*
@verbatim
==============================================================================
##### FLASH peripheral features #####
==============================================================================
[..] The Flash memory interface manages CPU AHB I-Code and D-Code accesses
to the Flash memory. It implements the erase and program Flash memory operations
and the read and write protection mechanisms.
[..] The Flash memory interface accelerates code execution with a system of instruction
prefetch and cache lines.
[..] The FLASH main features are:
(+) Flash memory read operations
(+) Flash memory program/erase operations
(+) Read / write protections
(+) Prefetch on I-Code
(+) 64 cache lines of 128 bits on I-Code
(+) 8 cache lines of 128 bits on D-Code
##### How to use this driver #####
==============================================================================
[..]
This driver provides functions and macros to configure and program the FLASH
memory of all STM32F4xx devices.
(#) FLASH Memory IO Programming functions:
(++) Lock and Unlock the FLASH interface using HAL_FLASH_Unlock() and
HAL_FLASH_Lock() functions
(++) Program functions: byte, half word, word and double word
(++) There Two modes of programming :
(+++) Polling mode using HAL_FLASH_Program() function
(+++) Interrupt mode using HAL_FLASH_Program_IT() function
(#) Interrupts and flags management functions :
(++) Handle FLASH interrupts by calling HAL_FLASH_IRQHandler()
(++) Wait for last FLASH operation according to its status
(++) Get error flag status by calling HAL_SetErrorCode()
[..]
In addition to these functions, this driver includes a set of macros allowing
to handle the following operations:
(+) Set the latency
(+) Enable/Disable the prefetch buffer
(+) Enable/Disable the Instruction cache and the Data cache
(+) Reset the Instruction cache and the Data cache
(+) Enable/Disable the FLASH interrupts
(+) Monitor the FLASH flags status
@endverbatim
******************************************************************************
* @attention
*
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Includes your_sha256_hash--*/
#include "stm32f4xx_hal.h"
/** @addtogroup STM32F4xx_HAL_Driver
* @{
*/
/** @defgroup FLASH FLASH
* @brief FLASH HAL module driver
* @{
*/
#ifdef HAL_FLASH_MODULE_ENABLED
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/** @addtogroup FLASH_Private_Constants
* @{
*/
#define FLASH_TIMEOUT_VALUE 50000U /* 50 s */
/**
* @}
*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/** @addtogroup FLASH_Private_Variables
* @{
*/
/* Variable used for Erase sectors under interruption */
FLASH_ProcessTypeDef pFlash;
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/** @addtogroup FLASH_Private_Functions
* @{
*/
/* Program operations */
static void FLASH_Program_DoubleWord(uint32_t Address, uint64_t Data);
static void FLASH_Program_Word(uint32_t Address, uint32_t Data);
static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data);
static void FLASH_Program_Byte(uint32_t Address, uint8_t Data);
static void FLASH_SetErrorCode(void);
HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout);
/**
* @}
*/
/* Exported functions --------------------------------------------------------*/
/** @defgroup FLASH_Exported_Functions FLASH Exported Functions
* @{
*/
/** @defgroup FLASH_Exported_Functions_Group1 Programming operation functions
* @brief Programming operation functions
*
@verbatim
===============================================================================
##### Programming operation functions #####
===============================================================================
[..]
This subsection provides a set of functions allowing to manage the FLASH
program operations.
@endverbatim
* @{
*/
/**
* @brief Program byte, halfword, word or double word at a specified address
* @param TypeProgram Indicate the way to program at a specified address.
* This parameter can be a value of @ref FLASH_Type_Program
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed
*
* @retval HAL_StatusTypeDef HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data)
{
HAL_StatusTypeDef status = HAL_ERROR;
/* Process Locked */
__HAL_LOCK(&pFlash);
/* Check the parameters */
assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
if(status == HAL_OK)
{
if(TypeProgram == FLASH_TYPEPROGRAM_BYTE)
{
/*Program byte (8-bit) at a specified address.*/
FLASH_Program_Byte(Address, (uint8_t) Data);
}
else if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD)
{
/*Program halfword (16-bit) at a specified address.*/
FLASH_Program_HalfWord(Address, (uint16_t) Data);
}
else if(TypeProgram == FLASH_TYPEPROGRAM_WORD)
{
/*Program word (32-bit) at a specified address.*/
FLASH_Program_Word(Address, (uint32_t) Data);
}
else
{
/*Program double word (64-bit) at a specified address.*/
FLASH_Program_DoubleWord(Address, Data);
}
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
/* If the program operation is completed, disable the PG Bit */
FLASH->CR &= (~FLASH_CR_PG);
}
/* Process Unlocked */
__HAL_UNLOCK(&pFlash);
return status;
}
/**
* @brief Program byte, halfword, word or double word at a specified address with interrupt enabled.
* @param TypeProgram Indicate the way to program at a specified address.
* This parameter can be a value of @ref FLASH_Type_Program
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed
*
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data)
{
HAL_StatusTypeDef status = HAL_OK;
/* Process Locked */
__HAL_LOCK(&pFlash);
/* Check the parameters */
assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
/* Enable End of FLASH Operation interrupt */
__HAL_FLASH_ENABLE_IT(FLASH_IT_EOP);
/* Enable Error source interrupt */
__HAL_FLASH_ENABLE_IT(FLASH_IT_ERR);
pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAM;
pFlash.Address = Address;
if(TypeProgram == FLASH_TYPEPROGRAM_BYTE)
{
/*Program byte (8-bit) at a specified address.*/
FLASH_Program_Byte(Address, (uint8_t) Data);
}
else if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD)
{
/*Program halfword (16-bit) at a specified address.*/
FLASH_Program_HalfWord(Address, (uint16_t) Data);
}
else if(TypeProgram == FLASH_TYPEPROGRAM_WORD)
{
/*Program word (32-bit) at a specified address.*/
FLASH_Program_Word(Address, (uint32_t) Data);
}
else
{
/*Program double word (64-bit) at a specified address.*/
FLASH_Program_DoubleWord(Address, Data);
}
return status;
}
/**
* @brief This function handles FLASH interrupt request.
* @retval None
*/
void HAL_FLASH_IRQHandler(void)
{
uint32_t addresstmp = 0U;
/* Check FLASH operation error flags */
#if defined(FLASH_SR_RDERR)
if(__HAL_FLASH_GET_FLAG((FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | \
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR | FLASH_FLAG_RDERR)) != RESET)
#else
if(__HAL_FLASH_GET_FLAG((FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | \
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR)) != RESET)
#endif /* FLASH_SR_RDERR */
{
if(pFlash.ProcedureOnGoing == FLASH_PROC_SECTERASE)
{
/*return the faulty sector*/
addresstmp = pFlash.Sector;
pFlash.Sector = 0xFFFFFFFFU;
}
else if(pFlash.ProcedureOnGoing == FLASH_PROC_MASSERASE)
{
/*return the faulty bank*/
addresstmp = pFlash.Bank;
}
else
{
/*return the faulty address*/
addresstmp = pFlash.Address;
}
/*Save the Error code*/
FLASH_SetErrorCode();
/* FLASH error interrupt user callback */
HAL_FLASH_OperationErrorCallback(addresstmp);
/*Stop the procedure ongoing*/
pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
}
/* Check FLASH End of Operation flag */
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP) != RESET)
{
/* Clear FLASH End of Operation pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
if(pFlash.ProcedureOnGoing == FLASH_PROC_SECTERASE)
{
/*Nb of sector to erased can be decreased*/
pFlash.NbSectorsToErase--;
/* Check if there are still sectors to erase*/
if(pFlash.NbSectorsToErase != 0U)
{
addresstmp = pFlash.Sector;
/*Indicate user which sector has been erased*/
HAL_FLASH_EndOfOperationCallback(addresstmp);
/*Increment sector number*/
pFlash.Sector++;
addresstmp = pFlash.Sector;
FLASH_Erase_Sector(addresstmp, pFlash.VoltageForErase);
}
else
{
/*No more sectors to Erase, user callback can be called.*/
/*Reset Sector and stop Erase sectors procedure*/
pFlash.Sector = addresstmp = 0xFFFFFFFFU;
pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
/* Flush the caches to be sure of the data consistency */
FLASH_FlushCaches() ;
/* FLASH EOP interrupt user callback */
HAL_FLASH_EndOfOperationCallback(addresstmp);
}
}
else
{
if(pFlash.ProcedureOnGoing == FLASH_PROC_MASSERASE)
{
/* MassErase ended. Return the selected bank */
/* Flush the caches to be sure of the data consistency */
FLASH_FlushCaches() ;
/* FLASH EOP interrupt user callback */
HAL_FLASH_EndOfOperationCallback(pFlash.Bank);
}
else
{
/*Program ended. Return the selected address*/
/* FLASH EOP interrupt user callback */
HAL_FLASH_EndOfOperationCallback(pFlash.Address);
}
pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
}
}
if(pFlash.ProcedureOnGoing == FLASH_PROC_NONE)
{
/* Operation is completed, disable the PG, SER, SNB and MER Bits */
CLEAR_BIT(FLASH->CR, (FLASH_CR_PG | FLASH_CR_SER | FLASH_CR_SNB | FLASH_MER_BIT));
/* Disable End of FLASH Operation interrupt */
__HAL_FLASH_DISABLE_IT(FLASH_IT_EOP);
/* Disable Error source interrupt */
__HAL_FLASH_DISABLE_IT(FLASH_IT_ERR);
/* Process Unlocked */
__HAL_UNLOCK(&pFlash);
}
}
/**
* @brief FLASH end of operation interrupt callback
* @param ReturnValue The value saved in this parameter depends on the ongoing procedure
* Mass Erase: Bank number which has been requested to erase
* Sectors Erase: Sector which has been erased
* (if 0xFFFFFFFFU, it means that all the selected sectors have been erased)
* Program: Address which was selected for data program
* @retval None
*/
__weak void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(ReturnValue);
/* NOTE : This function Should not be modified, when the callback is needed,
the HAL_FLASH_EndOfOperationCallback could be implemented in the user file
*/
}
/**
* @brief FLASH operation error interrupt callback
* @param ReturnValue The value saved in this parameter depends on the ongoing procedure
* Mass Erase: Bank number which has been requested to erase
* Sectors Erase: Sector number which returned an error
* Program: Address which was selected for data program
* @retval None
*/
__weak void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(ReturnValue);
/* NOTE : This function Should not be modified, when the callback is needed,
the HAL_FLASH_OperationErrorCallback could be implemented in the user file
*/
}
/**
* @}
*/
/** @defgroup FLASH_Exported_Functions_Group2 Peripheral Control functions
* @brief management functions
*
@verbatim
===============================================================================
##### Peripheral Control functions #####
===============================================================================
[..]
This subsection provides a set of functions allowing to control the FLASH
memory operations.
@endverbatim
* @{
*/
/**
* @brief Unlock the FLASH control register access
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_Unlock(void)
{
HAL_StatusTypeDef status = HAL_OK;
if(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != RESET)
{
/* Authorize the FLASH Registers access */
WRITE_REG(FLASH->KEYR, FLASH_KEY1);
WRITE_REG(FLASH->KEYR, FLASH_KEY2);
/* Verify Flash is unlocked */
if(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != RESET)
{
status = HAL_ERROR;
}
}
return status;
}
/**
* @brief Locks the FLASH control register access
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_Lock(void)
{
/* Set the LOCK Bit to lock the FLASH Registers access */
FLASH->CR |= FLASH_CR_LOCK;
return HAL_OK;
}
/**
* @brief Unlock the FLASH Option Control Registers access.
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void)
{
if((FLASH->OPTCR & FLASH_OPTCR_OPTLOCK) != RESET)
{
/* Authorizes the Option Byte register programming */
FLASH->OPTKEYR = FLASH_OPT_KEY1;
FLASH->OPTKEYR = FLASH_OPT_KEY2;
}
else
{
return HAL_ERROR;
}
return HAL_OK;
}
/**
* @brief Lock the FLASH Option Control Registers access.
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_OB_Lock(void)
{
/* Set the OPTLOCK Bit to lock the FLASH Option Byte Registers access */
FLASH->OPTCR |= FLASH_OPTCR_OPTLOCK;
return HAL_OK;
}
/**
* @brief Launch the option byte loading.
* @retval HAL Status
*/
HAL_StatusTypeDef HAL_FLASH_OB_Launch(void)
{
/* Set the OPTSTRT bit in OPTCR register */
*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;
/* Wait for last operation to be completed */
return(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE));
}
/**
* @}
*/
/** @defgroup FLASH_Exported_Functions_Group3 Peripheral State and Errors functions
* @brief Peripheral Errors functions
*
@verbatim
===============================================================================
##### Peripheral Errors functions #####
===============================================================================
[..]
This subsection permits to get in run-time Errors of the FLASH peripheral.
@endverbatim
* @{
*/
/**
* @brief Get the specific FLASH error flag.
* @retval FLASH_ErrorCode: The returned value can be a combination of:
* @arg HAL_FLASH_ERROR_RD: FLASH Read Protection error flag (PCROP)
* @arg HAL_FLASH_ERROR_PGS: FLASH Programming Sequence error flag
* @arg HAL_FLASH_ERROR_PGP: FLASH Programming Parallelism error flag
* @arg HAL_FLASH_ERROR_PGA: FLASH Programming Alignment error flag
* @arg HAL_FLASH_ERROR_WRP: FLASH Write protected error flag
* @arg HAL_FLASH_ERROR_OPERATION: FLASH operation Error flag
*/
uint32_t HAL_FLASH_GetError(void)
{
return pFlash.ErrorCode;
}
/**
* @}
*/
/**
* @brief Wait for a FLASH operation to complete.
* @param Timeout maximum flash operationtimeout
* @retval HAL Status
*/
HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout)
{
uint32_t tickstart = 0U;
/* Clear Error Code */
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
/* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
Even if the FLASH operation fails, the BUSY flag will be reset and an error
flag will be set */
/* Get tick */
tickstart = HAL_GetTick();
while(__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY) != RESET)
{
if(Timeout != HAL_MAX_DELAY)
{
if((Timeout == 0U)||((HAL_GetTick() - tickstart ) > Timeout))
{
return HAL_TIMEOUT;
}
}
}
/* Check FLASH End of Operation flag */
if (__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP) != RESET)
{
/* Clear FLASH End of Operation pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
}
#if defined(FLASH_SR_RDERR)
if(__HAL_FLASH_GET_FLAG((FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | \
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR | FLASH_FLAG_RDERR)) != RESET)
#else
if(__HAL_FLASH_GET_FLAG((FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | \
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR)) != RESET)
#endif /* FLASH_SR_RDERR */
{
/*Save the error code*/
FLASH_SetErrorCode();
return HAL_ERROR;
}
/* If there is no error flag set */
return HAL_OK;
}
/**
* @brief Program a double word (64-bit) at a specified address.
* @note This function must be used when the device voltage range is from
* 2.7V to 3.6V and Vpp in the range 7V to 9V.
*
* @note If an erase and a program operations are requested simultaneously,
* the erase operation is performed before the program one.
*
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed.
* @retval None
*/
static void FLASH_Program_DoubleWord(uint32_t Address, uint64_t Data)
{
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* If the previous operation is completed, proceed to program the new data */
CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
FLASH->CR |= FLASH_PSIZE_DOUBLE_WORD;
FLASH->CR |= FLASH_CR_PG;
/* Program first word */
*(__IO uint32_t*)Address = (uint32_t)Data;
/* Barrier to ensure programming is performed in 2 steps, in right order
(independently of compiler optimization behavior) */
__ISB();
/* Program second word */
*(__IO uint32_t*)(Address+4) = (uint32_t)(Data >> 32);
}
/**
* @brief Program word (32-bit) at a specified address.
* @note This function must be used when the device voltage range is from
* 2.7V to 3.6V.
*
* @note If an erase and a program operations are requested simultaneously,
* the erase operation is performed before the program one.
*
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed.
* @retval None
*/
static void FLASH_Program_Word(uint32_t Address, uint32_t Data)
{
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* If the previous operation is completed, proceed to program the new data */
CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
FLASH->CR |= FLASH_PSIZE_WORD;
FLASH->CR |= FLASH_CR_PG;
*(__IO uint32_t*)Address = Data;
}
/**
* @brief Program a half-word (16-bit) at a specified address.
* @note This function must be used when the device voltage range is from
* 2.1V to 3.6V.
*
* @note If an erase and a program operations are requested simultaneously,
* the erase operation is performed before the program one.
*
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed.
* @retval None
*/
static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data)
{
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* If the previous operation is completed, proceed to program the new data */
CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
FLASH->CR |= FLASH_PSIZE_HALF_WORD;
FLASH->CR |= FLASH_CR_PG;
*(__IO uint16_t*)Address = Data;
}
/**
* @brief Program byte (8-bit) at a specified address.
* @note This function must be used when the device voltage range is from
* 1.8V to 3.6V.
*
* @note If an erase and a program operations are requested simultaneously,
* the erase operation is performed before the program one.
*
* @param Address specifies the address to be programmed.
* @param Data specifies the data to be programmed.
* @retval None
*/
static void FLASH_Program_Byte(uint32_t Address, uint8_t Data)
{
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* If the previous operation is completed, proceed to program the new data */
CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
FLASH->CR |= FLASH_PSIZE_BYTE;
FLASH->CR |= FLASH_CR_PG;
*(__IO uint8_t*)Address = Data;
}
/**
* @brief Set the specific FLASH error flag.
* @retval None
*/
static void FLASH_SetErrorCode(void)
{
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_WRP;
/* Clear FLASH write protection error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_WRPERR);
}
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_PGA;
/* Clear FLASH Programming alignment error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_PGAERR);
}
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGPERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_PGP;
/* Clear FLASH Programming parallelism error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_PGPERR);
}
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGSERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_PGS;
/* Clear FLASH Programming sequence error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_PGSERR);
}
#if defined(FLASH_SR_RDERR)
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_RDERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_RD;
/* Clear FLASH Proprietary readout protection error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_RDERR);
}
#endif /* FLASH_SR_RDERR */
if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPERR) != RESET)
{
pFlash.ErrorCode |= HAL_FLASH_ERROR_OPERATION;
/* Clear FLASH Operation error pending bit */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPERR);
}
}
/**
* @}
*/
#endif /* HAL_FLASH_MODULE_ENABLED */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
```
|
Narasimha Purana (; ) is one of the Upapuranas. R.C. Hazra in his Studies in the Upapuranas came to the conclusion that the original text was written in the later part of the 5th century, though several portions of it were added much later. This work was translated into Telugu about 1300.
Content
The recension presented by the printed editions of the text has 68 chapters. The 8th chapter of the text is one of the three versions of the (other two versions are the Vishnu Purana, Book 3, ch.1-7 and the Agni Purana, Book 3, ch.381). The chapters 36-54 consist the narratives of the ten Avatars of Vishnu. Chapter 21 and 22 contain the short genealogical lists of the kings of the Surya Vamsha (Solar dynasty) and the Soma Vamsha (Lunar dynasty), the former ending with Buddha, son of Shuddhoana and the latter with Kshemaka, grandson of Udayana. Chapters 57-61 of this work is also found as an independent work, the Harita Samhita or Laghuharita Smriti.
See also
Markandeya
Narasimha
Puranas
References
Bibliography
External links
Narasimha Purana text in Devanagari script
Puranas
Vaishnava texts
|
Pavel Nikolayevich Balakshin (, born 10 July 1936) is a Russian politician. He was the first Head of Administration of his home region, Arkhangelsk Oblast, from 1991 to 1996.
Biography
Pavel Balakshin was born in the village of Dementyevo, Kotlassky District, Northern Krai (now Arkhangelsk Oblast) in a Russian working-class family. He began his career in 1952 at the Mir collective farm. He worked as a beacon, sailor, helmsman in the Northern river Shipping Company, then as a locksmith on the railway. From 1955 to 1958, he served in the Soviet Armed Forces as a mechanic of radar equipment. In 1959–85 he was working at the Kotlas Pulp and Paper Mill in Koryazhma. From 1987 to 1990 he was director general of Arkhangelsk Pulp and Paper Mill, Novodvinsk.
From 1990 to 1991 — Chairman of the Executive Committee of the Arkhangelsk Regional Council of People's Deputies. On 19 September 1991, by the Decree of the President of Russia Boris Yeltsin, Balakshin was appointed head of administration of Arkhangelsk Oblast. In December 1993 he was elected a deputy of the Federation Council of the first convocation from Arkhangelsk Oblast. During Balakshin's administration, in 1995, dismantling of nuclear submarines in Severodvinsk began along with removal of radioactive waste from the harbor.
In January 1996 he became a member of the second Federation Council. He was elected a member of its Committee on Federation Affairs, Treaty of Federation and Regional Policy. On February 21, Balakshin was ousted from his post by presidential decree "for gross violations when using targeted loans, allocated for the delivery of products to the regions of the Far North." On 15 March 1996, Balakshin was removed from the Federation Council.
On 8 December 1996 Pavel Balakshin became the first mayor of Arkhangelsk to be directly elected. He had occupied this position for the next four years.
Awards
Order "For Merit to the Fatherland" 4th class (6 January 1999) — for services to the state, high achievements in production activities and a great contribution to strengthening friendship and cooperation between the nations
Honorary Citizen of the city of Arkhangelsk (28 April 2011)
Order of the Red Banner of Labor
Order of the October Revolution
USSR State Prize in science and technology (1982, as a part of collective) — for the development of new technologies for the production of paper and cardboard
References
1936 births
Living people
Governors of Arkhangelsk Oblast
Mayors of Arkhangelsk
Members of the Federation Council of Russia (1994–1996)
Members of the Federation Council of Russia (1996–2000)
Our Home – Russia politicians
People from Kotlassky District
|
The Maligawatta stampede was a fatal incident which occurred on 21 May 2020, near a Muslim Jumma residence in Maligawatta, Colombo-10, amid lockdown and curfew which was imposed in the area due to COVID-19 pandemic in the country. The incident happened around 1:00pm while charity donation program was conducted to distribute money for the Maligawatta area residents on the eve of Ramadan.
Incident
Nearly 300-400 people were reported to have gathered in a queue during a private charity donation program conducted by businessman Zarook Hajiyar based in Dehiwala with the purpose of distributing money at least Rs. 5000 per person for the area residents, especially to the poor. Around three women were killed due to the stampede and it was revealed that it happened due to the panic situation and careless behaviour among women. Nine people were severely injured including seven women and four women who were injured in the stampede have been reported to be in critical condition after being admitted to the Colombo National Hospital.
Six suspects who were involved in relief distribution were arrested mainly for conducting such an event amid coronavirus and for not maintaining proper hygienic measures, ignoring the ban on public gatherings. Suspects related to the incident were remanded until 4 June.
References
History of Colombo District
Human stampedes in 2020
Human stampedes in Asia
Man-made disasters in Sri Lanka
May 2020 events in Asia
2020 disasters in Sri Lanka
|
Head lice infestation, also known as pediculosis capitis, is the infection of the head hair and scalp by the head louse (Pediculus humanus capitis). Itching from lice bites is common. During a person's first infection, the itch may not develop for up to six weeks. If a person is infected again, symptoms may begin much more quickly. The itch may cause problems with sleeping. Generally, however, it is not a serious condition. While head lice appear to spread some other diseases in Africa, they do not appear to do so in Europe or North America.
Head lice are spread by direct contact with the hair of someone who is infected. The cause of head lice infestations in children is not related to cleanliness. Other animals, such as cats and dogs, do not play a role in transmission. Head lice feed only on human blood and are only able to survive on human head hair. When adults, they are about 2 to 3 mm long. When not attached to a human, they are unable to live beyond three days. Humans can also become infected with two other lice – the body louse and the crab louse. To make the diagnosis, live lice must be found. Using a comb can help with detection. Empty eggshells (known as nits) are not sufficient for the diagnosis.
Possible treatments include: combing the hair frequently with a fine tooth comb or shaving the head completely. A number of topical medications are also effective, including malathion, ivermectin, and dimethicone. Dimethicone, which is a silicone oil, is often preferred due to the low risk of side effects. Pyrethroids such as permethrin have been commonly used; however, they have become less effective due to increasing pesticide resistance. There is little evidence for alternative medicines.
Head-lice infestations are common, especially in children. In Europe, they infect between 1 and 20% of different groups of people. In the United States, between 6 and 12 million children are infected a year. They occur more often in girls than boys. It has been suggested that historically, head lice infection were beneficial, as they protected against the more dangerous body louse. Infestations may cause stigmatization of the infected individual.
Signs and symptoms
Head lice are generally uncomfortable, but typically do not constitute a serious condition. The most common symptom is itching of the head, which normally worsens 3 to 4 weeks after the initial infestation. The bite reaction is very mild, and it can be rarely seen between the hairs. Bites can be seen, especially in the neck of long-haired individuals when the hair is pushed aside. Swelling of the local lymph nodes and fever are rare. Itching may cause skin breakdown and uncommonly result in a bacterial infection. Many individuals do not experience symptoms. Itching may take 2–6 weeks to develop upon first infestation, and sooner in subsequent infestations.
In Ethiopia, head lice appear to be able to spread louse-born epidemic typhus and Bartonella quintana. In Europe, the head lice do not appear to carry these infections.
Transmission
Head lice spreads through direct contact of the head of an infested person with the head of a non-infested person. The presence of live lice indicates an active infestation while the presence of nits indicates a past or currently inactive infection with the potential to become active. Head lice do not leap or spring as a means to transfer to their hosts; instead, they move by crawling. Transmission by indirect contact (e.g. sharing bedding, clothing, headwear, the same comb) is much less common. The cause of head lice infestations is not related to cleanliness. Neither hair length nor how often the hair is brushed affects the risk of infection. Pets are not vectors for head lice.
Other lice that infest humans are the body louse and the crab louse (aka pubic lice). The claws of these three species are adapted to attach to specific hair diameters. Pubic lice are most often spread by sexual contact with an infested person. Body lice can be found on clothing and they are not known to burrow into the skin.
Diagnosis
The condition is diagnosed by finding live lice and unhatched eggs in the hair. Finding empty eggs is not enough. Dandruff, lint, sand, hair casts, and dried hairspray, can be mistaken for eggs and nits. This is made easier by using a magnifying glass or running a comb through the child's wet hair, the latter of which is the most assured method of diagnosis and can be used to monitor treatment. In questionable cases, a child can be referred to a health professional. However, head lice infestation is commonly overdiagnosed, with extinct infestations being mistaken for active ones. Infestations are only considered extinct if nits are more than 0.25 inches away from the scalp and nymphs and adult lice are absent. As a result, lice-killing treatments are more often used on non-infested than infested children. The use of a louse comb is the most effective way to detect living lice. With both methods, special attention should be paid to the area near the ears and the nape of the neck. The use of a magnifying glass to examine the material collected between the teeth of the comb could prevent misdiagnosis.
The presence of nits alone, however, is not an accurate indicator of an active head louse infestation. Generally, white nits are empty egg casings, while brown nits may still contain viable louse larva. One way of determining the nit is to squeeze it between two fingernails; it gives a characteristic snapping pop sound as the egg bursts. Children with nits on their hair have a 35–40% chance of also being infested with living lice and eggs. If lice are detected, the entire family needs to be checked (especially children up to the age of 13 years) with a louse comb, and only those who are infested with living lice should be treated. As long as no living lice are detected, the child should be considered negative for head louse infestation. Accordingly, a child should be treated with a pediculicide only when living lice are detected on their hair (not because he/she has louse eggs/nits on the hair and not because the scalp is itchy).
Prevention
Examination of the child's head at regular intervals using a louse comb allows the diagnosis of louse infestation at an early stage. Early diagnosis makes treatment easier and reduces the possibility of infesting others. In times and areas when louse infestations are common, weekly examinations of children, especially those 4–15 years old, carried out by their parents, will aid control. Additional examinations are necessary if the child came in contact with infested individuals, if the child frequently scratches their head, or if nits suddenly appear on the child's hair.
Clothes, towels, bedding, combs, and brushes, which came in contact with the infested individual, can be disinfected either by leaving them outside for at least two days or by washing them at 60 °C (140 °F) for 30 minutes. This is because adult lice can survive only one to two days without a blood meal and are highly dependent on human body warmth.
Treatment
There are a number of treatments effective for head lice. These methods include combs, shaving, medical creams, and hot air. Medical creams usually require two treatments a week apart. Head lice are not justification to keep children home from school as the risk of spread is low.
Mechanical measures
Wet combing (mechanical removal of lice through combing wet hair) can be used as treatment measure for those who are too young for pediculicide treatment, which is intended for 6 years of age or older. Wet combing a few times a day for a few weeks may also get rid of the infestation in half of people. This requires the use of a special lice comb with extra fine teeth. This is the recommended method for infants and women who are pregnant. Shaving the head can also effectively treat lice.
Another treatment is the use of heated air applied by a hair dryer. This can be of special use in the early stages of an infestation, since it has very high mortality for eggs.
Medications
There are many medications which can kill lice. Dimethicone is between 70 and 97% effective with a low rate of side effects, and thus is seen as the preferred treatment. It works by physical means and there is no evidence of pesticide resistance. Ivermectin is around 80% effective, but can cause local skin irritation. Malathion has an effectiveness around 90%, but there's the possibility of toxicity. Pyrethroids such as permethrin, while commonly used, have lower rates of effectiveness due to the resistance among lice. Effectiveness varies from 10 to 80%, depending on the population studied. Medications within a lotion appear to work better than those within a shampoo. Benzyl alcohol appears effective but it is unclear if it is better than standard treatments. Abametapir was approved for medical use in the United States in July 2020.
Resistance to several commonly used treatments is increasing worldwide, with patterns of resistance varying by region. Head lice have demonstrated resistance to permethrin, malathion, phenothrin, and carbaryl in several countries around the world. A previous method used to delay resistance included utilizing a rotating list of recommended insecticides by health authorities. The mosaic model is the current recommendation, in which it is advised to use one product for a treatment course, followed by a different insecticide from another substance class if the first treatment fails.
Home remedies
Tea tree oil has been promoted as a treatment for head lice; however, there is no clear evidence of its effectiveness. A 2012 review of head lice treatment recommended against the use of tea tree oil for children because it could cause skin irritation or allergic reactions, because of contraindications, and because of a lack of knowledge about the oil's safety and effectiveness. Other home remedies, such as putting vinegar, isopropyl alcohol, olive oil, mayonnaise, or melted butter under a shower cap, have been disproven. The CDC states that swimming has no effect on drowning lice, and can decrease the effectiveness of some treatments.
Environment
After treatment, people are often instructed to wash all bedding and vacuum all areas the head may have been, such as car seats, coat hoods, and sofas, but this is not always necessary, since adult lice will die within 2 days without a blood meal, and newly hatched lice die within minutes of hatching. Combs and brushes may be deloused in boiling water for 5–10 minutes. Items may also be frozen for 24 hours well below the freezing point of water to ensure that ice crystals form within the cells of the lice.
Outbreak management
In addition to environmental management, an outbreak of head lice infestation requires synchronous treatment of all who are infested and evaluation of those who have been exposed or are suspected to have head lice. Synchronous ovoidal dimethicone treatment has been shown to successfully manage and terminate outbreaks, and a single treatment is likely sufficient. Other treatment methods can be repeated 8–10 days following initial treatment, and may sometimes require a third treatment. Outbreak status and treatment effectiveness can be monitored using the wet combing method.
Epidemiology
The number of cases of human louse infestations (or pediculosis) has increased worldwide since the mid-1960s, reaching hundreds of millions annually. It is estimated between 1 and 20% of specific groups in Europe are infected.
Despite improvements in medical treatment and prevention of human diseases during the 20th century, head louse infestation remains stubbornly prevalent. In 1997, 80% of American elementary schools reported at least one outbreak of lice. Lice infestation during that same period was more prevalent than chickenpox.
About 6–12 million children between the ages of 3 and 11 are treated annually for head lice in the United States alone. High levels of louse infestations have also been reported from all over the world, including Israel, Denmark, Sweden, U.K., France, and Australia.
The United Kingdom's National Health Service report that lice have no preference for any type of hair be it clean, dirty, or short. The number of children per family, the sharing of beds and closets, hair washing habits, local customs and social contacts, healthcare in a particular area (e.g. school), and socioeconomic status were found to be factors in head louse infestation in Iran. Other studies found no relationship between frequency of brushing or shampooing. The California Department of Public Health indicates that chronic head lice infestation may be a sign of socioeconomic or family problems. Children between 4 and 13 years of age are the most frequently infested group. In the U.S., African-American children have lower rates of infestation.
Head lice (Pediculus humanus capitis) infestation is most frequent on children aged 3–10 and their families. Females get head lice twice as often as males, and infestation in persons of Afro-Caribbean or other black descent could be rare due to difference in hair shape or width. But these children may have nits that hatch and the live lice could be transferred by head contact to other children.
Stigma
Head lice infestations are notably common, as is the stigma associated with those who experience infestations. Such stigma is even evidenced in the English language as the term "lousy", an adjective that describes something as very poor, bad, or disgusting. Misperceptions of those infected with head lice include that it is associated with low socioeconomic status, poor hygiene, unhealthiness, immigration status, and homelessness. Though these negative beliefs are unfounded, they can lead to consequences for both the caregivers and the affected individual, such as social exclusion and isolation from peers, victim-blaming, caregiver strain, inappropriate or unsafe treatment practices, and missed work or school.
Public-health implications
Over-treatment or mismanagement of head lice, which can be driven by stigma, has important implications at the level of the individual and community. Though evidence-based guidelines from the CDC, American Academy of Pediatrics (AAP) and National Association of School Nurses (NASN) all recommend discontinuing "no-nit" policies in schools (meaning that a child does not need to be free of nits before returning to school), 80 percent of schools in the United States still maintain stringent policies that prevent children with infestations from attending. Thus, to foster a return to school in a timely fashion, these policies can encourage unsafe or harsh treatment practices, including chemicals like bleach or kerosene. Similarly, over-treatment of head-lice using pesticide-based pediculicides has been linked to increased resistance and declining efficacy of these treatments.
Society and culture
To a Louse (on a lady's bonnet). Perhaps the most widely known cultural reference to pediculosis capitis, occurring in a noted poem by Robert Burns.
Other animals
Lice infestation in general is known as pediculosis, and occurs in many mammalian and bird species. Lice infesting other host species are not the same organism as that which causes head lice infestations in humans, nor do the three louse species which infest humans infest any other host species.
References
External links
CDC: Head lice
Parasitic infestations, stings, and bites of the skin
Arthropod infestations
Wikipedia medicine articles ready to translate
Wikipedia emergency medicine articles ready to translate
|
Cádiz is one of the eight constituencies () represented in the Parliament of Andalusia, the regional legislature of the Autonomous Community of Andalusia. The constituency currently elects 15 deputies. Its boundaries correspond to those of the Spanish province of Cádiz. The electoral system uses the D'Hondt method and a closed-list proportional representation, with a minimum threshold of three percent.
Electoral system
The constituency was created as per the Statute of Autonomy for Andalusia of 1981 and was first contested in the 1982 regional election. The Statute provided for the eight provinces in Andalusia—Almería, Cádiz, Córdoba, Granada, Huelva, Jaén, Málaga and Seville—to be established as multi-member districts in the Parliament of Andalusia, with this regulation being maintained under the 1986 regional electoral law. Each constituency is entitled to an initial minimum of eight seats, with the remaining 45 being distributed in proportion to their populations (provided that the number of seats in each province did not exceed two times that of any other). The exception was the 1982 election, when each constituency was allocated a fixed number of seats: 11 for Almería, 15 for Cádiz, 13 for Córdoba, 13 for Granada, 11 for Huelva, 13 for Jaén, 15 for Málaga and 18 for Seville.
Voting is on the basis of universal suffrage, which comprises all nationals over eighteen, registered in Andalusia and in full enjoyment of their political rights. Amendments to the electoral law in 2011 required for Andalusians abroad to apply for voting before being permitted to vote, a system known as "begged" or expat vote (). Seats are elected using the D'Hondt method and a closed list proportional representation, with an electoral threshold of three percent of valid votes—which includes blank ballots—being applied in each constituency. The use of the D'Hondt method may result in a higher effective threshold, depending on the district magnitude.
The electoral law allows for parties and federations registered in the interior ministry, coalitions and groupings of electors to present lists of candidates. Parties and federations intending to form a coalition ahead of an election are required to inform the relevant Electoral Commission within ten days of the election call—fifteen before 1985—whereas groupings of electors need to secure the signature of at least one percent of the electorate in the constituencies for which they seek election—one-thousandth of the electorate, with a compulsory minimum of 500 signatures, until 1985—disallowing electors from signing for more than one list of candidates.
Deputies
Elections
2022 regional election
2018 regional election
2015 regional election
2012 regional election
2008 regional election
2004 regional election
2000 regional election
1996 regional election
1994 regional election
1990 regional election
1986 regional election
1982 regional election
References
Parliament of Andalusia constituencies
Province of Cádiz
Constituencies established in 1982
1982 establishments in Spain
|
```objective-c
// IStream.h
#ifndef __ISTREAM_H
#define __ISTREAM_H
#include "../Common/MyUnknown.h"
#include "../Common/Types.h"
#include "IDecl.h"
#define STREAM_INTERFACE_SUB(i, base, x) DECL_INTERFACE_SUB(i, base, 3, x)
#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)
STREAM_INTERFACE(ISequentialInStream, 0x01)
{
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;
/*
Out: if size != 0, return_value = S_OK and (*processedSize == 0),
then there are no more bytes in stream.
if (size > 0) && there are bytes in stream,
this function must read at least 1 byte.
This function is allowed to read less than number of remaining bytes in stream.
You must call Read function in loop, if you need exact amount of data
*/
};
STREAM_INTERFACE(ISequentialOutStream, 0x02)
{
STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;
/*
if (size > 0) this function must write at least 1 byte.
This function is allowed to write less than "size".
You must call Write function in loop, if you need to write exact amount of data
*/
};
STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)
{
STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
};
STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)
{
STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
STDMETHOD(SetSize)(Int64 newSize) PURE;
};
STREAM_INTERFACE(IStreamGetSize, 0x06)
{
STDMETHOD(GetSize)(UInt64 *size) PURE;
};
STREAM_INTERFACE(IOutStreamFlush, 0x07)
{
STDMETHOD(Flush)() PURE;
};
#endif
```
|
Wilson Township may refer to several places in the U.S. state of Kansas:
Wilson Township, Ellsworth County, Kansas
Wilson Township, Lane County, Kansas
Wilson Township, Marion County, Kansas
Wilson Township, Rice County, Kansas
See also
Wilson Township (disambiguation)
Kansas township disambiguation pages
|
```shell
#!/bin/sh
#
#
# See /LICENSE for more information.
#
usage() {
echo "Usage: $0 <OM2P|OM5P|OM5PAC|MR600|MR900|MR1750|A60|A42|A62|PA300|PA1200|PA2200> <out file path> <kernel path> <rootfs path>"
rm -f $CFG_OUT
exit 1
}
[ "$#" -lt 4 ] && usage
CE_TYPE=$1
CFG_OUT=$2
KERNEL_PATH=$3
ROOTFS_PATH=$4
case $CE_TYPE in
PA300|\
OM2P)
MAX_PART_SIZE=7168
KERNEL_FLASH_ADDR=0x1c0000
SIZE_FACTOR=1
SIZE_FORMAT="%d"
;;
OM5P|OM5PAC|MR600|MR900|MR1750|A60)
MAX_PART_SIZE=7808
KERNEL_FLASH_ADDR=0xb0000
SIZE_FACTOR=1
SIZE_FORMAT="%d"
;;
A42|PA1200)
MAX_PART_SIZE=15616
KERNEL_FLASH_ADDR=0x180000
SIZE_FACTOR=1024
SIZE_FORMAT="0x%08x"
;;
A62|PA2200)
MAX_PART_SIZE=15552
KERNEL_FLASH_ADDR=0x1a0000
SIZE_FACTOR=1024
SIZE_FORMAT="0x%08x"
;;
*)
echo "Error - unsupported ce type: $CE_TYPE"
exit 1
;;
esac
CHECK_BS=65536
KERNEL_SIZE=$(stat -c%s "$KERNEL_PATH")
KERNEL_MD5=$($MKHASH md5 $KERNEL_PATH)
KERNEL_SHA256=$($MKHASH sha256 $KERNEL_PATH)
KERNEL_PART_SIZE_KB=$((KERNEL_SIZE / 1024))
KERNEL_PART_SIZE=$(printf $SIZE_FORMAT $(($KERNEL_PART_SIZE_KB * $SIZE_FACTOR)))
ROOTFS_FLASH_ADDR=$(addr=$(($KERNEL_FLASH_ADDR + ($KERNEL_PART_SIZE_KB * 1024))); printf "0x%x" $addr)
ROOTFS_SIZE=$(stat -c%s "$ROOTFS_PATH")
ROOTFS_SQUASHFS_SIZE=$((ROOTFS_SIZE-4))
ROOTFS_CHECK_BLOCKS=$((ROOTFS_SQUASHFS_SIZE / CHECK_BS))
ROOTFS_MD5=$(dd if=$ROOTFS_PATH bs=$CHECK_BS count=$ROOTFS_CHECK_BLOCKS 2>&- | $MKHASH md5)
ROOTFS_MD5_FULL=$($MKHASH md5 $ROOTFS_PATH)
ROOTFS_SHA256_FULL=$($MKHASH sha256 $ROOTFS_PATH)
ROOTFS_CHECK_SIZE=$(printf '0x%x' $ROOTFS_SQUASHFS_SIZE)
ROOTFS_PART_SIZE_KB=$(($MAX_PART_SIZE - $KERNEL_PART_SIZE_KB))
ROOTFS_PART_SIZE=$(printf $SIZE_FORMAT $(($ROOTFS_PART_SIZE_KB * $SIZE_FACTOR)))
cat << EOF > $CFG_OUT
[vmlinux]
filename=kernel
md5sum=$KERNEL_MD5
filemd5sum=$KERNEL_MD5
filesha256sum=$KERNEL_SHA256
flashaddr=$KERNEL_FLASH_ADDR
checksize=0x0
cmd_success=setenv bootseq 1,2; setenv kernel_size_1 $KERNEL_PART_SIZE; saveenv
cmd_fail=reset
[rootfs]
filename=rootfs
md5sum=$ROOTFS_MD5
filemd5sum=$ROOTFS_MD5_FULL
filesha256sum=$ROOTFS_SHA256_FULL
flashaddr=$ROOTFS_FLASH_ADDR
checksize=$ROOTFS_CHECK_SIZE
cmd_success=setenv bootseq 1,2; setenv kernel_size_1 $KERNEL_PART_SIZE; setenv rootfs_size_1 $ROOTFS_PART_SIZE; saveenv
cmd_fail=reset
EOF
```
|
```yaml
identifier: nucleo_f412zg
name: ST Nucleo F412ZG
type: mcu
arch: arm
toolchain:
- zephyr
- gnuarmemb
- xtools
ram: 256
flash: 1024
supported:
- arduino_i2c
- arduino_gpio
- arduino_spi
- pwm
- i2c
- spi
- gpio
- usb_device
- counter
vendor: st
```
|
```objective-c
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#ifndef STDLIB_CONSTANTS_FLOAT64_HIGH_WORD_SIGNIFICAND_MASK_H
#define STDLIB_CONSTANTS_FLOAT64_HIGH_WORD_SIGNIFICAND_MASK_H
/**
* Macro for the high word mask for the significand of a double-precision floating-point number.
*/
#define STDLIB_CONSTANT_FLOAT64_HIGH_WORD_SIGNIFICAND_MASK 0x000fffff
#endif // !STDLIB_CONSTANTS_FLOAT64_HIGH_WORD_SIGNIFICAND_MASK_H
```
|
```java
/*
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.oracle.truffle.llvm.parser.model.symbols.instructions;
import com.oracle.truffle.llvm.parser.model.SymbolImpl;
import com.oracle.truffle.llvm.parser.model.SymbolTable;
import com.oracle.truffle.llvm.parser.model.blocks.InstructionBlock;
import com.oracle.truffle.llvm.parser.model.visitors.SymbolVisitor;
import com.oracle.truffle.llvm.runtime.types.Type;
public final class PhiInstruction extends ValueInstruction {
private final SymbolImpl[] values;
private final InstructionBlock[] blocks;
private PhiInstruction(Type type, int size) {
super(type);
values = new SymbolImpl[size];
blocks = new InstructionBlock[size];
}
@Override
public void accept(SymbolVisitor visitor) {
visitor.visit(this);
}
public InstructionBlock getBlock(int index) {
return blocks[index];
}
public int getSize() {
return values.length;
}
public SymbolImpl getValue(int index) {
return values[index];
}
@Override
public void replace(SymbolImpl original, SymbolImpl replacment) {
for (int i = 0; i < values.length; i++) {
if (values[i] == original) {
values[i] = replacment;
}
}
}
public static PhiInstruction generate(SymbolTable symbols, Type type, int[] values, InstructionBlock[] blocks) {
final PhiInstruction phi = new PhiInstruction(type, values.length);
for (int i = 0; i < values.length; i++) {
phi.values[i] = symbols.getForwardReferenced(values[i], phi);
phi.blocks[i] = blocks[i];
}
return phi;
}
}
```
|
MicroBooNE is a liquid argon time projection chamber (LArTPC) at Fermilab in Batavia, Illinois. It is located in the Booster Neutrino Beam (BNB) beamline where neutrinos are produced by colliding protons from Fermilab's booster-accelerator on a beryllium target; this produces many short-lived particles (mainly charged pions) that decay into neutrinos. The neutrinos pass through solid ground (to filter out particles that are not neutrinos from the beam), through another experiment called ANNIE, then solid ground, then through the Short Baseline Near Detector (SBND, in construction, expected to begin operation 2023), then ground again before it arrives at the MicroBooNE detector 470 meters downrange from the target. After MicroBooNE the neutrinos continue to the MiniBooNE detector and to the ICARUS detector. MicroBooNE is also exposed to the neutrino beam from the Main Injector (NuMI) which enter the detector at a different angle.
MicroBooNE's two main physics goals are to investigate the MiniBooNE low-energy excess and neutrino-argon cross sections. As part of the Short Baseline Neutrino program (SBN), it will be one of a series of neutrino detectors along with the new Short-Baseline Near Detector (SBND) and moved ICARUS detector.
MicroBooNE was filled with argon in July 2015 and began data taking. The collaboration announced that they had found evidence of the first neutrino interactions in the detector in November 2015.
MicroBooNE collected five years of physics data, ending its run in 2021 as the longest continually operating liquid argon time projection chamber to date.
In October 2021 the results of the first three years of operation were reported. Analyses examined the MiniBooNE low-energy excess, one under a single photon hypothesis and under an electron hypothesis. No evidence for either of these explanations was found within MicroBooNE's sensitivity, which is set by the statistics and systematic uncertainty. The Fermilab press release accompanying the results claimed that the electron hypothesis test dealt "a blow to a theoretical particle known as the sterile neutrino." However, the accompanying commentary to the MicroBooNE papers, when they were published in Physical Review Letters, was entitled "Neutrino Mystery Endures." The full parameter space of sterile neutrino models hinted at by MiniBooNE and other data remains still under investigation.
References
External links
Neutrino experiments
Accelerator neutrino experiments
Fermilab
Fermilab experiments
2018 establishments in Illinois
Buildings and structures in DuPage County, Illinois
Buildings and structures in Kane County, Illinois
|
Sri Lanka is a tropical island situated close to the southern tip of India. The invertebrate fauna is as large as it is common to other regions of the world. There are about 2 million species of arthropods found in the world, and still it is counting. So many new species are discover up to this time also. So it is very complicated and difficult to summarize the exact number of species found within a certain region.
This a list of the ephemeropterans found from Sri Lanka.
Mayfly
Phylum: Arthropoda Class: Insecta
Order: Ephemeroptera
Mayflies or shadflies are aquatic insects belonging to the order Ephemeroptera. Over 3,000 species of mayfly are known worldwide, grouped into over 400 genera in 42 families.
Mayflies are relatively primitive insects and exhibit a number of ancestral traits that were probably present in the first flying insects, such as long tails and wings that do not fold flat over the abdomen. They are aquatic insects whose immature stages (called "naiads" or "nymphs") live in fresh water, where their presence indicates a clean, unpolluted environment. They are unique among insect orders in having a fully winged terrestrial adult stage, the subimago, which moults into a sexually mature adult, the imago.
In 1853, Walker first described about two species of mayflies from Sri Lanka. Then 1858, Hagen documented 8 more species from the country. The most useful taxonomic and other ecological aspects of mayflies of Sri Lanka came during 1960s and 1970s by Peters (1967) and Peters & Edmunds (1970). In 1965, Fernando described comprehensive work on mayflies. Through this, Hubbard and co-workers documented 46 species in 8 families from the country which is the most valuable source for present day as well. Currently there are 52 species of mayflies are reported from Sri Lanka, which belongs to 8 families.
Family: Baetidae
Acentrella feminalis (Eaton, 1885)
Baetis acceptus Muller-Liebenau & Hubbard 1985
Baetis collinus Muller-Liebenau & Hubbard, 1985
Baetis conservatus Muller-Liebenau & Hubbard, 1985
Baetis consuetus Hagen, 1853
Baetis frequentus Muller-Liebenau & Hubbard, 1985
Baetis pseudofrequentus Muller-Liebenau & Hubbard, 1985
Baetis solidus (Hagen, 1858)
Centroptella soldani Muller-Liebenau 1983
Chopralla ceylonensis (Muller-Liebenau 1983)
Chopralla similis (Muller-Liebenau 1983)
Cloeon marginale (Hagen, 1858)
Indobaetis costai Muller-Liebenau & Morihara, 1982
Indobaetis starmuehlneri Muller-Liebenau, 1982
Indocloeon primum Muller-Liebenau, 1982
Indocloeon secundum Kluge & Suttinun, 2020
Labiobaetis geminatus (Muller-Liebenau & Hubbard, 1985)
Labiobaetis ordinatum (Muller-Liebenau & Hubbard 1985)
Labiobaetis pulchellum (Muller-Liebenau & Hubbard 1985)
Liebebiella ambigua (Muller-Liebenau, 1982)
Liebebiella vera (Muller-Liebenau, 1982) [=Liebebiella difficila (Muller-Liebenau, 1982)]
Liebebiella klapaleki (Muller-Liebenau, 1982)
Liebebiella orientale (Muller-Liebenau, 1982)
Procloeon bimaculatum (Eaton, 1885)
Procloeon regularum Muller-Liebenau & Hubbard, 1985
Pseudocentroptiloides ceylonica Glazaczow, 1987
Family: Caenidae
Caenis perpusilla Walker, 1853
Clypeocaenis femorisetosa
Sparbarus gilliesi
Family: Ephemerellidae
Teloganodes hubbardi Sartori, 2008
Teloganodes insignis (Wang & McCafferty, 1996)
Teloganodes jacobusi Sartori, 2008
Teloganodes major Eaton, 1884
Teloganodes tristis (Hagen, 1858)
Teloganodes tuberculatus Sartori, 2008
Family: Ephemeridae
Ephemera hasakalensis Hubbard, 1983
Ephemera lankensis Hubbard, 1983
Ephemera nathani Hubbard, 1982
Ephemera supposita Eaton, 1883
Ephoron indicus (Pictet, 1843)
Povilla taprobanes Hubbard, 1984
Rhoenanthus posticus Banks, 1914
Family: Leptophlebiidae
Choroterpes signata (Hagen, 1858)
Isca serendiba Peters & Edmunds, 1970
Kimminsula annulata (Hagen, 1858)
Kimminsula fasciata (Hagen, 1858)
Kimminsula femoralis (Hagen, 1858)
Kimminsula taprobanes (Walker, 1853)
Megaglena brincki Peters & Edmunds, 1970
Family: Polymitarcyidae
Ephoron indica
Povilla taprobanes
Family: Prosopistomatidae
Prosopistoma lieftincki Peters, 1967
Family: Teloganodidae
Indoganodes tschertoprudi Martynov & Palatov, 2020
Family: Tricorythidae
Sparsorythus jacobsoni (Ulmer, 1913)
References
Sri Lanka
ephemeropterans
|
```javascript
/*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @constructor
* @extends {WebInspector.SDKModel}
*/
WebInspector.IndexedDBModel = function(target)
{
WebInspector.SDKModel.call(this, WebInspector.IndexedDBModel, target);
this._agent = target.indexedDBAgent();
/** @type {!Map.<!WebInspector.IndexedDBModel.DatabaseId, !WebInspector.IndexedDBModel.Database>} */
this._databases = new Map();
/** @type {!Object.<string, !Array.<string>>} */
this._databaseNamesBySecurityOrigin = {};
}
WebInspector.IndexedDBModel.KeyTypes = {
NumberType: "number",
StringType: "string",
DateType: "date",
ArrayType: "array"
};
WebInspector.IndexedDBModel.KeyPathTypes = {
NullType: "null",
StringType: "string",
ArrayType: "array"
};
/**
* @param {*} idbKey
* @return {?Object}
*/
WebInspector.IndexedDBModel.keyFromIDBKey = function(idbKey)
{
if (typeof(idbKey) === "undefined" || idbKey === null)
return null;
var key = {};
switch (typeof(idbKey)) {
case "number":
key.number = idbKey;
key.type = WebInspector.IndexedDBModel.KeyTypes.NumberType;
break;
case "string":
key.string = idbKey;
key.type = WebInspector.IndexedDBModel.KeyTypes.StringType;
break;
case "object":
if (idbKey instanceof Date) {
key.date = idbKey.getTime();
key.type = WebInspector.IndexedDBModel.KeyTypes.DateType;
} else if (Array.isArray(idbKey)) {
key.array = [];
for (var i = 0; i < idbKey.length; ++i)
key.array.push(WebInspector.IndexedDBModel.keyFromIDBKey(idbKey[i]));
key.type = WebInspector.IndexedDBModel.KeyTypes.ArrayType;
}
break;
default:
return null;
}
return key;
}
/**
* @param {?IDBKeyRange=} idbKeyRange
* @return {?{lower: ?Object, upper: ?Object, lowerOpen: *, upperOpen: *}}
*/
WebInspector.IndexedDBModel.keyRangeFromIDBKeyRange = function(idbKeyRange)
{
if (typeof idbKeyRange === "undefined" || idbKeyRange === null)
return null;
var keyRange = {};
keyRange.lower = WebInspector.IndexedDBModel.keyFromIDBKey(idbKeyRange.lower);
keyRange.upper = WebInspector.IndexedDBModel.keyFromIDBKey(idbKeyRange.upper);
keyRange.lowerOpen = idbKeyRange.lowerOpen;
keyRange.upperOpen = idbKeyRange.upperOpen;
return keyRange;
}
/**
* @param {!IndexedDBAgent.KeyPath} keyPath
* @return {?string|!Array.<string>|undefined}
*/
WebInspector.IndexedDBModel.idbKeyPathFromKeyPath = function(keyPath)
{
var idbKeyPath;
switch (keyPath.type) {
case WebInspector.IndexedDBModel.KeyPathTypes.NullType:
idbKeyPath = null;
break;
case WebInspector.IndexedDBModel.KeyPathTypes.StringType:
idbKeyPath = keyPath.string;
break;
case WebInspector.IndexedDBModel.KeyPathTypes.ArrayType:
idbKeyPath = keyPath.array;
break;
}
return idbKeyPath;
}
/**
* @param {?string|!Array.<string>|undefined} idbKeyPath
* @return {?string}
*/
WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath = function(idbKeyPath)
{
if (typeof idbKeyPath === "string")
return "\"" + idbKeyPath + "\"";
if (idbKeyPath instanceof Array)
return "[\"" + idbKeyPath.join("\", \"") + "\"]";
return null;
}
WebInspector.IndexedDBModel.EventTypes = {
DatabaseAdded: "DatabaseAdded",
DatabaseRemoved: "DatabaseRemoved",
DatabaseLoaded: "DatabaseLoaded"
}
WebInspector.IndexedDBModel.prototype = {
enable: function()
{
if (this._enabled)
return;
this._agent.enable();
this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginAdded, this._securityOriginAdded, this);
this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginRemoved, this._securityOriginRemoved, this);
var securityOrigins = this.target().resourceTreeModel.securityOrigins();
for (var i = 0; i < securityOrigins.length; ++i)
this._addOrigin(securityOrigins[i]);
this._enabled = true;
},
refreshDatabaseNames: function()
{
for (var securityOrigin in this._databaseNamesBySecurityOrigin)
this._loadDatabaseNames(securityOrigin);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
*/
refreshDatabase: function(databaseId)
{
this._loadDatabase(databaseId);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {function()} callback
*/
clearObjectStore: function(databaseId, objectStoreName, callback)
{
this._agent.clearObjectStore(databaseId.securityOrigin, databaseId.name, objectStoreName, callback);
},
/**
* @param {!WebInspector.Event} event
*/
_securityOriginAdded: function(event)
{
var securityOrigin = /** @type {string} */ (event.data);
this._addOrigin(securityOrigin);
},
/**
* @param {!WebInspector.Event} event
*/
_securityOriginRemoved: function(event)
{
var securityOrigin = /** @type {string} */ (event.data);
this._removeOrigin(securityOrigin);
},
/**
* @param {string} securityOrigin
*/
_addOrigin: function(securityOrigin)
{
console.assert(!this._databaseNamesBySecurityOrigin[securityOrigin]);
this._databaseNamesBySecurityOrigin[securityOrigin] = [];
this._loadDatabaseNames(securityOrigin);
},
/**
* @param {string} securityOrigin
*/
_removeOrigin: function(securityOrigin)
{
console.assert(this._databaseNamesBySecurityOrigin[securityOrigin]);
for (var i = 0; i < this._databaseNamesBySecurityOrigin[securityOrigin].length; ++i)
this._databaseRemoved(securityOrigin, this._databaseNamesBySecurityOrigin[securityOrigin][i]);
delete this._databaseNamesBySecurityOrigin[securityOrigin];
},
/**
* @param {string} securityOrigin
* @param {!Array.<string>} databaseNames
*/
_updateOriginDatabaseNames: function(securityOrigin, databaseNames)
{
var newDatabaseNames = databaseNames.keySet();
var oldDatabaseNames = this._databaseNamesBySecurityOrigin[securityOrigin].keySet();
this._databaseNamesBySecurityOrigin[securityOrigin] = databaseNames;
for (var databaseName in oldDatabaseNames) {
if (!newDatabaseNames[databaseName])
this._databaseRemoved(securityOrigin, databaseName);
}
for (var databaseName in newDatabaseNames) {
if (!oldDatabaseNames[databaseName])
this._databaseAdded(securityOrigin, databaseName);
}
},
/**
* @return {!Array.<!WebInspector.IndexedDBModel.DatabaseId>}
*/
databases: function()
{
var result = [];
for (var securityOrigin in this._databaseNamesBySecurityOrigin) {
var databaseNames = this._databaseNamesBySecurityOrigin[securityOrigin];
for (var i = 0; i < databaseNames.length; ++i) {
result.push(new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseNames[i]));
}
}
return result;
},
/**
* @param {string} securityOrigin
* @param {string} databaseName
*/
_databaseAdded: function(securityOrigin, databaseName)
{
var databaseId = new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseName);
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseAdded, databaseId);
},
/**
* @param {string} securityOrigin
* @param {string} databaseName
*/
_databaseRemoved: function(securityOrigin, databaseName)
{
var databaseId = new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseName);
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseRemoved, databaseId);
},
/**
* @param {string} securityOrigin
*/
_loadDatabaseNames: function(securityOrigin)
{
/**
* @param {?Protocol.Error} error
* @param {!Array.<string>} databaseNames
* @this {WebInspector.IndexedDBModel}
*/
function callback(error, databaseNames)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[securityOrigin])
return;
this._updateOriginDatabaseNames(securityOrigin, databaseNames);
}
this._agent.requestDatabaseNames(securityOrigin, callback.bind(this));
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
*/
_loadDatabase: function(databaseId)
{
/**
* @param {?Protocol.Error} error
* @param {!IndexedDBAgent.DatabaseWithObjectStores} databaseWithObjectStores
* @this {WebInspector.IndexedDBModel}
*/
function callback(error, databaseWithObjectStores)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[databaseId.securityOrigin])
return;
var databaseModel = new WebInspector.IndexedDBModel.Database(databaseId, databaseWithObjectStores.version, databaseWithObjectStores.intVersion);
this._databases.set(databaseId, databaseModel);
for (var i = 0; i < databaseWithObjectStores.objectStores.length; ++i) {
var objectStore = databaseWithObjectStores.objectStores[i];
var objectStoreIDBKeyPath = WebInspector.IndexedDBModel.idbKeyPathFromKeyPath(objectStore.keyPath);
var objectStoreModel = new WebInspector.IndexedDBModel.ObjectStore(objectStore.name, objectStoreIDBKeyPath, objectStore.autoIncrement);
for (var j = 0; j < objectStore.indexes.length; ++j) {
var index = objectStore.indexes[j];
var indexIDBKeyPath = WebInspector.IndexedDBModel.idbKeyPathFromKeyPath(index.keyPath);
var indexModel = new WebInspector.IndexedDBModel.Index(index.name, indexIDBKeyPath, index.unique, index.multiEntry);
objectStoreModel.indexes[indexModel.name] = indexModel;
}
databaseModel.objectStores[objectStoreModel.name] = objectStoreModel;
}
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseLoaded, databaseModel);
}
this._agent.requestDatabase(databaseId.securityOrigin, databaseId.name, callback.bind(this));
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
loadObjectStoreData: function(databaseId, objectStoreName, idbKeyRange, skipCount, pageSize, callback)
{
this._requestData(databaseId, databaseId.name, objectStoreName, "", idbKeyRange, skipCount, pageSize, callback);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {string} indexName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
loadIndexData: function(databaseId, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback)
{
this._requestData(databaseId, databaseId.name, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} databaseName
* @param {string} objectStoreName
* @param {string} indexName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
_requestData: function(databaseId, databaseName, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback)
{
/**
* @param {?Protocol.Error} error
* @param {!Array.<!IndexedDBAgent.DataEntry>} dataEntries
* @param {boolean} hasMore
* @this {WebInspector.IndexedDBModel}
*/
function innerCallback(error, dataEntries, hasMore)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[databaseId.securityOrigin])
return;
var entries = [];
for (var i = 0; i < dataEntries.length; ++i) {
var key = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].key));
var primaryKey = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].primaryKey));
var value = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].value));
entries.push(new WebInspector.IndexedDBModel.Entry(key, primaryKey, value));
}
callback(entries, hasMore);
}
var keyRange = WebInspector.IndexedDBModel.keyRangeFromIDBKeyRange(idbKeyRange);
this._agent.requestData(databaseId.securityOrigin, databaseName, objectStoreName, indexName, skipCount, pageSize, keyRange ? keyRange : undefined, innerCallback.bind(this));
},
__proto__: WebInspector.SDKModel.prototype
}
/**
* @constructor
* @param {!WebInspector.RemoteObject} key
* @param {!WebInspector.RemoteObject} primaryKey
* @param {!WebInspector.RemoteObject} value
*/
WebInspector.IndexedDBModel.Entry = function(key, primaryKey, value)
{
this.key = key;
this.primaryKey = primaryKey;
this.value = value;
}
/**
* @constructor
* @param {string} securityOrigin
* @param {string} name
*/
WebInspector.IndexedDBModel.DatabaseId = function(securityOrigin, name)
{
this.securityOrigin = securityOrigin;
this.name = name;
}
WebInspector.IndexedDBModel.DatabaseId.prototype = {
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @return {boolean}
*/
equals: function(databaseId)
{
return this.name === databaseId.name && this.securityOrigin === databaseId.securityOrigin;
},
}
/**
* @constructor
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} version
* @param {number} intVersion
*/
WebInspector.IndexedDBModel.Database = function(databaseId, version, intVersion)
{
this.databaseId = databaseId;
this.version = version;
this.intVersion = intVersion;
this.objectStores = {};
}
/**
* @constructor
* @param {string} name
* @param {*} keyPath
* @param {boolean} autoIncrement
*/
WebInspector.IndexedDBModel.ObjectStore = function(name, keyPath, autoIncrement)
{
this.name = name;
this.keyPath = keyPath;
this.autoIncrement = autoIncrement;
this.indexes = {};
}
WebInspector.IndexedDBModel.ObjectStore.prototype = {
/**
* @type {string}
*/
get keyPathString()
{
return WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath(this.keyPath);
}
}
/**
* @constructor
* @param {string} name
* @param {*} keyPath
* @param {boolean} unique
* @param {boolean} multiEntry
*/
WebInspector.IndexedDBModel.Index = function(name, keyPath, unique, multiEntry)
{
this.name = name;
this.keyPath = keyPath;
this.unique = unique;
this.multiEntry = multiEntry;
}
WebInspector.IndexedDBModel.Index.prototype = {
/**
* @type {string}
*/
get keyPathString()
{
return WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath(this.keyPath);
}
}
/**
* @param {!WebInspector.Target} target
* @return {?WebInspector.IndexedDBModel}
*/
WebInspector.IndexedDBModel.fromTarget = function(target)
{
var model = /** @type {?WebInspector.IndexedDBModel} */ (target.model(WebInspector.IndexedDBModel));
if (!model)
model = new WebInspector.IndexedDBModel(target);
return model;
}
```
|
```makefile
libavfilter/vf_lut.o: libavfilter/vf_lut.c libavutil/attributes.h \
libavutil/bswap.h libavutil/avconfig.h libavutil/attributes.h config.h \
libavutil/common.h libavutil/macros.h libavutil/version.h \
libavutil/intmath.h libavutil/common.h libavutil/mem.h libavutil/error.h \
libavutil/avutil.h libavutil/rational.h libavutil/mathematics.h \
libavutil/intfloat.h libavutil/log.h libavutil/pixfmt.h \
libavutil/internal.h libavutil/timer.h libavutil/cpu.h libavutil/dict.h \
libavutil/libm.h libavutil/eval.h libavutil/opt.h libavutil/samplefmt.h \
libavutil/pixdesc.h libavfilter/avfilter.h libavutil/avutil.h \
libavutil/buffer.h libavutil/dict.h libavutil/frame.h libavutil/buffer.h \
libavutil/log.h libavutil/samplefmt.h libavutil/pixfmt.h \
libavutil/rational.h libavfilter/version.h libavutil/version.h \
libavfilter/drawutils.h libavfilter/formats.h libavfilter/internal.h \
libavutil/internal.h libavfilter/avfiltergraph.h libavfilter/framepool.h \
libavfilter/thread.h libavfilter/version.h libavfilter/video.h \
libavcodec/avcodec.h libavutil/cpu.h libavutil/channel_layout.h \
libavcodec/version.h
```
|
Dresvyanka () is a rural locality (a selo) in Stolbovsky Selsoviet, Kamensky District, Altai Krai, Russia. The population was 411 as of 2013. There are 14 streets.
Geography
Dresvyanka is located 17 km north of Kamen-na-Obi (the district's administrative centre) by road. Novouvalsky is the nearest rural locality.
References
Rural localities in Kamensky District, Altai Krai
|
"The Dicks Hate the Police" (usually shortened to "Hate the Police") is the debut release and 7-inch single from the American hardcore punk band The Dicks, released in 1980. The record was released on the band's own Radical Records imprint. Mudhoney included a cover of the song on Superfuzz Bigmuff Plus Early Singles.
Critical reception
Pitchfork wrote that "the song contained few words and fewer chords, and yet, with an arch sneer, the singer—Gary Floyd, a genuine punk hero deserving of recognition beyond the underground—communicated the essence of state power deployed in its most wretched everyday form." The A.V. Club called it a "classic," writing that "even removed from its historical and geographical contexts 'Hate The Police' remains a powerful song." The Dallas Observer called it "perhaps the finest single ever released by a Texas punk band."
Track listing
The Dicks Hate the Police
Lifetime Problems
All Night Fever
Line up
Gary Floyd – Vocals
Glen Taylor – Guitar
Buxf Parrot – Bass, vocals on "All Night Fever"
Pat Deason – Drums
References
1980 debut singles
1980 songs
The Dicks albums
Protest songs
Songs against racism and xenophobia
Songs about police officers
|
```java
/*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
package io.flutter.utils;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.function.Consumer;
/**
* Simple class for listening for a value that can be repeatedly updated.
* <p>
* The benefit of using this class instead of listening for events is you
* don't have to worry about missing values posted to the stream before your
* code started listening which can lead to hard to find bugs.
* <p>
* The benefit of using this class over awaiting a Future is that the value can
* update multiple times.
* <p>
* The value associated with the EventStream can be set on any thread.
* <p>
* The class is inspired by listen method on the Stream class in Dart.
*/
public class EventStream<T> {
protected final HashSet<StreamSubscription<T>> subscriptions = new LinkedHashSet<>();
private volatile T currentValue;
public EventStream() {
this(null);
}
public EventStream(T initialValue) {
currentValue = initialValue;
}
public T getValue() {
return currentValue;
}
/**
* Returns whether the value was changed.
*/
public boolean setValue(T value) {
final List<StreamSubscription<T>> regularSubscriptions = new ArrayList<>();
final List<StreamSubscription<T>> uiThreadSubscriptions = new ArrayList<>();
synchronized (this) {
if (currentValue == value) {
return false;
}
currentValue = value;
for (StreamSubscription<T> subscription : subscriptions) {
if (subscription.onUIThread) {
uiThreadSubscriptions.add(subscription);
}
else {
regularSubscriptions.add(subscription);
}
}
for (StreamSubscription<T> subscription : regularSubscriptions) {
subscription.notify(value);
}
}
if (!uiThreadSubscriptions.isEmpty()) {
AsyncUtils.invokeLater(() -> {
synchronized (this) {
if (value != currentValue) {
// This update is obsolete.
return;
}
for (StreamSubscription<T> subscription : uiThreadSubscriptions) {
subscription.notify(value);
}
}
});
}
return true;
}
/**
* Listens for changes to the value tracked by the EventStream.
* onData is always called immediately with the current value specified
* by the EventStream.
*
* @param onData is called every time the value associated with the EventStream changes.
* @return a StreamSubscription object that is used to cancel the subscription.
*/
public StreamSubscription<T> listen(Consumer<T> onData) {
return listen(onData, false);
}
/**
* Listens for changes to the value tracked by the EventStream.
* onData is always called immediately with the current value specified
* by the EventStream.
*
* @param onData is called every time the value associated with the EventStream changes.
* @param onUIThread specifies that callbacks are made on the UI thread.
* @return a StreamSubscription object that is used to cancel the subscription.
*/
public StreamSubscription<T> listen(Consumer<T> onData, boolean onUIThread) {
final StreamSubscription<T> subscription = new StreamSubscription<>(onData, onUIThread, this);
final T cachedCurrentValue;
synchronized (this) {
cachedCurrentValue = currentValue;
subscriptions.add(subscription);
}
onData.accept(cachedCurrentValue);
return subscription;
}
protected void removeSubscription(StreamSubscription<T> subscription) {
synchronized (this) {
subscriptions.remove(subscription);
}
}
}
```
|
Barangay East Rembo or previously known as Barangay 15 is a Barangay or Barrio in Makati's 2nd congressional district. It Borders West Rembo on its North, Pasig on its East, Bonifacio Global City on its West, and Comembo on its South.
History
The History of East Rembo started in 1954 when the PAF authorized the construction of Barrios for the reserved military serving in the armed forces who were living in Fort Bonifacio. East Rembo is the heart of the three barangays of West Rembo, Comembo and Pembo. These settlements were named after EMBO, which means "Enlisted Men's Barrio''
East Rembo is claimed to be a self-sustaining community. Because after its foundation, it is recorded to haven't received any assistance from the military administration. The military administration of the barrio begun in 1956 when, President Ferdinand E. Marcos issued Presidential Proclamation 2425. in 1986, it was turned over to the Administration of Makati City.
The Barangay, like every barangays in Makati, has its own Parish church, named the Mater Dolorosa Parish.
References
External links
Barangays of Metro Manila
Makati
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
/**
* Create `test.validate.js` contents.
*
* @module @stdlib/_tools/scaffold/test-validate-js
*
* @example
* var create = require( '@stdlib/_tools/scaffold/test-validate-js' );
*
* var code = [
* '/**',
* '* Validates function options.',
* '*',
* '* @private',
* '* @param {Object} opts - destination object',
* '* @param {Options} options - function options',
* '* @param {string} [options.sep] - separator',
* '* @returns {(Error|null)} null or an error object',
* '*\/'
* ];
* code = code.join( '\n' );
*
* var tests = create( code );
*/
// MODULES //
var main = require( './main.js' );
// EXPORTS //
module.exports = main;
```
|
The uvea (; derived from meaning "grape"), also called the uveal layer, uveal coat, uveal tract, vascular tunic or vascular layer is the pigmented middle layer of the three concentric layers that make up an eye, precisely between the inner retina and the outer fibrous layer composed of the sclera and cornea.
History and etymology
The originally medieval Latin term comes from the Latin word uva ("grape") and is a reference to its grape-like appearance (reddish-blue or almost black colour, wrinkled appearance and grape-like size and shape when stripped intact from a cadaveric eye). In fact, it is a partial loan translation of the Ancient Greek term for the choroid, which literally means “covering resembling a grape”. Its use as a technical term for part of the eye is ancient, but it only referred to the choroid in Middle English and before.
Structure
Regions
The uvea is the vascular middle layer of the eye. It is traditionally divided into three areas, from front to back:
Iris
Ciliary body
Choroid
Function
The prime functions of the uveal tract as a unit are:
Nutrition and gas exchange: uveal vessels directly perfuse the ciliary body and iris, to support their metabolic needs, and indirectly supply diffusible nutrients to the outer retina, sclera, and lens, which lack any intrinsic blood supply. (The cornea has no adjacent blood vessels and is oxygenated by direct gas exchange with the environment.)
Light absorption: the uvea improves the contrast of the retinal image by reducing reflected light within the eye (analogous to the black paint inside a camera), and also absorbs outside light transmitted through the sclera, which is not fully opaque.
In addition, some uveal regions have special functions of great importance, including secretion of the aqueous humour by the ciliary processes, control of accommodation (focus) by the ciliary body, and optimisation of retinal illumination by the iris's control over the pupil. Many of these functions are under the control of the autonomic nervous system.
Pharmacology
The pupil provides a visible example of the neural feedback control in the body. This is subserved by a balance between the antagonistic sympathetic and parasympathetic divisions of the autonomic nervous system. Informal pharmacological experiments have been performed on the pupil for centuries, since the pupil is readily visible, and its size can be readily altered by applying drugs—even crude plant extracts—to the cornea. Pharmacological control over pupil size remains an important part of the treatment of some ocular diseases.
Drugs can also reduce the metabolically active process of secreting aqueous humour, which is important in treating both acute and chronic glaucoma.
Immunology
The normal uvea consists of immune competent cells, particularly lymphocytes, and is prone to respond to inflammation by developing lymphocytic infiltrates. A rare disease called sympathetic ophthalmia may represent 'cross-reaction' between the uveal and retinal antigens (i.e., the body's inability to distinguish between them, with resulting misdirected inflammatory reactions).
Clinical significance
See uveitis, choroiditis, iritis, iridocyclitis, anterior uveitis, sympathetic ophthalmia, and uveal melanoma.
References
External links
Diagram at visionweb.com
Human eye anatomy
|
```python
#############################################################################################
# File: rust_version_database.py
# Origin: Rust Repository path_to_url
#
# Description:
# This file serves as a comprehensive reference, capturing the commit hashes associated with Rust versions over time.
# It facilitates tracking the commit history and enables the precise association of specific versions with their respective commits.
#
# Regeneration Instructions:
#
# To regenerate or update this file, you can follow these steps:
# 1. Navigate to the script directory.
# 2. Execute the script 'extract_rust_hashes.py'.
# Example command: python extract_rust_hashes.py
#############################################################################################
rust_commit_hash = {
"a28077b28a02b92985b3a3faecf92813155f1ea1": "1.74.1",
"79e9716c980570bfd1f666e3b16ac583f0168962": "1.74.0",
"cc66ad468955717ab92600c770da8c1601a4ff33": "1.73.0",
"d5c2e9c342b358556da91d61ed4133f6f50fc0c3": "1.72.1",
"5680fa18feaa87f3ff04063800aec256c3d4b4be": "1.72.0",
"eb26296b556cef10fb713a38f3d16b9886080f26": "1.71.1",
"8ede3aae28fe6e4d52b38157d7bfe0d3bceef225": "1.71.0",
"90c541806f23a127002de5b4038be731ba1458ca": "1.70.0",
"84c898d65adf2f39a5a98507f1fe0ce10a2b8dbc": "1.69.0",
"9eb3afe9ebe9c7d2b84b71002d44f4a0edac95e0": "1.68.2",
"8460ca823e8367a30dda430efda790588b8c84d3": "1.68.1",
"2c8cc343237b8f7d5a3c3703e3a87f2eb2c54a74": "1.68.0",
"d5a82bbd26e1ad8b7401f6a718a9c57c96905483": "1.67.1",
"fc594f15669680fa70d255faec3ca3fb507c3405": "1.67.0",
"90743e7298aca107ddaa0c202a4d3604e29bfeb6": "1.66.1",
"69f9c33d71c871fc16ac445211281c6e7a340943": "1.66.0",
"897e37553bba8b42751c67658967889d11ecd120": "1.65.0",
"a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52": "1.64.0",
"4b91a6ea7258a947e59c6522cd5898e7c0a6a88f": "1.63.0",
"e092d0b6b43f2de967af0887873151bb1c0b18d3": "1.62.1",
"a8314ef7d0ec7b75c336af2c9857bfaf43002bfc": "1.62.0",
"fe5b13d681f25ee6474be29d748c65adcd91f69e": "1.61.0",
"7737e0b5c4103216d6fd8cf941b7ab9bdbaace7c": "1.60.0",
"9d1b2106e23b1abd32fce1f17267604a5102f57a": "1.59.0",
"db9d1b20bba1968c1ec1fc49616d4742c1725b4b": "1.58.1",
"02072b482a8b5357f7fb5e5637444ae30e423c40": "1.58.0",
"f1edd0429582dd29cccacaf50fd134b05593bd9c": "1.57.0",
"59eed8a2aac0230a8b53e89d4e99d55912ba6b35": "1.56.1",
"09c42c45858d5f3aedfa670698275303a3d19afa": "1.56.0",
"c8dfcfe046a7680554bf4eb612bad840e7631c4b": "1.55.0",
"a178d0322ce20e33eac124758e837cbd80a6f633": "1.54.0",
"53cb7b09b00cbea8754ffb78e7e3cb521cb8af4b": "1.53.0",
"9bc8c42bb2f19e745a63f3445f1ac248fb015e53": "1.52.1",
"88f19c6dab716c6281af7602e30f413e809c5974": "1.52.0",
"2fd73fabe469357a12c2c974c140f67e7cdd76d0": "1.51.0",
"cb75ad5db02783e8b0222fee363c5f63f7e2cf5b": "1.50.0",
"e1884a8e3c3e813aada8254edfa120e85bf5ffca": "1.49.0",
"7eac88abb2e57e752f3302f02be5f3ce3d7adfb4": "1.48.0",
"18bf6b4f01a6feaf7259ba7cdae58031af1b7b39": "1.47.0",
"04488afe34512aa4c33566eb16d8c912a3ae04f9": "1.46.0",
"d3fb005a39e62501b8b0b356166e515ae24e2e54": "1.45.2",
"c367798cfd3817ca6ae908ce675d1d99242af148": "1.45.1",
"5c1f21c3b82297671ad3ae1e8c942d2ca92e84f2": "1.45.0",
"c7087fe00d2ba919df1d813c040a5d47e43b0fe7": "1.44.1",
"49cae55760da0a43428eba73abcb659bb70cf2e4": "1.44.0",
"8d69840ab92ea7f4d323420088dd8c9775f180cd": "1.43.1",
"4fb7144ed159f94491249e86d5bbd033b5d60550": "1.43.0",
"b8cedc00407a4c56a3bda1ed605c6fc166655447": "1.42.0",
"f3e1a954d2ead4e2fc197c7da7d71e6c61bad196": "1.41.1",
"5e1a799842ba6ed4a57e91f7ab9435947482f7d8": "1.41.0",
"73528e339aae0f17a15ffa49a8ac608f50c6cf14": "1.40.0",
"4560ea788cb760f0a34127156c78e2552949f734": "1.39.0",
"625451e376bb2e5283fc4741caa0a3e8a2ca4d54": "1.38.0",
"eae3437dfe991621e8afdc82734f4a172d7ddf9b": "1.37.0",
"a53f9df32fbb0b5f4382caaad8f1a46f36ea887c": "1.36.0",
"3c235d5600393dfe6c36eeed34042efad8d4f26e": "1.35.0",
"6c2484dc3c532c052f159264e970278d8b77cdc9": "1.34.2",
"fc50f328b0353b285421b8ff5d4100966387a997": "1.34.1",
"91856ed52c58aa5ba66a015354d1cc69e9779bdf": "1.34.0",
"2aa4c46cfdd726e97360c2734835aa3515e8c858": "1.33.0",
"9fda7c2237db910e41d6a712e9a2139b352e558b": "1.32.0",
"b6c32da9b0481e3e9d737153286b3ff8aa39a22c": "1.31.1",
"abe02cefd6cd1916df62ad7dc80161bea50b72e8": "1.31.0",
"1433507eba7d1a114e4c6f27ae0e1a74f60f20de": "1.30.1",
"da5f414c2c0bfe5198934493f04c676e2b23ff2e": "1.30.0",
"17a9dc7513b9fea883dc9505f09f97c63d1d601b": "1.29.2",
"b801ae66425cf7c3c71052b19ef8f145b0d0513d": "1.29.1",
"aa3ca1994904f2e056679fce1f185db8c7ed2703": "1.29.0",
"9634041f0e8c0f3191d2867311276f19d0a42564": "1.28.0",
"58cc626de3301192d5d8c6dcbde43b5b44211ae2": "1.27.2",
"5f2b325f64ed6caa7179f3e04913db437656ec7e": "1.27.1",
"3eda71b00ad48d7bf4eef4c443e7f611fd061418": "1.27.0",
"594fb253c2b02b320c728391a425d028e6dc7a09": "1.26.2",
"827013a31b88e536e85b8e6ceb5b9988042ec335": "1.26.1",
"a7756804103447ea4e68a71ccf071e7ad8f7a03e": "1.26.0",
"84203cac67e65ca8640b8392348411098c856985": "1.25.0",
"d3ae9a9e08edf12de0ed82af57ba2a56c26496ea": "1.24.1",
"4d90ac38c0b61bb69470b61ea2cccea0df48d9e5": "1.24.0",
"766bd11c8a3c019ca53febdcd77b2215379dd67d": "1.23.0",
"05e2e1c41414e8fc73d0f267ea8dab1a3eeeaa99": "1.22.1",
"328886ba2eaf0d3ac7e78ef3ba27eb296d0af3c0": "1.22.0",
"3b72af97e42989b2fe104d8edbaee123cdf7c58f": "1.21.0",
"f3d6973f41a7d1fb83029c9c0ceaf0f5d4fd7208": "1.20.0",
"0ade339411587887bf01bcfa2e9ae4414c8900d4": "1.19.0",
"03fc9d622e0ea26a3d37f5ab030737fcca6928b9": "1.18.0",
"56124baa9e73f28c0709e59e74783cf234a978cf": "1.17.0",
"30cf806ef8881c41821fbd43e5cf3699c5290c16": "1.16.0",
"021bd294c039bd54aa5c4aa85bcdffb0d24bc892": "1.15.1",
"10893a9a349cdd423f2490a6984acb5b3b7c8046": "1.15.0",
"e8a0123241f0d397d39cd18fcc4e5e7edde22730": "1.14.0",
"2c6933acc05c61e041be764cb1331f6281993f3f": "1.13.0",
"d4f39402a0c2c2b94ec0375cd7f7f6d7918113cd": "1.12.1",
"3191fbae9da539442351f883bdabcad0d72efcb6": "1.12.0",
"9b21dcd6a89f38e8ceccb2ede8c9027cb409f6e3": "1.11.0",
"cfcb716cf0961a7e3a4eceac828d94805cf8140b": "1.10.0",
"e4e8b666850a763fdf1c3c2c142856ab51e32779": "1.9.0",
"db2939409db26ab4904372c82492cd3488e4c44e": "1.8.0",
"a5d1e7a59a2a3413c377b003075349f854304b5e": "1.7.0",
"c30b771ad9d44ab84f8c88b80c25fcfde2433126": "1.6.0",
"3d7cd77e442ce34eaac8a176ae8be17669498ebc": "1.5.0",
"8ab8581f6921bc7a8e3fa4defffd2814372dcb15": "1.4.0",
"9a92aaf19a64603b02b4130fe52958cc12488900": "1.3.0",
"082e4763615bdbe7b4dd3dfd6fc2210b7773edf5": "1.2.0",
"35ceea3997c79a3b7562e89b462ab76af5b86b22": "1.1.0",
"a59de37e99060162a2674e3ff45409ac73595c0e": "1.0.0",
"522d09dfecbeca1595f25ac58c6d0178bbd21d7d": "1.0.0-alpha.2",
"44a287e6eb22ec3c2a687fc156813577464017f7": "1.0.0-alpha",
"ba4081a5a8573875fed17545846f6f6902c8ba8d": "0.12.0",
"aa1163b92de7717eb7c5eba002b4012e0574a7fe": "0.11.0",
"46867cc3e4ddcbb1d359a315805de00094dacaf9": "0.10",
"7613b15fdbbb9bf770a2c731f4135886b0ff3cf0": "0.9",
"8a4f0fa6c518eb634687abe9659601d9d2a61899": "0.8",
"a2db7c15ce9f586164cabb15d83fb3f6bbeb3cf5": "0.7",
"00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9": "0.6",
"8b98e5a296d95c5e832db0756828e5bec31c6f50": "0.5",
"39c0d3591e0326874b7263a621ce09ecd64f0eb2": "0.4",
"2f32a1581f522e524009138b33b1c7049ced668d": "0.3",
"0622a74c48a708aec28d25964f4e9b4489580bc7": "0.2",
"16e4369fe3b5f00aa3cdc584a4e41c51c0d3ca8a": "0.1",
}
```
|
```go
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
// Code generated by client-gen. DO NOT EDIT.
package v1beta1
type CSIDriverExpansion interface{}
type CSINodeExpansion interface{}
type StorageClassExpansion interface{}
type VolumeAttachmentExpansion interface{}
```
|
Shallogan's Halt railway station served the area of Straboy in County Donegal, Ireland.
The station opened on 1 July 1903 on the Donegal Railway Company line from Glenties to Stranorlar.
It closed on 15 December 1947 when the County Donegal Railways Joint Committee closed the line from Glenties to Stranorlar in an effort to save money.
Freight services on the route continued until 10 March 1952.
Routes
References
Disused railway stations in County Donegal
Railway stations opened in 1903
1903 establishments in Ireland
1947 disestablishments in Ireland
Railway stations in the Republic of Ireland opened in the 1900s
Railway stations in the Republic of Ireland closed in 1947
|
Porras is a village in the municipality of Tammela, Finland. It lies on the Häme Ox Road and has a population of almost 400 inhabitants. An active village, it has about 30 active enterprises and nine unions, a school, cafeteria, and post office services. Porras is an old Finnish word for "bridge" or "duckboards"; the name comes from a bridge on the Häme Ox Road by the village.
Albert Edelfelt made paintwork Veräjällä in Tammela in 1889.
History
The village was first mentioned around 1470.
Porras was the main village of an administrative division (hallintopitäjä) from the early 1500s to the 1700s, when the division was split into Tammela and Somero. The division was further subdivided into the fourths (neljänneskunnat) of Pitkäjärvi, Hirsjärvi, Tammela and Jokioinen.
References
Villages in Finland
|
```smalltalk
"
Adds accessors (getter and setter) for a variable in a class, if they do not exist.
Usage:
| transformation |
transformation := (RBAddVariableAccessorTransformation
variable: 'variableName'
class: #RBVariableTransformation
classVariable: false)
transform.
(ChangesBrowser changes: transformation model changes changes) open
Preconditions:
- the variable with which the accessors will be created shall exist. The parameter isClassVariable indicates whether to look in the instance or class variables.
"
Class {
#name : 'RBAddVariableAccessorTransformation',
#superclass : 'RBVariableTransformation',
#instVars : [
'getterMethod',
'setterMethod'
],
#category : 'Refactoring-Transformations-Model',
#package : 'Refactoring-Transformations',
#tag : 'Model'
}
{ #category : 'preconditions' }
RBAddVariableAccessorTransformation >> applicabilityPreconditions [
class := self model classObjectFor: className.
^ { (isClassVariable
ifTrue: [
RBCondition definesClassVariable: variableName asSymbol in: class ]
ifFalse: [
RBCondition definesInstanceVariable: variableName in: class ]) }
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> createGetterAccessor [
(self definingClass getterMethodFor: variableName) ifNil: [ self defineGetterMethod ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> createSetterAccessor [
(self definingClass setterMethodFor: variableName)
ifNil: [ self defineSetterMethod ]
ifNotNil: [ setterMethod := self definingClass setterMethodFor: variableName ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> defineGetterMethod [
getterMethod := self safeMethodNameFor: self definingClass basedOn: variableName asString.
self generateChangesFor: (RBAddMethodTransformation
model: self model
sourceCode: ('<1s><r><r><t>^ <2s>' expandMacrosWith: getterMethod with: variableName)
in: self definingClass
withProtocol: 'accessing').
^ getterMethod
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> defineSetterMethod [
| sourceCode |
sourceCode := '<1s> anObject<r><r><t><2s> := anObject'.
setterMethod := self safeMethodNameFor: self definingClass basedOn: variableName asString , ':'.
self generateChangesFor: (RBAddMethodTransformation
model: self model
sourceCode: (sourceCode expandMacrosWith: setterMethod with: variableName)
in: self definingClass
withProtocol: 'accessing').
^ setterMethod
]
{ #category : 'accessing' }
RBAddVariableAccessorTransformation >> definingClass [
"Usually a shared variable is defined on the instance side and instance
variables on both instance and class side."
^ isClassVariable
ifTrue: [ super definingClass classSide ]
ifFalse: [ super definingClass ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> getterMethod [
^ getterMethod
]
{ #category : 'executing' }
RBAddVariableAccessorTransformation >> privateTransform [
self
createGetterAccessor;
createSetterAccessor
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> safeMethodNameFor: aClass basedOn: aString [
"Creates an unused method name containing aString"
| baseString newString hasParam i |
baseString := aString copy.
baseString at: 1 put: baseString first asLowercase.
newString := baseString.
hasParam := newString last = $:.
hasParam
ifTrue: [baseString := newString copyFrom: 1 to: newString size - 1].
i := 0.
[aClass hierarchyDefinesMethod: newString asSymbol] whileTrue:
[i := i + 1.
newString := baseString , i printString
, (hasParam ifTrue: [':'] ifFalse: [''])].
^newString asSymbol
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> setterMethod [
^ setterMethod
]
```
|
```javascript
import macro from 'vtk.js/Sources/macros';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
const { vtkErrorMacro } = macro;
// your_sha256_hash------------
// vtkTextureMapToSphere methods
// your_sha256_hash------------
function vtkTextureMapToSphere(publicAPI, model) {
// Set our className
model.classHierarchy.push('vtkTextureMapToSphere');
publicAPI.requestData = (inData, outData) => {
if (model.deleted) {
return;
}
const input = inData[0];
const nbPoints = input.getPoints().getNumberOfPoints();
if (nbPoints <= 1) {
vtkErrorMacro("Can't generate texture coordinates without points");
return;
}
const piOverTwo = Math.PI / 2;
const x = [];
const points = input.getPoints();
if (model.automaticSphereGeneration) {
model.center = [0, 0, 0];
for (let i = 0; i < nbPoints; i++) {
points.getPoint(i, x);
model.center[0] += x[0];
model.center[1] += x[1];
model.center[2] += x[2];
}
model.center[0] /= nbPoints;
model.center[1] /= nbPoints;
model.center[2] /= nbPoints;
}
let rho = 0;
let diff = 0;
let phi = 0;
const tc = [0, 0];
let r = 0;
let thetaX = 0;
let thetaY = 0;
const tcoordsData = [];
for (let i = 0; i < nbPoints; i++) {
points.getPoint(i, x);
rho = Math.sqrt(vtkMath.distance2BetweenPoints(x, model.center));
if (rho !== 0) {
diff = x[2] - model.center[2];
if (Math.abs(diff) > rho) {
phi = 0;
if (diff > 0) {
tc[1] = 0;
} else {
tc[1] = 1;
}
} else {
phi = Math.acos(diff / rho);
tc[1] = phi / Math.PI;
}
} else {
tc[1] = 0;
}
r = rho * Math.sin(phi);
if (r !== 0) {
diff = x[0] - model.center[0];
if (Math.abs(diff) > r) {
if (diff > 0) {
thetaX = 0;
} else {
thetaX = Math.PI;
}
} else {
thetaX = Math.acos(diff / r);
}
diff = x[1] - model.center[1];
if (Math.abs(diff) > r) {
if (diff > 0) {
thetaY = piOverTwo;
} else {
thetaY = -piOverTwo;
}
} else {
thetaY = Math.asin(diff / r);
}
} else {
thetaX = 0;
thetaY = 0;
}
if (model.preventSeam) {
tc[0] = thetaX / Math.PI;
} else {
tc[0] = thetaX / (2 * Math.PI);
if (thetaY < 0) {
tc[0] = 1 - tc[0];
}
}
tcoordsData.push(...tc);
}
const tCoords = vtkDataArray.newInstance({
name: 'Texture Coordinates',
numberOfComponents: 2,
size: nbPoints,
values: tcoordsData,
});
const output = vtkPolyData.newInstance();
output
.getPoints()
.setData(new Float32Array(input.getPoints().getData()), 3);
output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
output.getPointData().setTCoords(tCoords);
// Update output
outData[0] = output;
};
}
// your_sha256_hash------------
// Object factory
// your_sha256_hash------------
const DEFAULT_VALUES = {
center: [0, 0, 0],
automaticSphereGeneration: 1,
preventSeam: 1,
};
// your_sha256_hash------------
export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, DEFAULT_VALUES, initialValues);
// Build VTK API
macro.obj(publicAPI, model);
macro.setGetArray(publicAPI, model, ['center'], 3);
macro.setGet(publicAPI, model, ['automaticSphereGeneration', 'preventSeam']);
macro.algo(publicAPI, model, 1, 1);
vtkTextureMapToSphere(publicAPI, model);
}
// your_sha256_hash------------
export const newInstance = macro.newInstance(extend, 'vtkTextureMapToSphere');
// your_sha256_hash------------
export default { newInstance, extend };
```
|
```go
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v1
import (
"context"
time "time"
cephrookiov1 "github.com/rook/rook/pkg/apis/ceph.rook.io/v1"
versioned "github.com/rook/rook/pkg/client/clientset/versioned"
internalinterfaces "github.com/rook/rook/pkg/client/informers/externalversions/internalinterfaces"
v1 "github.com/rook/rook/pkg/client/listers/ceph.rook.io/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// CephRBDMirrorInformer provides access to a shared informer and lister for
// CephRBDMirrors.
type CephRBDMirrorInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1.CephRBDMirrorLister
}
type cephRBDMirrorInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewCephRBDMirrorInformer constructs a new informer for CephRBDMirror type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewCephRBDMirrorInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredCephRBDMirrorInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredCephRBDMirrorInformer constructs a new informer for CephRBDMirror type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredCephRBDMirrorInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.CephV1().CephRBDMirrors(namespace).List(context.TODO(), options)
},
WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.CephV1().CephRBDMirrors(namespace).Watch(context.TODO(), options)
},
},
&cephrookiov1.CephRBDMirror{},
resyncPeriod,
indexers,
)
}
func (f *cephRBDMirrorInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredCephRBDMirrorInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *cephRBDMirrorInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&cephrookiov1.CephRBDMirror{}, f.defaultInformer)
}
func (f *cephRBDMirrorInformer) Lister() v1.CephRBDMirrorLister {
return v1.NewCephRBDMirrorLister(f.Informer().GetIndexer())
}
```
|
```kotlin
package com.x8bit.bitwarden.ui.vault.model
import androidx.annotation.DrawableRes
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.ui.platform.base.util.Text
import com.x8bit.bitwarden.ui.platform.base.util.asText
/**
* Represents the icons displayed after the cipher name.
*/
enum class VaultTrailingIcon(
@DrawableRes val iconRes: Int,
val contentDescription: Text,
val testTag: String,
) {
COLLECTION(
iconRes = R.drawable.ic_collection,
contentDescription = R.string.collections.asText(),
testTag = "CipherInCollectionIcon",
),
ATTACHMENT(
iconRes = R.drawable.ic_attachment,
contentDescription = R.string.attachments.asText(),
testTag = "CipherWithAttachmentsIcon",
),
}
```
|
Lascheid is a municipality in the district of Bitburg-Prüm, in Rhineland-Palatinate, western Germany.
Geography
The site is located on a high altitude on a ridge in eastern Islek, which is counted to the southern Eifel . The state border with Luxembourg is about 20 km west of the village. Lascheid also includes a part of the hamlet Gesotz.
59.5% of the municipal area are used for agriculture, 35.6% are forest (status 2012).
To the community border Dackscheid in the north, Lasel in the east, Hargarten in the south and Waxweiler and Pintesfeld in the west.
History
The place probably has its origins in the medieval clearing phases. In 1540 he was first mentioned as "Lasscheid". Until the end of the 18th century Lascheid belonged to the condominium Pronsfeld. In the French rule he was managed by the Mairie Waxweiler, in the Prussian era by the mayor Waxweiler in Prüm.
References
Bitburg-Prüm
|
```xml
import gql from "graphql-tag";
import {
graphql,
GraphQLInt,
print,
DocumentNode,
GraphQLError,
getIntrospectionQuery,
GraphQLSchema,
GraphQLObjectType,
GraphQLID,
GraphQLString,
} from "graphql";
import { Observable } from "../../utilities";
import { ApolloLink } from "../../link/core";
import { Operation } from "../../link/core";
import { ApolloClient } from "../../core";
import { ApolloCache, InMemoryCache } from "../../cache";
import { itAsync } from "../../testing";
import { spyOnConsole } from "../../testing/internal";
describe("General functionality", () => {
it("should not impact normal non-@client use", () => {
const query = gql`
{
field
}
`;
const link = new ApolloLink(() => Observable.of({ data: { field: 1 } }));
const client = new ApolloClient({
cache: new InMemoryCache(),
link,
resolvers: {
Query: {
count: () => 0,
},
},
});
return client.query({ query }).then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
});
});
it("should not interfere with server introspection queries", () => {
const query = gql`
${getIntrospectionQuery()}
`;
const error = new GraphQLError("no introspection result found");
const link = new ApolloLink(() => Observable.of({ errors: [error] }));
const client = new ApolloClient({
cache: new InMemoryCache(),
link,
resolvers: {
Query: {
count: () => 0,
},
},
});
return client
.query({ query })
.then(() => {
throw new global.Error("should not call");
})
.catch((error: GraphQLError) =>
expect(error.message).toMatch(/no introspection/)
);
});
it("should support returning default values from resolvers", () => {
const query = gql`
{
field @client
}
`;
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers: {
Query: {
field: () => 1,
},
},
});
return client.query({ query }).then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
});
});
it("should cache data for future lookups", () => {
const query = gql`
{
field @client
}
`;
let count = 0;
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers: {
Query: {
field: () => {
count += 1;
return 1;
},
},
},
});
return client
.query({ query })
.then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
expect(count).toBe(1);
})
.then(() =>
client.query({ query }).then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
expect(count).toBe(1);
})
);
});
it("should honour `fetchPolicy` settings", () => {
const query = gql`
{
field @client
}
`;
let count = 0;
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers: {
Query: {
field: () => {
count += 1;
return 1;
},
},
},
});
return client
.query({ query })
.then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
expect(count).toBe(1);
})
.then(() =>
client
.query({ query, fetchPolicy: "network-only" })
.then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
expect(count).toBe(2);
})
);
});
it("should work with a custom fragment matcher", () => {
const query = gql`
{
foo {
... on Bar {
bar @client
}
... on Baz {
baz @client
}
}
}
`;
const link = new ApolloLink(() =>
Observable.of({
data: { foo: [{ __typename: "Bar" }, { __typename: "Baz" }] },
})
);
const resolvers = {
Bar: {
bar: () => "Bar",
},
Baz: {
baz: () => "Baz",
},
};
const fragmentMatcher = (
{ __typename }: { __typename: string },
typeCondition: string
) => __typename === typeCondition;
const client = new ApolloClient({
cache: new InMemoryCache({
possibleTypes: {
Foo: ["Bar", "Baz"],
},
}),
link,
resolvers,
fragmentMatcher,
});
return client.query({ query }).then(({ data }) => {
expect(data).toMatchObject({ foo: [{ bar: "Bar" }, { baz: "Baz" }] });
});
});
});
describe("Cache manipulation", () => {
it(
"should be able to query @client fields and the cache without defining " +
"local resolvers",
() => {
const query = gql`
{
field @client
}
`;
const cache = new InMemoryCache();
const client = new ApolloClient({
cache,
link: ApolloLink.empty(),
resolvers: {},
});
cache.writeQuery({ query, data: { field: "yo" } });
client
.query({ query })
.then(({ data }) => expect({ ...data }).toMatchObject({ field: "yo" }));
}
);
it("should be able to write to the cache using a local mutation", () => {
const query = gql`
{
field @client
}
`;
const mutation = gql`
mutation start {
start @client
}
`;
const resolvers = {
Mutation: {
start: (_1: any, _2: any, { cache }: { cache: InMemoryCache }) => {
cache.writeQuery({ query, data: { field: 1 } });
return { start: true };
},
},
};
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers,
});
return client
.mutate({ mutation })
.then(() => client.query({ query }))
.then(({ data }) => {
expect({ ...data }).toMatchObject({ field: 1 });
});
});
itAsync(
"should be able to write to the cache with a local mutation and have " +
"things rerender automatically",
(resolve, reject) => {
const query = gql`
{
field @client
}
`;
const mutation = gql`
mutation start {
start @client
}
`;
const resolvers = {
Query: {
field: () => 0,
},
Mutation: {
start: (_1: any, _2: any, { cache }: { cache: InMemoryCache }) => {
cache.writeQuery({ query, data: { field: 1 } });
return { start: true };
},
},
};
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers,
});
let count = 0;
client.watchQuery({ query }).subscribe({
next: ({ data }) => {
count++;
if (count === 1) {
expect({ ...data }).toMatchObject({ field: 0 });
client.mutate({ mutation });
}
if (count === 2) {
expect({ ...data }).toMatchObject({ field: 1 });
resolve();
}
},
});
}
);
it("should support writing to the cache with a local mutation using variables", () => {
const query = gql`
{
field @client
}
`;
const mutation = gql`
mutation start($id: ID!) {
start(field: $id) @client {
field
}
}
`;
const resolvers = {
Mutation: {
start: (
_1: any,
variables: { field: string },
{ cache }: { cache: ApolloCache<any> }
) => {
cache.writeQuery({ query, data: { field: variables.field } });
return {
__typename: "Field",
field: variables.field,
};
},
},
};
const client = new ApolloClient({
cache: new InMemoryCache(),
link: ApolloLink.empty(),
resolvers,
});
return client
.mutate({ mutation, variables: { id: "1234" } })
.then(({ data }) => {
expect({ ...data }).toEqual({
start: { field: "1234", __typename: "Field" },
});
})
.then(() => client.query({ query }))
.then(({ data }) => {
expect({ ...data }).toMatchObject({ field: "1234" });
});
});
itAsync(
"should read @client fields from cache on refetch (#4741)",
(resolve, reject) => {
const query = gql`
query FetchInitialData {
serverData {
id
title
}
selectedItemId @client
}
`;
const mutation = gql`
mutation Select {
select(itemId: $id) @client
}
`;
const serverData = {
__typename: "ServerData",
id: 123,
title: "Oyez and Onoz",
};
let selectedItemId = -1;
const client = new ApolloClient({
cache: new InMemoryCache(),
link: new ApolloLink(() => Observable.of({ data: { serverData } })),
resolvers: {
Query: {
selectedItemId() {
return selectedItemId;
},
},
Mutation: {
select(_, { itemId }) {
selectedItemId = itemId;
},
},
},
});
client.watchQuery({ query }).subscribe({
next(result) {
expect(result).toEqual({
data: {
serverData,
selectedItemId,
},
loading: false,
networkStatus: 7,
});
if (selectedItemId !== 123) {
client.mutate({
mutation,
variables: {
id: 123,
},
refetchQueries: ["FetchInitialData"],
});
} else {
resolve();
}
},
});
}
);
itAsync(
"should rerun @client(always: true) fields on entity update",
(resolve, reject) => {
const query = gql`
query GetClientData($id: ID) {
clientEntity(id: $id) @client(always: true) {
id
title
titleLength @client(always: true)
}
}
`;
const mutation = gql`
mutation AddOrUpdate {
addOrUpdate(id: $id, title: $title) @client
}
`;
const fragment = gql`
fragment ClientDataFragment on ClientData {
id
title
}
`;
const client = new ApolloClient({
cache: new InMemoryCache(),
link: new ApolloLink(() => Observable.of({ data: {} })),
resolvers: {
ClientData: {
titleLength(data) {
return data.title.length;
},
},
Query: {
clientEntity(_root, { id }, { cache }) {
return cache.readFragment({
id: cache.identify({ id, __typename: "ClientData" }),
fragment,
});
},
},
Mutation: {
addOrUpdate(_root, { id, title }, { cache }) {
return cache.writeFragment({
id: cache.identify({ id, __typename: "ClientData" }),
fragment,
data: { id, title, __typename: "ClientData" },
});
},
},
},
});
const entityId = 1;
const shortTitle = "Short";
const longerTitle = "A little longer";
client.mutate({
mutation,
variables: {
id: entityId,
title: shortTitle,
},
});
let mutated = false;
client.watchQuery({ query, variables: { id: entityId } }).subscribe({
next(result) {
if (!mutated) {
expect(result.data.clientEntity).toEqual({
id: entityId,
title: shortTitle,
titleLength: shortTitle.length,
__typename: "ClientData",
});
client.mutate({
mutation,
variables: {
id: entityId,
title: longerTitle,
},
});
mutated = true;
} else if (mutated) {
expect(result.data.clientEntity).toEqual({
id: entityId,
title: longerTitle,
titleLength: longerTitle.length,
__typename: "ClientData",
});
resolve();
}
},
});
}
);
});
describe("Sample apps", () => {
itAsync(
"should support a simple counter app using local state",
(resolve, reject) => {
const query = gql`
query GetCount {
count @client
lastCount # stored in db on server
}
`;
const increment = gql`
mutation Increment($amount: Int = 1) {
increment(amount: $amount) @client
}
`;
const decrement = gql`
mutation Decrement($amount: Int = 1) {
decrement(amount: $amount) @client
}
`;
const link = new ApolloLink((operation) => {
expect(operation.operationName).toBe("GetCount");
return Observable.of({ data: { lastCount: 1 } });
});
const client = new ApolloClient({
link,
cache: new InMemoryCache(),
resolvers: {},
});
const update = (
query: DocumentNode,
updater: (data: { count: number }, variables: { amount: number }) => any
) => {
return (
_result: {},
variables: { amount: number },
{ cache }: { cache: ApolloCache<any> }
): null => {
const read = client.readQuery<{ count: number }>({
query,
variables,
});
if (read) {
const data = updater(read, variables);
cache.writeQuery({ query, variables, data });
} else {
throw new Error("readQuery returned a falsy value");
}
return null;
};
};
const resolvers = {
Query: {
count: () => 0,
},
Mutation: {
increment: update(query, ({ count, ...rest }, { amount }) => ({
...rest,
count: count + amount,
})),
decrement: update(query, ({ count, ...rest }, { amount }) => ({
...rest,
count: count - amount,
})),
},
};
client.addResolvers(resolvers);
let count = 0;
client.watchQuery({ query }).subscribe({
next: ({ data }) => {
count++;
if (count === 1) {
try {
expect({ ...data }).toMatchObject({ count: 0, lastCount: 1 });
} catch (e) {
reject(e);
}
client.mutate({ mutation: increment, variables: { amount: 2 } });
}
if (count === 2) {
try {
expect({ ...data }).toMatchObject({ count: 2, lastCount: 1 });
} catch (e) {
reject(e);
}
client.mutate({ mutation: decrement, variables: { amount: 1 } });
}
if (count === 3) {
try {
expect({ ...data }).toMatchObject({ count: 1, lastCount: 1 });
} catch (e) {
reject(e);
}
resolve();
}
},
error: (e) => reject(e),
complete: reject,
});
}
);
itAsync(
"should support a simple todo app using local state",
(resolve, reject) => {
const query = gql`
query GetTasks {
todos @client {
message
title
}
}
`;
const mutation = gql`
mutation AddTodo($message: String, $title: String) {
addTodo(message: $message, title: $title) @client
}
`;
const client = new ApolloClient({
link: ApolloLink.empty(),
cache: new InMemoryCache(),
resolvers: {},
});
interface Todo {
title: string;
message: string;
__typename: string;
}
const update = (
query: DocumentNode,
updater: (todos: any, variables: Todo) => any
) => {
return (
_result: {},
variables: Todo,
{ cache }: { cache: ApolloCache<any> }
): null => {
const data = updater(
client.readQuery({ query, variables }),
variables
);
cache.writeQuery({ query, variables, data });
return null;
};
};
const resolvers = {
Query: {
todos: () => [],
},
Mutation: {
addTodo: update(query, ({ todos }, { title, message }: Todo) => ({
todos: todos.concat([{ message, title, __typename: "Todo" }]),
})),
},
};
client.addResolvers(resolvers);
let count = 0;
client.watchQuery({ query }).subscribe({
next: ({ data }: any) => {
count++;
if (count === 1) {
expect({ ...data }).toMatchObject({ todos: [] });
client.mutate({
mutation,
variables: {
title: "Apollo Client 2.0",
message: "ship it",
},
});
} else if (count === 2) {
expect(data.todos.map((x: Todo) => ({ ...x }))).toMatchObject([
{
title: "Apollo Client 2.0",
message: "ship it",
__typename: "Todo",
},
]);
resolve();
}
},
});
}
);
});
describe("Combining client and server state/operations", () => {
itAsync("should merge remote and local state", (resolve, reject) => {
const query = gql`
query list {
list(name: "my list") {
items {
id
name
isDone
isSelected @client
}
}
}
`;
const data = {
list: {
__typename: "List",
items: [
{ __typename: "ListItem", id: 1, name: "first", isDone: true },
{ __typename: "ListItem", id: 2, name: "second", isDone: false },
],
},
};
const link = new ApolloLink(() => Observable.of({ data }));
const client = new ApolloClient({
cache: new InMemoryCache(),
link,
resolvers: {
Mutation: {
toggleItem: async (_, { id }, { cache }) => {
id = `ListItem:${id}`;
const fragment = gql`
fragment item on ListItem {
__typename
isSelected
}
`;
const previous = cache.readFragment({ fragment, id });
const data = {
...previous,
isSelected: !previous.isSelected,
};
await cache.writeFragment({
id,
fragment,
data,
});
return data;
},
},
ListItem: {
isSelected(source) {
expect(source.name).toBeDefined();
// List items default to an unselected state
return false;
},
},
},
});
const observer = client.watchQuery({ query });
let count = 0;
observer.subscribe({
next: (response) => {
if (count === 0) {
const initial = { ...data };
initial.list.items = initial.list.items.map((x) => ({
...x,
isSelected: false,
}));
expect(response.data).toMatchObject(initial);
}
if (count === 1) {
expect((response.data as any).list.items[0].isSelected).toBe(true);
expect((response.data as any).list.items[1].isSelected).toBe(false);
resolve();
}
count++;
},
error: reject,
});
const variables = { id: 1 };
const mutation = gql`
mutation SelectItem($id: Int!) {
toggleItem(id: $id) @client
}
`;
// After initial result, toggle the state of one of the items
setTimeout(() => {
client.mutate({ mutation, variables });
}, 10);
});
itAsync(
"query resolves with loading: false if subsequent responses contain the same data",
(resolve, reject) => {
const request = {
query: gql`
query people($id: Int) {
people(id: $id) {
id
name
}
}
`,
variables: {
id: 1,
},
notifyOnNetworkStatusChange: true,
};
const PersonType = new GraphQLObjectType({
name: "Person",
fields: {
id: { type: GraphQLID },
name: { type: GraphQLString },
},
});
const peopleData = [
{ id: 1, name: "John Smith" },
{ id: 2, name: "Sara Smith" },
{ id: 3, name: "Budd Deey" },
];
const QueryType = new GraphQLObjectType({
name: "Query",
fields: {
people: {
type: PersonType,
args: {
id: {
type: GraphQLInt,
},
},
resolve: (_, { id }) => {
return peopleData;
},
},
},
});
const schema = new GraphQLSchema({ query: QueryType });
const link = new ApolloLink((operation) => {
// @ts-ignore
return new Observable(async (observer) => {
const { query, operationName, variables } = operation;
try {
const result = await graphql({
schema,
source: print(query),
variableValues: variables,
operationName,
});
observer.next(result);
observer.complete();
} catch (err) {
observer.error(err);
}
});
});
const client = new ApolloClient({
cache: new InMemoryCache(),
link,
});
const observer = client.watchQuery(request);
let count = 0;
observer.subscribe({
next: ({ loading, data }) => {
if (count === 0) expect(loading).toBe(false);
if (count === 1) expect(loading).toBe(true);
if (count === 2) {
expect(loading).toBe(false);
resolve();
}
count++;
},
error: reject,
});
setTimeout(() => {
observer.refetch({
id: 2,
});
}, 1);
}
);
itAsync(
"should correctly propagate an error from a client resolver",
async (resolve, reject) => {
const data = {
list: {
__typename: "List",
items: [
{ __typename: "ListItem", id: 1, name: "first", isDone: true },
{ __typename: "ListItem", id: 2, name: "second", isDone: false },
],
},
};
const link = new ApolloLink(() => Observable.of({ data }));
const client = new ApolloClient({
cache: new InMemoryCache(),
link,
resolvers: {
Query: {
hasBeenIllegallyTouched: (_, _v, _c) => {
throw new Error("Illegal Query Operation Occurred");
},
},
Mutation: {
touchIllegally: (_, _v, _c) => {
throw new Error("Illegal Mutation Operation Occurred");
},
},
},
});
const variables = { id: 1 };
const query = gql`
query hasBeenIllegallyTouched($id: Int!) {
hasBeenIllegallyTouched(id: $id) @client
}
`;
const mutation = gql`
mutation SelectItem($id: Int!) {
touchIllegally(id: $id) @client
}
`;
try {
await client.query({ query, variables });
reject("Should have thrown!");
} catch (e) {
// Test Passed!
expect(() => {
throw e;
}).toThrowErrorMatchingSnapshot();
}
try {
await client.mutate({ mutation, variables });
reject("Should have thrown!");
} catch (e) {
// Test Passed!
expect(() => {
throw e;
}).toThrowErrorMatchingSnapshot();
}
resolve();
}
);
it("should handle a simple query with both server and client fields", async () => {
using _consoleSpies = spyOnConsole.takeSnapshots("error");
await new Promise<void>((resolve, reject) => {
const query = gql`
query GetCount {
count @client
lastCount
}
`;
const cache = new InMemoryCache();
const link = new ApolloLink((operation) => {
expect(operation.operationName).toBe("GetCount");
return Observable.of({ data: { lastCount: 1 } });
});
const client = new ApolloClient({
cache,
link,
resolvers: {},
});
cache.writeQuery({
query,
data: {
count: 0,
},
});
client.watchQuery({ query }).subscribe({
next: ({ data }) => {
expect({ ...data }).toMatchObject({ count: 0, lastCount: 1 });
resolve();
},
});
});
});
it("should support nested querying of both server and client fields", async () => {
using _consoleSpies = spyOnConsole.takeSnapshots("error");
await new Promise<void>((resolve, reject) => {
const query = gql`
query GetUser {
user {
firstName @client
lastName
}
}
`;
const cache = new InMemoryCache();
const link = new ApolloLink((operation) => {
expect(operation.operationName).toBe("GetUser");
return Observable.of({
data: {
user: {
__typename: "User",
// We need an id (or a keyFields policy) because, if the User
// object is not identifiable, the call to cache.writeQuery
// below will simply replace the existing data rather than
// merging the new data with the existing data.
id: 123,
lastName: "Doe",
},
},
});
});
const client = new ApolloClient({
cache,
link,
resolvers: {},
});
cache.writeQuery({
query,
data: {
user: {
__typename: "User",
id: 123,
firstName: "John",
},
},
});
client.watchQuery({ query }).subscribe({
next({ data }: any) {
const { user } = data;
try {
expect(user).toMatchObject({
firstName: "John",
lastName: "Doe",
__typename: "User",
});
} catch (e) {
reject(e);
}
resolve();
},
});
});
});
itAsync(
"should combine both server and client mutations",
(resolve, reject) => {
const query = gql`
query SampleQuery {
count @client
user {
firstName
}
}
`;
const mutation = gql`
mutation SampleMutation {
incrementCount @client
updateUser(firstName: "Harry") {
firstName
}
}
`;
const counterQuery = gql`
{
count @client
}
`;
const userQuery = gql`
{
user {
firstName
}
}
`;
let watchCount = 0;
const link = new ApolloLink((operation: Operation): Observable<{}> => {
if (operation.operationName === "SampleQuery") {
return Observable.of({
data: { user: { __typename: "User", firstName: "John" } },
});
}
if (operation.operationName === "SampleMutation") {
return Observable.of({
data: { updateUser: { __typename: "User", firstName: "Harry" } },
});
}
return Observable.of({
errors: [new Error(`Unknown operation ${operation.operationName}`)],
});
});
const cache = new InMemoryCache();
const client = new ApolloClient({
cache,
link,
resolvers: {
Mutation: {
incrementCount: (_, __, { cache }) => {
const { count } = cache.readQuery({ query: counterQuery });
const data = { count: count + 1 };
cache.writeQuery({
query: counterQuery,
data,
});
return null;
},
},
},
});
cache.writeQuery({
query: counterQuery,
data: {
count: 0,
},
});
client.watchQuery({ query }).subscribe({
next: ({ data }: any) => {
if (watchCount === 0) {
expect(data.count).toEqual(0);
expect({ ...data.user }).toMatchObject({
__typename: "User",
firstName: "John",
});
watchCount += 1;
client.mutate({
mutation,
update(proxy, { data: { updateUser } }) {
proxy.writeQuery({
query: userQuery,
data: {
user: { ...updateUser },
},
});
},
});
} else {
expect(data.count).toEqual(1);
expect({ ...data.user }).toMatchObject({
__typename: "User",
firstName: "Harry",
});
resolve();
}
},
});
}
);
itAsync(
"handles server errors when root data property is null",
(resolve, reject) => {
const query = gql`
query GetUser {
user {
firstName @client
lastName
}
}
`;
const cache = new InMemoryCache();
const link = new ApolloLink((operation) => {
return Observable.of({
data: null,
errors: [
new GraphQLError("something went wrong", {
extensions: {
code: "INTERNAL_SERVER_ERROR",
},
path: ["user"],
}),
],
});
});
const client = new ApolloClient({
cache,
link,
resolvers: {},
});
client.watchQuery({ query }).subscribe({
error(error) {
expect(error.message).toEqual("something went wrong");
resolve();
},
next() {
reject();
},
});
}
);
});
```
|
Aghol Beyk-e Sofla (, also Romanized as Āghol Beyk-e Soflá; also known as Aghalbak, Aqalbak Pāin, Ash Oghulbeyn, Ogholbeyg, Oghol Beyg-e Pā’īn, Owghlī Beyg-e Soflá, and Owghol Beyg-e Pā’īn) is a village in Ijrud-e Bala Rural District of the Central District of Ijrud County, Zanjan province, Iran.
At the 2006 National Census, its population was 930 in 229 households. The following census in 2011 counted 1,101 people in 286 households. The latest census in 2016 showed a population of 1,155 people in 335 households; it was the largest village in its rural district.
References
Ijrud County
Populated places in Zanjan Province
Populated places in Ijrud County
|
```smalltalk
using Chloe.DbExpressions;
using Chloe.RDBMS;
using Chloe.RDBMS.MethodHandlers;
namespace Chloe.SQLite.MethodHandlers
{
class TrimEnd_Handler : TrimEnd_HandlerBase
{
public override void Process(DbMethodCallExpression exp, SqlGeneratorBase generator)
{
PublicHelper.EnsureTrimCharArgumentIsSpaces(exp.Arguments[0]);
generator.SqlBuilder.Append("RTRIM(");
exp.Object.Accept(generator);
generator.SqlBuilder.Append(")");
}
}
}
```
|
The Research Organization for Social Sciences and Humanities (, OR-IPSH), but goes by name Institute of Social Sciences and Humanities-BRIN or ISSH-BRIN, is one of Research Organizations under the umbrella of the National Research and Innovation Agency (, BRIN). It was founded on 1 September 2021 as transformation of Deputy IV (Social Sciences and Humanities) of Indonesian Institute of Sciences (, LIPI) after the liquidation of LIPI into BRIN.
On 24 January 2022, it is announced that the organization extended with fusion of elements from various elements from General Secretariat of People's Consultative Assembly, General Secretariat of Regional Representative Council, General Secretariat of People's Representative Council, former Agency for Research and Development and Book Affairs of the Ministry of Education and Culture (now Ministry of Education, Culture, Research and Technology), Ministry of Law and Human Rights, Ministry of Religious Affairs, National Population and Family Planning Agency, Ministry of Agrarian Affairs and Spatial Planning/National Land Agency. Total number of researchers at this institute is around 400 people.
History
Founded on 1 September 2021, OR-IPSH is transformation of Deputy IV (Social Sciences and Humanities) of LIPI after the liquidation of LIPI into BRIN. As a research organization of BRIN, as outlined in Article 175 and Article 176 of Chief of BRIN Decree No. 1/2021, every Research Organizations under BRIN are responsible and answered to Chief of BRIN. It also prescribed that the Research Organizations consisted with Head of Research Organizations, Centers, and Laboratories/Study Groups. For the transitional period, as in Article 210 of Chief of BRIN Decree No. 1/2021 mandated, the structure of OR-IPSH follows the preceding structure that already established during its time in LIPI. Due to this, the structure of ORIPSH follows the Chief of LIPI Decree No. 24/2020.
On 22 September 2021, OR-IPSH constituting document, Chief of BRIN Decree No. 10/2021, signed by Laksana Tri Handoko and fully published on 8 October 2021.
On 24 January 2022, it is announced that the organization extended with fusion from various elements for former research and development of various governmental agencies, significantly expanding the structure of OR-IPSH. The new structure will be effective from 1 February 2022. OR-IPSH formation is finalized on 1 March 2022 and is functional since 4 March 2022 since inauguration of its first head, Ahmad Najib Burhani.
Preceding agencies
Based on the structure of the current OR-IPSH, the preceding agencies of the OR-IPSH were:
Center for Research and Development of the National Population and Family Planning Agency
Center for Development and Standardization of Agrarian Affairs and Spatial Planning Policies of the Ministry of Agrarian Affairs and Spatial Planning/National Land Agency
General Secretariat of People's Consultative Assembly
General Secretariat of Regional Representative Council
General Secretariat of People's Representative Council
Agency for Law and Human Rights Research and Development of the Ministry of Law and Human Rights
former Agency for Research and Development and Book Affairs of the Ministry of Education and Culture
Research, Development, Education, and Training Agency of the Ministry of Religious Affairs
Structure
The structure of ORIPSH is as follows:
Office of the Chairman of OR-IPSH
Research Center for Society and Culture
Research Center for Politics
Research Center for Population
Research Center for Area Studies
Research Center for Law
Research Center for Education
Research Center for Religious Harmony and Moderation
Research Center for Religion and Belief
Research Groups
List of heads
References
Science and technology in Indonesia
2021 establishments in Indonesia
Research institutes in Indonesia
National Research and Innovation Agency
|
```python
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# A super basic python webhook receiver
# Run in a new terminal as:
#
# ./hook.py 0.0.0.0 8123
#
# Then setup your runserver.py with `-wh path_to_url`
import sys
import time
import json
import pprint
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
HOST_NAME = sys.argv[1]
HOST_PORT = int(sys.argv[2])
class S(BaseHTTPRequestHandler):
def do_POST(self):
data_string = self.rfile.read(int(self.headers['Content-Length']))
self.send_response(200)
self.end_headers()
pprint.pprint(json.loads(data_string))
if __name__ == '__main__':
httpd = HTTPServer((HOST_NAME, HOST_PORT), S)
print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, HOST_PORT)
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, HOST_PORT)
```
|
Coffin v. United States, 156 U.S. 432 (1895), was an appellate case before the United States Supreme Court in 1895 which established the presumption of innocence of persons accused of crimes.
F. A. Coffin and Percival B. Coffin, plaintiffs in error, and A. S. Reed had been charged with aiding and abetting the former president of the Indianapolis National Bank, Theodore P. Haughey, in misdemeanor bank fraud between January 1, 1891, and July 26, 1893.
It is a complex case with a 50-count indictment. But the most interesting aspect is commentary by the Court regarding presumption of innocence:
In the decision, the Court then goes on to detail the complete legal history of presumed innocence.
See also
Reasonable doubt
List of United States Supreme Court cases, volume 156
Further reading
External links
1895 in United States case law
United States criminal burden of proof case law
United States Supreme Court cases
United States Supreme Court cases of the Fuller Court
|
State Route 149 (SR-149) is a state highway in Uintah County in the U.S. state of Utah that connects U.S. Route 40 (US-40) in the town of Jensen with Dinosaur National Monument, to the north.
Route description
State Route 149 starts in the town of Jensen, Utah, travelling north on 9500 East. As it leaves town, it turns slightly to the east as the road turns into Quarry Entrance Road. While the road continues north into the Dinosaur National Monument, the legislated route ends at the monument boundary.
History
Route 149 was established on June 26, 1933, as the road from Jensen to the museum at Dinosaur National Monument. No changes were made to the route until August 20, 1987, when the state legislature determined that because state maintenance of the road ended at the monument boundary, the state route should be shortened so the route would also end at the boundary.
Major intersections
References
149
149
|
Rue Van Dyck is a street in Beirut, Lebanon. The street, which is located in the Ras Beirut district, was named after Cornelius Van Allen Van Dyck, who was professor of pathology and internal medicine in the medical school at the American University of Beirut from 1857 until 1882. The street runs east–west from Rue John Kennedy to Rue George Post.
See also
Ras Beirut
Beirut
References
Van Dyck, Rue
|
```ruby
RSpec.shared_context "form" do |field, value|
include_context "template" do
let(:admin) { double(readonly?: false) }
end
let(:builder) { Trestle::Form::Builder.new(object_name, object, template, options) }
let(:object_name) { :article }
let(:object) { double(errors: ActiveModel::Errors.new([])) }
let(:options) { {} }
before(:each) do
allow(object).to receive_messages(field => value)
end if field
end
```
|
Utricularia malabarica is a small annual carnivorous plant that belongs to the genus Utricularia. It is endemic to southern India and has been collected from the Kasaragod district. U. malabarica grows over wet rocks or lateritic soils in the presence of Eriocaulon species and grasses. It was originally collected by M. K. Janarthanam in 1985 and was formally described by Janarthanam and Ambrose Nathaniel Henry in 1989. It is most closely related to U. lazulina.
See also
List of Utricularia species
References
Carnivorous plants of Asia
Flora of India (region)
Plants described in 1989
malabarica
|
```html
<!DOCTYPE html>
<html lang="zh-TW">
<head>
<meta charset="utf-8">
<meta http-equiv="x-ua-compatible" content="ie=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title> - </title>
<meta property="og:title" content=" - ">
<meta property="og:type" content="website">
<meta property="og:url" content="path_to_url">
<meta property="og:image" content="path_to_url">
<meta property="og:description" content="">
<meta property="og:locale" content="zh-TW">
<link rel="canonical" href="path_to_url">
<link rel="alternate" href="path_to_url" hreflang="en">
<link rel="alternate" href="path_to_url" hreflang="pl">
<link rel="alternate" href="path_to_url" hreflang="zh-CN">
<link rel="alternate" href="path_to_url" hreflang="zh-TW">
<link rel="stylesheet" href="../../thirdparty/bootstrap-3.3.7/bootstrap.min.css">
<link rel="stylesheet" href="gallery.css">
<link rel="icon" href="../../icon128.png" type="image/png">
</head>
<body>
<div class="navbar navbar-fixed-top container" style="background-color:white;max-height:90px;overflow:hidden">
<a href="path_to_url" class="navbar-left brand">
<img src="../../icon128.png" alt="" style="width:18pt; height:18pt">
</a>
<div class="navbar-right">
<span class="navul">
<a href="path_to_url"></a>
<a href="path_to_url" class="active"></a>
<a href="path_to_url"></a>
</span>
<span class="github-button-container">
<a class="github-button" href="path_to_url" data-show-count="true" aria-label="Star ricktu288/ray-optics on GitHub">Star</a>
</span>
</div>
</div>
<div class="container">
<center>
<h1><b><span></span></b></h1>
<p>
Stas Fainer
</p>
<div class="description">
<p>Maxwell fisheye lens \(n(\rho) = \frac{n_0}{1+(\frac{\rho}{R})^2} \) \(n_0=2\) \(R=100\) \(\rho\) </p><p> \(N=20\) \(R_i=5(N+1-i)\) \(n_i = \frac{n_0}{1+(\frac{R_i}{R})^2} \) \(i=1,...,N\) \(i\) \(n_{i}^\text{numerical}=\frac{n_i}{\prod\limits_{k=i+1}^{N}n_k}\)</p><p>\(n(r)\)</p>
</div>
<p>
<a href="path_to_url#../tw/gallery/maxwell-fisheye-lens" target="_blank" class="btn btn-success btn-lg"></a>
</p>
<img src="maxwell-fisheye-lens.png" alt="" style="width:100%">
</center>
<div style="float: right; padding-top: 10px;">
<div class="dropup">
<button class="btn btn-default dropdown-toggle" type="button" data-toggle="dropdown">
<span id="language"></span>
<span class="caret"></span></button>
<ul class="dropdown-menu">
<li><a href="path_to_url">English</a></li><li><a href="path_to_url">polski</a></li><li><a href="path_to_url"></a></li><li><a href="path_to_url"></a></li>
</ul>
</div>
</div>
</div>
</div>
<script src="../../thirdparty/jquery.min.js"></script>
<script src="../../thirdparty/bootstrap-3.3.7/bootstrap.min.js"></script>
<script async defer src="path_to_url"></script>
<script src="path_to_url"></script>
<script id="MathJax-script" async src="path_to_url"></script>
</body>
</html>
```
|
Osmin Adrian Eugén Strömberg (4 March 1895 – 15 January 1971) was a Swedish physician. He served as Surgeon-in-Chief of the Swedish Army and head of the Swedish Army Medical Corps from 1953 to 1960.
Early life
Strömberg was born on 4 March 1895 in Oskarshamn Parish, Sweden, the son of Håkan Strömberg and his wife Lovisa Jonsson. He passed studentexamen in Kalmar in 1913 and received a Bachelor of Medical Sciences degree in Stockholm in 1918 and a Licentiate of Medical Science degree in 1923 and finally a Doctor of Medicine degree in 1931,
Career
Strömberg held various hospital positions in Uppsala and Gothenburg from 1929 to 1938.
Strömberg became a battalion surgeon in Västmanland Regiment in Västerås in 1923 and regimental surgeon there in 1927 and served in the same position in North Scanian Infantry Regiment in Kristianstad from 1930 to 1934 as well as in Göta Artillery Regiment in Gothenburg from 1934 to 1940. Strömberg served as health inspector from 1940 and 1949 and as an army surgeon in 1942. He became Acting Surgeon-in-Chief of the Swedish Army with the colonel's service class in 1949 and then served as Surgeon-in-Chief of the Swedish Army and head of the Swedish Army Medical Corps from 1953 to 1960.
Strömberg was a member of the 1944 Military Health Care Committee (1944 års militärsjukvårdskommitté), 1946 Eyesight Requirements Committee (1946 års synkravskommitté), the Military Doctor Salary Inquiry (militärläkarlöneutredningen) and an expert in the inquiry into health care during war in 1951.
Personal life
In 1920, Strömberg married Ada Lundmark-Sundström (1895–1960), the daughter of restaurantkeeper Fredrik Sundström and Theresia Sjöblom. They had five children: Bertel (born 1921), Eugen (born 1922), Gunnar (born 1924), Ulf (born 1925), Ånn (born 1937).
Death
Strömberg died on 15 January 1971 in Oscar Parish, Stockholm.
Awards and decorations
Swedish
Commander of the Order of the Polar Star (23 November 1953)
Knight of the Order of Vasa (1938)
Swedish Red Cross Silver Medal
Foreign
Commander 1st Class of the Order of the Lion of Finland
King Haakon VII Freedom Cross
Honours
Member of the Royal Swedish Academy of War Sciences (1954)
References
1895 births
1971 deaths
Swedish military doctors
People from Oskarshamn Municipality
Members of the Royal Swedish Academy of War Sciences
Commanders of the Order of the Polar Star
Knights of the Order of Vasa
Swedish colonels
|
```c++
#include <gtest/gtest.h>
#include <nnpack.h>
#include <nnpack/macros.h>
#include <nnpack/hwinfo.h>
#include <testers/convolution.h>
/*
* Test that implementation works for a single tile of transformation
*/
TEST(FT8x8, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
TEST(FT8x8, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
TEST(FT16x16, single_tile) {
ConvolutionTester()
.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
TEST(FT16x16, single_tile_with_relu) {
ConvolutionTester()
.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
TEST(WT8x8, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#if NNP_BACKEND_ARM
TEST(WT8x8, single_tile_with_subsample2x2) {
ConvolutionTester()
.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, single_tile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
TEST(WT8x8_FP16, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
TEST(FT8x8_PRECOMPUTE, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
TEST(FT8x8_PRECOMPUTE, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
TEST(FT16x16_PRECOMPUTE, single_tile) {
ConvolutionTester()
.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
TEST(FT16x16_PRECOMPUTE, single_tile_with_relu) {
ConvolutionTester()
.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
TEST(WT8x8_PRECOMPUTE, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, single_tile_with_subsample2x2) {
ConvolutionTester()
.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, single_tile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, single_tile) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
TEST(WT8x8_FP16_PRECOMPUTE, single_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
/*
* Test that the implementation handles extraction of input subtile
*/
TEST(FT8x8, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
TEST(FT8x8, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
TEST(FT16x16, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
TEST(FT16x16, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
TEST(WT8x8, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#if NNP_BACKEND_ARM
TEST(WT8x8, input_subtile_with_subsample2x2) {
ConvolutionTester()
.inputSize(4, 4)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, input_subtile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(4, 4)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
TEST(WT8x8_FP16, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
TEST(FT8x8_PRECOMPUTE, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
TEST(FT8x8_PRECOMPUTE, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
TEST(FT16x16_PRECOMPUTE, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
TEST(FT16x16_PRECOMPUTE, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
TEST(WT8x8_PRECOMPUTE, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, input_subtile_with_subsample2x2) {
ConvolutionTester()
.inputSize(4, 4)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, input_subtile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(4, 4)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-4)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, input_subtile) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
TEST(WT8x8_FP16_PRECOMPUTE, input_subtile_with_relu) {
ConvolutionTester()
.inputSize(4, 4)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
/*
* Test that the implementation handles multi-tile inputs
*/
TEST(FT8x8, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
TEST(FT8x8, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
TEST(FT16x16, multi_tile) {
ConvolutionTester()
.inputSize(29, 29)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
TEST(FT16x16, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(29, 29)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
TEST(WT8x8, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#if NNP_BACKEND_ARM
TEST(WT8x8, multi_tile_with_subsample2x2) {
ConvolutionTester()
.inputSize(13, 13)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, multi_tile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(13, 13)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
TEST(WT8x8_FP16, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
TEST(FT8x8_PRECOMPUTE, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
TEST(FT8x8_PRECOMPUTE, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
TEST(FT16x16_PRECOMPUTE, multi_tile) {
ConvolutionTester()
.inputSize(29, 29)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
TEST(FT16x16_PRECOMPUTE, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(29, 29)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
TEST(WT8x8_PRECOMPUTE, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, multi_tile_with_subsample2x2) {
ConvolutionTester()
.inputSize(13, 13)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, multi_tile_with_subsample2x2_relu) {
ConvolutionTester()
.inputSize(13, 13)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, multi_tile) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
TEST(WT8x8_FP16_PRECOMPUTE, multi_tile_with_relu) {
ConvolutionTester()
.inputSize(13, 13)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
/*
* Test that the implementation handles implicit padding of input
*/
TEST(FT8x8, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
}
}
}
}
TEST(FT8x8, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
}
}
}
}
TEST(FT16x16, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
}
}
}
}
TEST(FT16x16, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
}
}
}
}
TEST(WT8x8, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
}
}
}
TEST(WT8x8, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
}
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8, implicit_padding_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.outputSubsampling(2, 2)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
}
}
}
TEST(WT8x8, implicit_padding_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.outputSubsampling(2, 2)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
}
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
}
}
}
}
TEST(WT8x8_FP16, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
}
}
}
}
TEST(FT8x8_PRECOMPUTE, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
}
}
}
}
TEST(FT8x8_PRECOMPUTE, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
}
}
}
}
TEST(FT16x16_PRECOMPUTE, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
}
}
}
}
TEST(FT16x16_PRECOMPUTE, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(5, 5)
.iterations(5)
.errorLimit(5.0e-2);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
}
}
}
}
TEST(WT8x8_PRECOMPUTE, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
}
}
}
TEST(WT8x8_PRECOMPUTE, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
}
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, implicit_padding_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.outputSubsampling(2, 2)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
}
}
}
TEST(WT8x8_PRECOMPUTE, implicit_padding_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.outputSubsampling(2, 2)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
}
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, implicit_padding) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
}
}
}
}
TEST(WT8x8_FP16_PRECOMPUTE, implicit_padding_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(3, 3)
.iterations(15)
.errorLimit(1.0e-1);
for (size_t paddingTop = 0; paddingTop < tester.kernelHeight(); paddingTop++) {
for (size_t paddingRight = 0; paddingRight < tester.kernelWidth(); paddingRight++) {
for (size_t paddingLeft = 0; paddingLeft < tester.kernelWidth(); paddingLeft++) {
for (size_t paddingBottom = 0; paddingBottom < tester.kernelHeight(); paddingBottom++) {
tester.inputPadding(paddingTop, paddingRight, paddingBottom, paddingLeft)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
}
}
}
}
/*
* Test that the implementation can handle small non-unit number of input channels
*/
TEST(FT8x8, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
}
TEST(FT8x8, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
}
TEST(FT16x16, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
}
TEST(FT16x16, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
}
TEST(WT8x8, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
TEST(WT8x8, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8, few_input_channels_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
TEST(WT8x8, few_input_channels_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
}
TEST(WT8x8_FP16, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
}
TEST(FT8x8_PRECOMPUTE, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
}
TEST(FT8x8_PRECOMPUTE, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
}
TEST(FT16x16_PRECOMPUTE, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
}
TEST(FT16x16_PRECOMPUTE, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, few_input_channels_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_input_channels_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, few_input_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
}
TEST(WT8x8_FP16_PRECOMPUTE, few_input_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t inputChannels = 2; inputChannels <= 5; inputChannels++) {
tester.inputChannels(inputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
}
/*
* Test that the implementation can handle small non-unit number of output channels
*/
TEST(FT8x8, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
}
TEST(FT8x8, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
}
TEST(FT16x16, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
}
TEST(FT16x16, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
}
TEST(WT8x8, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
TEST(WT8x8, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8, few_output_channels_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
}
TEST(WT8x8, few_output_channels_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
}
TEST(WT8x8_FP16, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
}
TEST(FT8x8_PRECOMPUTE, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
}
TEST(FT8x8_PRECOMPUTE, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
}
TEST(FT16x16_PRECOMPUTE, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
}
TEST(FT16x16_PRECOMPUTE, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.iterations(100)
.errorLimit(1.0e-5);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, few_output_channels_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
}
TEST(WT8x8_PRECOMPUTE, few_output_channels_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, few_output_channels) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
}
TEST(WT8x8_FP16_PRECOMPUTE, few_output_channels_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.iterations(100)
.errorLimit(3.0e-2);
for (size_t outputChannels = 2; outputChannels <= 5; outputChannels++) {
tester.outputChannels(outputChannels)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
}
/*
* Test that the implementation can handle non-square kernels
*/
TEST(FT8x8, non_square_kernel) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
TEST(FT8x8, non_square_kernel_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
TEST(FT16x16, non_square_kernel) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
TEST(FT16x16, non_square_kernel_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
TEST(FT8x8_PRECOMPUTE, non_square_kernel) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
TEST(FT8x8_PRECOMPUTE, non_square_kernel_with_relu) {
ConvolutionTester tester;
tester.inputSize(8, 8)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
TEST(FT16x16_PRECOMPUTE, non_square_kernel) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
TEST(FT16x16_PRECOMPUTE, non_square_kernel_with_relu) {
ConvolutionTester tester;
tester.inputSize(16, 16)
.kernelSize(2, 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
/*
* Test that the implementation can handle non-square images
*/
TEST(FT8x8, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity);
}
TEST(FT8x8, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu);
}
TEST(FT16x16, non_square_image) {
ConvolutionTester tester;
tester.inputSize(17, 19)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity);
}
TEST(FT16x16, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(17, 19)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu);
}
TEST(WT8x8, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#if NNP_BACKEND_ARM
TEST(WT8x8, non_square_image_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity);
}
TEST(WT8x8, non_square_image_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity);
}
TEST(WT8x8_FP16, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu);
}
TEST(FT8x8_PRECOMPUTE, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_identity, true);
}
TEST(FT8x8_PRECOMPUTE, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft8x8, nnp_activation_relu, true);
}
TEST(FT16x16_PRECOMPUTE, non_square_image) {
ConvolutionTester tester;
tester.inputSize(17, 19)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_identity, true);
}
TEST(FT16x16_PRECOMPUTE, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(17, 19)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_ft16x16, nnp_activation_relu, true);
}
TEST(WT8x8_PRECOMPUTE, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#if NNP_BACKEND_ARM
TEST(WT8x8_PRECOMPUTE, non_square_image_with_subsample2x2) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_identity, true);
}
TEST(WT8x8_PRECOMPUTE, non_square_image_with_subsample2x2_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.outputSubsampling(2, 2)
.iterations(100)
.errorLimit(1.0e-3)
.testInference(nnp_convolution_algorithm_wt8x8, nnp_activation_relu, true);
}
#endif /* NNP_BACKEND_ARM */
TEST(WT8x8_FP16_PRECOMPUTE, non_square_image) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_identity, true);
}
TEST(WT8x8_FP16_PRECOMPUTE, non_square_image_with_relu) {
ConvolutionTester tester;
tester.inputSize(9, 10)
.iterations(100)
.errorLimit(3.0e-2)
.testInference(nnp_convolution_algorithm_wt8x8_fp16, nnp_activation_relu, true);
}
/*
* Test direct 1x1 convolution
*/
TEST(DIRECT_1x1, channel_tile) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr)
.outputChannels(nnp_hwinfo.conv1x1.nr)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
TEST(DIRECT_1x1, channel_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr)
.outputChannels(nnp_hwinfo.conv1x1.nr)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
TEST(DIRECT_1x1, channel_subtile) {
for (size_t inputChannels = 1; inputChannels <= nnp_hwinfo.conv1x1.mr; inputChannels++) {
for (size_t outputChannels = 1; outputChannels <= nnp_hwinfo.conv1x1.nr; outputChannels++) {
if (inputChannels == nnp_hwinfo.conv1x1.mr && outputChannels == nnp_hwinfo.conv1x1.nr) {
continue;
}
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(inputChannels)
.outputChannels(outputChannels)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
}
}
TEST(DIRECT_1x1, channel_subtile_with_relu) {
for (size_t inputChannels = 1; inputChannels <= nnp_hwinfo.conv1x1.mr; inputChannels++) {
for (size_t outputChannels = 1; outputChannels <= nnp_hwinfo.conv1x1.nr; outputChannels++) {
if (inputChannels == nnp_hwinfo.conv1x1.mr && outputChannels == nnp_hwinfo.conv1x1.nr) {
continue;
}
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(inputChannels)
.outputChannels(outputChannels)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
}
}
TEST(DIRECT_1x1, input_multi_tile) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr * 3)
.outputChannels(nnp_hwinfo.conv1x1.nr)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
TEST(DIRECT_1x1, input_multi_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr * 3)
.outputChannels(nnp_hwinfo.conv1x1.nr)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
TEST(DIRECT_1x1, output_multi_tile) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr)
.outputChannels(nnp_hwinfo.conv1x1.nr * 5)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
TEST(DIRECT_1x1, output_multi_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr)
.outputChannels(nnp_hwinfo.conv1x1.nr * 5)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
TEST(DIRECT_1x1, input_output_multi_tile) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr * 5)
.outputChannels(nnp_hwinfo.conv1x1.nr * 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
TEST(DIRECT_1x1, input_output_multi_tile_with_relu) {
ConvolutionTester()
.inputSize(8, 8)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr * 5)
.outputChannels(nnp_hwinfo.conv1x1.nr * 3)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
TEST(DIRECT_1x1, odd_image_size) {
for (size_t height = 1; height < 8; height++) {
for (size_t width = 1; width < 8; width++) {
if (height * width < nnp_hwinfo.simd_width) {
continue;
}
for (size_t inputChannels = 1; inputChannels <= nnp_hwinfo.conv1x1.mr; inputChannels++) {
for (size_t outputChannels = 1; outputChannels <= nnp_hwinfo.conv1x1.nr; outputChannels++) {
ConvolutionTester()
.inputSize(height, width)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr + 1)
.outputChannels(nnp_hwinfo.conv1x1.nr + 1)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_identity);
}
}
}
}
}
TEST(DIRECT_1x1, odd_image_size_with_relu) {
for (size_t height = 1; height < 8; height++) {
for (size_t width = 1; width < 8; width++) {
if (height * width < nnp_hwinfo.simd_width) {
continue;
}
for (size_t inputChannels = 1; inputChannels <= nnp_hwinfo.conv1x1.mr; inputChannels++) {
for (size_t outputChannels = 1; outputChannels <= nnp_hwinfo.conv1x1.nr; outputChannels++) {
ConvolutionTester()
.inputSize(height, width)
.kernelSize(1, 1)
.inputChannels(nnp_hwinfo.conv1x1.mr + 1)
.outputChannels(nnp_hwinfo.conv1x1.nr + 1)
.iterations(100)
.errorLimit(1.0e-5)
.testInference(nnp_convolution_algorithm_direct, nnp_activation_relu);
}
}
}
}
}
int main(int argc, char* argv[]) {
const enum nnp_status init_status = nnp_initialize();
assert(init_status == nnp_status_success);
setenv("TERM", "xterm-256color", 0);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
```
|
An anatomically correct doll or anatomically precise doll is a doll that depicts some of the primary and secondary sex characteristics of a human for educational purposes. A very detailed type of anatomically correct doll may be used in questioning children who may have been sexually abused. The use of dolls as interview aids has been criticized, and the validity of information obtained this way has been contested.
Overview
Some children's baby dolls and potty training dolls are anatomically correct for educational purposes. There are also dolls that are used as medical models, particularly in explaining medical procedures to child patients. These have a more detailed depiction of the human anatomy and may include features like removable internal organs. One notable anatomically correct doll was the "Archie Bunker's Grandson Joey Stivic" doll that was made by the Ideal Toy Co. in 1976. The doll, which was modeled after infant character Joey Stivic from the Television sitcom series All In The Family, was considered to be the first anatomically correct boy doll.
The dolls are also sometimes used by parents or teachers as sex education.
Forensic use
A particular type of anatomically correct dolls are used in law enforcement and therapy. These dolls have detailed depictions of all the primary and secondary sexual characteristics of a human: "oral and anal openings, ears, tongues, nipples, and hands with individual fingers" for all and a "vagina, clitoris and breasts" for each of the female dolls and a "penis and testicles" for each of the male dolls.
These dolls are used during interviews with children who may have been sexually abused. The dolls wear removable clothing, and the anatomically correct and similarly scaled body parts ensure that sexual activity can be simulated realistically.
There is some criticism with regard to using anatomically correct dolls to question victims of sexual abuse. Critics argue that because of the novelty of the dolls, children will act out sexually explicit maneuvers with the dolls even if the child has not been sexually abused. Another criticism is that because the studies that compare the differences between how abused and non-abused children play with these dolls are conflicting (some studies suggest that sexually abused children play with anatomically correct dolls in a more sexually explicit manner than non-abused children, while other studies suggest that there is no correlation), it is impossible to interpret what is meant by how a child plays with these dolls.
References
Sexuality and society
Dolls
Forensic equipment
|
Keith Rossiter (born 16 January 1984) is an Irish hurler and currently a selector with the Wexford senior hurling team. He plays for Wexford Senior Championship club Oulart–The Ballagh and was a member of the Wexford senior hurling team for 12 seasons, during which time he usually lined out as a full-back.
Playing career
Waterford Institute of Technology
As a student at the Waterford Institute of Technology, Rossiter immediately became involved in hurling as a member of the Waterford IT freshers' team. He joined the senior hurling team during his second year.
On 6 March 2004, Rossiter lined out at centre-back when the Waterford Institute of Technology faced University College Cork in the Fitzgibbon Cup final. He ended the game with his first winners' medal as Waterford IT retained the title following an 0-11 to 0-09 victory.
On 4 March 2006, Rossiter played in a second Fitzgibbon Cup final in three years. Lining out at right corner-back he claimed a second winners' medal after a 4-13 to 0-08 defeat of University College Dublin.
Oulart–The Ballagh
Rossiter joined the Oulart–The Ballagh club at a young age and played in every grade at juvenile and underage levels. He enjoyed championship success in the under-21 grade before becoming a member of the club's senior team.
On 17 October 2004, Rossiter lined out at full-back when Oulart–The Ballagh faced reigning-champions Rathnure in the Wexford Senior Championship final. He ended the game with a winners' medal following the 1-17 to 1-10 victory.
Oulart–The Ballagh qualified for a second successive final on 23 October 2005 with Rossiter once again lining out at full-back. He claimed a second successive winners' medal after the 1-15 to 1-09 victory over St. Martin's.
Rossiter lined out in a third successive final on 16 October 2006 with Rathnure providing the opposition. After starting the game at full-back he was switched to midfield to curb the influence of Paul Codd, however, the game ended in a draw. Rossiter was switched to right corner-back for the replay on 22 October 2006, however, he ended the game on the losing side after a 1-12 to 0-06 defeat.
On 21 October 2007, Rossiter lined out at centre-back in a fourth successive final when Oulart–The Ballagh faced Buffer's Alley. He claimed a third winners' medal following the 4-14 to 2-06 victory.
Oulart-the Ballagh qualified for a fifth successive final on 3 November 2008 with St. Martin's providing the opposition. Rossiter was switched from being a defender to centre-forward, however, he was held scoreless in the 1-13 to 1-08 defeat.
Rossiter was moved back to his more regular position of centre-back when Oulart–The Ballagh faced Buffer's Alley in a second final in three years on 11 October 2009. He ended the game with a fourth winners' medal following the 3-12 to 1-13 victory.
On 10 October 2010, Rossiter captained the team when Oulart–The Ballagh faced St. Martin's in the final once again. He ended the game with a fifth winners' medal following the 1-14 to 0-06 victory. Rossiter was again at full-back when Oulart–The Ballagh suffered a 0-14 to 1-08 defeat by O'Loughlin Gaels in the Leinster final on 30 January 2011.
Rossiter was selected at full-back when Oulart–The Ballagh faced Rathnure in the final on 9 October 2011. He claimed a sixth winners' medal following the 1-10 to 0-11 victory. On 27 November 2011, Rossiter lined out in a second successive Leinster final but ended on the losing side once again following a 1-15 to 1-11 defeat by Coolderry.
On 14 October 2012, Rossiter captained Oulart–The Ballagh against Faythe Harriers in the Wexford Senior Championship final. He was described as having an "inspirational game" at full-back and collected a seventh winners' medal following the 2-12 to 0-13 victory. On 9 December 2012, Rossiter was again at full-back when Oulart-the Ballagh suffered a 1-12 to 0-11 defeat by Kilcormac/Killoughey in the Leinster final.
On 20 October 2013, Rossiter lined out at full-back when Oulart–The Ballagh took on Ferns St. Aidan's in the 2013 Wexford Senior Championship final. He collected an eighth winners' medal following the 3-12 to 1-16 victory. On 1 December 2013, Rossiter was again at full-back when Oulart-the Ballagh suffered an 0-11 to 0-08 defeat by Mount Leinster Rangers in a fourth successive Leinster final.
Rossiter lined out in an 11th Wexford Senior Championship final on 25 October 2015. He "dominated" in front of goal as a full-back and collected a ninth winners' medal following the 2-15 to 0-13 defeat of St. Martin's. On 29 November 2015, Rossiter was again at full-back when Oulart–The Ballagh defeated Cuala by 2-13 to 0-13 to win the Leinster Championship.
On 16 October 2016, Rossiter played in his 12th Wexford Senior Championship final. Lining out at full-back, he ended the game with a remarkable 10th winners' medal following the 0-17 to 1-11 defeat of Cloughbawn.
Oulart–The Ballagh qualified for another Wexford Senior Championship final on 22 October 2017. Rossiter again lined out full-back, however, he ended the game on the losing side for the third time in his career following the 2-16 to 1-09 defeat by St. Martin's.
Wexford
Minor and under-21
Rossiter was just 16-years-old when he first lined out for Wexford as a member of the minor team during the 2000 Leinster Championship. He made his first appearance for the team on 24 June 2000 when he lined out at right corner-back in a 3-09 to 1-14 defeat by Dublin.
Eligible for the minor grade in 2001, Rossiter was unable to line out due to injury. After receiving a back injury in a club game, an MRI scan showed that he had cracked his spine after a vertebra broke off. Rossiter subsequently underwent an operation with a 25% chance of being confined to a wheelchair. The operation and year-long rehabilitation were a complete success.
Rossiter was drafted onto the Wexford under-21 team in advance of the 2003 Leinster Championship. He made his first appearance for the team on 24 June 2003 when he lined out at centre-back in Wexford's 2-16 to 0-09 defeat by Dublin.
On 14 July 2004, Rossiter was again at centre-back when Wexford qualified to play Kilkenny in the Leinster final at Wexford Park. He ended the game on the losing side following a 1-16 to 2-03 defeat.
Rossiter was eligible for the under-21 grade for a third and final season in 2005. He played his last game in the grade on 22 June 2005 when Wexford suffered a 2-13 to 0-15 defeat by Kilkenny.
Senior
Rossiter was added to the Wexford senior panel in advance of the 2003 National League. He made his first appearance for the team on 22 February 2003 when he lined out at left wing-back in Wexford's 2-16 to 1-14 defeat of Derry in their opening league game. Rossiter made his Leinster Championship debut on 8 June 2003 when he lined out at left corner-back in a 0-16 to 1-12 defeat of Offaly. He was switched to right wing-back for the Leinster final on 6 July 2003 but ended on the losing side after a 2-23 to 2-12 defeat by Kilkenny.
On 4 July 2004, Rossiter was selected on the bench when Wexford lined out against Offaly in the Leinster final. He remained on the bench for the entire game but ended the game with a winners' medal following the 2-12 to 1-11 defeat of Offaly.
Rossiter was back on the starting fifteen at left corner-back when Wexford faced Kilkenny in the Leinster final on 7 July 2005. He ended the game on the losing side after a 0-22 to 1-16 victory for Kilkenny.
Rossiter was appointed captain of the Wexford senior team for the 2006 season. He lined out in a fourth successive Leinster final on 2 July 2006 with Kilkenny providing the opposition for the third time. Rossiter ended the game as a runner-up following the 1-23 to 2-12 defeat.
On 1 July 2007, Rossiter lined out in a fifth successive Leinster final. Playing at centre-back, he ended the game on the losing side for the fourth time in his career after a 2-24 to 1-12 defeat by Kilkenny.
Rossiter lined out in a sixth successive Leinster final on 6 July 2008, however, for the fifth time in his career Rossiter ended up on the losing side after a 5-21 to 0-17 defeat by Kilkenny.
On 2 May 2010, Rossiter lined out at full-back when Wexford faced Clare in the National League Division 2 final. He ended the game with a winners' medal following the 1-16 to 2-09 victory.
Rossiter announced his retirement from inter-county hurling on 28 January 2015. He said: "It's something I've been thinking about probably since last year...In my own eyes I'd have looked at 2014, coming into that season, as being my last one. No one knew that, but it was always at the back of my mind."
Leinster
Rossiter was first selected for the Leinster inter-provincial team during the 2012 Inter-provincial Championship. On 4 March 2012, he lined out at full-back when Leinster defeated Connacht by 2-19 to 1-15 to win the Railway Cup.
On 1 March 2014, Rossiter was selected for the Leinster team for the Railway Cup final against Connacht. He was an unused substitute throughout the game but collected a second winners' medal following the 1-23 to 0-16 victory.
Coaching career
Wexford
On 9 November 2016, it was revealed that Rossiter had joined Davy Fitzgerald's Wexford senior hurling management team as a coach. In his first season as a coach, he helped guide the team to promotion to Division 1A of the National Hurling League after remaining undefeated in the group stage. On 2 July 2017, Rossiter was part of the management team that saw Wexford reach a first Leinster final in nine years, only to lose to Galway by 0-29 to 1-17.
On 20 January 2018, Rossiter was coach when Wexford drew 1-24 apiece with Kilkenny in the Walsh Cup final. Wexford won the subsequent free-taking shoot-out, with Rossiter securing his first silverware with Wexford.
Wexford reached a second Leinster final in three years on 30 June 2019 with Rossiter on the sideline once again. A 1-23 to 0-23 defeat of Kilkenny secured a first Leinster Championship since Rossiter's own playing career in 2004.
Career statistics
Honours
As a player
Waterford Institute of Technology
Fitzgibbon Cup (2): 2004, 2006
Oulart–The Ballagh
Leinster Senior Club Hurling Championship (1): 2015
Wexford Senior Hurling Championship (10): 2004, 2005, 2007, 2009, 2010 (c), 2011, 2012 (c), 2013, 2015, 2016
Wexford
Leinster Senior Hurling Championship (1): 2004
National Hurling League Division 2 (1): 2010
Leinster
Railway Cup (2): 2012, 2014
As a coach
Wexford
Leinster Senior Hurling Championship (1): 2019
Walsh Cup (1): 2018
References
1984 births
Living people
Oulart-the-Ballagh hurlers
Wexford inter-county hurlers
Hurling backs
Hurling selectors
Alumni of Waterford Institute of Technology
Waterford IT hurlers
|
```javascript
export const revalidate = 0
export default function Page() {
const err = new Error('this is a test')
err.digest = 'custom'
throw err
}
```
|
```asciidoc
//
include::{generated}/meta/{refprefix}VK_NV_private_vendor_info.adoc[]
=== Other Extension Metadata
*Last Modified Date*::
2022-08-10
*Contributors*::
- Daniel Koch, NVIDIA
- Jonathan McCaffrey, NVIDIA
- Jeff Bolz, NVIDIA
=== Description
This extension provides the application with access to vendor-specific enums
and structures that are not expected to be publicly documented.
include::{generated}/interfaces/VK_NV_private_vendor_info.adoc[]
=== Issues
1) What should we call this extension?
RESOLVED.
`apiext:VK_NV_private_vendor_info` as this contains details of NVIDIA's
implementation that we do not expect to publicly document.
=== Version History
* Revision 1, 2022-05-03 (Daniel Koch)
** Internal revisions
* Revision 2, 2022-08-10 (Daniel Koch)
** change number for extension (373 to 52) to avoid conflict
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.