text stringlengths 1 22.8M |
|---|
Gordana Gadžić (; born 21 August 1955) is a Serbian actress. She has appeared in more than 30 films since 1981.
Selected filmography
References
External links
1955 births
Living people
Actresses from Belgrade
Serbian film actresses
20th-century Serbian actresses
21st-century Serbian actresses
Golden Arena winners |
Chennamangaloor, also spelt as Chennamangallur and/or Chendamangallur is a village located in Kozhikode district, Kerala, India. It is about from the town of Kozhikode. The National Institute of Technology Calicut (NITC), the Indian Institute of Management Kozhikode (IIM-K), K.M.C.T. are located near to Chennamangallur.
Notable people
O Abdurahiman, journalist and author, Group Editor Madhyamam and Media One TV
Hameed Chennamangaloor, social critic
O Abdulla Journalist, Social Critique, Writer
CT Abdurahim, writer and educator
PT Kunjali, Writer, orator
External links
CMR on Web
Iruvazhinji
CMR
Islahiya Association
Media Academy
Sayanora Computer Academy
Chaithanya Samskarika V
Kozhikode east |
```smalltalk
using Volo.Abp.Collections;
namespace Volo.Abp.SimpleStateChecking;
public class AbpSimpleStateCheckerOptions<TState>
where TState : IHasSimpleStateCheckers<TState>
{
public ITypeList<ISimpleStateChecker<TState>> GlobalStateCheckers { get; }
public AbpSimpleStateCheckerOptions()
{
GlobalStateCheckers = new TypeList<ISimpleStateChecker<TState>>();
}
}
``` |
Taabwa (Ichitaabwa), or Rungu (Malungu), is a Bantu language of Congo and Zambia spoken by half a million or so people.
See also
Taabwa Twa
References
Further reading
Kalenga, Kaki A. 1992. Esquisse Grammaticale de la Langue Shila, Parler de Nkuba Bukongolo-Lac Moëro. Unpublished thesis, Université de Lubumbashi, DRC. Available Here
Kavimbwa, Pierre Mutono. 2002. Elements de Phonologie et de Morphologie du Kitaabwa (M41a): Approche Structuraliste. Unpublished thesis, Université de Lubumbashi, DRC. Available Here
Ntambo, Mwamba. 1984. Aspects Spatio-Temporels en Kitaabwa (M41). Unpublished thesis, Université de Lubumbashi, DRC. Available Here
Rwakazina, Alphonse-Marie. 1966. Esquisse Grammaticale de la Langue Taabwa: Phonologie et Morphologie. Unpublished thesis, Université Lovanium, Faculté de Philosophie et Lettres, DRC.
Tumbwe, Kasoro. 1979. Les Emprunts Francais en Taabwa. Unpublished thesis, Institut Supérieur Pédagogique de Kisangani, DRC. Available Here
van Acker, Auguste. 1907. Dictionnaire Kitabwa-Français et Français -Kitabwa. Annales du Musée du Congo, Ethnographie et Anthropologie, Série 5: Linguistique, 1:1. Bruxelles: Tervuren. Available Here
Sabi languages
Languages of the Democratic Republic of the Congo
Languages of Zambia |
Coleophora lebedella is a moth of the family Coleophoridae. It is found in Spain, southern Russia, central Asia and Iran. It occurs in desert-steppe and desert biotopes.
Adults are on wing from the end of May to June.
The larvae feed on Atriplex tatarica, Atriplex glauca, Atriplex nitens and possibly Chenopodium species. They feed on the leaves of their host plant.
References
lebedella
Moths described in 1982
Moths of Europe
Moths of Asia |
A Change of Destiny (Traditional Chinese: 天機算) is a TVB costume drama series broadcast in April 2007.
The series is about two young men having the same birthday but have both of them have a different life. Benny Chan is from a rich family while Steven Ma is poor and they both hope to change their destiny with tui bei tu.
Synopsis
Yip Yeung (Benny Chan) is interested in knowing the future with the use of diagrams,"tui bei tu", passed on from the past. These diagrams have the ability to predict future events so that readers can find luck or escape tragedy. Yuen Hei (Steven Ma) tricks Yip Yeung into buying fake diagrams he had created, but is later confronted by Lee Sing-Tin (Yuen Wah).
Lee Sing-Tin sees potential in Yip Yeung and Yuen Hei. He takes them in as his apprentice to teach them about his knowledge on these diagrams. Yip Yeung later discovers that he is a royal blood from the descendant of the last royal throne. He attempts to use his prediction skills to take over the King's throne but only foresees tragedy in every way he is planning to change destiny...
Cast
Note: Some of the characters' names are in Cantonese romanisation.
Viewership ratings
Awards and nominations
40th TVB Anniversary Awards (2007)
"Best Drama"
"Best Actress in a Supporting Role" (Mimi Lo - Chiu Fei)
References
External links
TVB.com A Change of Destiny - Official Website
K for TVB.net A Change of Destiny - Episodic Synopsis and Screen Captures
TVB dramas
Television series set in the Five Dynasties and Ten Kingdoms period
Television series set in the Northern Song
2007 Hong Kong television series debuts
2007 Hong Kong television series endings |
```objective-c
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
//
// This Source Code Form is subject to the terms of the Mozilla
// with this file, You can obtain one at path_to_url
#ifndef EIGEN_ASSIGN_EVALUATOR_H
#define EIGEN_ASSIGN_EVALUATOR_H
namespace Eigen {
// This implementation is based on Assign.h
namespace internal {
/***************************************************************************
* Part 1 : the logic deciding a strategy for traversal and unrolling *
***************************************************************************/
// copy_using_evaluator_traits is based on assign_traits
template <typename DstEvaluator, typename SrcEvaluator, typename AssignFunc, int MaxPacketSize = -1>
struct copy_using_evaluator_traits
{
typedef typename DstEvaluator::XprType Dst;
typedef typename Dst::Scalar DstScalar;
enum {
DstFlags = DstEvaluator::Flags,
SrcFlags = SrcEvaluator::Flags
};
public:
enum {
DstAlignment = DstEvaluator::Alignment,
SrcAlignment = SrcEvaluator::Alignment,
DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
};
private:
enum {
InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
: int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
: int(Dst::RowsAtCompileTime),
InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
: int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
: int(Dst::MaxRowsAtCompileTime),
RestrictedInnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(InnerSize,MaxPacketSize),
RestrictedLinearSize = EIGEN_SIZE_MIN_PREFER_FIXED(Dst::SizeAtCompileTime,MaxPacketSize),
OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
MaxSizeAtCompileTime = Dst::SizeAtCompileTime
};
// TODO distinguish between linear traversal and inner-traversals
typedef typename find_best_packet<DstScalar,RestrictedLinearSize>::type LinearPacketType;
typedef typename find_best_packet<DstScalar,RestrictedInnerSize>::type InnerPacketType;
enum {
LinearPacketSize = unpacket_traits<LinearPacketType>::size,
InnerPacketSize = unpacket_traits<InnerPacketType>::size
};
public:
enum {
LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
};
private:
enum {
DstIsRowMajor = DstFlags&RowMajorBit,
SrcIsRowMajor = SrcFlags&RowMajorBit,
StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
MightVectorize = bool(StorageOrdersAgree)
&& (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
&& bool(functor_traits<AssignFunc>::PacketAccess),
MayInnerVectorize = MightVectorize
&& int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
&& int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
&& (EIGEN_UNALIGNED_VECTORIZE || int(JointAlignment)>=int(InnerRequiredAlignment)),
MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
&& (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
/* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
so it's only good for large enough sizes. */
MaySliceVectorize = bool(MightVectorize) && bool(DstHasDirectAccess)
&& (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
/* slice vectorization can be slow, so we only want it if the slices are big, which is
indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
in a fixed-size matrix
However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
};
public:
enum {
Traversal = int(Dst::SizeAtCompileTime) == 0 ? int(AllAtOnceTraversal) // If compile-size is zero, traversing will fail at compile-time.
: (int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize)) ? int(LinearVectorizedTraversal)
: int(MayInnerVectorize) ? int(InnerVectorizedTraversal)
: int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
: int(MaySliceVectorize) ? int(SliceVectorizedTraversal)
: int(MayLinearize) ? int(LinearTraversal)
: int(DefaultTraversal),
Vectorized = int(Traversal) == InnerVectorizedTraversal
|| int(Traversal) == LinearVectorizedTraversal
|| int(Traversal) == SliceVectorizedTraversal
};
typedef typename conditional<int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType>::type PacketType;
private:
enum {
ActualPacketSize = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
: Vectorized ? InnerPacketSize
: 1,
UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
&& int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
MayUnrollInner = int(InnerSize) != Dynamic
&& int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
};
public:
enum {
Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
? (
int(MayUnrollCompletely) ? int(CompleteUnrolling)
: int(MayUnrollInner) ? int(InnerUnrolling)
: int(NoUnrolling)
)
: int(Traversal) == int(LinearVectorizedTraversal)
? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
? int(CompleteUnrolling)
: int(NoUnrolling) )
: int(Traversal) == int(LinearTraversal)
? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling)
: int(NoUnrolling) )
#if EIGEN_UNALIGNED_VECTORIZE
: int(Traversal) == int(SliceVectorizedTraversal)
? ( bool(MayUnrollInner) ? int(InnerUnrolling)
: int(NoUnrolling) )
#endif
: int(NoUnrolling)
};
#ifdef EIGEN_DEBUG_ASSIGN
static void debug()
{
std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl;
std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl;
std::cerr.setf(std::ios::hex, std::ios::basefield);
std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl;
std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl;
std::cerr.unsetf(std::ios::hex);
EIGEN_DEBUG_VAR(DstAlignment)
EIGEN_DEBUG_VAR(SrcAlignment)
EIGEN_DEBUG_VAR(LinearRequiredAlignment)
EIGEN_DEBUG_VAR(InnerRequiredAlignment)
EIGEN_DEBUG_VAR(JointAlignment)
EIGEN_DEBUG_VAR(InnerSize)
EIGEN_DEBUG_VAR(InnerMaxSize)
EIGEN_DEBUG_VAR(LinearPacketSize)
EIGEN_DEBUG_VAR(InnerPacketSize)
EIGEN_DEBUG_VAR(ActualPacketSize)
EIGEN_DEBUG_VAR(StorageOrdersAgree)
EIGEN_DEBUG_VAR(MightVectorize)
EIGEN_DEBUG_VAR(MayLinearize)
EIGEN_DEBUG_VAR(MayInnerVectorize)
EIGEN_DEBUG_VAR(MayLinearVectorize)
EIGEN_DEBUG_VAR(MaySliceVectorize)
std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost)
EIGEN_DEBUG_VAR(DstEvaluator::CoeffReadCost)
EIGEN_DEBUG_VAR(Dst::SizeAtCompileTime)
EIGEN_DEBUG_VAR(UnrollingLimit)
EIGEN_DEBUG_VAR(MayUnrollCompletely)
EIGEN_DEBUG_VAR(MayUnrollInner)
std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
std::cerr << std::endl;
}
#endif
};
/***************************************************************************
* Part 2 : meta-unrollers
***************************************************************************/
/************************
*** Default traversal ***
************************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
{
// FIXME: this is not very clean, perhaps this information should be provided by the kernel?
typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
typedef typename DstEvaluatorType::XprType DstXprType;
enum {
outer = Index / DstXprType::InnerSizeAtCompileTime,
inner = Index % DstXprType::InnerSizeAtCompileTime
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
kernel.assignCoeffByOuterInner(outer, inner);
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
template<typename Kernel, int Index_, int Stop>
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
{
kernel.assignCoeffByOuterInner(outer, Index_);
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_+1, Stop>::run(kernel, outer);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { }
};
/***********************
*** Linear traversal ***
***********************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel)
{
kernel.assignCoeff(Index);
copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
/**************************
*** Inner vectorization ***
**************************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_innervec_CompleteUnrolling
{
// FIXME: this is not very clean, perhaps this information should be provided by the kernel?
typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
typedef typename DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum {
outer = Index / DstXprType::InnerSizeAtCompileTime,
inner = Index % DstXprType::InnerSizeAtCompileTime,
SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
DstAlignment = Kernel::AssignmentTraits::DstAlignment
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
enum { NextIndex = Index + unpacket_traits<PacketType>::size };
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
template<typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
struct copy_using_evaluator_innervec_InnerUnrolling
{
typedef typename Kernel::PacketType PacketType;
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
{
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
enum { NextIndex = Index_ + unpacket_traits<PacketType>::size };
copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel, outer);
}
};
template<typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { }
};
/***************************************************************************
* Part 3 : implementation of all cases
***************************************************************************/
// dense_assignment_loop is based on assign_impl
template<typename Kernel,
int Traversal = Kernel::AssignmentTraits::Traversal,
int Unrolling = Kernel::AssignmentTraits::Unrolling>
struct dense_assignment_loop;
/************************
***** Special Cases *****
************************/
// Zero-sized assignment is a no-op.
template<typename Kernel, int Unrolling>
struct dense_assignment_loop<Kernel, AllAtOnceTraversal, Unrolling>
{
EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel& /*kernel*/)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
EIGEN_STATIC_ASSERT(int(DstXprType::SizeAtCompileTime) == 0,
EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)
}
};
/************************
*** Default traversal ***
************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel)
{
for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
kernel.assignCoeffByOuterInner(outer, inner);
}
}
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
const Index outerSize = kernel.outerSize();
for(Index outer = 0; outer < outerSize; ++outer)
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime>::run(kernel, outer);
}
};
/***************************
*** Linear vectorization ***
***************************/
// The goal of unaligned_dense_assignment_loop is simply to factorize the handling
// of the non vectorizable beginning and ending parts
template <bool IsAligned = false>
struct unaligned_dense_assignment_loop
{
// if IsAligned = true, then do nothing
template <typename Kernel>
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {}
};
template <>
struct unaligned_dense_assignment_loop<false>
{
// MSVC must not inline this functions. If it does, it fails to optimize the
// packet access path.
// FIXME check which version exhibits this issue
#if EIGEN_COMP_MSVC
template <typename Kernel>
static EIGEN_DONT_INLINE void run(Kernel &kernel,
Index start,
Index end)
#else
template <typename Kernel>
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
Index start,
Index end)
#endif
{
for (Index index = start; index < end; ++index)
kernel.assignCoeff(index);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index size = kernel.size();
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
packetSize = unpacket_traits<PacketType>::size,
dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
: int(Kernel::AssignmentTraits::DstAlignment),
srcAlignment = Kernel::AssignmentTraits::JointAlignment
};
const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);
for(Index index = alignedStart; index < alignedEnd; index += packetSize)
kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);
unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum { size = DstXprType::SizeAtCompileTime,
packetSize =unpacket_traits<PacketType>::size,
alignedSize = (int(size)/packetSize)*packetSize };
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
}
};
/**************************
*** Inner vectorization ***
**************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, NoUnrolling>
{
typedef typename Kernel::PacketType PacketType;
enum {
SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
DstAlignment = Kernel::AssignmentTraits::DstAlignment
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index innerSize = kernel.innerSize();
const Index outerSize = kernel.outerSize();
const Index packetSize = unpacket_traits<PacketType>::size;
for(Index outer = 0; outer < outerSize; ++outer)
for(Index inner = 0; inner < innerSize; inner+=packetSize)
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::AssignmentTraits Traits;
const Index outerSize = kernel.outerSize();
for(Index outer = 0; outer < outerSize; ++outer)
copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
}
};
/***********************
*** Linear traversal ***
***********************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index size = kernel.size();
for(Index i = 0; i < size; ++i)
kernel.assignCoeff(i);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
/**************************
*** Slice vectorization ***
***************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
packetSize = unpacket_traits<PacketType>::size,
requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
dstAlignment = alignable ? int(requestedAlignment)
: int(Kernel::AssignmentTraits::DstAlignment)
};
const Scalar *dst_ptr = kernel.dstDataPtr();
if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
{
// the pointer is not aligned-on scalar, so alignment is not possible
return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
}
const Index packetAlignedMask = packetSize - 1;
const Index innerSize = kernel.innerSize();
const Index outerSize = kernel.outerSize();
const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
for(Index outer = 0; outer < outerSize; ++outer)
{
const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
// do the non-vectorizable part of the assignment
for(Index inner = 0; inner<alignedStart ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
// do the vectorizable part of the assignment
for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
// do the non-vectorizable part of the assignment
for(Index inner = alignedEnd; inner<innerSize ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
}
}
};
#if EIGEN_UNALIGNED_VECTORIZE
template<typename Kernel>
struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum { innerSize = DstXprType::InnerSizeAtCompileTime,
packetSize =unpacket_traits<PacketType>::size,
vectorizableSize = (int(innerSize) / int(packetSize)) * int(packetSize),
size = DstXprType::SizeAtCompileTime };
for(Index outer = 0; outer < kernel.outerSize(); ++outer)
{
copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, innerSize>::run(kernel, outer);
}
}
};
#endif
/***************************************************************************
* Part 4 : Generic dense assignment kernel
***************************************************************************/
// This class generalize the assignment of a coefficient (or packet) from one dense evaluator
// to another dense writable evaluator.
// It is parametrized by the two evaluators, and the actual assignment functor.
// This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
// One can customize the assignment using this generic dense_assignment_kernel with different
// functors, or by completely overloading it, by-passing a functor.
template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
class generic_dense_assignment_kernel
{
protected:
typedef typename DstEvaluatorTypeT::XprType DstXprType;
typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
public:
typedef DstEvaluatorTypeT DstEvaluatorType;
typedef SrcEvaluatorTypeT SrcEvaluatorType;
typedef typename DstEvaluatorType::Scalar Scalar;
typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
typedef typename AssignmentTraits::PacketType PacketType;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
: m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr)
{
#ifdef EIGEN_DEBUG_ASSIGN
AssignmentTraits::debug();
#endif
}
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_dstExpr.size(); }
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index innerSize() const EIGEN_NOEXCEPT { return m_dstExpr.innerSize(); }
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerSize() const EIGEN_NOEXCEPT { return m_dstExpr.outerSize(); }
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_dstExpr.rows(); }
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_dstExpr.cols(); }
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT { return m_dstExpr.outerStride(); }
EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() EIGEN_NOEXCEPT { return m_dst; }
EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const EIGEN_NOEXCEPT { return m_src; }
/// Assign src(row,col) to dst(row,col) through the assignment functor.
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col)
{
m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col));
}
/// \sa assignCoeff(Index,Index)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index)
{
m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
}
/// \sa assignCoeff(Index,Index)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner)
{
Index row = rowIndexByOuterInner(outer, inner);
Index col = colIndexByOuterInner(outer, inner);
assignCoeff(row, col);
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
{
m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(row,col), m_src.template packet<LoadMode,PacketType>(row,col));
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
{
m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
{
Index row = rowIndexByOuterInner(outer, inner);
Index col = colIndexByOuterInner(outer, inner);
assignPacket<StoreMode,LoadMode,PacketType>(row, col);
}
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner)
{
typedef typename DstEvaluatorType::ExpressionTraits Traits;
return int(Traits::RowsAtCompileTime) == 1 ? 0
: int(Traits::ColsAtCompileTime) == 1 ? inner
: int(DstEvaluatorType::Flags)&RowMajorBit ? outer
: inner;
}
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner)
{
typedef typename DstEvaluatorType::ExpressionTraits Traits;
return int(Traits::ColsAtCompileTime) == 1 ? 0
: int(Traits::RowsAtCompileTime) == 1 ? inner
: int(DstEvaluatorType::Flags)&RowMajorBit ? inner
: outer;
}
EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
{
return m_dstExpr.data();
}
protected:
DstEvaluatorType& m_dst;
const SrcEvaluatorType& m_src;
const Functor &m_functor;
// TODO find a way to avoid the needs of the original expression
DstXprType& m_dstExpr;
};
// Special kernel used when computing small products whose operands have dynamic dimensions. It ensures that the
// PacketSize used is no larger than 4, thereby increasing the chance that vectorized instructions will be used
// when computing the product.
template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor>
class restricted_packet_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn>
{
protected:
typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn> Base;
public:
typedef typename Base::Scalar Scalar;
typedef typename Base::DstXprType DstXprType;
typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, 4> AssignmentTraits;
typedef typename AssignmentTraits::PacketType PacketType;
EIGEN_DEVICE_FUNC restricted_packet_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
: Base(dst, src, func, dstExpr)
{
}
};
/***************************************************************************
* Part 5 : Entry point for dense rectangular assignment
***************************************************************************/
template<typename DstXprType,typename SrcXprType, typename Functor>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/)
{
EIGEN_ONLY_USED_FOR_DEBUG(dst);
EIGEN_ONLY_USED_FOR_DEBUG(src);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
}
template<typename DstXprType,typename SrcXprType, typename T1, typename T2>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
}
template<typename DstXprType, typename SrcXprType, typename Functor>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
// we need to resize the destination after the source evaluator has been created.
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
// Specialization for filling the destination with a constant value.
#ifndef EIGEN_GPU_COMPILE_PHASE
template<typename DstXprType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<typename DstXprType::Scalar>, DstXprType>& src, const internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>& func)
{
resize_if_allowed(dst, src, func);
std::fill_n(dst.data(), dst.size(), src.functor()());
}
#endif
template<typename DstXprType, typename SrcXprType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
{
call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}
/***************************************************************************
* Part 6 : Generic assignment
***************************************************************************/
// Based on the respective shapes of the destination and source,
// the class AssignmentKind determine the kind of assignment mechanism.
// AssignmentKind must define a Kind typedef.
template<typename DstShape, typename SrcShape> struct AssignmentKind;
// Assignment kind defined in this file:
struct Dense2Dense {};
struct EigenBase2EigenBase {};
template<typename,typename> struct AssignmentKind { typedef EigenBase2EigenBase Kind; };
template<> struct AssignmentKind<DenseShape,DenseShape> { typedef Dense2Dense Kind; };
// This is the main assignment class
template< typename DstXprType, typename SrcXprType, typename Functor,
typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind,
typename EnableIf = void>
struct Assignment;
// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition.
// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
// does not has to bother about these annoying details.
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src)
{
call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(const Dst& dst, const Src& src)
{
call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
// Deal with "assume-aliasing"
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if<!evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
call_assignment_no_alias(dst, src, func);
}
// by-pass "assume-aliasing"
// When there is no aliasing, we require that 'dst' has been properly resized
template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
{
call_assignment_no_alias(dst.expression(), src, func);
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
{
enum {
NeedToTranspose = ( (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
|| (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
) && int(Dst::SizeAtCompileTime) != 1
};
typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
ActualDstType actualDst(dst);
// TODO check whether this is the right place to perform these checks:
EIGEN_STATIC_ASSERT_LVALUE(Dst)
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_restricted_packet_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
{
typedef evaluator<Dst> DstEvaluatorType;
typedef evaluator<Src> SrcEvaluatorType;
typedef restricted_packet_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Func> Kernel;
EIGEN_STATIC_ASSERT_LVALUE(Dst)
EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
SrcEvaluatorType srcEvaluator(src);
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src)
{
call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
{
// TODO check whether this is the right place to perform these checks:
EIGEN_STATIC_ASSERT_LVALUE(Dst)
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
Assignment<Dst,Src,Func>::run(dst, src, func);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
{
call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
// forward declaration
template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
// Generic Dense to Dense assignment
// Note that the last template argument "Weak" is needed to make it possible to perform
// both partial specialization+SFINAE without ambiguous specialization
template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak>
{
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
{
#ifndef EIGEN_NO_DEBUG
internal::check_for_aliasing(dst, src);
#endif
call_dense_assignment_loop(dst, src, func);
}
};
// Generic assignment through evalTo.
// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
// Note that the last template argument "Weak" is needed to make it possible to perform
// both partial specialization+SFINAE without ambiguous specialization
template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak>
{
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.evalTo(dst);
}
// NOTE The following two functions are templated to avoid their instantiation if not needed
// This is needed because some expressions supports evalTo only and/or have 'void' as scalar type.
template<typename SrcScalarType>
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.addTo(dst);
}
template<typename SrcScalarType>
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.subTo(dst);
}
};
} // namespace internal
} // end namespace Eigen
#endif // EIGEN_ASSIGN_EVALUATOR_H
``` |
The Clerkenwell Tales is an historical novel by English writer Peter Ackroyd, first published in 2003.
Plot summary
The novel is set in London in the year 1399, a year of revolt, revolution and religious conspiracy. As Henry Bolingbroke challenges Richard II for the throne of England the reader's attention is focused on Dominus, a secret society of religious fundamentalists, known to history as Lollards. The story is oriented similar to Chaucer's The Canterbury Tales and makes use of some of the characters from The Canterbury Tales as well. It turns on the conspiracies of a religious sect, led by the mad nun and making use of the prophecies of the mad Clerkenwell nun to foment panic and hysteria to bring forth the dethroning of Richard II. The result is a gothic novel which effortlessly merges fact and fiction into an almost recognizable alternate history.
References
2003 British novels
English novels
British mystery novels
British historical novels
Novels set in London
Novels by Peter Ackroyd
Chatto & Windus books |
In abstract algebra, the Weyl algebra is the ring of differential operators with polynomial coefficients (in one variable), namely expressions of the form
More precisely, let F be the underlying field, and let F[X] be the ring of polynomials in one variable, X, with coefficients in F. Then each fi lies in F[X].
∂X is the derivative with respect to X. The algebra is generated by X and ∂X.
The Weyl algebra is an example of a simple ring that is not a matrix ring over a division ring. It is also a noncommutative example of a domain, and an example of an Ore extension.
The Weyl algebra is isomorphic to the quotient of the free algebra on two generators, X and Y, by the ideal generated by the element
The Weyl algebra is the first in an infinite family of algebras, also known as Weyl algebras. The n-th Weyl algebra, An, is the ring of differential operators with polynomial coefficients in n variables. It is generated by Xi and ∂Xi, .
Weyl algebras are named after Hermann Weyl, who introduced them to study the Heisenberg uncertainty principle in quantum mechanics. It is a quotient of the universal enveloping algebra of the Heisenberg algebra, the Lie algebra of the Heisenberg group, by setting the central element of the Heisenberg algebra (namely [X,Y]) equal to the unit of the universal enveloping algebra (called 1 above).
The Weyl algebra is also referred to as the symplectic Clifford algebra. Weyl algebras represent the same structure for symplectic bilinear forms that Clifford algebras represent for non-degenerate symmetric bilinear forms.
Generators and relations
One may give an abstract construction of the algebras An in terms of generators and relations. Start with an abstract vector space V (of dimension 2n) equipped with a symplectic form ω. Define the Weyl algebra W(V) to be
where T(V) is the tensor algebra on V, and the notation means "the ideal generated by".
In other words, W(V) is the algebra generated by V subject only to the relation . Then, W(V) is isomorphic to An via the choice of a Darboux basis for .
Quantization
The algebra W(V) is a quantization of the symmetric algebra Sym(V). If V is over a field of characteristic zero, then W(V) is naturally isomorphic to the underlying vector space of the symmetric algebra Sym(V) equipped with a deformed product – called the Groenewold–Moyal product (considering the symmetric algebra to be polynomial functions on V∗, where the variables span the vector space V, and replacing iħ in the Moyal product formula with 1).
The isomorphism is given by the symmetrization map from Sym(V) to W(V)
If one prefers to have the iħ and work over the complex numbers, one could have instead defined the Weyl algebra above as generated by Xi and iħ∂Xi (as per quantum mechanics usage).
Thus, the Weyl algebra is a quantization of the symmetric algebra, which is essentially the same as the Moyal quantization (if for the latter one restricts to polynomial functions), but the former is in terms of generators and relations (considered to be differential operators) and the latter is in terms of a deformed multiplication.
In the case of exterior algebras, the analogous quantization to the Weyl one is the Clifford algebra, which is also referred to as the orthogonal Clifford algebra.
Properties of the Weyl algebra
In the case that the ground field has characteristic zero, the nth Weyl algebra is a simple Noetherian domain. It has global dimension n, in contrast to the ring it deforms, Sym(V), which has global dimension 2n.
It has no finite-dimensional representations. Although this follows from simplicity, it can be more directly shown by taking the trace of σ(X) and σ(Y) for some finite-dimensional representation σ (where ).
Since the trace of a commutator is zero, and the trace of the identity is the dimension of the representation, the representation must be zero dimensional.
In fact, there are stronger statements than the absence of finite-dimensional representations. To any finitely generated An-module M, there is a corresponding subvariety Char(M) of called the 'characteristic variety' whose size roughly corresponds to the size of M (a finite-dimensional module would have zero-dimensional characteristic variety). Then Bernstein's inequality states that for M non-zero,
An even stronger statement is Gabber's theorem, which states that Char(M) is a co-isotropic subvariety of for the natural symplectic form.
Positive characteristic
The situation is considerably different in the case of a Weyl algebra over a field of characteristic .
In this case, for any element D of the Weyl algebra, the element Dp is central, and so the Weyl algebra has a very large center. In fact, it is a finitely generated module over its center; even more so, it is an Azumaya algebra over its center. As a consequence, there are many finite-dimensional representations which are all built out of simple representations of dimension p.
Constant center
The center of Weyl algebra is the field of constants. For any element in the center, implies for all and implies for . Thus is a constant.
Generalizations
For more details about this quantization in the case n = 1 (and an extension using the Fourier transform to a class of integrable functions larger than the polynomial functions), see Wigner–Weyl transform.
Weyl algebras and Clifford algebras admit a further structure of a *-algebra, and can be unified as even and odd terms of a superalgebra, as discussed in CCR and CAR algebras.
Affine varieties
Weyl algebras also generalize in the case of algebraic varieties. Consider a polynomial ring
Then a differential operator is defined as a composition of -linear derivations of . This can be described explicitly as the quotient ring
See also
Jacobian conjecture
Dixmier conjecture
References
(Classifies subalgebras of the one-dimensional Weyl algebra over the complex numbers; shows relationship to SL(2,C))
Algebras
Differential operators
Ring theory |
An ethical job is a broad term to describe a job which accords with a person's ethics or values.
Surveys
In 2005, The Guardian newspaper polled 2,000 undergraduates in the UK, and found that "over 70% of students said that a company's ethical track record is a crucial factor when choosing their employer".
A 2005 poll by High Fliers Research of 6,227 final-year students at universities in Australia and New Zealand found that 40% said it was "very important" that their first employer be socially responsible, and 30% said it was "very important" that their first employer be environmentally responsible.
In 2007, Harris Interactive published the results of an opinion poll of 1,741 workers in the United States. 73% of respondents said it was "important that [one's] employer be environmentally and socially responsible".
In a 2009 poll of employers at Australian non-profit organizations conducted by EthicalJobs.com.au, 87% said that job seekers were more likely to apply for a position seen to be ethical.
See also
Green job
Green-collar worker
Corporate social responsibility
References
External links
ABC Radio National: Life Matters, Ethical Jobs, 23 June 2009.
Rosemary Sainty, Ethics and Graduate Recruitment November 2006.
UK Net Guide, Guide to Ethical Careers
Economy and the environment
Employment classifications |
```kotlin
package io.gitlab.arturbosch.detekt.internal
import io.gitlab.arturbosch.detekt.Detekt
import io.gitlab.arturbosch.detekt.DetektCreateBaselineTask
import io.gitlab.arturbosch.detekt.DetektPlugin
import io.gitlab.arturbosch.detekt.extensions.DetektExtension
import org.gradle.api.Project
import org.gradle.api.file.FileCollection
import org.gradle.api.provider.Provider
import org.gradle.language.base.plugins.LifecycleBasePlugin
internal class DetektPlain(private val project: Project) {
fun registerTasks(extension: DetektExtension) {
project.registerDetektTask(extension)
project.registerCreateBaselineTask(extension)
}
private fun Project.registerDetektTask(extension: DetektExtension) {
val detektTaskProvider = tasks.register(DetektPlugin.DETEKT_TASK_NAME, Detekt::class.java) { detektTask ->
detektTask.baseline.convention(extension.baseline)
detektTask.setSource(existingInputDirectoriesProvider(project, extension))
detektTask.setIncludes(DetektPlugin.defaultIncludes)
detektTask.setExcludes(DetektPlugin.defaultExcludes)
}
tasks.matching { it.name == LifecycleBasePlugin.CHECK_TASK_NAME }.configureEach {
it.dependsOn(detektTaskProvider)
}
}
private fun Project.registerCreateBaselineTask(extension: DetektExtension) {
tasks.register(DetektPlugin.BASELINE_TASK_NAME, DetektCreateBaselineTask::class.java) {
it.baseline.convention(extension.baseline)
it.setSource(existingInputDirectoriesProvider(project, extension))
}
}
private fun existingInputDirectoriesProvider(
project: Project,
extension: DetektExtension
): Provider<FileCollection> = project.provider { extension.source.filter { it.exists() } }
}
``` |
Inga porcata is a species of plant in the family Fabaceae. It is found only in Peru.
References
porcata
Trees of Peru
Conservation dependent plants
Taxonomy articles created by Polbot |
```python
from cryptography.fernet import Fernet
key = Fernet.generate_key()
f = Fernet(key)
``` |
New standard tuning (NST) is an alternative tuning for the guitar that approximates all-fifths tuning. The guitar's strings are assigned the notes C2-G2-D3-A3-E4-G4 (from lowest to highest); the five lowest open strings are each tuned to an interval of a perfect fifth {(C,G),(G,D),(D,A),(A,E)}; the two highest strings are a minor third apart (E,G).
All-fifths tuning is typically used for mandolins, cellos, violas, and violins. On a guitar, tuning the strings in fifths would mean the first string would be a high B. NST provides a good approximation to all-fifths tuning. Like other regular tunings, NST allows chord fingerings to be shifted from one set of strings to another.
NST's C-G range is wider, both lower and higher, than the E-E range of standard tuning in which the strings are tuned to the open notes E2-A2-D3-G3-B3-E4. The greater range allows NST guitars to play repertoire that would be impractical, if not impossible, on a standard-tuned guitar.
NST was developed by Robert Fripp, the guitarist for King Crimson. Fripp taught the new standard tuning in Guitar Craft courses beginning in 1985, and thousands of Guitar Craft students continue to use the tuning. Like other alternative tunings for guitar, NST provides challenges and new opportunities to guitarists, who have developed music especially suited to NST.
NST places the guitar strings under greater tension than standard tuning. Standard sets of guitar strings do not work well with the tuning as the lowest strings are too loose and the highest string may snap under the increased tension. Special sets of NST strings have been available for decades, and some guitarists have assembled NST sets from individual strings.
History
New standard tuning (NST) was invented by Robert Fripp of the band King Crimson in September 1983.
Fripp began using the tuning in 1985 before beginning his Guitar Craft seminars, which have taught the tuning to three thousand guitarists.
The tuning is (from low to high): C2-G2-D3-A3-E4-G4. The original version of NST was all-fifths tuning.
However, in the 1980s, Fripp never attained the all-fifth's high B. While he could attain A, the string's lifetime distribution was too short. Experimenting with a G string, Fripp succeeded. "Originally, seen in 5ths all the way, the top string would not go to B. so, as on a tenor banjo, I adopted an A on the first string. These kept breaking, so G was adopted." In 2012, Fripp suggested that Guitar Circle members experiment with an A string (0.007) from Octave4Plus of Gary Goodman; if successful, the experiment could lead to "the NST 1.2", C2G2D3A3E4-A4, according to Fripp. In 2010, Fripp suggested renaming the tuning as "Guitar Craft Standard Tuning or C Pentatonic tuning".
Properties
The lowest five strings are tuned in perfect fifths from a low C. The first string is a minor third up from the E to a G. Since the lowest five strings are tuned in fifths, guitars with NST can be played with the fingerings for chords and scales used on the violin, cello, and mandolin.
The first five strings of NST have all-fifths tuning, and so its all-fifths chords are movable around the fretboard. In contrast, standard tuning has an irregular major-third interjected among its perfect fourths, which complicates the learning of chords by beginners.
The distinct open-notes {C,G,D,A,E} are the notes of the major pentatonic scale on C, which contains only consonant intervals. The C-pentatonic scale omits the open B of standard tuning and all-fifths tuning, which forms a dissonant second-interval with C. With the 1980s King Crimson, Fripp had used pentatonic harmony in "Discipline", "Thela Hun Ginjeet", and "Sartori in Tangier".
Harmonics: Overtones
New standard tuning lists four notes (C,G,E,G) from the harmonic sequence (overtones) for the note C. When the low open-note C-string is struck, its harmonic sequence begins with the notes
(C,C,G,C,E,G,B,C).
To strengthen a given chord, Vincent Persichetti's Twentieth-century harmony recommends adding perfect fifths above the initial overtones, rather than adding higher overtones, such as B and the higher C. Persichetti's book influenced Fripp. In new standard tuning
C is the fundamental overtone,
G as a fifth reinforces C,
D as a fifth reinforces G,
A as a fifth reinforces D,
E both as a fifth reinforces A and as the fifth overtone reinforces C, and
G as the sixth overtone reinforces C.
Range
Like all-fifths tuning, NST has a greater range than the standard tuning, a perfect fifth greater (a major third lower and a minor third higher).
Chords: Perfect intervals rather than thirds
Asked whether NST facilitates "new intervals or harmonies that aren't readily available in standard tuning", Fripp responded, "Yes, that's part of it. It's more effective. It's a more rational system, but it's also better sounding—better for chords, better for single notes." To build chords, Fripp uses "perfect intervals in fourths, fifths and octaves", so avoiding minor and major thirds. Quartal and quintal harmony was stressed from the beginning of Fripp's teaching of Guitar Craft. Fripp began a 1986 course with these directions: "Now, pick a note from the following series—[it was a series of fourths or fifths]. When you are ready—do not be in any hurry, but when you are ready play your note, then pick others and play them as the situation demands it. Your first note will be the first intentional note you have played in a week."
It is a challenge to adapt conventional guitar chords to new standard tuning. NST has wider intervals between consecutive strings than standard tuning.
Historical background
Modern quartal and quintal harmony revives the polyphonic traditions of medieval Europe. Before the common practice period, European polyphony emphasized unison intervals and octaves and also perfect fifths. From the Renaissance to 1900, Western symphonic music was diatonic, emphasizing the tertian harmony of major and minor scales, keys, and chords. Much popular music, especially rock, retains diatonic harmony.
String gauges
With traditional guitar strings, the low C may be loose and the high G may be too tight. Special gauges are therefore more suitable for NST. For steel-stringed acoustic-guitars, many Guitar-Craft participants use either an .011–.058 inch set or an .011–.059 inch set; string-sets may be purchased as a set from a manufacturer or purchased singly and assembled by the guitarist.
In 2012, a 0.007 inch gauge was being evaluated by Fripp and other members of Guitar Circle, who are considering replacing the first string's G note with an A note, the better to approximate the B note of all-fifths tuning. The 0.007 inch gauge was produced by Octave4Plus of Gary Goodman. Robert Fripp uses lighter strings for electric guitar.
Artists who use NST
Robert Fripp has used the New Standard Tuning since 1984.
Fripp has taught NST in his Guitar-Craft courses. In Guitar Craft and since 2010 in the successor Guitar Circles, students use only New Standard Tuning. Having to use a new tuning, the students are challenged to approach their playing with greater mindfulness, putting to rest their habitual use of automatic chords or licks. With the new tuning, guitarists have to find new ways of musical expression.
The tuning is used by students of Guitar Craft, of which there have been three thousand. Guitar-Craft alumni who continue to practice NST are called "crafty guitarists" or "crafties". Some crafty guitarists formed The League of Crafty Guitarists (LCG), which toured with Robert Fripp and released several albums. The Guitar-Craft experience and the League of Crafty Guitarists trained guitarists who went on to form new bands, such as the California Guitar Trio and Trey Gunn; the California Guitar Trio and Gunn toured with Fripp as The Robert Fripp String Quintet. Other alumni of the League of Crafty Guitarists include members of Los Gauchos Alemanes, such as U.S. guitarist Steve Ball; Ball is associated with the Seattle Guitar Circle, along with LCG alumnus Curt Golden.
The collection A Plague of Crafty Guitarists features the following Guitar-Craft alumni, who were listed in a review by Barry Cleveland: Tobin Buttram, Nigel Gavin, Geary Street Quartet, Bill Hibbits, Janssen and Jensen, Alejandro Miniaci and From Power Trio /Project , Sur Pacifico, Playmovil, and Santos Luminosos.
NST has been adapted for instruments besides guitar. Italian guitarist Fabio Mittino plays in NST. Trey Gunn (Crimson's warr guitar player from 1994 to 2003) and Markus Reuter (TUNER with Crimson drummer Pat Mastelotto) have adapted NST for their 8- and 10-string instruments; in 2007 Reuter used a B-F-C-G-D-A-C-D tuning. Finnish musician Heikki Malmberg uses a 7-string guitar tuned in NST with an additional low F. Additionally, British musician Michael Linden West plays the oud in NST.
See also
Notes
References
Further reading
External links
Courses in New Standard Tuning are offered by Guitar Circle, the successor of Guitar Craft:
Guitar Circle of Europe
Guitar Circle of Latin America
Guitar Circle of North America
The FraKctured Zone is a King Crimson fan website with notation and tabs to songs in NST (with acknowledgment to Trey Gunn for permission).
Robert Fripp
Regular guitar-tunings
Pentatonic scales |
```objective-c
//your_sha256_hash---------------------------------------
//your_sha256_hash---------------------------------------
#pragma once
namespace Js
{
class DiagNativeStackFrame;
//
// Unified stack frame used by debugger (F12, inside VS)
// -- interpreter or native stack frame.
//
class DiagStackFrame
{
public:
virtual ~DiagStackFrame() {}
virtual JavascriptFunction* GetJavascriptFunction() = 0;
virtual int GetByteCodeOffset() = 0;
virtual DWORD_PTR GetStackAddress() = 0;
virtual Var GetRegValue(RegSlot slotId, bool allowTemp = false) = 0;
virtual Var GetNonVarRegValue(RegSlot slotId) = 0;
virtual void SetRegValue(RegSlot slotId, Var value) = 0;
virtual Var GetArgumentsObject() = 0;
virtual Var CreateHeapArguments() = 0;
virtual ScriptContext* GetScriptContext();
virtual PCWSTR GetDisplayName();
virtual bool IsInterpreterFrame();
virtual InterpreterStackFrame* AsInterpreterFrame();
virtual ArenaAllocator * GetArena();
virtual FrameDisplay * GetFrameDisplay();
virtual Var GetScopeObjectFromFrameDisplay(uint index);
virtual Var GetRootObject();
virtual Var GetInnerScopeFromRegSlot(RegSlot location);
bool IsTopFrame();
void SetIsTopFrame();
ScriptFunction* GetScriptFunction();
FunctionBody* GetFunction();
BOOL IsStrictMode();
BOOL IsThisAvailable();
Js::Var GetThisFromFrame(Js::IDiagObjectAddress ** ppOutAddress, Js::IDiagObjectModelWalkerBase * localsWalker = nullptr);
// This function will try to populate obj and address field of the ResolvedObject.
void TryFetchValueAndAddress(const char16 *source, int sourceLength, Js::ResolvedObject * pObj);
Js::ScriptFunction* TryGetFunctionForEval(Js::ScriptContext* scriptContext, const char16 *source, int sourceLength, BOOL isLibraryCode = FALSE);
void EvaluateImmediate(const char16 *source, int sourceLength, BOOL isLibraryCode, Js::ResolvedObject * pObj);
Js::Var DoEval(Js::ScriptFunction* pfuncScript);
protected:
DiagStackFrame();
private:
bool isTopFrame;
};
class DiagInterpreterStackFrame : public DiagStackFrame
{
InterpreterStackFrame* m_interpreterFrame;
public:
DiagInterpreterStackFrame(InterpreterStackFrame* frame);
virtual JavascriptFunction* GetJavascriptFunction() override;
virtual ScriptContext* GetScriptContext() override;
virtual int GetByteCodeOffset() override;
virtual DWORD_PTR GetStackAddress() override;
virtual bool IsInterpreterFrame() override;
virtual InterpreterStackFrame* AsInterpreterFrame() override;
virtual Var GetRegValue(RegSlot slotId, bool allowTemp = false) override;
virtual Var GetNonVarRegValue(RegSlot slotId) override;
virtual void SetRegValue(RegSlot slotId, Var value) override;
virtual Var GetArgumentsObject() override;
virtual Var CreateHeapArguments() override;
virtual FrameDisplay * GetFrameDisplay() override;
virtual Var GetInnerScopeFromRegSlot(RegSlot location) override;
};
#if ENABLE_NATIVE_CODEGEN
class DiagNativeStackFrame : public DiagStackFrame
{
ScriptFunction* m_function;
int m_byteCodeOffset;
void* m_stackAddr;
int32 m_localVarSlotsOffset; // the offset on the native stack frame where the locals are residing.
int32 m_localVarChangedOffset; // The offset which stores if any locals is changed from the debugger.
static const int32 InvalidOffset = -1;
public:
DiagNativeStackFrame(ScriptFunction* function, int byteCodeOffset, void* stackAddr, void *codeAddr);
virtual JavascriptFunction* GetJavascriptFunction() override;
virtual ScriptContext* GetScriptContext() override;
virtual int GetByteCodeOffset() override;
virtual DWORD_PTR GetStackAddress() override;
virtual Var GetRegValue(RegSlot slotId, bool allowTemp = false) override;
virtual Var GetNonVarRegValue(RegSlot slotId) override;
virtual void SetRegValue(RegSlot slotId, Var value) override;
virtual Var GetArgumentsObject() override;
virtual Var CreateHeapArguments() override;
private:
Var * GetSlotOffsetLocation(RegSlot slotId, bool allowTemp = false);
};
#endif
class DiagRuntimeStackFrame : public DiagStackFrame
{
JavascriptFunction* m_function;
PCWSTR m_displayName;
void* m_stackAddr;
public:
DiagRuntimeStackFrame(JavascriptFunction* function, PCWSTR displayName, void* stackAddr);
virtual JavascriptFunction* GetJavascriptFunction() override;
virtual int GetByteCodeOffset() override;
virtual DWORD_PTR GetStackAddress() override;
virtual Var GetRegValue(RegSlot slotId, bool allowTemp = false) override;
virtual Var GetNonVarRegValue(RegSlot slotId) override;
virtual void SetRegValue(RegSlot slotId, Var value) override;
virtual Var GetArgumentsObject() override;
virtual Var CreateHeapArguments() override;
virtual PCWSTR GetDisplayName() override;
};
}
``` |
The Harmony Historic District encompasses the first early 19th century settlement of the Harmony Society, in what is now Harmony, Butler County, Pennsylvania, USA. It covers an area two blocks wide, extending north from German Road to Conoquenessing Creek between Liberty and Wood Streets. The area retains a number of buildings dating to the original settlement period, and was designated a National Historic Landmark District in 1974.
Description and history
The Harmony Society was founded in what is now Germany in 1785 by Johann Georg Rapp. Meeting with opposition from the dominant Lutheran Church, Rapp and his followers emigrated to North America, and purchased the land in Butler County where the community of 200 families founded Harmony in 1805. The utopian community was run as a communist theocracy, with Rapp and later his son as its leading figure. The Harmonist community was successful, growing to about 700 by 1814, when Rapp's son Frederick established a new settlement in the Indiana Territory, now New Harmony, Indiana. They eventually moved back to Pennsylvania, settling Economy in 1825, and died out as an organization in 1905.
The surviving elements of the early Harmonist settlement include a grid of streets in the heart of the modern town of Harmony, and a number of primarily brick buildings in that area. The district includes ten contributing buildings and one contributing site. Principal among these are the George Rapp House, Great House or Bentle Building (c. 1811), Langenbacher House (c. 1805), Harmonist Church (1808), The "Stohr," Beam Hotel, Frederick Rapp House, Schmitt House, Jacob Neff House (c.1807), Schreiber House, Wagner House, and Mueller House. The original Harmonist Cemetery contains the unmarked graves of 100 early Harmonists.
See also
List of National Historic Landmarks in Pennsylvania
National Register of Historic Places listings in Butler County, Pennsylvania
References
External links
Harmony Museum, in the Great House
National Historic Landmarks in Pennsylvania
Historic districts on the National Register of Historic Places in Pennsylvania
Geography of Butler County, Pennsylvania
Museums in Butler County, Pennsylvania
History museums in Pennsylvania
Religious museums in Pennsylvania
1804 establishments in Pennsylvania
National Register of Historic Places in Butler County, Pennsylvania |
```yaml
---
image:
file: .gitpod.dockerfile
tasks:
- init: |
mvn dependency:resolve
mvn compile
vscode:
extensions:
- xaver.clang-format
``` |
Heinrich Reschauer (3 October 1838, Vienna – 1 September 1888, Neulengbach) was an Austrian journalist and politician.
Biography
He came from a petite bourgeoisie family that lost everything they owned during the Revolution of 1848. As a result, he was unable to finish his education and found employment as a bookseller. This led to an involvement in journalism. In 1861 he published The Tasks of German Austria after February 26, 1861, the date that a new constitution, known as the "February Patent" was established. During the course of promoting this work, he became close friends with the publicist, Franz Schuselka, who helped him obtain a position on the editorial board of , a daily newspaper.
Shortly after, he became the Viennese correspondent for Die Volksstimme (The People's Voice), a newspaper in Graz. He eventually was promoted to editor-in-chief. He returned briefly to Der Wanderer then, in 1863, took over the editorial board of . In 1867, together with and Moritz Szeps, he co-founded the Neues Wiener Tagblatt. After 1872, he worked in the editorial offices of the . From 1875 to 1886, he was their editor-in-chief and publisher.
He also wrote historical works, the best known of which is Das jahr 1848. Geschichte der Wiener revolution (1872), a two volume history of the Vienna Uprising. The second volume was written together with Moritz Smetazko, known as "Moritz Smets" (1828–1890), a freelance history writer.
In addition to his journalistic work, he was politically active. From 1873 to 1878, he sat on the Vienna Gemeinderat (Municipal Council). He was aligned with the Constitutional Party and promoted programs favorable to small business owners. In the 1880s, he also served as a member of the Imperial Council.
He died at his summer home in the Sankt Pölten-Land District, leaving behind a wife and five children, but very little in the way of an estate.
References
External links
1838 births
1888 deaths
19th-century Austrian journalists
Austrian politicians
Austrian newspaper editors
Austrian newspaper founders
19th-century Austrian historians
Writers from Vienna |
Vernayaz railway station (, ) is a railway station in the municipality of Vernayaz, in the Swiss canton of Valais. It is an intermediate stop on the Simplon line and is served by local trains only.
Services
The following services stop at Vernayaz:
Regio: half-hourly service between and , with every other train continuing from Monthey to .
References
External links
Railway stations in the canton of Valais
Swiss Federal Railways stations |
```php
<?php
/**
* Shop-PHP-Yii2
*
* @author Tony Wong
* @date 2016-08-02
* @email 908601756@qq.com
*/
namespace common\models;
use common\components\ETActiveRecord;
use Yii;
/**
* This is the model class for table "order_item".
*
* @property integer $id
* @property integer $order_id
* @property integer $cart_item_id
* @property integer $user_id
* @property integer $product_id
* @property integer $created_at
* @property integer $created_by
* @property integer $updated_at
* @property string $update_by
* @property integer $count
* @property string $image
* @property string $featured_image
* @property string $image_small
* @property string $name
* @property string $price
* @property string $sku_price ProductSku::$price
* @property string $subtotal_price
* @property integer $status
* @property integer $product_type
*
* @property Order $order
*/
class OrderItem extends BaseModel
{
/**
* @inheritdoc
*/
public static function tableName()
{
return 'order_item';
}
/**
* {@inheritdoc}
*/
public static function primaryKey()
{
return ['id'];
}
/**
* @inheritdoc
*/
public function rules()
{
return [
[['order_id', 'user_id', 'product_id', 'created_at', 'created_by', 'updated_at', 'count', 'product_type', 'status'], 'integer'],
[['order_id', 'user_id', 'product_id', 'created_at', 'created_by', 'updated_at', 'count', 'product_type', 'status'], 'integer'],
[['price', 'subtotal_price'], 'number'],
[['update_by'], 'string', 'max' => 64],
[['image', 'image_small', 'name'], 'string', 'max' => 255],
[['featured_image'], 'string', 'max' => 1],
[['order_id'], 'exist', 'skipOnError' => true, 'targetClass' => Order::className(), 'targetAttribute' => ['order_id' => 'id']],
];
}
/**
* @inheritdoc
*/
public function attributeLabels()
{
return [
'id' => 'ID',
];
}
/**
* @return \yii\db\ActiveQuery
*/
public function getOrder()
{
return $this->hasOne(Order::className(), ['id' => 'order_id']);
}
}
``` |
```objective-c
/**
* \file block_cipher_internal.h
*
* \brief Lightweight abstraction layer for block ciphers with 128 bit blocks,
* for use by the GCM and CCM modules.
*/
/*
*/
#ifndef MBEDTLS_BLOCK_CIPHER_INTERNAL_H
#define MBEDTLS_BLOCK_CIPHER_INTERNAL_H
#include "mbedtls/build_info.h"
#include "mbedtls/cipher.h"
#include "mbedtls/block_cipher.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* \brief Initialize the context.
* This must be the first API call before using the context.
*
* \param ctx The context to initialize.
*/
static inline void mbedtls_block_cipher_init(mbedtls_block_cipher_context_t *ctx)
{
memset(ctx, 0, sizeof(*ctx));
}
/**
* \brief Set the block cipher to use with this context.
* This must be called after mbedtls_block_cipher_init().
*
* \param ctx The context to set up.
* \param cipher_id The identifier of the cipher to use.
* This must be either AES, ARIA or Camellia.
* Warning: this is a ::mbedtls_cipher_id_t,
* not a ::mbedtls_block_cipher_id_t!
*
* \retval \c 0 on success.
* \retval #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA if \p cipher_id was
* invalid.
*/
int mbedtls_block_cipher_setup(mbedtls_block_cipher_context_t *ctx,
mbedtls_cipher_id_t cipher_id);
/**
* \brief Set the key into the context.
*
* \param ctx The context to configure.
* \param key The buffer holding the key material.
* \param key_bitlen The size of the key in bits.
*
* \retval \c 0 on success.
* \retval #MBEDTLS_ERR_CIPHER_INVALID_CONTEXT if the context was not
* properly set up before calling this function.
* \retval One of #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH,
* #MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
* #MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA if \p key_bitlen is
* invalid.
*/
int mbedtls_block_cipher_setkey(mbedtls_block_cipher_context_t *ctx,
const unsigned char *key,
unsigned key_bitlen);
/**
* \brief Encrypt one block (16 bytes) with the configured key.
*
* \param ctx The context holding the key.
* \param input The buffer holding the input block. Must be 16 bytes.
* \param output The buffer to which the output block will be written.
* Must be writable and 16 bytes long.
* This must either not overlap with \p input, or be equal.
*
* \retval \c 0 on success.
* \retval #MBEDTLS_ERR_CIPHER_INVALID_CONTEXT if the context was not
* properly set up before calling this function.
* \retval Another negative value if encryption failed.
*/
int mbedtls_block_cipher_encrypt(mbedtls_block_cipher_context_t *ctx,
const unsigned char input[16],
unsigned char output[16]);
/**
* \brief Clear the context.
*
* \param ctx The context to clear.
*/
void mbedtls_block_cipher_free(mbedtls_block_cipher_context_t *ctx);
#ifdef __cplusplus
}
#endif
#endif /* MBEDTLS_BLOCK_CIPHER_INTERNAL_H */
``` |
Castleknock Hurling and Football Club is a Dublin GAA club centered on the townlands of Carpenterstown and Diswellstown in the civil parish of Castleknock in Fingal, Ireland. It serves large parts of the suburban areas of Castleknock, Hartstown, Coolmine, Blanchardstown, Laurel Lodge and Clonsilla. The club plays the following Gaelic games at all age levels from nursery to adult: Hurling, Gaelic football, Camogie and Ladies' Gaelic football.
It has a rivalry with the St Brigid's club.
Grounds
The club's main grounds are located at Somerton Lane, Diswellstown. It also uses grounds managed by Fingal County Council at Porterstown, St.Catherine's Park and "Tir na nÓg" (beside Castleknock Community College).
History
The club's first major discovery was a then five-year-old Ciarán Kilkenny, whom it invited to participate in its "Tir na nÓg" sessions in 1998.
The club began life in the tenth tier of the Dublin Senior Football Championship, later rising to the top tier.
The club won the National Féile in 2007 and recently 2016 and 2017.
The club has teams from juvenile to senior level. It has 1500 members from 650 different families.
A clubhouse worth about €1.5 million was about to be opened in 2019, as Kilkenny was winning All-Ireland titles around him. The man who opened it, Leo Varadkar, was Taoiseach and had nephews playing for the club at the time.
Lar Norton is the coach of the Castleknock senior footballers. Maria Bergin from Naas is the club's full-time "games promotion officer", paid by the Dublin County Board to visit local schools and inculcate the children she finds there into football and hurling. She runs a nursery for four to seven year-olds each Saturday morning in Carpenterstown to the west of Castleknock.
Honours
Dublin Senior Football Championship Runners up 2016
Leinster Junior Club Football Championship Winners 2012
Dublin Junior Football Championship Winners 2012
Dublin Junior Hurling Championship Winners 2013
Leinster Special Junior Hurling Championship Winners (1) 2013
Dublin Intermediate Football Championship Winners 2014
Dublin Intermediate Hurling Championship Winners 2015
Dublin Under 21 C Football Championship Winners 2011
Feile Division 1 Football All Ireland Championship Winners 2016
Feile Division 1 Hurling All Ireland Championship Winners 2007
Dublin Minor A Football Championship Winners 2011, 2019
Dublin Senior Football League Division 2 Winners 2015
Dublin AFL Div. 4 Winners 2012
Dublin AFL Div. 5 Winners 2011
Dublin AFL Div. 10 Winners 2015
Dublin Junior F Hurling Championship Winners 2010
Dublin Junior B Hurling Championship Winners 2006
Dublin Junior B+ Hurling Championship Winners 2004
Dublin Junior D Hurling Championship Winners 2003
Dublin Minor B Hurling Championship Winners 2009
Dublin Minor C Hurling Championship Winners 2017
Dublin Minor D Hurling Championship Winners 2012
References
External links
Gaelic games clubs in Fingal
Gaelic football clubs in Fingal
Hurling clubs in Fingal
Castleknock |
```yaml
identifier: qemu_x86/atom/xip
name: QEMU Emulation for X86 (XIP enabled)
type: qemu
arch: x86
simulation: qemu
toolchain:
- zephyr
- xtools
testing:
default: true
only_tags:
- xip
vendor: qemu
``` |
The 2018 Lombard regional election took place on 4 March 2018.
The election took place concurrently with the Italian general election and the Lazio regional election.
Electoral system
Since 2012, Lombardy has adopted its legislation to elect its Council, very similar to the national Tatarella Law of 1995.
While the President of Lombardy and the leader of the opposition are still elected at-large, 78 councilors are elected by party lists under a form of semi-proportional representation. The winning coalition receives a jackpot of at least 45 seats, which are divided between all majority parties using the D'Hondt method, as it happens between the losing lists. Each party then distributes its seats to its provincial lists, where candidates are openly selected.
According to the Law 17 February 1968, no. 108, the Regional Council is elected every five years. The election can take place on the fourth Sunday before the completion of five years period.
Campaign
On 1 March 2016, President Maroni announced his intention to run for re-election as president. Nonetheless, on 8 January 2018 he announced he'd not seek a re-election as president, citing personal reasons and launching former mayor of Varese Attilio Fontana as a candidate of the center-right coalition.
On 1 June 2017 Giorgio Gori, the incumbent mayor of Bergamo, announced his decision to run for the presidency for the center-left coalition.
On 15 January 2018, Fontana stated that the white race and the Western culture were in danger due to the migration flows from Africa. This created lot of protests and criticisms from the centre-left Democratic Party and also the anti-establishment Five Star Movement.
Parties and candidates
Results
According to the final results, Attilio Fontana was the new President of Lombardy with more than 49% of the votes, obtaining the greater bonus given by the electoral law.
Results by province
Results by capital city
Seats by province
References
2018 elections in Italy
21st century in Lombardy
Regional elections in Lombardy
March 2018 events in Italy |
Richard George Duckfield (2 July 1907 – 30 December 1959) was a Welsh cricketer who played first-class cricket for Glamorgan between 1930 and 1938 as a right-hand bat. Largely successful between 1932 and 1938, Duckfield held for a time the record high score for any Glamorgan player – 280 against Surrey. He retired from the game in 1938 after a loss of confidence in his own fielding, having scored exactly 7,000 runs.
Career
Born in Maesteg, then part of Glamorgan but now lying within Bridgend County Borough, Duckfield began as a player for various local invitational XIs as well as for Maesteg Town cricket club in 1925, and Glamorgan Club and Ground from 1926. From 1930 he began to feature for Glamorgan in the County Championship, and by 1932 he had established himself with Glamorgan and scored 1,000 runs over one season for the first time, as well as his first century against Middlesex. He would go on to score 7,000 runs for them and for the invitational 'Players' Eleven – his century during a Gentlemen v Players match drew many plaudits from Wisden in 1934. His career-high score of 280 not out, made against Surrey in 1936, was for a time the record high score for Glamorgan. However, by 1938 a loss of confidence in the field led to his retirement from the game. Glamorgan historian Dr. A. K. Hignell noted that "he started to doubt his ability in the field and found it increasingly difficult to either catch a ball in the air or field a ball running along the ground. As this preyed on his mind, Duckfield lost his place in the county's side."
Notes
External links
1907 births
1959 deaths
Sportspeople from Maesteg
Welsh cricketers
Glamorgan cricketers
Players cricketers
English cricketers of 1919 to 1945 |
The Mysterious Desperado is a 1949 American Western film. The Los Angeles Times reported that "Tim Holt Westerns have attained a good standard which is adequately maintained" in the film.
Plot
Tim Holt and his partner, Chito Rafferty, investigate when Rafferty's uncle is killed and his son disappears, leaving Rafferty the possible heir to the estate.
Cast
Tim Holt as himself
Richard Martin as Chito Rafferty
Movita Castaneda as Luisa
Edward Norris as Ramon
References
External links
1949 films
American Western (genre) films
1949 Western (genre) films
RKO Pictures films
American black-and-white films
Films directed by Lesley Selander
1940s American films
1940s English-language films |
Manolis Chiotis (Greek: Μανώλης Χιώτης; March 21, 1921 – March 20, 1970) was a Greek rebetiko and laiko composer, singer, and bouzouki player. He is considered one of the greatest bouzouki soloists of all time. He popularised the four-course bouzouki (tetrachordo) and introduced the guitar-like tuning, who found it better suited to the kind of virtuoso playing he was famous for.
Chiotis had other successes. In the summer of 1961, he played for Aristotle Onassis and Maria Callas, Prince Rainier III of Monaco and Grace Kelly. Journalist Dimitris Liberopoulos, Onassis’ biographer, writes in his book that when the two couples joined one of Chiotis’ shows in Athens, they asked to meet him in person to congratulate him.
Callas told Chiotis that she had been translating the lyrics of his songs to Princess Grace all night long and the American actress loved them because “she is a woman in love.” At that moment, Kelly asked Chiotis what the difference between a bouzouki and an electric guitar is.
Chiotis’ answer was rather unexpected; “Mrs. Callas, please explain to Princess Grace that the strings of an electric guitar vibrate due to electricity, while the strings of a bouzouki vibrate through the heart.”
References
See also
Bouzouki
Rebetes
Rebetiko
Laiko
Greek nightclubs
Greek music
1921 births
1970 deaths
Greek Macedonians
Musicians from Thessaloniki
Greek male songwriters
Rebetiko musicians
Greek bouzouki players
Greek rebetiko singers
20th-century Greek male singers |
Mitchell Evan Haniger (born December 23, 1990) is an American professional baseball left fielder for the San Francisco Giants of Major League Baseball (MLB). He has previously played in MLB for the Arizona Diamondbacks and Seattle Mariners.
A collegiate All-American for California Polytechnic State University, San Luis Obispo, in 2012, the Milwaukee Brewers selected Haniger in the supplemental section of the first round of the 2012 MLB draft. He was traded to the Diamondbacks in 2014, made his MLB debut with them in 2016, and was traded to the Mariners after the season. Haniger was an All Star in 2018.
Amateur career
High school
Haniger attended Archbishop Mitty High School in San Jose, California, part of the West Catholic Athletic League. Haniger was a star two-sport athlete for Archbishop Mitty. In baseball, he batted in the .370s and showed near the top among prep home run hitters on the diamond. In football, he racked up 75 catches for 789 yards and 5 touchdowns as a wide receiver on the school's team.
College
Haniger was recruited as an athlete by California Polytechnic State University (Cal Poly San Luis Obispo), Cal State Fullerton, University of California, Berkeley, the University of Oregon, UC Santa Barbara, and UC Davis, all of whom wanted Haniger to play on their college baseball team. The New York Mets selected Haniger in the 31st round of the 2009 Major League Baseball (MLB) Draft, but he did not sign with the team, choosing instead to enroll at Cal Poly, to play for the Cal Poly Mustangs.
While at Cal Poly, Haniger played right field as a freshman and sophomore, and center field as a junior. Haniger was named the 2010 Big West Conference Freshman of the Year following his debut season with the Mustangs, a year in which he batted an impressive .325.
Following his freshman season at Cal Poly, Haniger spent the summer of 2010 playing wood bat baseball as part of the Corvallis Knights of the West Coast League, hitting .299 over 134 at bats with the team, racking up 11 stolen bases in 38 games played. Haniger was named a member of the first-team All-WCL Team and was rated as the WCL's No. 5 pro prospect by Baseball America following the 2010 summer schedule.
His sophomore season proved less successful at the plate than his freshman year, but Haniger nevertheless managed to bat .275/.371/.466 in 189 at bats. He once again spent the summer playing wood bat collegiate ball, this time in the colors of the Green Bay Bullfrogs of the Northwoods League.
His summer work paid dividends, paving the way for an offensive explosion in 2012, during which spent much of the year heading the Big West Conference in the power categories of home runs, runs batted in, and slugging percentage. Haniger finished the season batting .346 (7th in the league)/.438(3rd)/.626(first) in 211 at bats with 48 runs (3rd), 18 doubles (6rd), 13 home runs (first), 64 RBIs (first), 36 walks (4th), and 7 sacrifice flies (first). Haniger won the league's highest plaudit, being named the 2012 Big West Conference Player of the Year and gained national recognition as an All-American.
Professional career
Milwaukee Brewers
The Milwaukee Brewers selected Haniger as a supplemental draft pick at the end of the first round of the 2012 MLB draft — the 38th overall selection. The pick with which Haniger was selected was awarded to the Brewers as partial compensation for the loss of slugger Prince Fielder to the Detroit Tigers in the 2011-12 offseason. Haniger's signing bonus with the Brewers was $1.2 million — less than the $1.359 million bonus for his draft slot recommended by MLB. After signing with the Brewers, Haniger was dispatched to the team's affiliate in Appleton, Wisconsin, where he appeared in 14 games for the Wisconsin Timber Rattlers of the Class A Midwest League. He missed most of the 2012 season with a partial tear of his posterior cruciate ligament in his right knee, which he injured on a play at the plate.
In 2013, Haniger began the season rated the 10th-best prospect and best outfield arm in the Brewers organization by Baseball America. With Wisconsin, before being promoted to the Brevard County Manatees of the Class A-Advanced Florida State League. Combined, Haniger had a .264 batting average, a .348 on-base percentage, 11 home runs, and 68 runs batted in. After the 2013 season, the Brewers assigned Haniger to play for the Surprise Saguaros of the Arizona Fall League. He was named co-player of the week, along with Kris Bryant, in the first week of the fall league season. He batted .280/.354/.480 in 100 at bats, and was named to the AFL All-Prospect team.
The Brewers invited Haniger to spring training in 2014. Failing to make the cut for the team's 25-man roster, Haniger was assigned to the Huntsville Stars of the Class AA Southern League to begin the season. Entering the season, he was rated the third-best prospect in the organization by Baseball America.
Arizona Diamondbacks
On July 31, 2014, the Brewers traded Haniger and Anthony Banda to the Arizona Diamondbacks for Gerardo Parra. The Diamondbacks assigned him to the Mobile BayBears of the Southern League. Haniger began the 2015 season with Mobile. Though he batted .281/.351/.379 in 153 at bats for Mobile, the Diamondbacks demoted Haniger to the Visalia Rawhide of the Class A-Advanced California League in June so that he could play more frequently. With Visalia he hit .332(8th in the California League/.381/.619(4th) in 202 at bats. He spent the 2015 season retooling his batting stance and swing to focus on generating more power.
Haniger began the 2016 season with Mobile, with whom he batted .294/.407(5th in the league)/.462 with 8 hit by pitch (6th) in 236 at bats, and was named to the Southern League midseason All Star team. He was promoted to the Reno Aces of the Class AAA Pacific Coast League during the season. After batting .341/.428/.670 in 261 at bats with 20 home runs for Reno, he was named a 2016 PCL All Star. After the season he was named the Diamondbacks Minor League Player of the Year.
The Diamondbacks called up Haniger to the major leagues on August 16, 2016. Haniger played his first major league game against the New York Mets that day, becoming the first Diamondbacks player to have a triple as his first major league hit. Haniger also set a record as the first player in Diamondbacks history to tally three RBIs in his inaugural game. For the 2016 season with the Diamondbacks, he hit .229/.309/.404 in 109 at bats. He played 22 games in center field, nine in left field, and four in right field.
Seattle Mariners
On November 23, 2016, the Diamondbacks traded Haniger, Jean Segura, and Zac Curtis to the Seattle Mariners for Taijuan Walker and Ketel Marte.
2017
He was rated the fifth-best prospect in the Mariners' farm system by Baseball America heading into the 2017 season. Haniger began the year as the Mariners' Opening Day right fielder, batting second. On July 29, Haniger was hit in the face by a fastball from Mets' starting pitcher Jacob DeGrom. On August 19, Haniger hit his first career grand slam off Rays' pitcher Jake Odorizzi at Tropicana Field in his return from the 10-day disabled list.
Haniger finished 2017, his rookie season, batting .282/.352/.491 in 369 at bats with 58 runs, 16 home runs, and 47 RBIs in 96 games. He played 94 games in right field, six in center field, and two in left field. His range factor of 2.37 per 9 innings was the second-best among AL right fielders, though his five errors were third-most.
2018
Coming off a productive, yet injury-shortened, rookie campaign, Haniger finished the first half of the season hitting .272/.358/.488 with 18 home runs and 67 RBIs. Haniger was named to the 2018 MLB All-Star Game in Washington, D.C., his first ever All-Star Game selection.
Haniger's breakout season ended with a .285/.366/.493 slash line in 596 at bats (7th in the AL) with 58 runs, 26 home runs, 93 RBIs (10th), and 7 sacrifice flies (7th) in 157 games, finishing 11th in AL MVP voting. His 15 game-winning RBIs ranked 6th in the major leagues. He posted a bWAR of 6.5, which ranked 8th-best among American League position players. He reached base at a high frequency, ranking 11th in on-base percentage and tied for 13th in walks in the American League. In addition, he displayed excellent defense in the outfield, tied for most outfield assists in all of baseball (12) and tied for 10th in the AL with 5 defensive runs saved, while leading AL right fielders with 8 errors. His range factor per 9 innings of 2.29 was second-best in the AL. He played 144 games in right field, 35 games in center field, two in left field, and one at DH.
2019-20
Following the departure of star teammates such as Robinson Cano, Nelson Cruz, James Paxton and Edwin Diaz over the offseason, Haniger found himself as the new leader of the rebuilding Mariners team. After a relatively slow start in which he hit .220/.314/.463 in 246 at bats with 46 runs, 15 homers, and 32 RBIs in 63 games, Haniger was placed on the injured list with a ruptured testicle after fouling off a fastball directly in his groin area on June 6, 2019, and missed the remainder of the season. He played 43 games in right field, 24 games in center field, and one game at DH.
Haniger sat out the 2020 season due to numerous surgeries between the offseason and during the pandemic-shortened season.
2021
Haniger returned to baseball in 2021 and had a career year. He was named July 18 AL Player of the Week.
He hit .253/.318/.486 in 620 at bats (7th in the AL) with 110 runs (6th), 39 home runs (5th), 100 RBIs, 8 sacrifice flies (8th), and 169 strikeouts (8th). He set career highs in home runs, runs batted in, and runs scored. He played 123 games in right field, and 34 at DH. He led the AL in range factor per game as a right fielder (2.22), and was second in fielding percentage (.989). He came in 20th in the voting for MVP.
2022
On June 16, 2022, Haniger was placed on the 60-day injured list with an ankle injury. He was activated on August 6. In 2022 Haniger batted .246/.308/.429 in 224 at bats, with 11 home runs and 34 RBIs. He played 47 games in right field, and 12 at DH.
San Francisco Giants
On December 7, 2022, Haniger signed a three-year, $43.5 million contract with the San Francisco Giants. Haniger hit .230 in 40 games for the Giants before he was hit in the arm by a pitch from St. Louis Cardinals starter Jack Flaherty on June 13, 2023. He was later diagnosed with a fractured right forearm and underwent surgery to repair the injury. Haniger was transferred to the 60–day injured list on June 22. He was activated on August 29.
International career
On October 29, 2018, Haniger was named to the MLB All-Stars team at the 2018 MLB Japan All-Star Series.
Personal life
Haniger married his high school sweetheart, Amanda Gimenez, in 2016. Their daughter was born in December 2020. The family resides in Seattle.
References
External links
1990 births
Living people
American League All-Stars
Arizona Diamondbacks players
Arizona League Diamondbacks players
Baseball players from Santa Clara County, California
Brevard County Manatees players
Cal Poly Mustangs baseball players
California Polytechnic State University alumni
Everett AquaSox players
Huntsville Stars players
Major League Baseball outfielders
Mobile BayBears players
Modesto Nuts players
Reno Aces players
Sacramento River Cats players
San Francisco Giants players
Seattle Mariners players
Sportspeople from Santa Clara, California
Surprise Saguaros players
Tacoma Rainiers players
Wisconsin Timber Rattlers players
Archbishop Mitty High School alumni |
Reinhard Lerch is an electrical engineer at the University of Erlangen-Nuremberg in Erlangen, Bavaria. He was named a Fellow of the Institute of Electrical and Electronics Engineers (IEEE) in 2012 for his contributions to ultrasonic transducer technology and computer modeling of sensors and actuators.
Lerch is currently the dean of the technical department of the University of Erlangen-Nuremberg.
References
Fellow Members of the IEEE
Living people
Date of birth missing (living people)
American electrical engineers
Year of birth missing (living people)
Academic staff of the University of Erlangen-Nuremberg |
Monarch High School (MHS) is a public high school located in Coconut Creek, Florida. Monarch is a part of the Broward County Public Schools system, and serves neighborhoods in: Coconut Creek, Deerfield Beach, Margate, and Pompano Beach.
Monarch had an FCAT school grade of "B" for the 2018-2019 and 2021-2022 academic years.
Campus
The pair of buildings that make up the school were designed by the Miami architectural firm Zyscovitch on a design and build basis. Building four, which houses the gym, cafeteria, and numerous classrooms, has the ability to be utilized as a hurricane shelter if necessary. The campus is also designed to enable community use of the facilities when not being used by the school.
During the school's third academic year, an additional building, Building 5, was constructed to relieve "critical overcrowding" and meet class size requirements. The school also has a number of portable classrooms. Currently MHS is trying to raise funds to build a football stadium on campus.
Excalibur Program
Monarch High School offers the Excalibur Program, an integrated and accelerated curriculum for talented students at Monarch. The program offers a rigorous curriculum consisting of high caliber classes, including those of the Honors, AICE, and AP level. Throughout the students' participation in the program, their inclusion depends upon GPA and test scores.
Academics
The school offers a large array of academic courses. The core academics include math, social studies, science, and English. There are many extra clubs and activities at the school, including (but not limited to) Drama Club, a wide variety of sports, a marching band, jazz band, concert band, drumline, indoor percussion, color guard, chamber orchestra, full orchestra, Debate Team, chorus, arts, step team, cheerleading, foreign language clubs, journalism club, flag football, multicultural society, an Environmental Club, Mu Alpha Theta, DECA, National Honor Society (NHS) and JROTC. Advanced Placement classes are offered also.
Monarch students presently attend school from 7:40 AM to 2:40 PM, Monday through Friday on Block schedule. The current schedule requires students to attend four classes out of eight each day and a 40-minute lunch period each day with an eight-minute passing period between each class.
The school has an online gradebook which allows students to check their grades from any computer connected to the internet. Other information, such as absences and missing assignments, can also be viewed.
2015 Academic Indicators
College Readiness Index 22.6
Mathematics Proficiency 2.7
Reading Proficiency 2.8
Student-Teacher Ratio 24:1
Sports
Test Scores
U.S. News calculates these values based on student performance on state exit exams and internationally available exams on college-level course work (AP/IB exams).
Subject Proficiency Testing
Student exit exams receive grades among multiple proficiency levels established by the state. These figures display how the school as a whole performed in different subjects.
Reading Proficiency Distribution
Reading proficiency is determined by student results on the school's Florida Comprehensive Assessment Test or End-of-Course Assessments.
Mathematics Proficiency Distribution
Mathematics proficiency is determined by student results on the school's Florida Comprehensive Assessment Test or End-of-Course Assessments tests.
Overall Student Performance
This measures overall student performance on state exams. The calculations by U.S. News were the first of two steps in determining which schools received at least a bronze medal.
Disadvantaged Student Performance
This measures the proficiency on state exams among typically underperforming subgroups. The calculations by U.S. News were the second of two steps in determining which schools received at least a bronze medal.
College-Ready Student Performance
High school students take AP and IB exams to earn college credit and demonstrate success at college-level course work. U.S. News calculated a College Readiness Index based on exam participation rates and percentages of students passing at least one exam. The index determined which types of medals (gold, silver or bronze) were awarded to top-performing schools.
Advanced Placement (AP) Student Performance
Many U.S. higher educational institutions grant credits or advanced placement based on student performance on AP exams. This shows this school's student participation and performance on these exams if data were available.
Data are based on the 2012-2013 school year.
Student Body
Class
These details on the school's student body are based on data reported to the government.
Demographics
As of the 2021-22 school year, the total student enrollment was 2,406. The ethnic makeup of the school was 67.3% White, 23.9% Black, 40.1% Hispanic, 3.9% Asian, 3.5% Multiracial, 1% Native American or Native Alaskan, and 0.4% Native Hawaiian or Pacific Islander. 53.1% of the students were eligible for free or reduced cost lunch.
Digital Learning Environment
At the beginning of the Digital Learning Environment program, in the school's second academic year (2004–2005), students were provided with a laptop that could be taken home and brought back with them to school on a regular basis to further enhance the program. This element was withdrawn after three years because of budget cuts, the expense of computer repairs and maintenance and because of misuse, vandalism and stolen/ lost computers.
Pinwheels for Peace
A program started by two teachers, Ellen McMillan and Ann Ayers at Monarch High, the Pinwheels for Peace Project invites students to create and display their pinwheels on the campus during the International Day of Peace and has been adopted internationally. Groups in more than 1,500 places have planted more than half a million pinwheels throughout the world.
Traditions
Knights Code of Chivalry
The school emphasizes a code of conduct among students, teachers, faculty and peers dubbed the "Knights Code of Chivalry." The code was created by a student panel the year before the school opened. Plaques containing the code are present in every classroom.
Responsibility
Citizenship
Kindness
Respect
Honesty
Self-Control
Tolerance
Cooperation
Notable alumni
Calvin Ridley (Class of 2015): American football wide receiver for the Jacksonville Jaguars
Ryan Shakes, American social media personality
References
External
Broward County Public Schools
Broward County Public Schools
High schools in Broward County, Florida
Public high schools in Florida
Coconut Creek, Florida
Educational institutions established in 2003
2003 establishments in Florida |
Elachista dumosa is a moth of the family Elachistidae that can be found in North Macedonia and Ukraine.
References
dumosa
Moths described in 1981
Moths of Europe |
Sugarloaf Mountain near the town of Patrick (Chesterfield County, South Carolina) is an unusual hill, known locally as "The Mountain," that towers a hundred feet above the surrounding terrain. This site is located within the Sand Hills State Forest, just off US highway 1, near Patrick, South Carolina in the Carolina Sandhills region of the U.S. Atlantic Coastal Plain province.
Geology
On published geologic maps of the area, Sugarloaf Mountain is mapped as part of the Middendorf Formation, a sequence of sandstone, pebbly sandstone, sand, silt, and clay that are interpreted as fluvial (river) deposits that accumulated during the Cretaceous Period. While much of the mountain is composed of unconsolidated to semi-consolidated beds of quartz-rich sand, silt, and clay, outcrops and boulders of iron-cemented, pebbly sandstone can be found both on the mountain-side and the immediate vicinity. The iron-rich cement holding these sandstones together likely precipitated from groundwater interactions.
Biology
Wildlife is abundant. Flora/fauna include whitetail deer, turkeys, quail, wood ducks, fish, black squirrels and flying squirrels as well as rhododendron, moss, lichen, ferns. Some of these plants are rare for the area. The Red-cockaded woodpecker resides here. You might even see a Pine Barrens tree frog. Hunting is allowed in a few areas as it is treated as a Wildlife Management Area of South Carolina.
There are timber rattlesnakes, black racers, and water moccasins during the spring, summer, and fall.
Camping
There are plenty of primitive camping sites(16 total). You must reserve them in advance. Call (843) 498–6478 to reserve. They are 15 dollars a night for sheltered sites, 10 dollars for non sheltered sites. There is no electricity or water/sewage. However, there are two small outhouses located at Site 1 and Site 6. There is plenty of acreage at each site to set up multiple tents. Keep fires contained in the provided fire pits. Do not create fires outside of the pits as there are only Pine Trees and straw on the ground which can ignite quickly. There is also plenty of room for to throw football or baseball, play frisbee golf, cornhole, or create a game and play i.e. such as botchi-golf.
Hiking
There are a few marked hiking trails. The woods are wide open with little underbrush. The sand makes for very easy primitive hikes around the "mountain." Take sufficient beverages and water because of the length of hikes. Be cautious and alert for wildlife To get to the base of the mountain, stop just past camp site number 6 and it is on the left. There's a parking area to indicate this. Also, directly across from the main "mountain", there is also what is known locally as, "Little Sugarloaf." It's a little harder to find, so look for the small sign to ascend. The view is not quite as good though.
Horses
"Trails of red clay and patches of white sand through an assorted forest of new and old growth dogwoods, pine, and hardwoods. During your ride you may encounter deer, fox squirrels, turkey, and possibly an elusive red cockaded woodpecker. All of the trails have something special.
The Pine Barrens Wagon Trail is in service (though not used often). This trail is unique in that it was devoted to horse drawn wagons and buggies. Occasional creeks along the trails provide water for your horse, but even though there are facilities at the trailheads, due to the length of these trails, you might want to carry water for yourself."
Horses do not have to be shod. During warm months, insect repellent is also recommended as there can be mosquitoes and other pesky bugs.
Fishing
Nearby, there is a large pond, (no swimming), that contains fish such as bream, redbreast, and crappie. An occasional small catfish may be caught. No outboards are allowed, but canoes and kayaks are welcome.
References
Hills of South Carolina |
Abu Zayyan as-Sa'id Muhammad ibn Abd al-Aziz( Arabic: أبو زيان السيد محمد بن عبد العزيز), was Marinid Sultan of Morocco from 1372 to 1374.
Life
Muhammad Abu Zayyan ascended the throne as a minor on the death of his father, Sultan Abu Faris Abd al-Aziz. His father had befriended Lisan al-Din bin al-Khatib, former vizier of Muhammed V of Granada, and during Muhammad bin Abd al-Aziz's rule al-Khatib was safe.
Muhammed V sent two Marinid princes to Morocco whom he had been holding captive in Granada: Ahmad ibn Abd al-Aziz and Abdul Rahman bin Yaflusin, and supported them in taking control of northern Morocco.
Muhammad Abu Zayyan was succeeded in 1374 by Abul Abbas Ahmad and Abd-al-Rahman.
Abul-Abbas Ahmad (Mustanzir) became the Sultan of Fez, while Abdul Rahman became the independent Sultan of Marrakesh.
Al-Khatib was imprisoned and in 1375 was strangled to death while in captivity.
References
Citations
Sources
Royalty from Fez, Morocco
Marinid sultans of Morocco
14th-century Moroccan people
14th-century monarchs in Africa
14th-century Berber people |
```xml
import { inject, injectable, named } from 'inversify';
import * as path from 'path';
import { DebugConfiguration, l10n, Uri, WorkspaceFolder } from 'vscode';
import { IApplicationShell, IDebugService } from '../../common/application/types';
import { EXTENSION_ROOT_DIR } from '../../common/constants';
import * as internalScripts from '../../common/process/internal/scripts';
import { IConfigurationService, IPythonSettings } from '../../common/types';
import { DebuggerTypeName, PythonDebuggerTypeName } from '../../debugger/constants';
import { IDebugConfigurationResolver } from '../../debugger/extension/configuration/types';
import { DebugPurpose, LaunchRequestArguments } from '../../debugger/types';
import { IServiceContainer } from '../../ioc/types';
import { traceError } from '../../logging';
import { TestProvider } from '../types';
import { ITestDebugLauncher, LaunchOptions } from './types';
import { getConfigurationsForWorkspace } from '../../debugger/extension/configuration/launch.json/launchJsonReader';
import { getWorkspaceFolder, getWorkspaceFolders } from '../../common/vscodeApis/workspaceApis';
import { showErrorMessage } from '../../common/vscodeApis/windowApis';
import { createDeferred } from '../../common/utils/async';
import { pythonTestAdapterRewriteEnabled } from '../testController/common/utils';
import { addPathToPythonpath } from './helpers';
@injectable()
export class DebugLauncher implements ITestDebugLauncher {
private readonly configService: IConfigurationService;
constructor(
@inject(IServiceContainer) private serviceContainer: IServiceContainer,
@inject(IDebugConfigurationResolver)
@named('launch')
private readonly launchResolver: IDebugConfigurationResolver<LaunchRequestArguments>,
) {
this.configService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
}
public async launchDebugger(options: LaunchOptions, callback?: () => void): Promise<void> {
const deferred = createDeferred<void>();
if (options.token && options.token.isCancellationRequested) {
return undefined;
deferred.resolve();
callback?.();
}
const workspaceFolder = DebugLauncher.resolveWorkspaceFolder(options.cwd);
const launchArgs = await this.getLaunchArgs(
options,
workspaceFolder,
this.configService.getSettings(workspaceFolder.uri),
);
const debugManager = this.serviceContainer.get<IDebugService>(IDebugService);
debugManager.onDidTerminateDebugSession(() => {
deferred.resolve();
callback?.();
});
debugManager.startDebugging(workspaceFolder, launchArgs);
return deferred.promise;
}
private static resolveWorkspaceFolder(cwd: string): WorkspaceFolder {
const hasWorkspaceFolders = (getWorkspaceFolders()?.length || 0) > 0;
if (!hasWorkspaceFolders) {
throw new Error('Please open a workspace');
}
const cwdUri = cwd ? Uri.file(cwd) : undefined;
let workspaceFolder = getWorkspaceFolder(cwdUri);
if (!workspaceFolder) {
const [first] = getWorkspaceFolders()!;
workspaceFolder = first;
}
return workspaceFolder;
}
private async getLaunchArgs(
options: LaunchOptions,
workspaceFolder: WorkspaceFolder,
configSettings: IPythonSettings,
): Promise<LaunchRequestArguments> {
let debugConfig = await DebugLauncher.readDebugConfig(workspaceFolder);
if (!debugConfig) {
debugConfig = {
name: 'Debug Unit Test',
type: 'debugpy',
request: 'test',
subProcess: true,
};
}
if (!debugConfig.rules) {
debugConfig.rules = [];
}
debugConfig.rules.push({
path: path.join(EXTENSION_ROOT_DIR, 'python_files'),
include: false,
});
DebugLauncher.applyDefaults(debugConfig!, workspaceFolder, configSettings);
return this.convertConfigToArgs(debugConfig!, workspaceFolder, options);
}
public async readAllDebugConfigs(workspace: WorkspaceFolder): Promise<DebugConfiguration[]> {
try {
const configs = await getConfigurationsForWorkspace(workspace);
return configs;
} catch (exc) {
traceError('could not get debug config', exc);
const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
await appShell.showErrorMessage(
l10n.t('Could not load unit test config from launch.json as it is missing a field'),
);
return [];
}
}
private static async readDebugConfig(
workspaceFolder: WorkspaceFolder,
): Promise<LaunchRequestArguments | undefined> {
try {
const configs = await getConfigurationsForWorkspace(workspaceFolder);
for (const cfg of configs) {
if (
cfg.name &&
(cfg.type === DebuggerTypeName || cfg.type === PythonDebuggerTypeName) &&
(cfg.request === 'test' ||
(cfg as LaunchRequestArguments).purpose?.includes(DebugPurpose.DebugTest))
) {
// Return the first one.
return cfg as LaunchRequestArguments;
}
}
return undefined;
} catch (exc) {
traceError('could not get debug config', exc);
await showErrorMessage(l10n.t('Could not load unit test config from launch.json as it is missing a field'));
return undefined;
}
}
private static applyDefaults(
cfg: LaunchRequestArguments,
workspaceFolder: WorkspaceFolder,
configSettings: IPythonSettings,
) {
// cfg.pythonPath is handled by LaunchConfigurationResolver.
// Default value of justMyCode is not provided intentionally, for now we derive its value required for launchArgs using debugStdLib
// Have to provide it if and when we remove complete support for debugStdLib
if (!cfg.console) {
cfg.console = 'internalConsole';
}
if (!cfg.cwd) {
cfg.cwd = configSettings.testing.cwd || workspaceFolder.uri.fsPath;
}
if (!cfg.env) {
cfg.env = {};
}
if (!cfg.envFile) {
cfg.envFile = configSettings.envFile;
}
if (cfg.stopOnEntry === undefined) {
cfg.stopOnEntry = false;
}
cfg.showReturnValue = cfg.showReturnValue !== false;
if (cfg.redirectOutput === undefined) {
cfg.redirectOutput = true;
}
if (cfg.debugStdLib === undefined) {
cfg.debugStdLib = false;
}
if (cfg.subProcess === undefined) {
cfg.subProcess = true;
}
}
private async convertConfigToArgs(
debugConfig: LaunchRequestArguments,
workspaceFolder: WorkspaceFolder,
options: LaunchOptions,
): Promise<LaunchRequestArguments> {
const pythonTestAdapterRewriteExperiment = pythonTestAdapterRewriteEnabled(this.serviceContainer);
const configArgs = debugConfig as LaunchRequestArguments;
const testArgs =
options.testProvider === 'unittest' ? options.args.filter((item) => item !== '--debug') : options.args;
const script = DebugLauncher.getTestLauncherScript(options.testProvider, pythonTestAdapterRewriteExperiment);
const args = script(testArgs);
const [program] = args;
configArgs.program = program;
configArgs.args = args.slice(1);
// We leave configArgs.request as "test" so it will be sent in telemetry.
let launchArgs = await this.launchResolver.resolveDebugConfiguration(
workspaceFolder,
configArgs,
options.token,
);
if (!launchArgs) {
throw Error(`Invalid debug config "${debugConfig.name}"`);
}
launchArgs = await this.launchResolver.resolveDebugConfigurationWithSubstitutedVariables(
workspaceFolder,
launchArgs,
options.token,
);
if (!launchArgs) {
throw Error(`Invalid debug config "${debugConfig.name}"`);
}
launchArgs.request = 'launch';
if (pythonTestAdapterRewriteExperiment) {
if (options.pytestPort && options.runTestIdsPort) {
launchArgs.env = {
...launchArgs.env,
TEST_RUN_PIPE: options.pytestPort,
RUN_TEST_IDS_PIPE: options.runTestIdsPort,
};
} else {
throw Error(
`Missing value for debug setup, both port and uuid need to be defined. port: "${options.pytestPort}" uuid: "${options.pytestUUID}"`,
);
}
}
const pluginPath = path.join(EXTENSION_ROOT_DIR, 'python_files');
// check if PYTHONPATH is already set in the environment variables
if (launchArgs.env) {
const additionalPythonPath = [pluginPath];
if (launchArgs.cwd) {
additionalPythonPath.push(launchArgs.cwd);
} else if (options.cwd) {
additionalPythonPath.push(options.cwd);
}
// add the plugin path or cwd to PYTHONPATH if it is not already there using the following function
// this function will handle if PYTHONPATH is undefined
addPathToPythonpath(additionalPythonPath, launchArgs.env.PYTHONPATH);
}
// Clear out purpose so we can detect if the configuration was used to
// run via F5 style debugging.
launchArgs.purpose = [];
return launchArgs;
}
private static getTestLauncherScript(testProvider: TestProvider, pythonTestAdapterRewriteExperiment?: boolean) {
switch (testProvider) {
case 'unittest': {
if (pythonTestAdapterRewriteExperiment) {
return internalScripts.execution_py_testlauncher; // this is the new way to run unittest execution, debugger
}
return internalScripts.visualstudio_py_testlauncher; // old way unittest execution, debugger
}
case 'pytest': {
if (pythonTestAdapterRewriteExperiment) {
return internalScripts.pytestlauncher; // this is the new way to run pytest execution, debugger
}
return internalScripts.testlauncher; // old way pytest execution, debugger
}
default: {
throw new Error(`Unknown test provider '${testProvider}'`);
}
}
}
}
``` |
The grand chancellor () was one of the most senior offices in the Republic of Venice. Alone among the senior magistracies, which were reserved for the Venetian patriciate, it was held by common citizens ().
History and functions
The origins of the title are unknown. It appeared along with the chancery of the Doge of Venice, and is first mentioned in the sources in 1268. It was the highest office held exclusively by , the non-noble citizens of the Republic of Venice, and as a result it was also the de facto head of this social class, just as the Doge was for the patriciate. The holder of the office enjoyed unusual privileges: the title of Excellency, purple clothing like the Doge's, and a very high place in the order of precedence—right after the Doge, the ducal councillors, and the Procurators of Saint Mark.
The grand chancellor was elected by the Great Council of Venice, and supervised the Doge's chancery and the archives of the Venetian state. Exceptionally for Venetian magistracies, tenure was for life, as for the Doge and the Procurators of Saint Mark. The chancellor had the right to enter all governing councils of the Republic, along with the Doge. He kept the registers of elections to the councils, was responsible for the appointment of notaries, and kept the state treaties with foreign powers in a locked closet (the ), to which only he had access.
His deputies were the and of the chancery. The chancery comprised a hundred clerks, likewise recruited exclusively from the non-noble citizenry; The historian Ioana Iordanou stresses that "[t]hese were different from other public officers in a significant way: recruitment was subject to rigorous public examinations, formal training, and,
more often than not, continuous professional development". After an examination, they attained the rank of extraordinary clerk (), and after five years progressed to become ordinary clerk (). The clerks were often entrusted with sensitive missions on behalf of the state, including as residents in embassies abroad (though not as amabssadors). Higher levels still were as secretary to the Venetian Senate and ultimately as secretary to the Council of Ten, posts which were attained after further years of service or successful missions abroad.
List of grand chancellors
Corrado Ducato from 13 July 1268
Tanto de Tanti from 20 March 1281
Jacopo Bertoldi from 10 September 1314
Nicolò Pistorino from 25 April 1323
from 1 July 1352
from 25 June 1365
Pietro Rossi from 11 September 1390
Desiderato Lucio from 10 January 1394
Giovanni Vito from 23 April 1396
Nicolò Ghirardo from 8 May 1402
Giovanni Piumazzo from 12 July 1405
Francesco Bevazzano from 28 June 1428
Francesco della Siega from 18 November 1439
Alessandro fromle Fornaci from 19 August 1470
Febo Cappella from 20 May 1480
Luigi Dardani from 22 December 1510
from 23 March 1511
Giampietro Stella from 26 January 1516
Nicolò Aurelio from 22 August 1523
Girolamo Dedo from 17 July 1524
Andrea de Franceschi from 17 September 1529
Lorenzo Rocca from 20 January 1551
Francesco Ottobon from 19 April 1559
Andrea Frizier from 25 December 1575
Giovanni Formenti from 8 January 1580
Andrea Suriano from 20 January 1586
Domenico de Vico from 17 May 1595
Francesco Girardi from 15 February 1604
Bonifaccio Antelami from 30 May 1605
Leonardo Ottoboni from 14 November 1610
Giovambattista Padavino from 15 November 1630
Marco Ottoboni from 25 May 1639
Marcantonio Businello from 1 September 1646
Agostino Vianoli from 12 May 1651
Giovambattista Ballarin from 15 November 1660
Domenico Ballarin from 14 November 1666
Pietro Businello from 1 November 1698
Giovambattista Nicolosi from 8 August 1713
Angelo Zon from 28 June 1717
Giovanni Maria Vincenti from 16 February 1726
Giovanni Domenico Imberti from 24 February 1745
Orazio Bertolini from 8 May 1746
Giovanni Colombo from 18 December 1766
Giovan Girolamo Zuccato from 8 March 1772
Giovanni Antonio Gabrieli from 7 June 1784 to 12 May 1797 (Fall of the Republic of Venice)
References
Sources
Further reading
Government of the Republic of Venice
Chancellors (government)
1797 disestablishments in the Republic of Venice
Lists of office-holders |
Deerfield is a town in Oneida County, New York, United States. The population was 4,273 at the 2010 census.
The Town of Deerfield is on the eastern border of the county and northeast of the City of Utica.
History
Deerfield was formed from the Town of Schuyler in 1798.
In Walter D. Edmonds' 1936 novel "Drums Along the Mohawk" and the 1939 film of the same name, the story portrays settlers of the New York frontier in the 1700s. The main protagonists (played in the film by Henry Fonda and Claudette Colbert) leave their luxurious home to build a small frontier farm in Deerfield in the Mohawk Valley.
Geography
According to the United States Census Bureau, the town, which lies immediately north of the city of Utica, has a total area of , of which is land and (0.39%) is water.
The eastern town line is the border of Herkimer County. The New York State Thruway and the Erie Canal pass south of the town. The Mohawk River once formed the southern border of the town but has since been annexed into Utica.
Demographics
As of the census of 2000, there were 3,906 people, 1,449 households, and 1,146 families residing in the town. The population density was . There were 1,512 housing units at an average density of . The racial makeup of the town was 98.75% White, 0.59% African American, 0.05% Native American, 0.28% Asian, 0.03% from other races, and 0.31% from two or more races. Hispanic or Latino of any race were 0.72% of the population.
There were 1,449 households, out of which 35.0% had children under the age of 18 living with them, 68.9% were married couples living together, 7.2% had a female householder with no husband present, and 20.9% were non-families. 17.8% of all households were made up of individuals, and 9.0% had someone living alone who was 65 years of age or older. The average household size was 2.70 and the average family size was 3.06.
In the town, the population was spread out, with 25.5% under the age of 18, 5.5% from 18 to 24, 27.0% from 25 to 44, 26.1% from 45 to 64, and 15.9% who were 65 years of age or older. The median age was 40 years. For every 100 females, there were 99.3 males. For every 100 females age 18 and over, there were 97.7 males.
The median income for a household in the town was $47,197, and the median income for a family was $53,631. Males had a median income of $37,540 versus $24,441 for females. The per capita income for the town was $20,676. About 2.0% of families and 3.8% of the population were below the poverty line, including 0.5% of those under age 18 and 8.1% of those age 65 or over.
Communities and locations in Deerfield
Bell Hill – An elevation located northeast of Utica; partially in Herkimer County.
Deerfield – The hamlet of Deerfield is a northern suburb of the City of Utica. The community is located on Route 5 by the Mohawk River and Erie Canal.
Deerfield Heights – Another suburb of Utica, north of Deerfield.
Dewey Corners – A location south of Dewey Corners on Route 8.
North Gage – A hamlet in the northwestern part of the town.
Smith Hill – An elevation located northeast of Utica.
Walker Corners – A location east of North Gage, located on Route 8.
Notable people
John Atkinson (1835–1897), born in Deerfield, noted Methodist clergyman and author
Pádraig Phiarais Cúndún (1777-1856), Irish-American poet in the Irish language from Ballymacoda, County Cork, who settled with his family on a homestead near Deerfield around 1826.
Hanmer Robbins (1815–1890), Wisconsin State Assemblyman
Michael Zarnock, published author/columnist and two-time Guinness World Record Holder, born April 21, 1958, in Utica; moved to Deerfield in 1998.
References
External links
Town of Deerfield Home Page
Utica–Rome metropolitan area
Towns in Oneida County, New York
Towns in New York (state) |
Piotr Jan Szczypa, now known as Peter Szczypa (born 19 April 1948) is a former pair skater who competed for Poland with Janina Poremska and Teresa Skrzek. He is currently the national ladies' figure skating coach of Germany.
Personal life
Szczypa was born on 19 April 1948 in Siemianowice Śląskie. His sister, Joanna Szczypa, is also a skating coach.
Career
As a pair skater, Szczypa won ten Polish national titles and competed at ten European and five World Championships as well as at the Olympic Winter Games in Grenoble in 1968. Besides his figure skating career he studied international economics and sports. In 1979 he moved to Denmark where he lived for seven years before moving to Germany in 1986.
Peter Szczypa coached Claudia Leistner when she took the gold medal at the 1989 European Championships and silver at the 1989 Worlds. Since the 1990s, he is one of Germany's most successful ladies' figure skating coaches. Based in Mannheim, Szczypa coached four-time German champion Sarah Hecken at the 2010 Olympic Winter Games in Vancouver. He was also the coach of Nathalie Weinzierl who placed 9th at the 2013 European Championships. He has also coached Kristina Isaev and Jonathan Hess.
Competitive highlights
With Poremska
With Skrzek
References
External links
Sports-Reference: Piotr Szczypa
1948 births
Living people
Polish male pair skaters
Olympic figure skaters for Poland
German figure skating coaches
Polish figure skating coaches
People from Siemianowice Śląskie
Sportspeople from Silesian Voivodeship |
```cuda
//
//
// 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.
#include "paddle/phi/kernels/unpool_kernel.h"
#include <algorithm>
#include <vector>
#include "paddle/phi/backends/gpu/gpu_context.h"
#include "paddle/phi/core/kernel_registry.h"
#include "paddle/phi/kernels/funcs/math_function.h"
namespace phi {
template <typename T>
__global__ void KernelUnpool2dMax(const int nthreads,
const T* input_data,
const int* indices_data,
const int input_height,
const int input_width,
const int channels,
T* output_data,
const int output_height,
const int output_width) {
CUDA_KERNEL_LOOP(linearIndex, nthreads) {
int c = (linearIndex / input_width / input_height) % channels;
int n = linearIndex / input_width / input_height / channels;
output_data += (n * channels + c) * output_height * output_width;
int maxind = indices_data[linearIndex];
output_data[maxind] = input_data[linearIndex];
}
}
template <typename T>
__global__ void KernelUnpool3dMax(const int nthreads,
const T* input_data,
const int* indices_data,
const int input_depth,
const int input_height,
const int input_width,
const int channels,
T* output_data,
const int output_depth,
const int output_height,
const int output_width) {
CUDA_KERNEL_LOOP(linearIndex, nthreads) {
int c = (linearIndex / input_depth / input_width / input_height) % channels;
int n = linearIndex / input_depth / input_width / input_height / channels;
output_data +=
(n * channels + c) * output_depth * output_height * output_width;
int maxind = indices_data[linearIndex];
output_data[maxind] = input_data[linearIndex];
}
}
template <typename T, typename Context>
class Unpool2dMaxFunctor {
public:
void operator()(const Context& dev_ctx,
const DenseTensor& input,
const DenseTensor& indices,
DenseTensor* output) {
const int batch_size = input.dims()[0];
const int input_height = input.dims()[2];
const int input_width = input.dims()[3];
const int output_channels = output->dims()[1];
const int output_height = output->dims()[2];
const int output_width = output->dims()[3];
const T* input_data = input.data<T>();
const int* indices_data = indices.data<int>();
T* output_data = dev_ctx.template Alloc<T>(output);
int threads = 1024;
int grid = (input.numel() + threads - 1) / threads;
KernelUnpool2dMax<T>
<<<grid, threads, 0, dev_ctx.stream()>>>(input.numel(),
input_data,
indices_data,
input_height,
input_width,
output_channels,
output_data,
output_height,
output_width);
}
};
template <typename T, typename Context>
class Unpool3dMaxFunctor {
public:
void operator()(const Context& dev_ctx,
const DenseTensor& input,
const DenseTensor& indices,
DenseTensor* output) {
const int batch_size = input.dims()[0];
const int input_depth = input.dims()[2];
const int input_height = input.dims()[3];
const int input_width = input.dims()[4];
const int output_channels = output->dims()[1];
const int output_depth = output->dims()[2];
const int output_height = output->dims()[3];
const int output_width = output->dims()[4];
const T* input_data = input.data<T>();
const int* indices_data = indices.data<int>();
T* output_data = dev_ctx.template Alloc<T>(output);
int threads = 1024;
int grid = (input.numel() + threads - 1) / threads;
KernelUnpool3dMax<T>
<<<grid, threads, 0, dev_ctx.stream()>>>(input.numel(),
input_data,
indices_data,
input_depth,
input_height,
input_width,
output_channels,
output_data,
output_depth,
output_height,
output_width);
}
};
template <typename T, typename Context>
void UnpoolKernel(const Context& dev_ctx,
const DenseTensor& x,
const DenseTensor& indices,
const std::vector<int>& ksize,
const std::vector<int>& strides,
const std::vector<int>& paddings,
const IntArray& output_size,
const std::string& data_format,
DenseTensor* out) {
T* output_data = dev_ctx.template Alloc<T>(out);
if (output_data) {
phi::funcs::SetConstant<Context, T> set_zero;
set_zero(dev_ctx, out, static_cast<T>(0));
}
Unpool2dMaxFunctor<T, Context> unpool2d_max_forward;
unpool2d_max_forward(dev_ctx, x, indices, out);
}
template <typename T, typename Context>
void Unpool3dKernel(const Context& dev_ctx,
const DenseTensor& x,
const DenseTensor& indices,
const std::vector<int>& ksize,
const std::vector<int>& strides,
const std::vector<int>& paddings,
const std::vector<int>& output_size,
const std::string& data_format,
DenseTensor* out) {
T* output_data = dev_ctx.template Alloc<T>(out);
if (output_data) {
phi::funcs::SetConstant<Context, T> set_zero;
set_zero(dev_ctx, out, static_cast<T>(0));
}
Unpool3dMaxFunctor<T, Context> unpool3d_max_forward;
unpool3d_max_forward(dev_ctx, x, indices, out);
}
} // namespace phi
PD_REGISTER_KERNEL(
unpool, GPU, ALL_LAYOUT, phi::UnpoolKernel, int, float, double, int64_t) {}
PD_REGISTER_KERNEL(unpool3d,
GPU,
ALL_LAYOUT,
phi::Unpool3dKernel,
int,
float,
double,
int64_t) {}
``` |
```ruby
# code is released under a tri EPL/GPL/LGPL license. You can use it,
# redistribute it and/or modify it under the terms of the:
#
module BenchmarkInterface
module Backends
module Bm
MIN_SAMPLING_TIME = 0.1 # seconds
def self.run(benchmark_set, names, options)
# If we don't remove these we'll get a warning when we load the real
# implementation.
::Benchmark.send(:remove_const, :CAPTION) if defined?(::Benchmark::CAPTION)
::Benchmark.send(:remove_const, :FORMAT) if defined?(::Benchmark::FORMAT)
benchmark_interface_original_require 'benchmark'
unless options['--no-scale']
min_time = benchmark_set.benchmarks.map(&:basic_iteration_time).min
if min_time < MIN_SAMPLING_TIME
short_iterations = true
samples = (MIN_SAMPLING_TIME / min_time / MIN_SAMPLING_TIME).to_i
puts "These are short benchmarks - we're running each #{samples} times so they take about a second"
end
end
label_width = benchmark_set.benchmarks(names).map(&:name).map(&:size).max
block = Proc.new do |x|
benchmark_set.benchmarks(names).each do |benchmark|
block = benchmark.block
if short_iterations
x.report(benchmark.name) do
BenchmarkInterface.run_n_iterations(samples, &block)
end
else
x.report(benchmark.name, &benchmark.block)
end
end
end
if self == BmBm
::Benchmark.bmbm label_width, &block
else
::Benchmark.bm label_width, &block
end
end
end
module BmBm
def self.run(benchmark_set, names, options)
Bm.run benchmark_set, names, options
end
end
end
end
``` |
Criminal Behaviour and Mental Health is a peer-reviewed scientific journal covering the relationship between criminal behavior and psychiatry. It was established in 1991 and is published five times per year by John Wiley & Sons. The editors-in-chief are Pamela Taylor (Cardiff University), David P. Farrington (Cambridge Institute of Criminology), John Gunn (Institute of Psychiatry, Psychology and Neuroscience), and Mary McMurran (University of Nottingham). According to the Journal Citation Reports, the journal has a 2020 impact factor of 1.929, ranking it 44th out of 69 journals in the category "Criminology & Penology" and 107th out of 144 journals in the category "Psychiatry (Social Science)".
References
External links
Criminology journals
Forensic psychiatry journals
Academic journals established in 1991
Wiley (publisher) academic journals
English-language journals
5 times per year journals |
```go
package wcswidth
import (
"fmt"
)
var _ = fmt.Print
type current_cell struct {
head, tail, width int
}
type forward_iterator struct {
width_iter *WCWidthIterator
current_cell current_cell
cell_num, pos int
}
type reverse_iterator struct {
cells []string
pos int
}
func (self *forward_iterator) reset() {
self.width_iter.Reset()
self.current_cell = current_cell{}
self.pos = 0
self.cell_num = 0
}
type CellIterator struct {
text, current string
forward_iter forward_iterator
reverse_iter reverse_iterator
}
func NewCellIterator(text string) *CellIterator {
ans := &CellIterator{text: text}
ans.forward_iter.width_iter = CreateWCWidthIterator()
return ans
}
func (self *CellIterator) GotoStart() *CellIterator {
self.forward_iter.reset()
self.reverse_iter.pos = -1
self.current = ""
return self
}
func (self *CellIterator) GotoEnd() *CellIterator {
self.current = ""
self.reverse_iter.pos = len(self.reverse_iter.cells)
self.forward_iter.pos = len(self.text)
self.forward_iter.cell_num = len(self.text) + 1
return self
}
func (self *CellIterator) Current() string { return self.current }
func (self *CellIterator) forward_one_rune() bool {
for self.forward_iter.pos < len(self.text) {
rune_count_before := self.forward_iter.width_iter.rune_count
self.forward_iter.width_iter.ParseByte(self.text[self.forward_iter.pos])
self.forward_iter.pos++
if self.forward_iter.width_iter.rune_count != rune_count_before {
return true
}
}
return false
}
func (self *CellIterator) Forward() (has_more bool) {
if self.reverse_iter.cells != nil {
if self.reverse_iter.pos < len(self.reverse_iter.cells) {
self.reverse_iter.pos++
}
if self.reverse_iter.pos >= len(self.reverse_iter.cells) {
self.current = ""
return false
}
self.current = self.reverse_iter.cells[self.reverse_iter.pos]
return true
}
fi := &self.forward_iter
cc := &fi.current_cell
for {
width_before := fi.width_iter.current_width
pos_before := fi.pos
if !self.forward_one_rune() {
break
}
change_in_width := fi.width_iter.current_width - width_before
cc.tail = fi.pos
if cc.width > 0 && change_in_width > 0 {
self.current = self.text[cc.head:pos_before]
cc.width = change_in_width
cc.head = pos_before
fi.cell_num++
return true
}
cc.width += change_in_width
}
if cc.tail > cc.head {
self.current = self.text[cc.head:cc.tail]
cc.head = fi.pos
cc.tail = fi.pos
cc.width = 0
fi.cell_num++
return true
}
self.current = ""
return false
}
func (self *CellIterator) Backward() (has_more bool) {
ri := &self.reverse_iter
if ri.cells == nil {
current_cell_num := self.forward_iter.cell_num
cells := make([]string, 0, len(self.text))
self.GotoStart()
for self.Forward() {
cells = append(cells, self.current)
}
ri.pos = min(max(-1, current_cell_num-1), len(cells))
ri.cells = cells
}
if ri.pos > -1 {
ri.pos--
}
if ri.pos < 0 {
self.current = ""
return false
}
self.current = ri.cells[ri.pos]
return true
}
``` |
Warhammer 40,000: Gladius – Relics of War is a turn-based strategy 4X video game developed by Proxy Studios and published by Slitherine Software for Windows and Linux on July 12, 2018. It is based on Games Workshop's tabletop wargame Warhammer 40,000.
Gameplay
Gladius – Relics of War is a turn-based strategy 4X game played on a hex grid, set on an imperial world of Gladius in the Warhammer 40,000 universe. There are four races to choose from: Imperial Guard, Space Marines, Orks, or Necrons. There is no diplomacy, a departure from a typical 4X game. The multiplayer supports hotseat mode.
Release
Gladius – Relics of War was announced on November 27, 2017. Several downloadable content (DLC) packs have been released for the game.
Reception
Gladius – Relics of War received "mixed or average" reviews according to review aggregator Metacritic.
Leana Hafer of IGN said that "[w]hile it didn’t wow me as a competitor to Endless Legend or Civ 6 in the 4X race, there’s a lot of action-saturated, tactically-driven fun to be had when you look at Gladius - Relics of war for what it truly is: a really well-done, turn-based 40K wargame. It’s one of the best turn-based 40K games I’ve played through that lens."
Tom Senior of PC Gamer summarized that the game is "[a] plodding and predictable 4X strategy game that's relaxing in its own way, but rarely challenging."
Davide Pessach of Eurogamer gave seven out of ten to the Tyranids expansion.
See also
Pandora: First Contact, the previous 4X game by the same developer and publisher
References
External links
2018 video games
4X video games
Linux games
Multiplayer and single-player video games
Multiplayer hotseat games
Multiplayer online games
Slitherine Software games
Turn-based strategy video games
Video games developed in Germany
Video games with expansion packs
Gladius
Windows games
Proxy Studios games |
is a city located in Kōchi Prefecture, Japan. , the city had an estimated population of 16,370 in 8076 households and a population density of 52 persons per km². The total area of the city is .
Geography
Aki is located in southeastern Kōchi Prefecture, facing Tosa Bay of the Pacific Ocean to the south and bordered by mountains to the north. The urban area is on the plains of the Aki River.
Neighbouring municipalities
Kōchi Prefecture
Kōnan
Kami
Yasuda
Umaji
Geisei
Tokushima Prefecture
Naka
Climate
Aki has a humid subtropical climate (Köppen climate classification Cfa) with hot, humid summers and cool winters. There is significant precipitation throughout the year, especially during June and July. The average annual temperature in Aki is . The average annual rainfall is with June as the wettest month. The temperatures are highest on average in August, at around , and lowest in January, at around . The highest temperature ever recorded in Aki was on 21 August 2016; the coldest temperature ever recorded was on 26 February 1981.
Demographics
Per Japanese census data, the population of Aki in 2020 is 16,243 people. Aki has been conducting censuses since 1950.
History
As with all of Kōchi Prefecture, the area of Aki was part of ancient Tosa Province. During the Edo period, the area was part of the holdings of Tosa Domain ruled by the Yamauchi clan from their seat at Kōchi Castle. Following the Meiji restoration, the village of Aki was established within Aki District, Kōchi with the creation of the modern municipalities system on October 1, 1889. Aki was elevated to town status on November 21, 1895. On August 1, 1954 Aki merged with the villages of Ananai (穴内村), Ioki (伊尾木村), Kawakita (川北村), Higashigawa (東川村), Hatayama (畑山村), Inokuchi (井ノ口村),Doi (土居村), and Akano (赤野村) to form the city of Aki.
Government
Aki has a mayor-council form of government with a directly elected mayor and a unicameral city council of 14 members. Aki, together with the village of Geisei, contributes one member to the Kōchi Prefectural Assembly. In terms of national politics, the city is part of Kōchi 1st district of the lower house of the Diet of Japan.
Economy
Traditionally, forestry and charcoal production were mainstays of the local economy, along with commercial fishing and agriculture. In particular, the city is of the leading eggplant and yuzu production areas in Japan.
Education
Aki has nine public elementary schools and two public middle schools operated by the city government and one public middle school and two public high schools operated by the Kōchi Prefectural Department of Education.
Transportation
Railway
Tosa Kuroshio Railway - Asa Line
- - - - - -
Highways
Kōchi-Tōbu Expressway
Local attractions
Historical sites
Iwasaki Yatarō Residence: (founder of Mitsubishi) His childhood home is located in Aki, north of the Aki City Train station off of Route 29 in Inokuchi, Aki.
Aki Castle, A castle ruin.
Noradokei Clock (野良時計): Located in Doi, Aki along Route 213.
Samurai Residence (武家屋敷): Located in Doi, Aki.
Sugio Shrine (杉尾神社)
Ryutaro Hirota's music monuments: There are 10 music monuments, each engraved with a different song of Ryutaro's. They are located all around the city.
Kariyon Clock (カリヨン時計): Large clock monument to Ryutaro Hirota. At certain hours, the clock plays music and has mechanical dolls that come out and dance.
Sites of interest
Uchiharano Pottery Center: This pottery center sells locally made pottery and blown glass art. With an appointment, you can make your own pottery in the studio.
Aki Station Jiba-San Market (安芸市ぢばさん市場): Located within the station's main building, local produce, plants, bakery goods, Aki City omiyage, and home-made bento are brought/made fresh every day and sold cheaply.
Aki Dome: This is where the Hanshin Tigers practice in the spring (beginning in February) and play their first game of the season. It draws Hanshin Tigers fans every year from all over Japan. The Dome is located in Sakuragaoka-machi and is visible along Kokudo Route 55. One can also access the Dome by going to Kyūjōmae Station (球場前駅).
Aki City Calligraphy Museum (安芸市書道美術館): Located in Doi-chō, Aki City along Route 29 next to the History Museum. The museum is a two floor establishment that displays and hosts many different calligraphy exhibitions and contests.
Aki City History Museum (安芸市歴史民俗資料館): Located in Doi-chō, Aki City along Route 29 next to the Calligraphy Museum. The museum contains information on the evolution of Aki City through history, as well as an extensive history of Iwasaki Yatarou.
Aki Fishing Port (安芸漁港)
Kikusui Sake Brewing Company (菊水酒造株式会社): Located in Hon-machi, Aki City, is a local sake brewery well known around Shikoku and the second largest producer of sake in Kochi Prefecture. The company constantly comes up with new and innovative products and is sold widely around the prefecture. Along with their constantly updating product list, they are well known for their "Shimantogawa" (四万十川) sake.
Arimitsu Brewing Company: A very small sake brewery located in Akano-chō, Aki City (along the border of Geisei Village) that produces sake using traditional methods. Production is minimal and sales are limited to Aki City and select retail stores around Kochi City. The most well-known sake they produce is called "Aki Tora" (安芸虎), which is not named after the Hanshin Tigers but instead, after Kunitora Aki who resided in the Aki Castle.
Nasu Park and Uchiharano Park: Located in Uchiharano-Chō, Aki City. Nasu park is known for the playground equipment shaped like vegetables (among which is eggplant). Uchiharano park is a large public park with a man-made lake. In the spring and summer, it is a good place to go for flower viewing while picnicking. Boats may be rented for a row around the lake.
Doyo Washroom: The Doyo Washroom is located next to the Aki City Office and is a bathroom known for playing the famous nursery rhymes that were created in Aki City.
Culture
Aki City is an agricultural city where many farmers reside and thus, is well known for its locally grown eggplant (なす), dekopon, yuzu, and tobacco. It is also well known for a dish called chirimendon (ちりめん丼), a bowl of rice covered in tiny sardines, green onions, and tsuyu sauce.
Every August, Aki City holds a Yosakoi (よさこい) festival and parade in the city. Since Yosakoi dance originated in Kōchi Prefecture, many cities around the prefecture hold smaller-scale festivals in relation to the main three-day Yosakoi festival in Kōchi, which draws groups of performers from all over Japan. Aki City's festival is one of the larger festivals held on the east side of Kochi Prefecture, and takes place over two weekends in August. Various groups from around the city, nearby cities, as well as groups from Tokushima Prefecture and Ehime Prefecture come and perform in the Aki City Yosakoi festival in preparation for the three-day festival in Kōchi.
Another well-known festival held in Aki City is the Aki City Candle-Light Festival and Illumination Event. This event takes place over two days and is held around the mid-end of December. The festivities take place in front of the Aki City train station where local music groups, junior high school bands, and high school bands perform while various local restaurants set-up stalls to sell food, drinks, and other local products. The event takes place around the birthday of Iwasaki Yatarō and is thus included in the festivities. There is also a very large display of handmade candles set up around the station, and nearby residence often participate by setting up Christmas "illuminations" and elaborate light displays.
Since Kōchi Prefecture is well known for shodo (書道) or calligraphy, the Aki City Calligraphy Museum holds a nationwide calligraphy contest every May, and another contest for high school students every July/August. Calligraphy from all over Japan is sent in to be judged by highly regarded calligraphy teachers from the prefecture, and later displayed in a public exhibition. Along with this contest, Aki City also holds a general arts (photography, painting, drawing, sculpture, wood-work) contest every September/October in the Aki City Shuminkaikan.
Other than these larger events, Aki City is also the host to various small festivals, local music performances, art exhibitions, and events. In addition, every November, Aki City is host to the "Turtle Marathon," a marathon held for people ages 30 and over from all over Japan.
References
External links
Aki City official website
Aki City Map
Cities in Kōchi Prefecture
Populated coastal places in Japan
Aki, Kōchi |
Pyrausta dissimulans is a moth in the family Crambidae. It was described by Harrison Gray Dyar Jr. in 1914. It is found in Mexico.
References
Moths described in 1914
dissimulans
Moths of Central America |
Eamonn Butler (born 1953) is a British economist. He is the co-founder and director of the Adam Smith Institute.
Early life
Eamonn Butler was born in 1953. His brother is Stuart Butler. He graduated from the University of St Andrews. and also studied at the University of Aberdeen.
Career
Butler worked on pensions and welfare issues for the United States House of Representatives in Washington DC, before returning to the UK where he served as editor of the British Insurance Broker Monthly.
He co-founded the Adam Smith Institute in London with his brother Stuart and Madsen Pirie, both graduates from the University of St Andrews. He now serves as its Director.
He is author of books on the work of three economists: Hayek: His Contribution to the Economic and Political Thought of Our Time; Milton Friedman: A Guide to his Economic Thought; Ludwig von Mises: A Primer; Ludwig von Mises: Fountainhead of the Modern Microeconomics Revolution. Additionally, he has contributed extensively to national magazines and newspapers such as The Times on subjects ranging from health policy, economic management, taxation and public spending, transport, pensions, and e-government.
He served as the Secretary on the 2012–14 Board of Directors of the Mont Pelerin Society.
He received an Honorary Doctorate from Heriot-Watt University in 2012.
Bibliography
Ayn Rand: An Introduction, 2018
The Condensed Wealth of Nations, Eamonn Butler, 2011
Milton Friedman: A Concise Guide to the Ideas and Influence of the Free-Market Economist, Eamonn Butler, 2011
Austrian Economics: A Primer, Eamonn Butler, 2010
Ludwig Von Mises: A Primer, Eamonn Butler, 2010
The Alternative Manifesto, Eamonn Butler, 2010
Hayek: His Contribution to the Political and Economic Thought of Our Time, Eamonn Butler & Jeff Riggenbach, 2010 (Audiobook)
Ludwig Von Mises: Fountainhead of the Modern Microeconomics Revolution, Eamonn Butler & Jeff Riggenbach, 2010 (Audiobook)
The Rotten State of Britain, Eamonn Butler, 2009
The Best Book on the Market, Eamonn Butler, 2008
Adam Smith - A Primer, Eamonn Butler, 2007
The Future of the NHS, Eamonn Butler, 2006
Simply No Mistake: How the Stakeholder Pension Must Work, Eamonn Butler, 1998
The Great Escape: Financing the Transition to Funded Welfare, Eamonn Butler, 1997
Fortune Account, Eamonn Butler & Madsen Pirie, 1995
The End of the Welfare State, Eamonn Butler & Madsen Pirie, 1994
Taming the Trade Unions, Eamonn Butler, 1991
Ludwig Von Mises: Fountainhead of the Modern Microeconomic Revolution, Eamonn Butler, 1988
The Health Alternatives, Eamonn Butler & Madsen Pirie, 1988
Good Health: Role of Health Maintenance Organizations, Eamonn Butler, 1986
Milton Friedman: A Guide to His Economic Thought, Eamonn Butler, 1985
Hayek, Eamonn Butler, 1985
Aid by Enterprise, Eamonn Butler & Madsen Pirie, 1984
Free Ports, Eamonn Butler & Madsen Pirie, 1983
Private Road Ahead, Eamonn Butler & Gabriel Roth, 1982
Economy and Local Government, Eamonn Butler & Madsen Pirie, 1981
Forty Centuries of Wage and Price Controls, Eamonn Butler & Robert Schuettinger, 1979
References
External links
Eamonn Butler website
1953 births
Living people
People from London
Alumni of the University of St Andrews
British economists |
Haslingden railway station served the town of Haslingden, Rossendale, Lancashire. The station was built by the East Lancashire Railway (ELR) on their Bury to line and opened on 17 August 1848.
In 1959, the ELR was incorporated into the Lancashire and Yorkshire Railway, who operated it until 1923 when it became part of the London Midland and Scottish Railway. Owned by the London Midland Region of British Railways from 1948, it was closed on 7 November 1960. The route through the station closed on 5 December 1966 and the tracks were subsequently lifted.
References
Lost Railways of Lancashire by Gordon Suggitt ()
The Directory of Railway Stations, R.V.J. Butt, 1995, Patrick Stephens, Yeovil, ()
Disused railway stations in the Borough of Rossendale
Former Lancashire and Yorkshire Railway stations
Railway stations in Great Britain opened in 1848
Railway stations in Great Britain closed in 1960 |
```smalltalk
namespace Xamarin.Forms
{
internal sealed class TelephoneKeyboard : Keyboard
{
}
}
``` |
Sarin Darreh () may refer to:
Sarin Darreh, Khodabandeh
Sarin Darreh, Mahneshan |
District 83 is a district in the Texas House of Representatives. Following 2021 redistricting, the district represents the entirety of the following counties: Borden, Crosby, Dickens, Floyd, Garza, Kent, Lynn, Mitchell, Scurry, and Terry. In addition, the district represents a portion of Lubbock County. Since 2014, it has been represented by Republican Dustin Burrows.
Representatives
References
083
Borden County, Texas
Crosby County, Texas
Dickens County, Texas
Floyd County, Texas
Garza County, Texas
Kent County, Texas
Lynn County, Texas
Mitchell County, Texas
Scurry County, Texas
Terry County, Texas |
Warhawk was a multiplayer third-person shooter video game developed by Incognito Entertainment for the PlayStation 3. It was a remake of an aerial warfare game of the same name, which was an early title on the original PlayStation. Santa Monica Studio assisted on development. It was the first PlayStation 3 game to be available both for download on the PlayStation Network and for retail on Blu-ray Disc. For the United States, Blu-ray Disc and PlayStation Network versions were released on August 28, 2007. The PlayStation Network version was released in Europe, Australia and Japan on August 30, August 31 and October 4 respectively. The Blu-ray Disc version was released in Australia and Europe on September 20 and September 21, respectively, but was not released in Japan.
Warhawk was initially intended to have both single-player and multiplayer modes, however the single-player element was canceled during development due to concerns that it was inferior to the game's multiplayer component. The game was released with five maps (each with five possible configurations) and four game types, Deathmatch, Team Deathmatch, Zones and Capture the Flag. After the 1.4 update, the number of game types increased to six with the addition of the Hero and Collection modes. Three optional expansion packs for the game containing new maps and equipment increase the number of available maps to eight.
Warhawk was met with a generally positive reception by reviewers. However, for a few months after its initial launch it was plagued by connection and server issues, including ranking issues with players, which were subsequently corrected in updates. The player is able to rank-up though 20 ranks ranging from Recruit to General, unlocking new personnel and aircraft customization options at each rank. A spiritual successor, Starhawk, was released in May 2012.
Sony shut down Warhawk's online servers on January 31, 2019, at 8 am GMT, providing notice by email to PlayStation Network members. Since the shutdown, numerous players in the game's community have utilised third party tools and services such as XLink Kai and PlayStation Online Network Emulated to continue playing.
Gameplay
Warhawk is a third-person shooter set in a science fictional, perpetual war between the Eucadian Republic and Chernovan Empire (blue and red team, respectively).
There are two ground vehicles, a jeep and a tank, and an armored personnel carrier is added by the Operation: Broken Mirror expansion. There are two air vehicles, the Warhawk and Nemesis (which are only cosmetically different), both of which can use nine weapons, an example is the AS-3 Tow Missile system. That weapon is the only weapon in the game where the player guides the weapon, the players screen is devoted to guiding the missile and leaving the player open to getting hit. But the upside is that it does massive damage and is the largest explosion in the game. The Omega Dawn expansion adds a dropship, and the Fallen Star expansion adds a jetpack. There are three turrets available to the player (anti-air missile turret, anti-air flak turret, and the .50 caliber anti-infantry machine gun). The game uses the PlayStation 3 Sixaxis and DualShock 3 controllers. The game can be set to make use of these controllers' motion sensing function to allow the players to control aircraft and ground vehicles by tilting the controller in different directions rather than the more conventional methods of using the D-pad or analog sticks. However, a traditional control scheme is the default option. Warhawk offers online and offline multiplayer play. Offline allows for 1-4 players splitscreen (without bots). Online features up to 32-player battles, with the ability to have up to 4 players use one PlayStation 3 in split screen mode (on non-ranked servers that permit it). Players 2-4 can enter or exit the game while a match is in progress.
The game uses medals and rewards, which are awarded for certain tasks. As of v1.50, the game supports trophies, which will be used in the online service PlayStation Home. Players are also able to customize their characters with armor squad markings, Warhawk paint schemes, and other accessories. More customization options are unlocked as the player increases in rank. Warhawk also allows the creation of clans, which may participate in online events and competitions. The game also makes use of arbiters, paid anonymous players who are tasked to find cheaters within the game. They are able to punish offending players in several ways, such as an email warning, a forum post, a kick, or a temporary/permanent ban. Arbiters can also request that the player's stats be erased.
PlayStation Home
Warhawk is one of many games that supports game launching in PlayStation Home. This feature allows players to host a game in Home and then launch it once other players have joined. The player may even invite friends to the game launch. Once the game has been launched from Home the players may return to Home at any time via the "Return to PlayStation Home" option that appears instead of the "Quit Game" option. On February 26, 2009, Incognito Entertainment and Santa Monica Studio launched the Warhawk space for PlayStation Home. Beyond its unique aesthetics, the space is functionally similar to those for Uncharted: Drake's Fortune and Far Cry 2, with one notable exception: the "Warhawk Sand Table". It's a place to plan in-game strategies using "VR" set-pieces—vehicles, maneuver icons, etc. - which can be moved around on 2D versions of any of the game's maps (and their variants).
The first person to access the table is in control. Here's where one of the problems arises: anyone can walk up and watch as a user plans their "secret" strategy. Furthermore, there's no way to share or use the finished battle plan within the game. It's all up to each player's memory (or notepad).
There is also a "Learning Terminal" (eight in all) that tells the users about General Hints, Weapons, and Flying.
Outso developed the Warhawk game space for Incognito Entertainment and Santa Monica Studio as well as the "Warhawk Sand Table" in the space.
On February 11, 2010, a Warhawk personal space was released in Home. It includes the Sand Table featured in the Game Space as well as a multiplayer turret mini-game.
As of July 2010, the Warhawk game space has been removed from PlayStation Home, due to lack of players actually using the space.
Game modes
Warhawk supports six separate game modes compatible with all variations of all of the maps.
Deathmatch. Every man for himself. The game ends when a player reaches the score limit, or when time expires.
Team Deathmatch. Same rules as a deathmatch except the player is automatically assigned to either the Chernovan (red) or Eucadian (blue) teams. Game ends when the combined score limit is met or when time expires.
Dogfight. A variation on Deathmatch/Team Deathmatch where you play only in the Warhawk/Nemesis planes.
Hero. A version of the team deathmatch where a hero is randomly selected on both sides for one minute, or until the hero dies. The hero gets a health boost, damage boost, and every weapon in the game (which the hero can keep if he survives the one minute). The key difference between Hero and TDM is that in TDM all enemy kills are counted to the team total whereas in Hero, only when killing the Hero or when the Hero kills an enemy are they counted towards the total.
Capture the Flag. This mode of game play is by far the most popular among Warhawk players. In this mode each team has a flag at their base which they must defend while attempting to capture the second flag in their opponent's base. You can only capture the flag if your flag remains at the base.
Collection. This mode features four "cores" scattered along the map. The object is to collect as many cores as possible. Once a core has been collected, a new one will respawn in the same spot as where the player got it. If a player dies, all cores are lost, and an enemy, or nearby teammate can collect them.
Zones. The object of this mode is to capture various control points on the map. Each control point has three levels for each team, and a neutral level. A player can do this in other game modes (except deathmatch) to earn points for yourself, but in Zones, their team gains points for the number of zones the player has, and how many levels each one has. The player will only be able to capture levels if the area around it is clear, or captured by their team. The game ends when the time runs out, score limit is reached, or if the player is able to capture all control points.
Development
Warhawk was first announced to the public in May 2005, with a working build shown at E3 in 2006. This version was the first PlayStation 3 title to be shown with the newly announced Sixaxis motion sensing technology. In February 2007, it was announced that the single player element of the game was to be pulled. This was due to concerns Incognito had over the quality of the single-player campaign, particularly when compared to the multi-player modes. Dylan Jobe, the game's director, stated, "If we were to continue down our single-player/multiplayer approach, it would have resulted in not as good single player or not as good multiplayer". The extra development of the multiplayer mode was used to improve existing elements such as in-game communication, and to implement new features such as On Demand Split Screen, whereby players can easily enter split screen mid-game. Split screen can only be used in battles that allow it. Only unranked servers have the ability to have it and even then, it is an option whether or not the host wants it on or off. It was also revealed at the same time that Warhawk would be made available for download over the PlayStation Network.
In August 2007, Sony Computer Entertainment America released news that PlayStation 3 consoles would be used as the dedicated servers for Warhawk. A photograph was released which showed a server room with several PlayStation 3 consoles in racks. Each server is able to support 32 players. The games developers have commented that the engine used in the game features technology which could not be easily implemented on any other platform, such as procedurally generated water and waves, as well as volumetric clouds.
Following the games release, many issues with networking and player statistics were reported, such as delays in receiving points and awards, failure to receive the points or awards, and "connection failed" and "connection lost" errors. To address these issues, Incognito released several server-side patches before releasing the game's first update, Version 1.1. This update addressed the majority of issues users experienced with the game, with others being addressed in the Version 1.2 update. A demo was released on the PlayStation Store on October 9, 2008.
Release
There was initial confusion as to how this game would be distributed to consumers, after the announcement that it would be a multiplayer-only title. Sony announced on May 16, 2007, that there would be two iterations of the game. The game alone is downloadable from the PlayStation Store for US$29.99 (£19.99, €29.99), with an initial download size of 798MB. This version is restricted to the PlayStation Network account that buys it. The second is a retail Blu-ray Disc version that sells for $59.99 (the standard retail price of most PlayStation 3 games upon release), bundled with a Jabra BT125 Bluetooth headset in America and the Jabra BT135 in Europe, allowing players to chat with other players online while playing the game. An additional third was later released on October 10, 2007 without the inclusion of a USB headset, which was priced at US$39.99. Both retail versions feature extra content such as behind-the-scenes developer interviews, concept art and trailers. Warhawk was re-released as a Greatest Hits title on July 28, 2008 for $29.99.
Updates and expansions
Additional downloadable content (DLC) has been released, with more announced, since the game's launch. Expansions include new maps, weapon upgrades and character customization options. The DualShock 3 controller became compatible with the game upon the release of the version 1.20 patch. Incognito has stated that any future development on the incomplete single player campaign would only be released as a separate product, and not as an expansion to the current game. Warhawk updates are free, but expansion packs are sold online for a price. Updates are mandatory installations that must be completed in order to play the game. Expansion packs are optional, and the ability to purchase expansion packs is available within the menu of the game itself, as well as through the PlayStation Store.
The 1.1 and 1.2 updates were released on October 19, 2007 and December 19, 2007 respectively, fixing numerous exploits and stability issues. Update 1.3 was released on April 2, 2008 and included two new weapons, eighteen new player-made customizations for planes and forty-four new player-made custom insignias for both troops and planes, integration of PlayStation Home, and new in-game chat features, such as cross-team chat. Also in update 1.3, the "stat padding" issue, a bug that allowed game players to cheat by increasing their points cumulatively by dropping the opponents' flag off the level and having it respawn back into the players' hands to repeat, was resolved by completely removing the ability to drop the flag. Update 1.4, released on July 16, 2008, features two new game modes called "Hero" and "Collection," and introduced the Quick Join feature, which searches for a server that connects the user to matches that work with the user's current level. The next update, Version 1.5, was released on August 27, 2008 and includes trophy support, the winning entries from the European version of the paint and insignia contest, and allows the user to play music via the XrossMediaBar in-game.
Three expansion packs have been released. The first, "Operation: Omega Dawn," released on December 20, 2007, includes a new night-themed map, Omega Factory, and a new aircraft, the KT-424 Combat Dropship. The second expansion pack was released on April 17, 2008 entitled "Operation: Broken Mirror", which includes a new armoured personnel carrier equipped with an energy shield and the ability to boost, similar to a Warhawk, as well as serving as a mobile spawn point. A new map called Vaporfield Glacier was also included in the new expansion. It is the largest map to date, and includes 10 different layouts. In the PlayStation Store, there is also an option to purchase the first two Booster-packs for a reduced price, and there will be another combo pack with all three included. The latest booster pack, "Operation Fallen Star," was released on August 28, 2008 and added the Icarus MK1 Jetpack which allows troops to fire while airborne as well as a new map called Tau Crater. All three of the booster packs cannot be combined, nor can one affiliate with another, and people who do not own an expansion featured in a server they are attempting to join will not be able to join the server.
On August 27, 2008 the 1.5 patch was released and included the addition of trophy support. A total of 57 trophies are available in the game, 10 of which are retroactive and can be obtained based on previously recorded statistics without the user having to complete tasks a second time. A further 34 are based upon gameplay and so are not retroactive. The trophies can be attained Split-screen or Unranked as well. Each of the available expansions also feature an additional 4 trophies.
On May 13, 2011, game developer Dylan Jobe unveiled the successor to the game entitled Starhawk on GTTV. Starhawk was released on May 8, 2012.
Music
The music is composed by both Christopher Lennertz and Timothy Michael Wynn. Their scores for this video game were recognized as one of the best video game scores of 2007 by IGN.
Reception
Warhawk generally received positive reviews, with its aggregate review scores being classed as generally favorable by Metacritic and GameRankings. PSM provided the lowest review score officially qualified by the GameRankings website. The magazine described it as "a third-person shooter that never quite gets off the ground." Other reviews were more positive in their outlook. PSM3 described the game as "a masterpiece of balance, of design, and the jewel in Sony's online crown." UK magazine Edge described it as an "instantly gratifying experience", also saying that the lack of a single-player campaign was made up for by "its brilliantly implemented notion of flight and considered balance". Nick Costanza and Vin Acosta were largely critical of the game, saying "it can't be taken seriously".
1UP.com gave Warhawk a positive review, but said, "It's just not quite $40 worth," referring to the price of the downloadable version on the U.S. PlayStation Store. It was given the IGN Editors' Choice Award, calling it "a AAA experience that is an adrenaline rush for online fans." Game Informer described Warhawk as "better than they'd hoped for". GamePro stated that although Warhawk offers an intense online combat experience, being dropped immediately into the action leaves you "somewhat bewildered" and doesn't give you that "feeling of connection" to the game. GameTrailers described Warhawk as "simply fun, easy to compete, but challenging to shine." Adam Sessler from X-Play complimented the game's multiplayer only style saying "...I wouldn't have it any other way." Gaming Target selected Warhawk as one of their "52 Games We'll Still Be Playing From 2007" and awarded it "PlayStation 3-Exclusive Game of the Year".
Notes
References
External links
2007 video games
PlayStation 3 games
PlayStation Network games
PlayStation 3-only games
Science fiction video games
Sony Interactive Entertainment games
Third-person shooters
Video game remakes
Warhawk (franchise)
Multiplayer video games
Video games developed in the United States
Video games scored by Christopher Lennertz
Products and services discontinued in 2019
Inactive multiplayer online games
Incognito Entertainment games |
Among the Ghosts is the tenth studio album by American country-punk band Lucero. It was released August 3, 2018 under Thirty Tigers.
Production
The album was recorded live at Phillips Recording with producer Matt Ross-Spang. American actor Michael Shannon features on "Back to the Night". The track "Loving" features on the 2016 film, Loving
Critical reception
Among the Ghosts was met with "generally favorable" reviews from critics. At Metacritic, which assigns a weighted average rating out of 100 to reviews from mainstream publications, this release received an average score of 77, based on 7 reviews. Aggregator Album of the Year gave the release a 74 out of 100 based on a critical consensus of 4 reviews.
Mark Deming of AllMusic said the album "demonstrates how smart and versatile these guys can be; it's a brave and satisfying set that finds beauty and meaning in the valleys on the human experience." Eric Danton from Paste said of the album: "The songs are full of minor-key acoustic guitars, moody electric flourishes and downhearted piano parts, augmented here and there with overdriven, but restrained, riffs."
Accolades
Track listing
Personnel
Musicians
Ben Nichols – vocals, guitar
Rick Steff – piano
John C. Stubblefield – bass
Brian Venable – guitar
Roy Berry – drums
Eugenio Figueroa – viola
Heather Trussell – violin
Gaylon Patterson – violin
Dara Hankins – cello
Jim Spake – saxophone
Michael Shannon – vocals
Production
Matt Ross-Spang – engineer, mixing, producer
Wesley Graham – engineer
Jeff Powell – mastering
Alex McCollough – mastering
Matthew Cole – design
Charts
References
2018 albums
Lucero (band) albums
Thirty Tigers albums |
Wasdale is a civil parish in the Borough of Copeland, Cumbria, England. It contains eight listed buildings that are recorded in the National Heritage List for England. Of these, one is listed at Grade II*, the middle of the three grades, and the others are at Grade II, the lowest grade. The parish is in the Lake District National Park. It contains the village of Nether Wasdale and the community of Wasdale Head, together with the countryside, moorland and mountains surrounding Wastwater. The listed buildings comprise two churches, two farmhouses and associated buildings, two bridges, a boundary stone, and a maypole.
Key
Buildings
References
Citations
Sources
Lists of listed buildings in Cumbria |
```javascript
`hasOwnProperty` method
Treating a boolean as number
Most efficient way to build `HTML` strings
Meaning of polyfill
Apply `map` function to array items
``` |
```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.
*/
// Package fuzz is a library for populating go objects with random values.
package fuzz
``` |
Buffalo Bull's Back Fat, or Stu-mick-o-súcks (in the Blackfoot language), was a head war chief of the Blood Indians. He is remembered today for his portrait, painted by George Catlin in 1832, located at the Smithsonian American Art Museum.
In one of his letters, Catlin wrote:
The painting appeared in the exhibit Pictures from the New World at Schloss Charlottenburg, which was held in the Orangerie of Charlottenburg Palace, Berlin, Germany, in 1989.
References
Kainai Nation people
Masterpiece Museum
Native American leaders
19th-century Native Americans |
Carol R. Hughes (born November 26, 1958 in Val Caron, Ontario) is a Canadian politician, who has represented the electoral district of Algoma—Manitoulin—Kapuskasing in the House of Commons of Canada since 2008. She is a member of the New Democratic Party.
Prior to being elected, she worked as a staff representative for the Canadian Labour Congress. She ran as the NDP's candidate in the 2004 election and the 2006 election, losing to Liberal incumbent Brent St. Denis both times.
She had told the press that she would not run in the 2008 election, but changed her mind after she stopped in Blind River for dinner on her way home from a Canadian Labour Congress meeting, and a couple she had never met approached her and encouraged her to run again. She won the riding in that election, and was re-elected in the 2011 election.
Hughes endorsed Niki Ashton in the 2012 NDP leadership election, and Charlie Angus in the 2017 leadership election.
Hughes has been appointed Assistant Deputy Speaker and Deputy Chair of Committees of the Whole for a second time; she previously held this role in the 42nd Parliament.
Electoral record
References
External links
1958 births
Members of the House of Commons of Canada from Ontario
New Democratic Party MPs
Women members of the House of Commons of Canada
Franco-Ontarian people
People from Elliot Lake
Politicians from Greater Sudbury
Trade unionists from Ontario
Living people
Women in Ontario politics
21st-century Canadian politicians
21st-century Canadian women politicians
Canadian women trade unionists |
```python
"""
Test scalar buffer interface adheres to PEP 3118
"""
import sys
import numpy as np
import pytest
from numpy.testing import assert_, assert_equal, assert_raises
# PEP3118 format strings for native (standard alignment and byteorder) types
scalars_and_codes = [
(np.bool_, '?'),
(np.byte, 'b'),
(np.short, 'h'),
(np.intc, 'i'),
(np.int_, 'l'),
(np.longlong, 'q'),
(np.ubyte, 'B'),
(np.ushort, 'H'),
(np.uintc, 'I'),
(np.uint, 'L'),
(np.ulonglong, 'Q'),
(np.half, 'e'),
(np.single, 'f'),
(np.double, 'd'),
(np.longdouble, 'g'),
(np.csingle, 'Zf'),
(np.cdouble, 'Zd'),
(np.clongdouble, 'Zg'),
]
scalars_only, codes_only = zip(*scalars_and_codes)
@pytest.mark.skipif(sys.version_info.major < 3,
reason="Python 2 scalars lack a buffer interface")
class TestScalarPEP3118(object):
@pytest.mark.parametrize('scalar', scalars_only, ids=codes_only)
def test_scalar_match_array(self, scalar):
x = scalar()
a = np.array([], dtype=np.dtype(scalar))
mv_x = memoryview(x)
mv_a = memoryview(a)
assert_equal(mv_x.format, mv_a.format)
@pytest.mark.parametrize('scalar', scalars_only, ids=codes_only)
def test_scalar_dim(self, scalar):
x = scalar()
mv_x = memoryview(x)
assert_equal(mv_x.itemsize, np.dtype(scalar).itemsize)
assert_equal(mv_x.ndim, 0)
assert_equal(mv_x.shape, ())
assert_equal(mv_x.strides, ())
assert_equal(mv_x.suboffsets, ())
@pytest.mark.parametrize('scalar, code', scalars_and_codes, ids=codes_only)
def test_scalar_known_code(self, scalar, code):
x = scalar()
mv_x = memoryview(x)
assert_equal(mv_x.format, code)
def test_void_scalar_structured_data(self):
dt = np.dtype([('name', np.unicode_, 16), ('grades', np.float64, (2,))])
x = np.array(('ndarray_scalar', (1.2, 3.0)), dtype=dt)[()]
assert_(isinstance(x, np.void))
mv_x = memoryview(x)
expected_size = 16 * np.dtype((np.unicode_, 1)).itemsize
expected_size += 2 * np.dtype((np.float64, 1)).itemsize
assert_equal(mv_x.itemsize, expected_size)
assert_equal(mv_x.ndim, 0)
assert_equal(mv_x.shape, ())
assert_equal(mv_x.strides, ())
assert_equal(mv_x.suboffsets, ())
# check scalar format string against ndarray format string
a = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
assert_(isinstance(a, np.ndarray))
mv_a = memoryview(a)
assert_equal(mv_x.itemsize, mv_a.itemsize)
assert_equal(mv_x.format, mv_a.format)
def test_datetime_memoryview(self):
# gh-11656
# Values verified with v1.13.3, shape is not () as in test_scalar_dim
def as_dict(m):
return dict(strides=m.strides, shape=m.shape, itemsize=m.itemsize,
ndim=m.ndim, format=m.format)
dt1 = np.datetime64('2016-01-01')
dt2 = np.datetime64('2017-01-01')
expected = {'strides': (1,), 'itemsize': 1, 'ndim': 1,
'shape': (8,), 'format': 'B'}
v = memoryview(dt1)
res = as_dict(v)
assert_equal(res, expected)
v = memoryview(dt2 - dt1)
res = as_dict(v)
assert_equal(res, expected)
dt = np.dtype([('a', 'uint16'), ('b', 'M8[s]')])
a = np.empty(1, dt)
# Fails to create a PEP 3118 valid buffer
assert_raises((ValueError, BufferError), memoryview, a[0])
``` |
Wolf Frameworks is a web application designing and development platform as a service based in India and United States and represented via partners worldwide.
Founded in 2006, the cloud computing Infrastructure offered by the company enables users to design & deliver cross platform SaaS applications without writing technical code.
Product
WOLF is 100% AJAX, XML and .NET based and enables building of mashable and interoperable web applications by using a browser, an internet connection and the knowledge of modelling business.
Features
A technical code free designing environment for creating & delivering SaaS type business applications on the Internet
Built using a late bound SOA architecture which uses XML framework
Prevents cloud lock-in by allowing users to save their application data in their own preferred database server
Provides the ability to view & extract the Business Design (Intellectual Property) of your software application in XML.
Import, Export or filter data from Word, Excel, Project Management or CSV files
Accessed over a 128-bit secured SSL connection and hosted in a highly secured data center
Benefits
Multi-tenant SOA
Requires no coding & less technical skills
Built-in actions to integrate with external software systems
Standards oriented web service technology
Save data in a private database server & extract Application Design in XML
Requires no up-front capital expenses and minimizes operational cost
References
Web applications
Privately held companies of India
Cloud computing providers
Cloud platforms |
The Ministry of Oil () is the Iraqi government agency responsible for Iraqi petroleum. The Minister of Oil since October 2022 is Hayyan Abdul Ghani.
Abdul Ghani, a former director general of the South Gas Co, was also previously director general of Basra Oil Co. He holds a master’s degree in mechanical engineering.
Establishments
North Oil Company (NOC)
South Oil Company (SOC)
Petroleum Research & Development Center (PRDC)
Baiji Oil Training Institute (BAJOTI)
Basrah Oil Training Institute (BASOTI)
Kirkuk Oil Training Institute (KOTI)
Baghdad Oil Training Institute (BOTI)
Heavy Engineering Equipments Company (HEESCO)
South Refineries Company (SRC)
Midland Refineries Company (MRC)
North Refineries Company (NRC)
Gas Filling Company (GFC)
Midland Oil Company (MDOC)
South Gas Company (SGC)
North Gas Company (NGC)
Missan Oil Company (MOC)
Iraqi Drilling Company (IDC)
Oil Products Distribution Company (OPDC)
State Organization for Marketing of Oil (SOMO)
Oil Pipelines Company (OPC)
Iraqi Oil Tankers Company (IOTC)
Oil Exploration Company (OEC)
State Company for Oil Projects (SCOP)
References
External links
Will Iraq Be a Global Gas Pump? The (Re)Making of a Petro-State Michael T. Klare, The Huffington Post, 14 July 2009
Oil
Economy of Iraq
Energy ministries
Oil reserves in Iraq |
```objective-c
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
//
// This Source Code Form is subject to the terms of the Mozilla
// with this file, You can obtain one at path_to_url
#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
// evaluator for thread pool device
#ifdef EIGEN_USE_THREADS
namespace Eigen {
#ifdef EIGEN_USE_SIMPLE_THREAD_POOL
namespace internal {
template<typename LhsScalar, typename LhsMapper, typename Index>
struct packLhsArg {
LhsScalar* blockA;
const LhsMapper& lhs;
const Index m_start;
const Index k_start;
const Index mc;
const Index kc;
};
template<typename LhsScalar, typename RhsScalar, typename RhsMapper, typename OutputMapper, typename Index>
struct packRhsAndKernelArg {
const MaxSizeVector<LhsScalar*>* blockAs;
RhsScalar* blockB;
const RhsMapper& rhs;
OutputMapper& output;
const Index m;
const Index k;
const Index n;
const Index mc;
const Index kc;
const Index nc;
const Index num_threads;
const Index num_blockAs;
const Index max_m;
const Index k_block_idx;
const Index m_block_idx;
const Index n_block_idx;
const Index m_blocks;
const Index n_blocks;
MaxSizeVector<Notification*>* kernel_notifications;
const MaxSizeVector<Notification*>* lhs_notifications;
const bool need_to_pack;
};
} // end namespace internal
#endif // EIGEN_USE_SIMPLE_THREAD_POOL
template<typename Indices, typename LeftArgType, typename RightArgType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType>, ThreadPoolDevice> :
public TensorContractionEvaluatorBase<TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType>, ThreadPoolDevice> > {
typedef ThreadPoolDevice Device;
typedef TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType>, Device> Self;
typedef TensorContractionEvaluatorBase<Self> Base;
typedef TensorContractionOp<Indices, LeftArgType, RightArgType> XprType;
typedef typename internal::remove_const<typename XprType::Scalar>::type Scalar;
typedef typename XprType::Index Index;
typedef typename XprType::CoeffReturnType CoeffReturnType;
typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
enum {
Layout = TensorEvaluator<LeftArgType, Device>::Layout,
};
// Most of the code is assuming that both input tensors are ColMajor. If the
// inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
// If we want to compute A * B = C, where A is LHS and B is RHS, the code
// will pretend B is LHS and A is RHS.
typedef typename internal::conditional<
static_cast<int>(Layout) == static_cast<int>(ColMajor), LeftArgType, RightArgType>::type EvalLeftArgType;
typedef typename internal::conditional<
static_cast<int>(Layout) == static_cast<int>(ColMajor), RightArgType, LeftArgType>::type EvalRightArgType;
static const int LDims =
internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
static const int RDims =
internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
static const int ContractDims = internal::array_size<Indices>::value;
typedef array<Index, LDims> left_dim_mapper_t;
typedef array<Index, RDims> right_dim_mapper_t;
typedef array<Index, ContractDims> contract_t;
typedef array<Index, LDims - ContractDims> left_nocontract_t;
typedef array<Index, RDims - ContractDims> right_nocontract_t;
static const int NumDims = LDims + RDims - 2 * ContractDims;
typedef DSizes<Index, NumDims> Dimensions;
// typedefs needed in evalTo
typedef typename internal::remove_const<typename EvalLeftArgType::Scalar>::type LhsScalar;
typedef typename internal::remove_const<typename EvalRightArgType::Scalar>::type RhsScalar;
typedef typename internal::gebp_traits<LhsScalar, RhsScalar> Traits;
typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
TensorEvaluator(const XprType& op, const Device& device) :
Base(op, device) {}
#ifndef EIGEN_USE_SIMPLE_THREAD_POOL
template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous,
bool rhs_inner_dim_reordered, int Alignment>
void evalProduct(Scalar* buffer) const {
const Index m = this->m_i_size;
const Index n = this->m_j_size;
const Index k = this->m_k_size;
if (m == 0 || n == 0 || k == 0) return;
#if defined(EIGEN_VECTORIZE_AVX) && defined(EIGEN_USE_LIBXSMM)
if (this->m_can_use_xsmm) {
bool transposeA = !this->m_lhs_inner_dim_contiguous;
bool transposeB = !this->m_rhs_inner_dim_contiguous;
internal::TensorXsmmContractionBlocking<LhsScalar, RhsScalar, Index>
blocking(k, m, n, this->m_device.numThreads(), transposeA,
transposeB);
if (blocking.num_threads() == 1) {
this->evalGemmXSMM(buffer);
} else {
ContextXsmm<Alignment>(this, buffer, m, n, k, blocking).run();
}
return;
}
#endif
typedef
typename internal::remove_const<typename EvalLeftArgType::Scalar>::type
LhsScalar;
typedef
typename internal::remove_const<typename EvalRightArgType::Scalar>::type
RhsScalar;
typedef typename internal::gebp_traits<LhsScalar, RhsScalar> Traits;
typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
typedef internal::TensorContractionInputMapper<
LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
contract_t, internal::packet_traits<LhsScalar>::size,
lhs_inner_dim_contiguous, false, Unaligned>
LhsMapper;
typedef internal::TensorContractionInputMapper<
RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
contract_t, internal::packet_traits<RhsScalar>::size,
rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Unaligned>
RhsMapper;
typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
typedef internal::gemm_pack_lhs<LhsScalar, Index,
typename LhsMapper::SubMapper, Traits::mr,
Traits::LhsProgress, ColMajor>
LhsPacker;
typedef internal::gemm_pack_rhs<
RhsScalar, Index, typename RhsMapper::SubMapper, Traits::nr, ColMajor>
RhsPacker;
typedef internal::gebp_kernel<LhsScalar, RhsScalar, Index, OutputMapper,
Traits::mr, Traits::nr, false, false>
GebpKernel;
// Compute a set of algorithm parameters:
// - kernel block sizes (bm, bn, bk)
// - task grain sizes (number of kernels executed per task: gm, gn)
// - number of threads
// - sharding by row/column
// - parallel packing or first lhs then rhs
// and some derived parameters:
// - number of tasks (nm, nn, nk)
// - number of kernels (nm0, nn0)
// Unfortunately, all these parameters are tightly interdependent.
// So in some cases we first compute approximate values, then compute other
// values based on these approximations and then refine the approximations.
// There are lots of heuristics here. There is some reasoning behind them,
// but ultimately they are just tuned on contraction benchmarks for
// different input configurations, thread counts and instruction sets.
// So feel free to question any of them.
// Compute whether we want to shard by row or by column.
// This is a first approximation, it will be refined later. Since we don't
// know number of threads yet we use 2, because what's we are most
// interested in at this point is whether it makes sense to use
// parallelization at all or not.
bool shard_by_col = shardByCol(m, n, 2);
// First approximation of kernel blocking sizes.
// Again, we don't know number of threads yet, so we use 2.
Index bm, bn, bk;
if (shard_by_col) {
internal::TensorContractionBlocking<LhsMapper, RhsMapper, Index,
internal::ShardByCol>
blocking(k, m, n, 2);
bm = blocking.mc();
bn = blocking.nc();
bk = blocking.kc();
} else {
internal::TensorContractionBlocking<LhsMapper, RhsMapper, Index,
internal::ShardByRow>
blocking(k, m, n, 2);
bm = blocking.mc();
bn = blocking.nc();
bk = blocking.kc();
}
// Compute optimal number of threads.
// Note: we use bk instead of k here because we are interested in amount of
// _parallelizable_ computations, and computations are not parallelizable
// across k dimension.
const TensorOpCost cost =
contractionCost(m, n, bm, bn, bk, shard_by_col, false);
int num_threads = TensorCostModel<ThreadPoolDevice>::numThreads(
static_cast<double>(n) * m, cost, this->m_device.numThreads());
// TODO(dvyukov): this is a stop-gap to prevent regressions while the cost
// model is not tuned. Remove this when the cost model is tuned.
if (n == 1) num_threads = 1;
if (num_threads == 1) {
// The single-threaded algorithm should be faster in this case.
if (n == 1)
this->template evalGemv<lhs_inner_dim_contiguous,
rhs_inner_dim_contiguous,
rhs_inner_dim_reordered, Alignment>(buffer);
else
this->template evalGemm<lhs_inner_dim_contiguous,
rhs_inner_dim_contiguous,
rhs_inner_dim_reordered, Alignment>(buffer);
return;
}
// Now that we know number of threads, recalculate sharding and blocking.
shard_by_col = shardByCol(m, n, num_threads);
if (shard_by_col) {
internal::TensorContractionBlocking<LhsMapper, RhsMapper, Index,
internal::ShardByCol>
blocking(k, m, n, num_threads);
bm = blocking.mc();
bn = blocking.nc();
bk = blocking.kc();
} else {
internal::TensorContractionBlocking<LhsMapper, RhsMapper, Index,
internal::ShardByRow>
blocking(k, m, n, num_threads);
bm = blocking.mc();
bn = blocking.nc();
bk = blocking.kc();
}
// Number of kernels for each dimension.
Index nm0 = divup(m, bm);
Index nn0 = divup(n, bn);
Index nk = divup(k, bk);
// Calculate task grain size (number of kernels executed per task).
// This task size coarsening serves two purposes:
// 1. It reduces per-task overheads including synchronization overheads.
// 2. It allows to use caches better (reuse the same packed rhs in several
// consecutive kernels).
Index gm = 1;
Index gn = 1;
// If we are sharding by column, then we prefer to reduce rows first.
if (shard_by_col) {
gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
} else {
gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
}
// Number of tasks in each dimension.
Index nm = divup(nm0, gm);
Index nn = divup(nn0, gn);
// Last by not least, decide whether we want to issue both lhs and rhs
// packing in parallel; or issue lhs packing first, and then issue rhs
// packing when lhs packing completes (for !shard_by_col lhs and rhs are
// swapped). Parallel packing allows more parallelism (for both packing and
// kernels), while sequential packing provides better locality (once
// a thread finishes rhs packing it proceed to kernels with that rhs).
// First, we are interested in parallel packing if there are few tasks.
bool parallel_pack = num_threads >= nm * nn;
// Also do parallel packing if all data fits into L2$.
if (m * bk * Index(sizeof(LhsScalar)) + n * bk * Index(sizeof(RhsScalar)) <=
l2CacheSize() * num_threads)
parallel_pack = true;
// But don't do it if we will use each rhs only once. Locality seems to be
// more important in this case.
if ((shard_by_col ? nm : nn) == 1) parallel_pack = false;
LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides,
this->m_i_strides, this->m_left_contracting_strides,
this->m_k_strides);
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides,
this->m_j_strides, this->m_right_contracting_strides,
this->m_k_strides);
Context<LhsPacker, RhsPacker, GebpKernel, LhsMapper, RhsMapper,
OutputMapper>(this->m_device, num_threads, lhs, rhs, buffer, m, n,
k, bm, bn, bk, nm, nn, nk, gm, gn, nm0, nn0,
shard_by_col, parallel_pack)
.run();
}
// Context coordinates a single parallel gemm operation.
template <typename LhsPacker, typename RhsPacker, typename GebpKernel,
typename LhsMapper, typename RhsMapper, typename OutputMapper>
class Context {
public:
Context(const Device& device, int num_threads, LhsMapper& lhs,
RhsMapper& rhs, Scalar* buffer, Index tm, Index tn, Index tk, Index bm,
Index bn, Index bk, Index nm, Index nn, Index nk, Index gm,
Index gn, Index nm0, Index nn0, bool shard_by_col,
bool parallel_pack)
: device_(device),
lhs_(lhs),
rhs_(rhs),
buffer_(buffer),
output_(buffer, tm),
num_threads_(num_threads),
shard_by_col_(shard_by_col),
parallel_pack_(parallel_pack),
m_(tm),
n_(tn),
k_(tk),
bm_(bm),
bn_(bn),
bk_(bk),
nm_(nm),
nn_(nn),
nk_(nk),
gm_(gm),
gn_(gn),
nm0_(nm0),
nn0_(nn0)
{
for (Index x = 0; x < P; x++) {
// Normal number of notifications for k slice switch is
// nm_ + nn_ + nm_ * nn_. However, first P - 1 slices will receive only
// nm_ + nn_ notifications, because they will not receive notifications
// from preceeding kernels.
state_switch_[x] =
x == 0
? 1
: (parallel_pack_ ? nn_ + nm_ : (shard_by_col_ ? nn_ : nm_)) +
(x == P - 1 ? nm_ * nn_ : 0);
state_packing_ready_[x] =
parallel_pack_ ? 0 : (shard_by_col_ ? nm_ : nn_);
state_kernel_[x] = new std::atomic<uint8_t>*[nm_];
for (Index m = 0; m < nm_; m++) {
state_kernel_[x][m] = new std::atomic<uint8_t>[nn_];
// Kernels generally receive 3 notifications (previous kernel + 2
// packing), but the first slice won't get notifications from previous
// kernels.
for (Index n = 0; n < nn_; n++)
state_kernel_[x][m][n].store(
(x == 0 ? 0 : 1) + (parallel_pack_ ? 2 : 1),
std::memory_order_relaxed);
}
}
// Allocate memory for packed rhs/lhs matrices.
size_t align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
size_t lhs_size =
divup<size_t>(bm_ * bk_ * sizeof(LhsScalar), align) * align;
size_t rhs_size =
divup<size_t>(bn_ * bk_ * sizeof(RhsScalar), align) * align;
packed_mem_ = static_cast<char*>(internal::aligned_malloc(
(nm0_ * lhs_size + nn0_ * rhs_size) * std::min<size_t>(nk_, P - 1)));
char* mem = static_cast<char*>(packed_mem_);
for (Index x = 0; x < numext::mini<Index>(nk_, P - 1); x++) {
packed_lhs_[x].resize(nm0_);
for (Index m = 0; m < nm0_; m++) {
packed_lhs_[x][m] = reinterpret_cast<LhsScalar*>(mem);
mem += lhs_size;
}
packed_rhs_[x].resize(nn0_);
for (Index n = 0; n < nn0_; n++) {
packed_rhs_[x][n] = reinterpret_cast<RhsScalar*>(mem);
mem += rhs_size;
}
}
}
~Context() {
for (Index x = 0; x < P; x++) {
for (Index m = 0; m < nm_; m++) delete[] state_kernel_[x][m];
delete[] state_kernel_[x];
}
internal::aligned_free(packed_mem_);
}
void run() {
// Kick off packing of the first slice.
signal_switch(0, 1);
// Wait for overall completion.
// TODO(dvyukov): this wait can lead to deadlock.
// If nthreads contractions are concurrently submitted from worker
// threads, this wait will block all worker threads and the system will
// deadlock.
done_.Wait();
}
private:
Notification done_;
const Device& device_;
LhsMapper& lhs_;
RhsMapper& rhs_;
Scalar* const buffer_;
OutputMapper output_;
const int num_threads_;
const bool shard_by_col_;
const bool parallel_pack_;
// Matrix sizes.
const Index m_;
const Index n_;
const Index k_;
// Block sizes.
const Index bm_;
const Index bn_;
const Index bk_;
// Number of tasks.
const Index nm_;
const Index nn_;
const Index nk_;
// Task grain sizes (number of kernels executed per task).
const Index gm_;
const Index gn_;
// Number of blocks (this is different from ni_/nn_ because of task size
// coarsening).
const Index nm0_;
const Index nn0_;
// Parallelization strategy.
//
// Blocks related to the same k block can run in parallel because they write
// to different output blocks. So we parallelize within k slices, this
// gives us parallelism level of m x n. Before we can start any kernels
// related to k-th slice, we need to issue m lhs packing tasks and n rhs
// packing tasks.
//
// However, there is a bottleneck when we are finishing kernels for k-th
// slice (at the very end there is only 1 runnable kernel). To mitigate this
// bottleneck we allow kernels from k-th and k+1-th slices to run in
// parallel. Note that (m, n, k) and (m, n, k+1) kernels write to the same
// output block, so they must not run in parallel.
//
// This gives us the following dependency graph.
// On each k slice we have m x n kernel tasks, m lhs paking tasks and n rhs
// packing tasks.
// Kernel (m, n, k) can start when:
// - kernel (m, n, k-1) has finished
// - lhs packing (m, k) has finished
// - rhs packing (n, k) has finished
// Lhs/rhs packing can start when:
// - all k-1 packing has finished (artificially imposed to limit amount of
// parallel packing)
//
// On top of that we limit runnable tasks to two consecutive k slices.
// This is done to limit amount of memory we need for packed lhs/rhs
// (for each k slice we need m*bk + n*bk memory in packed_lhs_/packed_rhs_).
//
// state_switch_ tracks when we are ready to switch to the next k slice.
// state_kernel_[m][n] tracks when we are ready to kick off kernel (m, n).
// These variable are rolling over 3 consecutive k slices: first two we are
// actively executing + one to track completion of kernels in the second
// slice.
static const Index P = 3;
void* packed_mem_;
std::vector<LhsScalar*> packed_lhs_[P - 1];
std::vector<RhsScalar*> packed_rhs_[P - 1];
std::atomic<uint8_t>** state_kernel_[P];
// state_switch_ is frequently modified by worker threads, while other
// fields are read-only after constructor. Let's move it to a separate cache
// line to reduce cache-coherency traffic.
char pad_[128];
std::atomic<Index> state_packing_ready_[P];
std::atomic<Index> state_switch_[P];
void pack_lhs(Index m, Index k) {
const Index mend = m * gm_ + gm(m);
for (Index m1 = m * gm_; m1 < mend; m1++)
LhsPacker()(packed_lhs_[k % (P - 1)][m1],
lhs_.getSubMapper(m1 * bm_, k * bk_), bk(k), bm(m1));
if (!parallel_pack_ && shard_by_col_) {
signal_packing(k);
} else {
signal_switch(k + 1);
for (Index n = nn_ - 1; n >= 0; n--) signal_kernel(m, n, k, n == 0);
}
}
void pack_rhs(Index n, Index k) {
const Index nend = n * gn_ + gn(n);
for (Index n1 = n * gn_; n1 < nend; n1++) {
if (k == 0) {
// Zero the output memory in parallel.
// On 10000x2x10000 mm zeroing can easily take half of time.
// Zero (bn x m) row. Safe to do here because all kernels that will
// write to this memory depend on completion of this task.
// Note: don't call device_.memset() here. device_.memset() blocks on
// thread pool worker thread, which can lead to underutilization and
// deadlocks.
memset(buffer_ + n1 * bn_ * m_, 0, bn(n1) * m_ * sizeof(Scalar));
}
RhsPacker()(packed_rhs_[k % (P - 1)][n1],
rhs_.getSubMapper(k * bk_, n1 * bn_), bk(k), bn(n1));
}
if (parallel_pack_ || shard_by_col_) {
signal_switch(k + 1);
for (Index m = nm_ - 1; m >= 0; m--) signal_kernel(m, n, k, m == 0);
} else {
signal_packing(k);
}
}
void kernel(Index m, Index n, Index k) {
// Note: order of iteration matters here. Iteration over m is innermost
// because we want to reuse the same packed rhs in consequetive tasks
// (rhs fits into L2$ while lhs only into L3$).
const Index nend = n * gn_ + gn(n);
const Index mend = m * gm_ + gm(m);
if (shard_by_col_) {
for (Index n1 = n * gn_; n1 < nend; n1++) {
for (Index m1 = m * gm_; m1 < mend; m1++)
GebpKernel()(output_.getSubMapper(m1 * bm_, n1 * bn_),
packed_lhs_[k % (P - 1)][m1],
packed_rhs_[k % (P - 1)][n1], bm(m1), bk(k), bn(n1),
Scalar(1), -1, -1, 0, 0);
}
} else {
for (Index m1 = m * gm_; m1 < mend; m1++)
for (Index n1 = n * gn_; n1 < nend; n1++) {
GebpKernel()(output_.getSubMapper(m1 * bm_, n1 * bn_),
packed_lhs_[k % (P - 1)][m1],
packed_rhs_[k % (P - 1)][n1], bm(m1), bk(k), bn(n1),
Scalar(1), -1, -1, 0, 0);
}
}
signal_kernel(m, n, k + 1, false);
signal_switch(k + 2);
}
void signal_packing(Index k) {
eigen_assert(!parallel_pack_);
Index s = state_packing_ready_[k % P].fetch_sub(1);
eigen_assert(s > 0);
if (s != 1) return;
state_packing_ready_[k % P] = shard_by_col_ ? nm_ : nn_;
enqueue_packing(k, shard_by_col_);
}
void signal_kernel(Index m, Index n, Index k, bool sync) {
std::atomic<uint8_t>* state = &state_kernel_[k % P][m][n];
Index s = state->load();
eigen_assert(s > 0);
if (s != 1 && state->fetch_sub(1) != 1) return;
state->store(parallel_pack_ ? 3 : 2, std::memory_order_relaxed);
if (sync)
kernel(m, n, k);
else
device_.enqueueNoNotification([=]() { kernel(m, n, k); });
}
void signal_switch(Index k, Index v = 1) {
Index s = state_switch_[k % P].fetch_sub(v);
eigen_assert(s >= v);
if (s != v) return;
// Ready to switch to the next k slice.
// Reset counter for the next iteration.
state_switch_[k % P] =
(parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_)) +
nm_ * nn_;
if (k < nk_) {
// Issue lhs/rhs packing. Their completion will in turn kick off
// kernels.
if (parallel_pack_) {
enqueue_packing(k, !shard_by_col_);
enqueue_packing(k, shard_by_col_);
} else if (shard_by_col_) {
enqueue_packing(k, false);
} else {
enqueue_packing(k, true);
}
// Termination handling.
// Because kernel completion signals k + 2 switch, we need to finish nk
// + 2 slices without issuing any tasks on nk + 1 slice. So here we
// pretend that all nk + 1 packing tasks just finish instantly; so that
// nk + 2 switch only waits for completion of nk kernels.
} else if (k == nk_) {
signal_switch(k + 1,
parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_));
} else {
done_.Notify();
}
}
// Enqueue all rhs/lhs packing for k-th slice.
void enqueue_packing(Index k, bool rhs) {
enqueue_packing_helper(0, rhs ? nn_ : nm_, k, rhs);
}
void enqueue_packing_helper(Index start, Index end, Index k, bool rhs) {
if (end - start == 1) {
if (rhs)
pack_rhs(start, k);
else
pack_lhs(start, k);
} else {
Index mid = (start + end) / 2;
device_.enqueueNoNotification(
[=]() { enqueue_packing_helper(mid, end, k, rhs); });
device_.enqueueNoNotification(
[=]() { enqueue_packing_helper(start, mid, k, rhs); });
}
}
// Block sizes with accounting for potentially incomplete last block.
Index bm(Index m) const { return m + 1 < nm0_ ? bm_ : m_ + bm_ - bm_ * nm0_; }
Index bn(Index n) const { return n + 1 < nn0_ ? bn_ : n_ + bn_ - bn_ * nn0_; }
Index bk(Index k) const { return k + 1 < nk_ ? bk_ : k_ + bk_ - bk_ * nk_; }
// Task grain sizes accounting for potentially incomplete last task.
Index gm(Index m) const { return m + 1 < nm_ ? gm_ : nm0_ + gm_ - gm_ * nm_; }
Index gn(Index n) const { return n + 1 < nn_ ? gn_ : nn0_ + gn_ - gn_ * nn_; }
Context(const Context&) = delete;
void operator=(const Context&) = delete;
};
// Decide whether we want to shard m x n contraction by columns or by rows.
static bool shardByCol(Index m, Index n, Index num_threads) {
// Note: we are comparing both n and m against Traits::nr, it is not
// a mistake. We are trying to figure out how both n and m will fit into
// the main sharding dimension.
// Sharding by column is the default
// ... unless there is enough data for vectorization over rows
if (m / num_threads >= Traits::nr &&
// and not enough data for vectorization over columns
(n / num_threads < Traits::nr ||
// ... or barely enough data for vectorization over columns,
// but it is not evenly dividable across threads
(n / num_threads < 4 * Traits::nr &&
(n % (num_threads * Traits::nr)) != 0 &&
// ... and it is evenly dividable across threads for rows
((m % (num_threads * Traits::nr)) == 0 ||
// .. or it is not evenly dividable for both dimensions but
// there is much more data over rows so that corner effects are
// mitigated.
(m / n >= 6)))))
return false;
// Wait, or if matrices are just substantially prolonged over the other
// dimension.
if (n / num_threads < 16 * Traits::nr && m > n * 32) return false;
return true;
}
Index coarsenM(Index m, Index n, Index bm, Index bn, Index bk, Index gn,
int num_threads, bool shard_by_col) const {
Index gm = 1;
Index gm1 = 1;
Index nm0 = divup(m, bm);
Index nm1 = nm0;
for (;;) {
// Find the next candidate for m grain size. It needs to result in
// different number of blocks. E.g. if we have 10 kernels, we want to try
// 5 and 10, but not 6, 7, 8 and 9.
while (gm1 <= nm0 && nm1 == divup(nm0, gm1)) gm1++;
if (gm1 > nm0) break;
// Check the candidate.
int res = checkGrain(m, n, bm, bn, bk, gm1, gn, gm, gn, num_threads,
shard_by_col);
if (res < 0) break;
nm1 = divup(nm0, gm1);
if (res == 0) continue;
// Commit new grain size.
gm = gm1;
}
return gm;
}
Index coarsenN(Index m, Index n, Index bm, Index bn, Index bk, Index gm,
int num_threads, bool shard_by_col) const {
Index gn = 1;
Index gn1 = 1;
Index nn0 = divup(n, bn);
Index nn1 = nn0;
for (;;) {
while (gn1 <= nn0 && nn1 == divup(nn0, gn1)) gn1++;
if (gn1 > nn0) break;
int res = checkGrain(m, n, bm, bn, bk, gm, gn1, gm, gn, num_threads,
shard_by_col);
if (res < 0) break;
nn1 = divup(nn0, gn1);
if (res == 0) continue;
gn = gn1;
}
return gn;
}
// checkGrain checks whether grain (gm, gn) is suitable and is better than
// (oldgm, oldgn).
int checkGrain(Index m, Index n, Index bm, Index bn, Index bk, Index gm,
Index gn, Index oldgm, Index oldgn, int num_threads,
bool shard_by_col) const {
const TensorOpCost cost =
contractionCost(bm * gm, bn * gn, bm, bn, bk, shard_by_col, true);
double taskSize = TensorCostModel<ThreadPoolDevice>::taskSize(
static_cast<double>(bm) * gm * bn * gn, cost);
// If the task is too small, then we agree on it regardless of anything
// else. Otherwise synchronization overheads will dominate.
if (taskSize < 1) return 1;
// If it is too large, then we reject it and all larger tasks.
if (taskSize > 2) return -1;
// Now we are in presumably good task size range.
// The main deciding factor here is parallelism. Consider that we have 12
// kernels and 4 threads. Grains of 2, 3 and 4 all yield good task sizes.
// But 2/4 yield 6/3 tasks, which gives us parallelism of 0.75 (at most 3/4
// of cores will be busy). While grain size 3 gives us 4 tasks, which gives
// us parallelism of 1 (we can load all cores).
Index nm0 = divup(m, bm);
Index nn0 = divup(n, bn);
Index new_tasks = divup(nm0, gm) * divup(nn0, gn);
double new_parallelism = static_cast<double>(new_tasks) /
(divup<int>(new_tasks, num_threads) * num_threads);
Index old_tasks = divup(nm0, oldgm) * divup(nn0, oldgn);
double old_parallelism = static_cast<double>(old_tasks) /
(divup<int>(old_tasks, num_threads) * num_threads);
if (new_parallelism > old_parallelism || new_parallelism == 1) return 1;
return 0;
}
#else // EIGEN_USE_SIMPLE_THREAD_POOL
template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
void evalProduct(Scalar* buffer) const {
if (this->m_j_size == 1) {
this->template evalGemv<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(buffer);
return;
}
evalGemm<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(buffer);
}
template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
void evalGemm(Scalar* buffer) const {
// columns in left side, rows in right side
const Index k = this->m_k_size;
// rows in left side
const Index m = this->m_i_size;
// columns in right side
const Index n = this->m_j_size;
// zero out the result buffer (which must be of size at least m * n * sizeof(Scalar)
this->m_device.memset(buffer, 0, m * n * sizeof(Scalar));
const int lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
const int rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
typedef internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs,
LeftEvaluator, left_nocontract_t,
contract_t, lhs_packet_size,
lhs_inner_dim_contiguous,
false, Unaligned> LhsMapper;
typedef internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs,
RightEvaluator, right_nocontract_t,
contract_t, rhs_packet_size,
rhs_inner_dim_contiguous,
rhs_inner_dim_reordered, Unaligned> RhsMapper;
typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
// TODO: packing could be faster sometimes if we supported row major tensor mappers
typedef internal::gemm_pack_lhs<LhsScalar, Index, typename LhsMapper::SubMapper, Traits::mr,
Traits::LhsProgress, ColMajor> LhsPacker;
typedef internal::gemm_pack_rhs<RhsScalar, Index, typename RhsMapper::SubMapper, Traits::nr, ColMajor> RhsPacker;
// TODO: replace false, false with conjugate values?
typedef internal::gebp_kernel<LhsScalar, RhsScalar, Index, OutputMapper,
Traits::mr, Traits::nr, false, false> GebpKernel;
typedef internal::packLhsArg<LhsScalar, LhsMapper, Index> packLArg;
typedef internal::packRhsAndKernelArg<LhsScalar, RhsScalar, RhsMapper, OutputMapper, Index> packRKArg;
// initialize data mappers
LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
this->m_left_contracting_strides, this->m_k_strides);
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
OutputMapper output(buffer, m);
// compute block sizes (which depend on number of threads)
const Index num_threads = this->m_device.numThreads();
internal::TensorContractionBlocking<LhsMapper, RhsMapper, Index, internal::ShardByCol> blocking(k, m, n, num_threads);
Index mc = blocking.mc();
Index nc = blocking.nc();
Index kc = blocking.kc();
eigen_assert(mc <= m);
eigen_assert(nc <= n);
eigen_assert(kc <= k);
#define CEIL_DIV(a, b) (((a) + (b) - 1) / (b))
const Index k_blocks = CEIL_DIV(k, kc);
const Index n_blocks = CEIL_DIV(n, nc);
const Index m_blocks = CEIL_DIV(m, mc);
const Index sizeA = mc * kc;
const Index sizeB = kc * nc;
/* cout << "m: " << m << " n: " << n << " k: " << k << endl;
cout << "mc: " << mc << " nc: " << nc << " kc: " << kc << endl;
cout << "m_blocks: " << m_blocks << " n_blocks: " << n_blocks << " k_blocks: " << k_blocks << endl;
cout << "num threads: " << num_threads << endl;
*/
// note: m_device.allocate should return 16 byte aligned pointers, but if blockA and blockB
// aren't 16 byte aligned segfaults will happen due to SIMD instructions
// note: You can get away with allocating just a single blockA and offsets and meet the
// the alignment requirements with the assumption that
// (Traits::mr * sizeof(ResScalar)) % 16 == 0
const Index numBlockAs = numext::mini(num_threads, m_blocks);
MaxSizeVector<LhsScalar *> blockAs(num_threads);
for (int i = 0; i < num_threads; i++) {
blockAs.push_back(static_cast<LhsScalar *>(this->m_device.allocate(sizeA * sizeof(LhsScalar))));
}
// To circumvent alignment issues, I'm just going to separately allocate the memory for each thread
// TODO: is this too much memory to allocate? This simplifies coding a lot, but is wasteful.
// Other options: (1) reuse memory when a thread finishes. con: tricky
// (2) allocate block B memory in each thread. con: overhead
MaxSizeVector<RhsScalar *> blockBs(n_blocks);
for (int i = 0; i < n_blocks; i++) {
blockBs.push_back(static_cast<RhsScalar *>(this->m_device.allocate(sizeB * sizeof(RhsScalar))));
}
// lhs_notifications starts with all null Notifications
MaxSizeVector<Notification*> lhs_notifications(num_threads, nullptr);
// this should really be numBlockAs * n_blocks;
const Index num_kernel_notifications = num_threads * n_blocks;
MaxSizeVector<Notification*> kernel_notifications(num_kernel_notifications,
nullptr);
for (Index k_block_idx = 0; k_block_idx < k_blocks; k_block_idx++) {
const Index k_start = k_block_idx * kc;
// make sure we don't overshoot right edge of left matrix
const Index actual_kc = numext::mini(k_start + kc, k) - k_start;
for (Index m_block_idx = 0; m_block_idx < m_blocks; m_block_idx += numBlockAs) {
const Index num_blocks = numext::mini(m_blocks-m_block_idx, numBlockAs);
for (Index mt_block_idx = m_block_idx; mt_block_idx < m_block_idx+num_blocks; mt_block_idx++) {
const Index m_start = mt_block_idx * mc;
const Index actual_mc = numext::mini(m_start + mc, m) - m_start;
eigen_assert(actual_mc > 0);
Index blockAId = (k_block_idx * m_blocks + mt_block_idx) % num_threads;
for (int i = 0; i < n_blocks; ++i) {
Index notification_id = (blockAId * n_blocks + i);
// Wait for any current kernels using this slot to complete
// before using it.
if (kernel_notifications[notification_id]) {
wait_until_ready(kernel_notifications[notification_id]);
delete kernel_notifications[notification_id];
}
kernel_notifications[notification_id] = new Notification();
}
const packLArg arg = {
blockAs[blockAId], // blockA
lhs, // lhs
m_start, // m
k_start, // k
actual_mc, // mc
actual_kc, // kc
};
// Delete any existing notification since we may be
// replacing it. The algorithm should ensure that there are
// no existing waiters on this notification.
delete lhs_notifications[blockAId];
lhs_notifications[blockAId] =
this->m_device.enqueue(&Self::packLhs<packLArg, LhsPacker>, arg);
}
// now start kernels.
const Index m_base_start = m_block_idx * mc;
const bool need_to_pack = m_block_idx == 0;
for (Index n_block_idx = 0; n_block_idx < n_blocks; n_block_idx++) {
const Index n_start = n_block_idx * nc;
const Index actual_nc = numext::mini(n_start + nc, n) - n_start;
// first make sure the previous kernels are all done before overwriting rhs. Also wait if
// we're going to start new k. In both cases need_to_pack is true.
if (need_to_pack) {
for (Index i = num_blocks; i < num_threads; ++i) {
Index blockAId = (k_block_idx * m_blocks + i + m_block_idx) % num_threads;
Index future_id = (blockAId * n_blocks + n_block_idx);
wait_until_ready(kernel_notifications[future_id]);
}
}
packRKArg arg = {
&blockAs, // blockA
blockBs[n_block_idx], // blockB
rhs, // rhs
output, // output
m_base_start, // m
k_start, // k
n_start, // n
mc, // mc
actual_kc, // kc
actual_nc, // nc
num_threads,
numBlockAs,
m,
k_block_idx,
m_block_idx,
n_block_idx, // n_block_idx
m_blocks, // m_blocks
n_blocks, // n_blocks
&kernel_notifications, // kernel notifications
&lhs_notifications, // lhs notifications
need_to_pack, // need_to_pack
};
// We asynchronously kick off this function, which ends up
// notifying the appropriate kernel_notifications objects,
// which this thread waits on before exiting.
this->m_device.enqueueNoNotification(&Self::packRhsAndKernel<packRKArg, RhsPacker, GebpKernel>, arg);
}
}
}
// Make sure all the kernels are done.
for (size_t i = 0; i < kernel_notifications.size(); ++i) {
wait_until_ready(kernel_notifications[i]);
delete kernel_notifications[i];
}
// No need to wait for lhs notifications since they should have
// already been waited on. Just clean them up.
for (size_t i = 0; i < lhs_notifications.size(); ++i) {
delete lhs_notifications[i];
}
// deallocate all of the memory for both A and B's
for (size_t i = 0; i < blockAs.size(); i++) {
this->m_device.deallocate(blockAs[i]);
}
for (size_t i = 0; i < blockBs.size(); i++) {
this->m_device.deallocate(blockBs[i]);
}
#undef CEIL_DIV
}
/*
* Packs a LHS block of size (mt, kc) starting at lhs(m, k). Before packing
* the LHS block, check that all of the kernels that worked on the same
* mt_block_idx in the previous m_block are done.
*/
template <typename packLArg, typename LhsPacker>
static void packLhs(const packLArg arg) {
// perform actual packing
LhsPacker pack_lhs;
pack_lhs(arg.blockA, arg.lhs.getSubMapper(arg.m_start, arg.k_start), arg.kc, arg.mc);
}
/*
* Packs a RHS block of size (kc, nc) starting at (k, n) after checking that
* all kernels in the previous block are done.
* Then for each LHS future, we wait on the future and then call GEBP
* on the area packed by the future (which starts at
* blockA + future_idx * mt * kc) on the LHS and with the full packed
* RHS block.
* The output of this GEBP is written to output(m + i * mt, n).
*/
template <typename packRKArg, typename RhsPacker, typename GebpKernel>
static void packRhsAndKernel(packRKArg arg) {
if (arg.need_to_pack) {
RhsPacker pack_rhs;
pack_rhs(arg.blockB, arg.rhs.getSubMapper(arg.k, arg.n), arg.kc, arg.nc);
}
GebpKernel gebp;
for (Index mt_block_idx = 0; mt_block_idx < arg.num_blockAs; mt_block_idx++) {
const Index m_base_start = arg.m + arg.mc*mt_block_idx;
if (m_base_start < arg.max_m) {
Index blockAId = (arg.k_block_idx * arg.m_blocks + mt_block_idx + arg.m_block_idx) % arg.num_threads;
wait_until_ready((*arg.lhs_notifications)[blockAId]);
const Index actual_mc = numext::mini(m_base_start + arg.mc, arg.max_m) - m_base_start;
gebp(arg.output.getSubMapper(m_base_start, arg.n),
(*arg.blockAs)[blockAId], arg.blockB,
actual_mc, arg.kc, arg.nc, Scalar(1), -1, -1, 0, 0);
// Notify that the kernel is done.
const Index set_idx = blockAId * arg.n_blocks + arg.n_block_idx;
(*arg.kernel_notifications)[set_idx]->Notify();
}
}
}
#endif // EIGEN_USE_SIMPLE_THREAD_POOL
TensorOpCost contractionCost(Index m, Index n, Index bm, Index bn, Index bk,
bool shard_by_col, bool prepacked) const {
const int packed_size = std::min<int>(PacketType<LhsScalar, Device>::size,
PacketType<RhsScalar, Device>::size);
const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
const double kd = static_cast<double>(bk);
// Peak VFMA bandwidth is 0.5. However if we have not enough data for
// vectorization bandwidth drops. The 4.0 and 2.0 bandwidth is determined
// experimentally.
double computeBandwidth = bk == 1 ? 4.0 :
(shard_by_col ? bn : bm) < Traits::nr ||
(shard_by_col ? bm : bn) < Traits::mr ? 2.0 : 0.5;
#ifndef EIGEN_VECTORIZE_FMA
// Bandwidth of all of VFMA/MULPS/ADDPS is 0.5 on latest Intel processors.
// However for MULPS/ADDPS we have dependent sequence of 2 such instructions,
// so overall bandwidth is 1.0.
if (computeBandwidth == 0.5) computeBandwidth = 1.0;
#endif
// Computations.
TensorOpCost cost = TensorOpCost(0, 0, kd * computeBandwidth, true, packed_size);
// Output stores.
cost += TensorOpCost(0, sizeof(CoeffReturnType), 0, true, output_packet_size);
if (prepacked) {
// Packing and kernels are executed in different tasks. When we calculate
// task grain size we look only at kernel cost assuming that kernel
// is more expensive than packing.
return cost;
}
// Lhs/rhs loads + computations.
TensorOpCost lhsCost = this->m_leftImpl.costPerCoeff(true) * (kd / n);
TensorOpCost rhsCost = this->m_rightImpl.costPerCoeff(true) * (kd / m);
// Lhs packing memory cost does not contribute considerably to overall
// execution time because lhs is prefetched early and accessed sequentially.
if (shard_by_col)
lhsCost.dropMemoryCost();
else
rhsCost.dropMemoryCost();
return cost + lhsCost + rhsCost;
}
#if defined(EIGEN_VECTORIZE_AVX) && defined(EIGEN_USE_LIBXSMM)
template<int Alignment>
class ContextXsmm {
public:
ContextXsmm(const Self* self, Scalar* buffer, Index m, Index n, Index k,
const internal::TensorXsmmContractionBlocking<LhsScalar,
RhsScalar, Index>& blocking):
device(self->m_device),
m(m), k(k), n(n),
stride_a(blocking.transposeA() ? k : m),
stride_b(blocking.transposeB() ? n : k),
stride_c(m),
bm(blocking.mc()), bk(blocking.kc()), bn(blocking.nc()),
blocks_m(blocking.blocks_m()), blocks_k(blocking.blocks_k()),
blocks_n(blocking.blocks_n()),
copyA(blocking.copyA()), copyB(blocking.copyB()),
transposeA(blocking.transposeA()), transposeB(blocking.transposeB()),
num_threads(blocking.num_threads()),
buffer(buffer),
leftData(self->m_leftImpl.data()), rightData(self->m_rightImpl.data()),
workers_done(blocking.num_threads()),
packingA_jobs(0), packingB_jobs(0), compute_jobs(0),
packingA_done(blocking.blocks_m()), packingB_done(blocking.blocks_n()) {}
void worker() {
// Pack
if (copyA) {
while (true) {
uint32_t mk = packingA_jobs++;
Index mi = mk / blocks_k;
Index ki = mk % blocks_k;
if (mi >= blocks_m) break;
LhsScalar * blockA = blocksA + (bk*bm) * (mi*blocks_k+ki);
if (transposeA) {
const LhsScalar * current_a = leftData + (bm*mi)*stride_a + (bk*ki);
libxsmm_otrans(blockA, current_a, sizeof(LhsScalar), actual_bk(ki),
actual_bm(mi), stride_a, bm);
} else {
const LhsScalar * current_a = leftData + (bk*ki)*stride_a + (bm*mi);
internal::pack_simple<LhsScalar, Index>(blockA, current_a,
actual_bk(ki), actual_bm(mi), bm, stride_a);
}
packingA_done.at(mi)++;
}
}
if (copyB) {
while (true) {
uint32_t nk = packingB_jobs++;
Index ni = nk / blocks_k;
Index ki = nk % blocks_k;
if (ni >= blocks_n) break;
RhsScalar * blockB = blocksB + (bk*bn) * (ni*blocks_k+ki);
if (transposeB) {
const RhsScalar * current_b = rightData + (ki*bk)*stride_b +
(ni*bn);
libxsmm_otrans(blockB, current_b, sizeof(RhsScalar), actual_bn(ni),
actual_bk(ki), stride_b, bk);
} else {
const RhsScalar * current_b = rightData + (ni*bn)*stride_b +
(ki*bk);
internal::pack_simple<RhsScalar, Index>(blockB, current_b,
actual_bn(ni), actual_bk(ki), bk, stride_b);
}
packingB_done.at(ni)++;
}
}
// Compute
while (true) {
uint32_t mn = compute_jobs++;
Index mi = mn / blocks_n;
Index ni = mn % blocks_n;
if (mi >= blocks_m) break;
// Wait for mi, ni packings to be done. This is more fine-grained than
// waiting for all workers to finish packing.
while ((copyA && (packingA_done.at(mi) < blocks_k)) ||
(copyB && (packingB_done.at(ni) < blocks_k)))
{}
for (Index ki=0; ki < blocks_k; ++ki) {
const LhsScalar * current_a = copyA ?
blocksA + (bk*bm) * (mi*blocks_k+ki) :
leftData + (bk*ki)*stride_a + (bm*mi);
const RhsScalar * current_b = copyB ?
blocksB + (bk*bn) * (ni*blocks_k+ki) :
rightData + (ni*bn)*stride_b + (bk*ki);
Index current_stride_a = copyA ? bm : stride_a;
Index current_stride_b = copyB ? bk : stride_b;
// Memory may not be zeroed, overwrite instead of adding in first
// iteration.
float beta = ki == 0 ? 0 : 1;
Scalar * current_c = buffer + (mi*bm) + (ni*bn)*stride_c;
internal::libxsmm_wrapper<LhsScalar, RhsScalar, Scalar>(
0, actual_bm(mi), actual_bn(ni), actual_bk(ki),
current_stride_a, current_stride_b, stride_c, 1, beta, 0)
(current_a, current_b, current_c);
}
}
workers_done.Notify();
}
void run() {
// Parallelization strategy.
//
// First pack A into blocks (sharding by m, k) and B (sharding by n,k),
// then shard by m, n.
//
// Do not use advanced ThreadPool queuing, just run a single long-standing
// function in each thread.
if (copyA) {
blocksA = static_cast<LhsScalar*>(device.allocate(
(blocks_m*bm)*(blocks_k*bk)*sizeof(LhsScalar)));
}
if (copyB) {
blocksB = static_cast<RhsScalar*>(device.allocate(
(blocks_n*bn)*(blocks_k*bk)*sizeof(RhsScalar)));
}
for (Index i = 0; i < num_threads; ++i) {
device.enqueueNoNotification([=]() { worker(); });
}
workers_done.Wait();
if (copyA) {
device.deallocate(blocksA);
}
if (copyB) {
device.deallocate(blocksB);
}
}
private:
// real block size for block index in [0, ..., blocks - 1].
Index actual_bm(Index mi) const {
return mi != blocks_m - 1 ? bm : m + bm - bm * blocks_m;
}
Index actual_bk(Index ki) const {
return ki != blocks_k - 1 ? bk : k + bk - bk * blocks_k;
}
Index actual_bn(Index ni) const {
return ni != blocks_n - 1 ? bn : n + bn - bn * blocks_n;
}
const Device& device;
Index m, k, n;
Index stride_a, stride_b, stride_c;
Index bm, bk, bn; // Block sizes.
Index blocks_m, blocks_k, blocks_n; // Number of blocks in each dimension.
bool copyA, copyB, transposeA, transposeB;
Index num_threads;
Scalar *buffer;
const LhsScalar *leftData;
const RhsScalar *rightData;
LhsScalar *blocksA;
RhsScalar *blocksB;
// barrier for joining all threads after all done.
Barrier workers_done;
// "queues" of (mi,ki), (ki,ni), (mi,ni) jobs packed [0,p)x[0,q) -> [0, p*q)
std::atomic<uint32_t> packingA_jobs;
std::atomic<uint32_t> packingB_jobs;
std::atomic<uint32_t> compute_jobs;
// already packed blocks for each mi-panel in A and ni-panel in B.
std::vector<std::atomic<uint8_t>> packingA_done;
std::vector<std::atomic<uint8_t>> packingB_done;
};
#endif
};
} // end namespace Eigen
#endif // EIGEN_USE_THREADS
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
``` |
The Atascadero Administration Building is the historic facility where Atascadero City Hall conducts operations. W.D. Bliss designed the building, began construction in 1914 and completed in 1918.
History of use
The building is now a California Historical Landmark.
Earthquake damage and restoration
The building was damaged in the San Simeon Earthquake and was closed for 10 years during a period of significant restoration. The city reopened the building in August 2013.
References
Atascadero, California
California Historical Landmarks
Buildings and structures in Atascadero, California
National Register of Historic Places in San Luis Obispo County, California
Government buildings completed in 1918 |
```shell
#!/usr/bin/env bats
teardown() {
skip "This is not working (path_to_url"
}
@test "skip in test and teardown" {
skip "This is not working (path_to_url"
}
``` |
Zaborowo is a village in the administrative district of Gmina Grajewo, within Grajewo County, Podlaskie Voivodeship, in north-eastern Poland. It lies approximately south of Grajewo and north-west of the regional capital Białystok.
References
Zaborowo |
Samay: When Time Strikes is a 2003 Indian Hindi-language thriller film directed by Robbie Grewal. It starred Sushmita Sen and Sushant Singh.
Plot
ACP Malvika Chauhan (Sushmita Sen) is a widowed cop with a 10-year-old daughter. She is saddled with the murder case of a reputed businessman, where the killer has left no evidence. Before she can get into the investigation, a famous heroine is killed. Malvika suspects that it might be the work of a serial killer.
Investigation reveals that the victims were not connected with each other. Plus, even the suspects with motives were not near the crime scenes. Suddenly Malvika realizes that somebody is stalking her. Malvika accosts her stalker, but he reveals that he was just doing it for a criminal named Suleman Bhai. As Suleman has that much expertise to kill someone without leaving evidence, Malvika thinks she has got a killer for at least one case. But when Malvika goes to Suleman's house, she finds Suleman dead.
Again out of leads, Malvika starts going through case files of all 3 victims. She finds 4 connections:
All were the best people in their fields.
All had a poor eyesight with eye power of -2.
All ordered their spectacles from the same shop.
The position of their hands on the crime scene indicated their time of death (12 am, 3 pm, and 6 pm).
Malvika goes to the shop to investigate, where the assistant says that her eyesight is perfect, but her vision is very weak. Malvika does not realize what he means, but after learning that the assistant did not turn up that day, she realizes that she talked with the killer (whom she could not see, as the room was dark). Later, she finds out from the list of customers that a person named Amod Parekh (Jackie Shroff), also with eye power -2, visited the same optical shop on the days when all the three murdered persons visited the shop, and believes him to be the killer.
A frustrated Malvika sends her associate Satya (Sushant Singh) to investigate the whereabouts of the killer, while she tries to figure out who the next target is. She finds that a renowned musician, who also has a power of -2, is the customer of the shop and is performing the same evening. Malvika arranges for a tight security, but the musician is not killed by the killer even after the given time (9 pm).
Meanwhile, Malvika's associate finds out the killer's address. Amod reveals himself to Malvika in front of the musician. Amod explains that he was also a graduate from the '94 batch of the police academy, the same batch from which Malvika graduated. He explains that his credentials were much better than Malvika's, but he was toppled, as he had poor eyesight with power -2.
Amod vents out his anger by saying that this same fault did not affect the lives of his victims, in fact, they became famous. He also goes on to say that he did not want to kill them, but time was not on their side as somebody else, too had a motive to kill them. Malvika thinks that he is trying to prove that she has lost, and he has proved himself a genius, if not as a cop, then as a killer.
Malvika asks why Amod did not kill the musician. Suddenly her associate arrives with a broken pair of glasses retrieved from Amod's house. Amod tells her that her daughter was the perfect daughter of the best cop. He clarifies that he killed her daughter instead (9 pm), who also has an eyesight power of -2 and came to the same optical shop in the same evening. He again taunts Malvika that her eyesight is perfect, but her vision is very weak as she didn't notice her daughter's name in the customers' list. Malvika's associate begs her to not to kill the killer, as he wants her to do the same. However, an angry Malvika shoots the killer dead (12 am).
Cast
Sushmita Sen as ACP Malvika Chauhan
Sushant Singh as Inspector Satya Anand
Jackie Shroff as Amod Parekh (Guest Appearance)
Rajesh Khera as Postmortem Doctor
Dinesh Lamba as Sub Inspector Rafique
Shishir Sharma as Police Commissioner
Tushar Dalvi as Dr. Ravi Ghatge
Barkha Singh as Anjalee Chauhan
Deepak Dobriyal as Production Designer on Film Set
Lucy Bartholomew as Rithika Sabhrawal
Mona Ghosh Shetty as Namrata Sharma, Sandhya's Sister
Soundtrack
"Aaj Ki Raat": Sneha Pant
"Jab Andhera Hota Hai": Vaishali Samant
"Laila Laila": Sowmya Raoh
"Last Clue": Instrumental
"Zindagi": Sowmya Raoh
"Losing To Win" (Zindagi Reprise)
"Man Hunt": Instrumental
"The Chase": Instrumental
"The Theme": Instrumental
Reception
Samay was well received at the box office, and Sushmita Sen was praised for her professional portrayal of ACP Malavika Chauhan. Reviews praised the well-written screenplay, and its storyline kept its audiences guessing until the last minute.
Samay won a National Award in 2004 for Best Editing by Aarif Sheikh.
While not reaching cult classic status, Samay became popular among those who follow the thriller genre.
References
External links
2003 films
2000s Hindi-language films
Indian detective films
Films scored by Sandeep Chowta
Films whose editor won the Best Film Editing National Award
Indian crime thriller films
2003 crime thriller films
Indian mystery thriller films
Indian police films
2000s police procedural films
2000s mystery thriller films
Hindi-language crime thriller films
Hindi-language mystery thriller films |
It was a Dacian fortified town.
References
Dacian fortresses in Covasna County
Historic monuments in Covasna County |
```python
# -*- coding: utf-8 -*-
__all__ = ['Distribution']
import io
import sys
import re
import os
import warnings
import numbers
import distutils.log
import distutils.core
import distutils.cmd
import distutils.dist
from distutils.util import strtobool
from distutils.debug import DEBUG
from distutils.fancy_getopt import translate_longopt
import itertools
from collections import defaultdict
from email import message_from_file
from distutils.errors import DistutilsOptionError, DistutilsSetupError
from distutils.util import rfc822_escape
from distutils.version import StrictVersion
from setuptools.extern import packaging
from setuptools.extern import ordered_set
from . import SetuptoolsDeprecationWarning
import setuptools
from setuptools import windows_support
from setuptools.monkey import get_unpatched
from setuptools.config import parse_configuration
import pkg_resources
__import__('setuptools.extern.packaging.specifiers')
__import__('setuptools.extern.packaging.version')
def _get_unpatched(cls):
warnings.warn("Do not call this function", DistDeprecationWarning)
return get_unpatched(cls)
def get_metadata_version(self):
mv = getattr(self, 'metadata_version', None)
if mv is None:
if self.long_description_content_type or self.provides_extras:
mv = StrictVersion('2.1')
elif (self.maintainer is not None or
self.maintainer_email is not None or
getattr(self, 'python_requires', None) is not None or
self.project_urls):
mv = StrictVersion('1.2')
elif (self.provides or self.requires or self.obsoletes or
self.classifiers or self.download_url):
mv = StrictVersion('1.1')
else:
mv = StrictVersion('1.0')
self.metadata_version = mv
return mv
def read_pkg_file(self, file):
"""Reads the metadata values from a file object."""
msg = message_from_file(file)
def _read_field(name):
value = msg[name]
if value == 'UNKNOWN':
return None
return value
def _read_list(name):
values = msg.get_all(name, None)
if values == []:
return None
return values
self.metadata_version = StrictVersion(msg['metadata-version'])
self.name = _read_field('name')
self.version = _read_field('version')
self.description = _read_field('summary')
# we are filling author only.
self.author = _read_field('author')
self.maintainer = None
self.author_email = _read_field('author-email')
self.maintainer_email = None
self.url = _read_field('home-page')
self.license = _read_field('license')
if 'download-url' in msg:
self.download_url = _read_field('download-url')
else:
self.download_url = None
self.long_description = _read_field('description')
self.description = _read_field('summary')
if 'keywords' in msg:
self.keywords = _read_field('keywords').split(',')
self.platforms = _read_list('platform')
self.classifiers = _read_list('classifier')
# PEP 314 - these fields only exist in 1.1
if self.metadata_version == StrictVersion('1.1'):
self.requires = _read_list('requires')
self.provides = _read_list('provides')
self.obsoletes = _read_list('obsoletes')
else:
self.requires = None
self.provides = None
self.obsoletes = None
# Based on Python 3.5 version
def write_pkg_file(self, file):
"""Write the PKG-INFO format data to a file object.
"""
version = self.get_metadata_version()
def write_field(key, value):
file.write("%s: %s\n" % (key, value))
write_field('Metadata-Version', str(version))
write_field('Name', self.get_name())
write_field('Version', self.get_version())
write_field('Summary', self.get_description())
write_field('Home-page', self.get_url())
if version < StrictVersion('1.2'):
write_field('Author', self.get_contact())
write_field('Author-email', self.get_contact_email())
else:
optional_fields = (
('Author', 'author'),
('Author-email', 'author_email'),
('Maintainer', 'maintainer'),
('Maintainer-email', 'maintainer_email'),
)
for field, attr in optional_fields:
attr_val = getattr(self, attr)
if attr_val is not None:
write_field(field, attr_val)
if self.download_url:
write_field('Download-URL', self.download_url)
for project_url in self.project_urls.items():
write_field('Project-URL', '%s, %s' % project_url)
long_desc = rfc822_escape(self.get_long_description())
write_field('Description', long_desc)
keywords = ','.join(self.get_keywords())
if keywords:
write_field('Keywords', keywords)
if version >= StrictVersion('1.2'):
for platform in self.get_platforms():
write_field('Platform', platform)
else:
self._write_list(file, 'Platform', self.get_platforms())
self._write_list(file, 'Classifier', self.get_classifiers())
# PEP 314
self._write_list(file, 'Requires', self.get_requires())
self._write_list(file, 'Provides', self.get_provides())
self._write_list(file, 'Obsoletes', self.get_obsoletes())
# Setuptools specific for PEP 345
if hasattr(self, 'python_requires'):
write_field('Requires-Python', self.python_requires)
# PEP 566
if self.long_description_content_type:
write_field(
'Description-Content-Type',
self.long_description_content_type
)
if self.provides_extras:
for extra in self.provides_extras:
write_field('Provides-Extra', extra)
sequence = tuple, list
def check_importable(dist, attr, value):
try:
ep = pkg_resources.EntryPoint.parse('x=' + value)
assert not ep.extras
except (TypeError, ValueError, AttributeError, AssertionError) as e:
raise DistutilsSetupError(
"%r must be importable 'module:attrs' string (got %r)"
% (attr, value)
) from e
def assert_string_list(dist, attr, value):
"""Verify that value is a string list"""
try:
# verify that value is a list or tuple to exclude unordered
# or single-use iterables
assert isinstance(value, (list, tuple))
# verify that elements of value are strings
assert ''.join(value) != value
except (TypeError, ValueError, AttributeError, AssertionError) as e:
raise DistutilsSetupError(
"%r must be a list of strings (got %r)" % (attr, value)
) from e
def check_nsp(dist, attr, value):
"""Verify that namespace packages are valid"""
ns_packages = value
assert_string_list(dist, attr, ns_packages)
for nsp in ns_packages:
if not dist.has_contents_for(nsp):
raise DistutilsSetupError(
"Distribution contains no modules or packages for " +
"namespace package %r" % nsp
)
parent, sep, child = nsp.rpartition('.')
if parent and parent not in ns_packages:
distutils.log.warn(
"WARNING: %r is declared as a package namespace, but %r"
" is not: please correct this in setup.py", nsp, parent
)
def check_extras(dist, attr, value):
"""Verify that extras_require mapping is valid"""
try:
list(itertools.starmap(_check_extra, value.items()))
except (TypeError, ValueError, AttributeError) as e:
raise DistutilsSetupError(
"'extras_require' must be a dictionary whose values are "
"strings or lists of strings containing valid project/version "
"requirement specifiers."
) from e
def _check_extra(extra, reqs):
name, sep, marker = extra.partition(':')
if marker and pkg_resources.invalid_marker(marker):
raise DistutilsSetupError("Invalid environment marker: " + marker)
list(pkg_resources.parse_requirements(reqs))
def assert_bool(dist, attr, value):
"""Verify that value is True, False, 0, or 1"""
if bool(value) != value:
tmpl = "{attr!r} must be a boolean value (got {value!r})"
raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
def check_requirements(dist, attr, value):
"""Verify that install_requires is a valid requirements list"""
try:
list(pkg_resources.parse_requirements(value))
if isinstance(value, (dict, set)):
raise TypeError("Unordered types are not allowed")
except (TypeError, ValueError) as error:
tmpl = (
"{attr!r} must be a string or list of strings "
"containing valid project/version requirement specifiers; {error}"
)
raise DistutilsSetupError(
tmpl.format(attr=attr, error=error)
) from error
def check_specifier(dist, attr, value):
"""Verify that value is a valid version specifier"""
try:
packaging.specifiers.SpecifierSet(value)
except packaging.specifiers.InvalidSpecifier as error:
tmpl = (
"{attr!r} must be a string "
"containing valid version specifiers; {error}"
)
raise DistutilsSetupError(
tmpl.format(attr=attr, error=error)
) from error
def check_entry_points(dist, attr, value):
"""Verify that entry_points map is parseable"""
try:
pkg_resources.EntryPoint.parse_map(value)
except ValueError as e:
raise DistutilsSetupError(e) from e
def check_test_suite(dist, attr, value):
if not isinstance(value, str):
raise DistutilsSetupError("test_suite must be a string")
def check_package_data(dist, attr, value):
"""Verify that value is a dictionary of package names to glob lists"""
if not isinstance(value, dict):
raise DistutilsSetupError(
"{!r} must be a dictionary mapping package names to lists of "
"string wildcard patterns".format(attr))
for k, v in value.items():
if not isinstance(k, str):
raise DistutilsSetupError(
"keys of {!r} dict must be strings (got {!r})"
.format(attr, k)
)
assert_string_list(dist, 'values of {!r} dict'.format(attr), v)
def check_packages(dist, attr, value):
for pkgname in value:
if not re.match(r'\w+(\.\w+)*', pkgname):
distutils.log.warn(
"WARNING: %r not a valid package name; please use only "
".-separated package names in setup.py", pkgname
)
_Distribution = get_unpatched(distutils.core.Distribution)
class Distribution(_Distribution):
"""Distribution with support for tests and package data
This is an enhanced version of 'distutils.dist.Distribution' that
effectively adds the following new optional keyword arguments to 'setup()':
'install_requires' -- a string or sequence of strings specifying project
versions that the distribution requires when installed, in the format
used by 'pkg_resources.require()'. They will be installed
automatically when the package is installed. If you wish to use
packages that are not available in PyPI, or want to give your users an
alternate download location, you can add a 'find_links' option to the
'[easy_install]' section of your project's 'setup.cfg' file, and then
setuptools will scan the listed web pages for links that satisfy the
requirements.
'extras_require' -- a dictionary mapping names of optional "extras" to the
additional requirement(s) that using those extras incurs. For example,
this::
extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
indicates that the distribution can optionally provide an extra
capability called "reST", but it can only be used if docutils and
reSTedit are installed. If the user installs your package using
EasyInstall and requests one of your extras, the corresponding
additional requirements will be installed if needed.
'test_suite' -- the name of a test suite to run for the 'test' command.
If the user runs 'python setup.py test', the package will be installed,
and the named test suite will be run. The format is the same as
would be used on a 'unittest.py' command line. That is, it is the
dotted name of an object to import and call to generate a test suite.
'package_data' -- a dictionary mapping package names to lists of filenames
or globs to use to find data files contained in the named packages.
If the dictionary has filenames or globs listed under '""' (the empty
string), those names will be searched for in every package, in addition
to any names for the specific package. Data files found using these
names/globs will be installed along with the package, in the same
location as the package. Note that globs are allowed to reference
the contents of non-package subdirectories, as long as you use '/' as
a path separator. (Globs are automatically converted to
platform-specific paths at runtime.)
In addition to these new keywords, this class also has several new methods
for manipulating the distribution's contents. For example, the 'include()'
and 'exclude()' methods can be thought of as in-place add and subtract
commands that add or remove packages, modules, extensions, and so on from
the distribution.
"""
_DISTUTILS_UNSUPPORTED_METADATA = {
'long_description_content_type': None,
'project_urls': dict,
'provides_extras': ordered_set.OrderedSet,
'license_files': ordered_set.OrderedSet,
}
_patched_dist = None
def patch_missing_pkg_info(self, attrs):
# Fake up a replacement for the data that would normally come from
# PKG-INFO, but which might not yet be built if this is a fresh
# checkout.
#
if not attrs or 'name' not in attrs or 'version' not in attrs:
return
key = pkg_resources.safe_name(str(attrs['name'])).lower()
dist = pkg_resources.working_set.by_key.get(key)
if dist is not None and not dist.has_metadata('PKG-INFO'):
dist._version = pkg_resources.safe_version(str(attrs['version']))
self._patched_dist = dist
def __init__(self, attrs=None):
have_package_data = hasattr(self, "package_data")
if not have_package_data:
self.package_data = {}
attrs = attrs or {}
self.dist_files = []
# Filter-out setuptools' specific options.
self.src_root = attrs.pop("src_root", None)
self.patch_missing_pkg_info(attrs)
self.dependency_links = attrs.pop('dependency_links', [])
self.setup_requires = attrs.pop('setup_requires', [])
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
vars(self).setdefault(ep.name, None)
_Distribution.__init__(self, {
k: v for k, v in attrs.items()
if k not in self._DISTUTILS_UNSUPPORTED_METADATA
})
# Fill-in missing metadata fields not supported by distutils.
# Note some fields may have been set by other tools (e.g. pbr)
# above; they are taken preferrentially to setup() arguments
for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
for source in self.metadata.__dict__, attrs:
if option in source:
value = source[option]
break
else:
value = default() if default else None
setattr(self.metadata, option, value)
self.metadata.version = self._normalize_version(
self._validate_version(self.metadata.version))
self._finalize_requires()
@staticmethod
def _normalize_version(version):
if isinstance(version, setuptools.sic) or version is None:
return version
normalized = str(packaging.version.Version(version))
if version != normalized:
tmpl = "Normalizing '{version}' to '{normalized}'"
warnings.warn(tmpl.format(**locals()))
return normalized
return version
@staticmethod
def _validate_version(version):
if isinstance(version, numbers.Number):
# Some people apparently take "version number" too literally :)
version = str(version)
if version is not None:
try:
packaging.version.Version(version)
except (packaging.version.InvalidVersion, TypeError):
warnings.warn(
"The version specified (%r) is an invalid version, this "
"may not work as expected with newer versions of "
"setuptools, pip, and PyPI. Please see PEP 440 for more "
"details." % version
)
return setuptools.sic(version)
return version
def _finalize_requires(self):
"""
Set `metadata.python_requires` and fix environment markers
in `install_requires` and `extras_require`.
"""
if getattr(self, 'python_requires', None):
self.metadata.python_requires = self.python_requires
if getattr(self, 'extras_require', None):
for extra in self.extras_require.keys():
# Since this gets called multiple times at points where the
# keys have become 'converted' extras, ensure that we are only
# truly adding extras we haven't seen before here.
extra = extra.split(':')[0]
if extra:
self.metadata.provides_extras.add(extra)
self._convert_extras_requirements()
self._move_install_requirements_markers()
def _convert_extras_requirements(self):
"""
Convert requirements in `extras_require` of the form
`"extra": ["barbazquux; {marker}"]` to
`"extra:{marker}": ["barbazquux"]`.
"""
spec_ext_reqs = getattr(self, 'extras_require', None) or {}
self._tmp_extras_require = defaultdict(list)
for section, v in spec_ext_reqs.items():
# Do not strip empty sections.
self._tmp_extras_require[section]
for r in pkg_resources.parse_requirements(v):
suffix = self._suffix_for(r)
self._tmp_extras_require[section + suffix].append(r)
@staticmethod
def _suffix_for(req):
"""
For a requirement, return the 'extras_require' suffix for
that requirement.
"""
return ':' + str(req.marker) if req.marker else ''
def _move_install_requirements_markers(self):
"""
Move requirements in `install_requires` that are using environment
markers `extras_require`.
"""
# divide the install_requires into two sets, simple ones still
# handled by install_requires and more complex ones handled
# by extras_require.
def is_simple_req(req):
return not req.marker
spec_inst_reqs = getattr(self, 'install_requires', None) or ()
inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs))
simple_reqs = filter(is_simple_req, inst_reqs)
complex_reqs = itertools.filterfalse(is_simple_req, inst_reqs)
self.install_requires = list(map(str, simple_reqs))
for r in complex_reqs:
self._tmp_extras_require[':' + str(r.marker)].append(r)
self.extras_require = dict(
(k, [str(r) for r in map(self._clean_req, v)])
for k, v in self._tmp_extras_require.items()
)
def _clean_req(self, req):
"""
Given a Requirement, remove environment markers and return it.
"""
req.marker = None
return req
def _parse_config_files(self, filenames=None):
"""
Adapted from distutils.dist.Distribution.parse_config_files,
this method provides the same functionality in subtly-improved
ways.
"""
from configparser import ConfigParser
# Ignore install directory options if we have a venv
if sys.prefix != sys.base_prefix:
ignore_options = [
'install-base', 'install-platbase', 'install-lib',
'install-platlib', 'install-purelib', 'install-headers',
'install-scripts', 'install-data', 'prefix', 'exec-prefix',
'home', 'user', 'root']
else:
ignore_options = []
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
with io.open(filename, encoding='utf-8') as reader:
if DEBUG:
self.announce(" reading {filename}".format(**locals()))
parser.read_file(reader)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != '__name__' and opt not in ignore_options:
val = parser.get(section, opt)
opt = opt.replace('-', '_')
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if 'global' in self.command_options:
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ('verbose', 'dry_run'): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as e:
raise DistutilsOptionError(e) from e
def _set_command_options(self, command_obj, option_dict=None):
"""
Set the options for 'command_obj' from 'option_dict'. Basically
this means copying elements of a dictionary ('option_dict') to
attributes of an instance ('command').
'command_obj' must be a Command instance. If 'option_dict' is not
supplied, uses the standard option dictionary for this command
(from 'self.command_options').
(Adopted from distutils.dist.Distribution._set_command_options)
"""
command_name = command_obj.get_command_name()
if option_dict is None:
option_dict = self.get_option_dict(command_name)
if DEBUG:
self.announce(" setting options for '%s' command:" % command_name)
for (option, (source, value)) in option_dict.items():
if DEBUG:
self.announce(" %s = %s (from %s)" % (option, value,
source))
try:
bool_opts = [translate_longopt(o)
for o in command_obj.boolean_options]
except AttributeError:
bool_opts = []
try:
neg_opt = command_obj.negative_opt
except AttributeError:
neg_opt = {}
try:
is_string = isinstance(value, str)
if option in neg_opt and is_string:
setattr(command_obj, neg_opt[option], not strtobool(value))
elif option in bool_opts and is_string:
setattr(command_obj, option, strtobool(value))
elif hasattr(command_obj, option):
setattr(command_obj, option, value)
else:
raise DistutilsOptionError(
"error in %s: command '%s' has no such option '%s'"
% (source, command_name, option))
except ValueError as e:
raise DistutilsOptionError(e) from e
def parse_config_files(self, filenames=None, ignore_option_errors=False):
"""Parses configuration files from various levels
and loads configuration.
"""
self._parse_config_files(filenames=filenames)
parse_configuration(self, self.command_options,
ignore_option_errors=ignore_option_errors)
self._finalize_requires()
def fetch_build_eggs(self, requires):
"""Resolve pre-setup requirements"""
resolved_dists = pkg_resources.working_set.resolve(
pkg_resources.parse_requirements(requires),
installer=self.fetch_build_egg,
replace_conflicting=True,
)
for dist in resolved_dists:
pkg_resources.working_set.add(dist, replace=True)
return resolved_dists
def finalize_options(self):
"""
Allow plugins to apply arbitrary operations to the
distribution. Each hook may optionally define a 'order'
to influence the order of execution. Smaller numbers
go first and the default is 0.
"""
group = 'setuptools.finalize_distribution_options'
def by_order(hook):
return getattr(hook, 'order', 0)
eps = map(lambda e: e.load(), pkg_resources.iter_entry_points(group))
for ep in sorted(eps, key=by_order):
ep(self)
def _finalize_setup_keywords(self):
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
value = getattr(self, ep.name, None)
if value is not None:
ep.require(installer=self.fetch_build_egg)
ep.load()(self, ep.name, value)
def _finalize_2to3_doctests(self):
if getattr(self, 'convert_2to3_doctests', None):
# XXX may convert to set here when we can rely on set being builtin
self.convert_2to3_doctests = [
os.path.abspath(p)
for p in self.convert_2to3_doctests
]
else:
self.convert_2to3_doctests = []
def get_egg_cache_dir(self):
egg_cache_dir = os.path.join(os.curdir, '.eggs')
if not os.path.exists(egg_cache_dir):
os.mkdir(egg_cache_dir)
windows_support.hide_file(egg_cache_dir)
readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
with open(readme_txt_filename, 'w') as f:
f.write('This directory contains eggs that were downloaded '
'by setuptools to build, test, and run plug-ins.\n\n')
f.write('This directory caches those eggs to prevent '
'repeated downloads.\n\n')
f.write('However, it is safe to delete this directory.\n\n')
return egg_cache_dir
def fetch_build_egg(self, req):
"""Fetch an egg needed for building"""
from setuptools.installer import fetch_build_egg
return fetch_build_egg(self, req)
def get_command_class(self, command):
"""Pluggable version of get_command_class()"""
if command in self.cmdclass:
return self.cmdclass[command]
eps = pkg_resources.iter_entry_points('distutils.commands', command)
for ep in eps:
ep.require(installer=self.fetch_build_egg)
self.cmdclass[command] = cmdclass = ep.load()
return cmdclass
else:
return _Distribution.get_command_class(self, command)
def print_commands(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.print_commands(self)
def get_command_list(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.get_command_list(self)
def include(self, **attrs):
"""Add items to distribution that are named in keyword arguments
For example, 'dist.include(py_modules=["x"])' would add 'x' to
the distribution's 'py_modules' attribute, if it was not already
there.
Currently, this method only supports inclusion for attributes that are
lists or tuples. If you need to add support for adding to other
attributes in this or a subclass, you can add an '_include_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'include()'. So, 'dist.include(foo={"bar":"baz"})'
will try to call 'dist._include_foo({"bar":"baz"})', which can then
handle whatever special inclusion logic is needed.
"""
for k, v in attrs.items():
include = getattr(self, '_include_' + k, None)
if include:
include(v)
else:
self._include_misc(k, v)
def exclude_package(self, package):
"""Remove packages, modules, and extensions in named package"""
pfx = package + '.'
if self.packages:
self.packages = [
p for p in self.packages
if p != package and not p.startswith(pfx)
]
if self.py_modules:
self.py_modules = [
p for p in self.py_modules
if p != package and not p.startswith(pfx)
]
if self.ext_modules:
self.ext_modules = [
p for p in self.ext_modules
if p.name != package and not p.name.startswith(pfx)
]
def has_contents_for(self, package):
"""Return true if 'exclude_package(package)' would do something"""
pfx = package + '.'
for p in self.iter_distribution_names():
if p == package or p.startswith(pfx):
return True
def _exclude_misc(self, name, value):
"""Handle 'exclude()' for list/tuple attrs without a special handler"""
if not isinstance(value, sequence):
raise DistutilsSetupError(
"%s: setting must be a list or tuple (%r)" % (name, value)
)
try:
old = getattr(self, name)
except AttributeError as e:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
) from e
if old is not None and not isinstance(old, sequence):
raise DistutilsSetupError(
name + ": this setting cannot be changed via include/exclude"
)
elif old:
setattr(self, name, [item for item in old if item not in value])
def _include_misc(self, name, value):
"""Handle 'include()' for list/tuple attrs without a special handler"""
if not isinstance(value, sequence):
raise DistutilsSetupError(
"%s: setting must be a list (%r)" % (name, value)
)
try:
old = getattr(self, name)
except AttributeError as e:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
) from e
if old is None:
setattr(self, name, value)
elif not isinstance(old, sequence):
raise DistutilsSetupError(
name + ": this setting cannot be changed via include/exclude"
)
else:
new = [item for item in value if item not in old]
setattr(self, name, old + new)
def exclude(self, **attrs):
"""Remove items from distribution that are named in keyword arguments
For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
the distribution's 'py_modules' attribute. Excluding packages uses
the 'exclude_package()' method, so all of the package's contained
packages, modules, and extensions are also excluded.
Currently, this method only supports exclusion from attributes that are
lists or tuples. If you need to add support for excluding from other
attributes in this or a subclass, you can add an '_exclude_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'exclude()'. So, 'dist.exclude(foo={"bar":"baz"})'
will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
handle whatever special exclusion logic is needed.
"""
for k, v in attrs.items():
exclude = getattr(self, '_exclude_' + k, None)
if exclude:
exclude(v)
else:
self._exclude_misc(k, v)
def _exclude_packages(self, packages):
if not isinstance(packages, sequence):
raise DistutilsSetupError(
"packages: setting must be a list or tuple (%r)" % (packages,)
)
list(map(self.exclude_package, packages))
def _parse_command_opts(self, parser, args):
# Remove --with-X/--without-X options when processing command args
self.global_options = self.__class__.global_options
self.negative_opt = self.__class__.negative_opt
# First, expand any aliases
command = args[0]
aliases = self.get_option_dict('aliases')
while command in aliases:
src, alias = aliases[command]
del aliases[command] # ensure each alias can expand only once!
import shlex
args[:1] = shlex.split(alias, True)
command = args[0]
nargs = _Distribution._parse_command_opts(self, parser, args)
# Handle commands that want to consume all remaining arguments
cmd_class = self.get_command_class(command)
if getattr(cmd_class, 'command_consumes_arguments', None):
self.get_option_dict(command)['args'] = ("command line", nargs)
if nargs is not None:
return []
return nargs
def get_cmdline_options(self):
"""Return a '{cmd: {opt:val}}' map of all command-line options
Option names are all long, but do not include the leading '--', and
contain dashes rather than underscores. If the option doesn't take
an argument (e.g. '--quiet'), the 'val' is 'None'.
Note that options provided by config files are intentionally excluded.
"""
d = {}
for cmd, opts in self.command_options.items():
for opt, (src, val) in opts.items():
if src != "command line":
continue
opt = opt.replace('_', '-')
if val == 0:
cmdobj = self.get_command_obj(cmd)
neg_opt = self.negative_opt.copy()
neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
for neg, pos in neg_opt.items():
if pos == opt:
opt = neg
val = None
break
else:
raise AssertionError("Shouldn't be able to get here")
elif val == 1:
val = None
d.setdefault(cmd, {})[opt] = val
return d
def iter_distribution_names(self):
"""Yield all packages, modules, and extension names in distribution"""
for pkg in self.packages or ():
yield pkg
for module in self.py_modules or ():
yield module
for ext in self.ext_modules or ():
if isinstance(ext, tuple):
name, buildinfo = ext
else:
name = ext.name
if name.endswith('module'):
name = name[:-6]
yield name
def handle_display_options(self, option_order):
"""If there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
"""
import sys
if self.help_commands:
return _Distribution.handle_display_options(self, option_order)
# Stdout may be StringIO (e.g. in tests)
if not isinstance(sys.stdout, io.TextIOWrapper):
return _Distribution.handle_display_options(self, option_order)
# Don't wrap stdout if utf-8 is already the encoding. Provides
# workaround for #334.
if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
return _Distribution.handle_display_options(self, option_order)
# Print metadata in UTF-8 no matter the platform
encoding = sys.stdout.encoding
errors = sys.stdout.errors
newline = sys.platform != 'win32' and '\n' or None
line_buffering = sys.stdout.line_buffering
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
try:
return _Distribution.handle_display_options(self, option_order)
finally:
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), encoding, errors, newline, line_buffering)
class DistDeprecationWarning(SetuptoolsDeprecationWarning):
"""Class for warning about deprecations in dist in
setuptools. Not ignored by default, unlike DeprecationWarning."""
``` |
Alonso S. Perales (October 17, 1898 May 9, 1960) was an American lawyer, diplomat, and civil rights activist based in Texas. He was a founder of the League of United Latin American Citizens (LULAC) and served as the second president, helping write its constitution. Perales also served as a diplomat in the Eisenhower administration.
Early life
Perales was born on October 17, 1898, in Alice, Texas to Susana (née Sandoval) and Nicolás Perales. At the age of 6, he was orphaned. He worked as a child and later married local bookstore owner, Marta Pérez. Together, they had a daughter and two sons.
Raised by Crecensio Treviño and Eugenia Naranjo, he attended school in Alice and later graduated from Draughon’s Business College in San Antonio in 1915.
When World War I broke out, Perales immigrated to the United States and joined the United States Army as a Field Army Clerk. After serving, he received an honorary discharge in 1920. He then took and passed the civil service examination and moved to Washington D.C. during this time he worked for the Department of Commerce for about a year and a half. While in Washington D.C., he continued his studies, receiving a Master of Arts degree from the National University's School of Economics and Government. He received his law degree from what would become the George Washington University Law School in 1925. He moved to Texas shortly afterward as one of the first Spaniards to practice law in the United States.
Career
Diplomacy
In the 1920s through the 1930s, Perales served as a diplomat, traveling to the Dominican Republic, Cuba, Nicaragua, Mexico, Chile, and the West Indies on various diplomatic missions. Later, in 1945, he served as legal counsel to the Nicaraguan delegation at the United Nations Conference on International Organization (UNCIO), also known as the San Francisco Conference. This conference took place from 25 April 1945 to 26 June 1945 in San Francisco, California. During this meeting, delegates reviewed the 1944 Dumbarton Oaks agreements and created the Charter of the United Nations.
Civil rights
Perales was active in civil rights advocacy and according to scholars, is one of the most influential Hispanic Americans of his time. He moved back to Texas and dedicated his life to combatting discrimination against people of Mexican descent through law, advocacy, and his writings, including two volumes of En Defensa de mi raza (In Defense of My People), first published in 1937. These volumes included essays, letters, speeches, and work by other intellectuals on the problem of discrimination in Texas. His book, Are We Good Neighbors?, published in 1948 by Artes Gráficas, examined the discrimination, exploitation, and injustices faced by people of Mexican and Latin American descent throughout the United States. Are We Good Neighbors? also includes affidavits from the public that detail these incidents of discrimination.
In San Antonio, Texas, Perales collaborated with Maury Maverick. And in the 1940s, he petitioned to introduce a bill in the Texas legislature that would prohibit discrimination based on race.
LULAC
During the 1930s, Mexican Americans, as well as other communities of Latin American descent, began organizing in response to Juan Crow, or José Cuervo, laws in Texas. This resulted in the formation of Order of the Sons of America (El Orden Hijos de América) and the Order of the Knights of America (El Orden Caballeros de América), Mexican American organizations with various statewide chapters. Between 1927-1928, Perales and Ben Garza, leader of the Order of the Sons of America Council #4 in Corpus Christi, discussed how to merge these organizations.
In 1929, these organizations, along with the League of Latin American Citizens (headed by Perales), decided to merge to form the League of United Latin American Citizens (LULAC). Perales, thus, joined Garza, Manuel C. Gonzales, Andres de Luna, Louis Wilmot, Rafael Galvan Sr., Juan Galván, Vicente Lozano, José Tomás Canales, Edwardo Idar, Mauro Machado, J. Luz Saenz, Juan C. Solis, and E.H. Marin to found what would become the oldest Hispanic civil rights organization in the country, LULAC. Perales, with the help of Canales and Idar, drafted the LULAC constitution.
Perales went on to form LULAC Council 16 in San Antonio, Texas, and served as LULAC's second president. As president of LULAC, he focused on the creation of 24 new councils across South Texas. According to the LULAC News (LULAC's official newsletter), Perales helped to cement the organization's spirit: "LULAC is much indebted to the efforts and sacrifices put forth by these pioneers like Alonso S. Perales. It was this spirit of courage - tenacity, and self-sacrifice - during the early history of LULAC that became known as the 'LULAC Spirit.'"
Among his efforts was also the 1930 defeat of House Resolution 6465, also known as the Box Bill, introduced by U.S. Representative John C. Box, which proposed expanding the Immigration Act of 1924 to include quotas on Mexican immigrants to the United States. Perales, together with his fellow LULACers, Canales and Garza, traveled to Washington D.C. to testify in US congressional hearings against the bill. The bill did not pass.
Honors and Memorials
In 1977, the Edgewood Independent School District in San Antonio named the Alonso S. Perales Elementary School in his honor.
In 2011, the Perales family donated his archive to Arte Público Press and its historical arm, Recovering the US Hispanic Literary Heritage program. The collection includes correspondence, historic LULAC papers and publications, photographs, and rare manuscripts. It is housed at the University of Houston's MD Anderson Libraries Special Collections. Shortly after the donation, the organization held a Recovering the US Hispanic Literary Heritage academic conference dedicated to the work of Perales. The edited collection of scholarly essays, In Defense of my people: Alonso S. Perales and the development of Mexican-American public intellectuals, edited by Michael A. Olivas, was a result of the scholarship presented at the conference.
Using the collection stated above, A digital humanities project which illustrates visually the spread of these correspondences, documents, pictures, and manuscripts related to Perales and his work as well as information directly related to LULAC. The project is titled The Alonso S. Perales Correspondence.
Works
En Defensa de mi raza, vol. I & II. (Artes Gráficas, 1937)
Are We Good Neighbors? (Artes Gráficas, 1948)
"La Evolución De La Raza Mexicana En Texas," La Prensa (San Antonio, TX), Sep. 13, 1927.
Further reading
Cynthia Orozco. Pioneer of Mexican American Civil Rights: Alonso S. Perales. (Arte Público Press, 2020).
Michael A. Olivas (ed.), In Defense of My People: Alonso S. Perales and the Development of Mexican-American Public Intellectuals. (Arte Público Press, 2012).
Adela Sloss-Vento, Alonso S. Perales: His Struggles for the Rights of Mexican Americans. (Austin, Texas: Artes Graficas, 1977).
Amy Waters, Yarsinske. All For One, One For All: A Celebration of 75 Years of the League of United Latin American Citizens. (The Donning Company Publishers, 2004).
References
External links
Texas State Historical Association Handbook entry on Alonso S. Perales
League of United Latin American Citizens (LULAC)
1898 births
1960 deaths
American civil rights lawyers
George Washington University Law School alumni
League of United Latin American Citizens activists |
```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';
// MODULES //
var bench = require( '@stdlib/bench' );
var pow = require( '@stdlib/math/base/special/pow' );
var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
var zeros = require( '@stdlib/ndarray/base/zeros' );
var pkg = require( './../package.json' ).name;
var zerosLike = require( './../lib' );
// FUNCTIONS //
/**
* Creates a benchmark function.
*
* @private
* @param {PositiveInteger} len - array length
* @returns {Function} benchmark function
*/
function createBenchmark( len ) {
var x = zeros( 'int32', [ len ], 'row-major' );
return benchmark;
/**
* Benchmark function.
*
* @private
* @param {Benchmark} b - benchmark instance
*/
function benchmark( b ) {
var arr;
var i;
b.tic();
for ( i = 0; i < b.iterations; i++ ) {
arr = zerosLike( x );
if ( arr.length !== len ) {
b.fail( 'unexpected length' );
}
}
b.toc();
if ( !isndarrayLike( arr ) ) {
b.fail( 'should return an ndarray' );
}
b.pass( 'benchmark finished' );
b.end();
}
}
// MAIN //
/**
* Main execution sequence.
*
* @private
*/
function main() {
var len;
var min;
var max;
var f;
var i;
min = 1; // 10^min
max = 6; // 10^max
for ( i = min; i <= max; i++ ) {
len = pow( 10, i );
f = createBenchmark( len );
bench( pkg+':dtype=int32,size='+len, f );
}
}
main();
``` |
```shell
Let's play the blame game
Specify a commit by its ancestry
Specify a range of commits using double dot syntax
Remember the results of previous hunk conflicts
Sharing data by bundling
``` |
Florin Gheorghe Nohai (born 13 April 1981) is a Romanian former footballer who played as a right back for teams such as Ceahlăul Piatra Neamț, Gaz Metan Mediaș or ACS Poli Timișoara, among others.
References
External links
Florin Nohai at frf-ajf.ro
1981 births
Living people
Footballers from Piatra Neamț
Romanian men's footballers
Men's association football defenders
Liga I players
Liga II players
CSM Ceahlăul Piatra Neamț players
CS Gaz Metan Mediaș players
ACS Poli Timișoara players
FC Ripensia Timișoara players
CSC Dumbrăvița players |
Tappen may refer to:
Places
Tappen Park, a park on Staten Island in New York City
Tappen, North Dakota, a small city in North Dakota
Tappen, British Columbia, a small city in British Columbia
Games
Tappen (card game), a 4-player, tarock card game, also known as Dobbm, played in Austria
Viennese Tappen, a 3-player, tarock card game, also known as Tapp Tarock, played in Austria
People
Tappen (surname)
Other
Tappen (biology), an indigestible mass found in the intestines of bears after hibernation |
Atatláhuca–San Miguel Mixtec is a diverse Mixtec language of Oaxaca.
Dialects
Egland & Bartholomew found six dialects (with > ≈80% internal intelligibility) which had about 70% mutual intelligibility with each other:
San Esteban Atatláhuca [mib] + Santa Lucía Monteverde [mdv]
Molinos
Itundujía [mce]
Yosondúa [mpm] + San Miguel el Grande + Chalcatongo [mig]
Yolotepec [xtt]
Teita [xtj]
Ethnologue notes that two additional varieties Egland & Bartholomew had not looked at, Sinicahua [xti] and Tijaltepec [xtl], are about as similar.
References
Alexander, Ruth Mary. 1980. Gramática mixteca de Atatláhuca. Gramática yuhu sasau jee cahan ñayuu San Esteban Atatláhuca. Instituto Lingüístico de Verano. México. Series: Gramáticas de Lenguas Indígenas de México; 2.
Macaulay, Monica. 1996. A grammar of Chalcatongo Mixtec, University of California Publications in Linguistics. .
Mixtec language |
The NBL1 is a semi-professional basketball league in Australia run by the National Basketball League (NBL). The league consists of five conference: NBL1 South, NBL1 North, NBL1 Central, NBL1 West and NBL1 East, with each consisting of both men's and women's competitions. Each conference is run by their respective state governing body, with the league including 74 clubs from across every state and territory.
The NBL1 in 2019 was a single league and consisted of one conference. That conference would go on to become the South Conference in 2020 after the inclusion of the former Queensland Basketball League (QBL) and South Australian Premier League saw them become the new North and Central conferences. The league grew to four conferences in 2021 with the inclusion of the former WA State Basketball League (SBL) and then five conferences in 2022 with the inclusion of the former NSW Waratah League.
History
In October 2018, following the demise of the South East Australian Basketball League (SEABL), Basketball Victoria announced a new senior elite league to take the reins as Australia's pre-eminent semi-professional basketball league. All Victorian-based SEABL teams joined the new league, while Eltham Wildcats, Knox Raiders, Ringwood Hawks and Waverley Falcons also joined the league from the Big V. The North-West Tasmania Thunder men and Launceston Tornadoes women also kept their place, as did Basketball Australia's Centre of Excellence teams. In February 2019, the league was named NBL1 after Basketball Victoria partnered with the National Basketball League (NBL).
After a successful first season in 2019, the NBL expanded the NBL1 in 2020 by introducing Basketball Victoria's inaugural 2019 league and teams as the new South Conference and partnering with Basketball Queensland and Basketball South Australia to make the Queensland Basketball League (QBL) and South Australian Premier League the new North and Central conferences. However, due to the COVID-19 pandemic, the 2020 season was cancelled for all three conferences.
In 2021, the league expanded to four conferences after partnering with Basketball Western Australia to make the State Basketball League (SBL) the new West Conference. The inaugural NBL1 National Finals was set to take place in 2021, comprising the champions of the four conferences. However, the event was cancelled due to the COVID-19 pandemic. The South Conference later cancelled the remaining weeks of its season due to ongoing complications with the pandemic.
In 2022, the league expanded to five conferences after partnering with Basketball New South Wales to make the Waratah League the new East Conference. Additionally, a club from Darwin, Northern Territory, the Darwin Salties, joined the North Conference in 2022 which saw the NBL1 become the first Australian sport league to have clubs based in and playing out of every state and territory in Australia. The NBL1 National Finals took place for the first time in 2022.
Conferences
South Conference
Founded in 2019, the South Conference was the only NBL1 conference during its inaugural season and predominantly consisted of teams from the defunct South East Australian Basketball League (SEABL). The South Conference currently has 20 clubs spread across Victoria, Tasmania and South Australia.
North Conference
In 2020, the North Conference joined the league, becoming the second conference introduced following NBL1's merger with the former Queensland Basketball League (QBL). The North Conference currently consists of 14 clubs, with 13 based in Queensland and one based in the Northern Territory.
Central Conference
In 2020, the Central Conference joined the league, becoming the third conference introduced following NBL1's merger with the former South Australian Premier League. The Central Conference currently consists of 10 clubs, all of which are based in South Australia.
West Conference
In 2021, the West Conference joined the league, becoming the fourth conference introduced following NBL1's merger with the former Western Australian State Basketball League (SBL). The West Conference currently consists of 14 clubs, all of which are based in Western Australia.
East Conference
In 2022, the East Conference joined the league, becoming the fifth conference introduced following NBL1's merger with the former New South Wales Waratah League. The East Conference currently consists of 16 clubs, with 14 based in New South Wales and two based in the Australian Capital Territory.
Current clubs
Spread across the five conferences, a total of 74 clubs compete in the league.
South Conference: 20 clubs (includes 19 female teams and 19 male teams)
North Conference: 14 clubs
Central Conference: 10 clubs
West Conference: 14 clubs
East Conference: 16 clubs
List of National champions
References
External links
"NBL1 to return in 2021 with blockbuster schedule" at nbl1.com.au
Basketball leagues in Australia
2019 establishments in Australia
Sports leagues established in 2019
National Basketball League (Australia)
Professional sports leagues in Australia |
"Fifty Shades of Grayson" is the tenth episode of the fifth season of the American series The Vampire Diaries and the series' 99th episode overall. "Fifty Shades of Grayson" was originally aired on December 12, 2013, on The CW. The episode was written by Caroline Dries and directed by Kellie Cyrus.
Plot
Damon (Ian Somerhalder) escapes from his cell and returns to the Salvatore house looking for Elena (Nina Dobrev). Instead, he discovers Katherine who just ran from Stefan's (Paul Wesley) bedroom because she found more grey hair and panicked. Damon asks her if she has seen Elena. Katherine says she has not, and not so innocently mentions her tryst with Stefan the previous night.
Damon tells Stefan he cannot find Elena and they both head to the university to find Aaron (Shaun Sipos) since he is the only one who can help them track her down. Aaron is surprised seeing Damon alive since he shot him in the head back in Wes' prison cell. Aaron tries to run with no luck, and the two brothers use him as leverage to get Elena back. Aaron calls Wes (Rick Cosnett) and tells him that Damon and Stefan will kill him if he does not give them Elena. Wes agrees to the exchange and tells Aaron to meet him at his classroom.
But Wes sets a trap instead. He releases Enzo (Michael Malarkey), sending him to the classroom to deal with his own unresolved business with Damon. Before Wes sends him, he injects Enzo with poison telling him not to come back for the antidote unless he kills Damon.
Damon, Aaron and Stefan arrive at Wes' classroom but they find only Enzo. Stefan calls Wes but Wes refuses to come and threatens to kill Elena if they hurt Aaron. Stefan retorts that the threat goes both ways. Damon volunteers to kill Aaron when Stefan tells him about the phone call and Aaron, to save his life, reveals he has Augustine files in his dorm room. But Enzo, who wants them to listen to what happened to him after Damon failed to save him several decades ago, becomes quite aggravated and demands that Damon stay to listen when Aaron and Stefan leave for the dorm.
Enzo is still mad at Damon for leaving him behind and after a while they start fighting. He throws Damon through a window but Damon tells him he will not fight him back. Enzo informs him about the poison and that he has to kill him but the poison acts quickly on him and he collapses. Damon takes him back to the lab and injects him with everything that writes "antidote" on it. One of them works and Enzo wakes up. Damon explains him how he was able to leave him behind and the price he paid for it but Enzo does not care and he tells him that he will always be a monster.
Meanwhile, Stefan and Aaron arrive at the dorm and Aaron attempts to kill Stefan with one of the vampire weapons he has there. Stefan realizes his intentions and he stops him but before he kills him Aaron tells him the rest of Damon's story and how Damon killed all his family members for generations just to revenge. Stefan, after hearing Damon's revenge plan, lets Aaron live saying that not all vampires are like his brother. Stefan turns to leave but Aaron gives him all Wes' files before he goes.
In the meantime, Wes keeps Elena in the basement of her father's old medical practice. She wakes up and Wes informs her about her father's experiments and Elena stars having some memories of her as a little girl (Kayla Madison) with her father (Jason MacDonald). Despite the tortures she remembers that her father was doing all these to help people, for example to use the vampire blood as a cure to many diseases.
Wes prepares to inject Elena with the serum that will make her crave for vampire blood instead of human blood, but before can do it, Stefan arrives and saves her. Elena gets her father's journal before they leave and Aaron comes later on the basement finding Wes unconscious. He wakes him up and tells him that he is not helping people with this research and he is also furious at him because he sold him out to the Salvatore brothers without caring for his life. He tells him that he does not want to see him again and he leaves taking with him the syringe that contains the serum that Wes was going to inject Elena with.
Back at home, Elena reads her father's journal while Damon comes in and is mad at her because she defends him all the time, no matter what he has done in the past and how horrible it was. He tells her that he cannot change and he does not want to change her so he breaks up with her.
In the meantime, Katherine decides to solve her problem by working out and he asks Matt's (Zach Roerig) help. Matt calls Nadia (Olga Fonda) who is mad at Katherine for trying to kill herself without saying goodbye. Katherine asks about forgiveness and Nadia has a plan that might help Katherine; to put her spirit into another body like a traveler does. Katherine declines her offer because she likes her current body and Stefan likes it as well. Nadia realizes that the forgiveness Katherine asked was about Stefan and not her and she leaves disappointed. Before she leaves, she meets Matt and asks him to hold on to the traveler's knife in case Katherine changes her mind.
Katherine does change her mind after a conversation she has with Stefan that makes her think that there is yet hope for a relationship with him and at the end of the episode she calls Nadia to tell her she has changed his mind. She wants to make the exchange, but before she gets out of the house she has a heart attack and collapses.
Featured music
In the "Fifty Shades of Grayson" episode we can hear the songs:
"The Love Club" by Lorde
"Where It Ends, Where It Begins" by Sacco
"Fitzpleasure" by Alt-J
"Slave" by Yeah Yeah Yeahs
"All I Want" by Kodaline
Reception
Ratings
In its original American broadcast, "Fifty Shades of Grayson" was watched by 2.44 million; slightly up by 0.08 from the previous episode.
Reviews
"Fifry Shades of Grayson" received mixed reviews.
Cindy McLennan of Television Without Pity" gave an A− rate to the episode.
Stephanie Flasher of TV After Dark also gave and A− rated to the episode saying that it was a great episode for a midseason finale and it was a game changer. "The episode had everything TVD fans have come to expect from the supernatural drama. There was a little something for everyone; suspense, drama, sorrow, heart break and even a little humor."
Thedude35 of Bitch Stole My Remote gave a good review to the episode saying that it was not bad for a midseason finale. "Besides a clever, laugh out loud title, ‘Fifty Shades of Grayson’ brings us some humour to break up the torture, death threats and broken hearts a-plenty."
Jen from TV Overmind said that the episode was a little bit "overwhelming" and "predictable" for a midseason finale. "I was expecting a bigger cliffhanger than just Katherine collapsing from a heart attack. That ending seemed less effective especially since we saw that she’ll be just barely hanging on in the hospital in the preview for the next episode in January. The little amount of time she’ll have left will probably be just enough time for Nadia, Matt, and Stefan (her only friends in Mystic Falls) to save her life. At least let’s hope they can save her, otherwise I’d be very disappointed."
Carrie Raisler from The A.V. Club gave a C− rate to the episode stating: "...it’s become readily apparent that the show is in the midst of a good, old-fashioned slump."
Matt Richenthal of TV Fanatic rated the episode with 2.1/5 saying that it was a little bit of disappointment. "The Vampire Diaries has become a victim of its own success. Especially on a midseason finale, fans expect violence. They expect shocks. They look forward to twists and turns and one doozy of a cliffhanger. But The Vampire Diaries Season 5 Episode 10 offered up none of the above."
Mike from No White Noise gave the episode 1.5/4 saying that the episode was not particularly awful but "it was sort of like, “Sure. That satisfied the requirements for one hour.”"
References
External links
2013 American television episodes
The Vampire Diaries (season 5) episodes |
The Diamond DART is a series of tandem, two-seat civilian and military turboprop trainers manufactured by Austrian Diamond Aircraft, "DART" meaning Diamond Aircraft Reconnaissance Trainer.
Development
The DART-450 made its first flight on 17 May 2016.
Certification of the $3.1 million plane was expected by the end of 2017.
The first two deliveries were to be for a non-certificated kit version in 2017, while a certificated aircraft was expected to be delivered in September 2018. Diamond intends to deliver 50 aircraft per year.
The third prototype was expected to fly in late 2017, powered by a 550hp (410kW) GE Aviation engine.
Design
The DART-450 is built predominately from carbon fibre. It is powered by a Ivchenko-Progress Motor Sich AI-450S turboprop engine, driving a five-bladed MT Propeller. The cockpit accommodates two crew on ejection seats. The avionics are provided by Garmin and the fuselage is able to mount an optional retractable surveillance camera, plus other equipment.
Variants
Diamond DART-450
First flown on 17 May 2016. It has a Ivchenko-Progress Motor Sich AI-450S turboprop, weighs empty and has a max takeoff weight.
Diamond DART-550
Version powered by a General Electric GE H75-100 turboprop, first flown on 24 May 2018. It has eight hours endurance, Martin-Baker MK16 ejection seats, a Garmin G3000 cockpit, 1,600 kg (3,527 lbs) OEW, 2,400 kg (5,291 lbs) MTOW.
Diamond DART-750
Upgrade to the Pratt & Whitney Canada PT6 turboprop engine rated at 750 hp (560 kW). First flight on 16 June 2023.
CETC TA-20
Chinese licensed locally manufactured variant of the DART-450 utilizing alternate Chinese avionics. It is being proposed as a possible candidate for the development of a basic military trainer aircraft for the People's Liberation Army Air Force. The aircraft had its first flight on 12 June 2023.
Specifications (DART-450, utility (reconnaissance) configuration)
See also
References
External links
Dart series
Single-engined tractor aircraft
Low-wing aircraft
Single-engined turboprop aircraft
Aircraft first flown in 2016 |
The 1979–80 Scottish Cup was the 95th staging of Scotland's most prestigious football knockout competition. The Cup was won by Celtic who defeated Rangers in the final. The match was marred by crowd trouble which resulted in violent clashes between rival fans and led to the current ban on alcohol at Scottish grounds.
First round
Replays
Second Replays
Second round
Replays
Third round
Replays
Second Replays
Fourth round
Replays
Quarter-finals
Replays
Semi-finals
Final
See also
1979–80 in Scottish football
1979–80 Scottish League Cup
References
Scottish Cup seasons
Cup |
```shell
#!/bin/bash
set -x
UNTAR_COMPONENT_NAME=$1
copy_pkg_files_to_rocm() {
local comp_folder=$1
local comp_pkg_name=$2
cd "${OUT_DIR}/${PKGTYPE}/${comp_folder}"|| exit 2
if [ "${PKGTYPE}" = 'deb' ]; then
dpkg-deb -x ${comp_pkg_name}_*.deb pkg/
else
mkdir pkg && pushd pkg/ || exit 2
if [[ "${comp_pkg_name}" != *-dev* ]]; then
rpm2cpio ../${comp_pkg_name}-*.rpm | cpio -idmv
else
rpm2cpio ../${comp_pkg_name}el-*.rpm | cpio -idmv
fi
popd || exit 2
fi
ls ./pkg -alt
${SUDO} cp -r ./pkg${ROCM_PATH}/* "${ROCM_PATH}" || exit 2
rm -rf pkg/
}
get_os_name() {
local os_name
os_name=$(grep -oP '^NAME="\K.*(?=")' < /etc/os-release)
echo "${os_name,,}"
}
set_pkg_type() {
local os_name
os_name=$(grep -oP '^NAME="\K.*(?=")' < /etc/os-release)
[ "${os_name,,}" = ubuntu ] && echo "deb" || echo "rpm"
}
setup_rocm_compilers_hash_file() {
local clang_version
clang_version="$("${ROCM_PATH}/llvm/bin/clang" --version | head -n 1)"
printf '%s: %s\n' 'clang version' "${clang_version}" | tee "${OUT_DIR}/rocm_compilers_hash_file"
}
PKGTYPE=$(set_pkg_type)
case $UNTAR_COMPONENT_NAME in
(lightning)
if [ "${CCACHE_ENABLED}" == "true" ] ; then
setup_rocm_compilers_hash_file
fi
mkdir -p ${ROCM_PATH}/bin
printf '%s\n' > ${ROCM_PATH}/bin/target.lst gfx900 gfx906 gfx908 gfx803 gfx1030
if [ -e "${ROCM_PATH}/lib/llvm/bin/rocm.cfg" ]; then
sed -i '/-frtlib-add-rpath/d' ${ROCM_PATH}/lib/llvm/bin/rocm.cfg
elif [ -e "${ROCM_PATH}/llvm/bin/rocm.cfg" ]; then
sed -i '/-frtlib-add-rpath/d' ${ROCM_PATH}/llvm/bin/rocm.cfg
fi
;;
(hipify_clang)
copy_pkg_files_to_rocm hipify hipify-clang
;;
(hip_on_rocclr)
rm -f ${ROCM_PATH}/bin/hipcc.bat
;;
(openmp_extras)
copy_pkg_files_to_rocm openmp-extras openmp-extras-runtime
copy_pkg_files_to_rocm openmp-extras openmp-extras-dev
;;
(rocblas)
copy_pkg_files_to_rocm rocblas rocblas-dev
;;
(*)
echo "post processing is not required for ${UNTAR_COMPONENT_NAME}"
;;
esac
``` |
```css
CSS Specificity
Use `border-radius` to style rounded corners of an element
Use `:not()` to apply/unapply styles
Select items using negative `nth-child`
`:required` and `:optional` pseudo classes
``` |
Banko (Bambara: ߓߊߣߞߏ tr. Banko) is a rural commune and village in the Cercle of Dioïla in the Koulikoro Region of south-western Mali. The village lies on the Banifing River. The commune contains 31 villages.
References
External links
.
Communes of Koulikoro Region |
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta
name="viewport"
content="width=device-width, initial-scale=1, shrink-to-fit=no"
/>
<meta name="theme-color" content="#000" />
<link rel="icon" type="image/svg+xml" href="/favicon.ico" />
<title>Medium Zoom | React Markdown Demo</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
``` |
The crane kick is a fictionalized version of the Mae tobi geri (). The move was created by Daryll Vidal for the classic film The Karate Kid (1984). The move is taught by the character Mr. Miyagi to Daniel LaRusso and eventually used in the final scene with his arch rival Johnny Lawrence. The move involves a one-legged karate stance and launches into a flying jumping kick. The movie became synonymous with karate in the United States and helped popularize the martial art in that country. The kick is shown multiple times in the Karate Kid franchise, including the season five finale of Cobra Kai, where Daniel uses the crane kick to defeat the main antagonist of The Karate Kid Part III (1989), Terry Silver.
Usage and effectiveness
The move's effectiveness and practicality have been questioned by critics. The premise of the technique is to lure the opponent to move forward into a counterattack by appearing vulnerable. This vulnerability is created through two obvious tactical errors which an aggressive opponent would immediately take advantage of. First, standing tall with just one foot flat on the ground creates a stationary target for an opponent to strike. Second, spreading arms wide leaves the head and center of mass undefended. It is also worth noting this kick is an extreme feat of athleticism; it takes unusual leg strength and coordination for any fighter to leap off one foot (which is already bearing all their body weight) to deliver an effective strike with that same foot. Modified versions have been used effectively in Mixed Martial Arts, most notably by Lyoto Machida. Starting from a southpaw stance, Machida feinted with his left leg before leaping off his right foot to deliver an upwards right kick to the mouth of former UFC champion Randy Couture, earning a knockout victory. Commentators Mike Goldberg and Joe Rogan immediately noted the similarity to the crane kick.
In popular culture
In the videogame Street Fighter Alpha 2, the elderly character Gen uses a crane style. He uses it again when he returns in Street Fighter IV.
References
See also
Fujian White Crane
Tibetan White Crane
Karate techniques
The Karate Kid (franchise)
Fictional martial arts
Kicks |
István Javorek (born January 6, 1943 in eastern Europe) is a United States sports conditioning coach. Coach Javorek is the retired head strength and conditioning coach at Johnson County Community College, Kansas, United States. He supervised the strength and conditioning program for JCCC’s 18 sports and serves as a professor emeritus of fitness in the physical education department. He has been married to Julia Javorek since 1968, and they have one child, Dr. Henriette A. Javorek. He now lives in Overland Park, Kansas. He is the new strength and conditioning coach at Overland Park racquet club.
Early coaching career
In 1964, Javorek graduated from college and by 1968 was a coach at the Clujana Athletic Club in Cluj, Romania. Two of his more famous athletes were Dragomir Cioroslan (bronze medalist in Weightlifting at the 1984 Olympics) and Istvan Tasnadi (silver
medalist in weightlifting at the 1984 Olympics). It was also during this time that Javorek passed the first class coaching board examination (the highest coaching level in Romania). He presented to the coaching board his revolutionary creation, the Javorek
Complex #1 and Javorek Complex #2 (performed with dumbbells or barbells). Javorek felt that the main purpose of these exercises was to figure out an easier way to do an exercise complex, which could then change the monotony of a workout, and he hoped at the same time have a greater influence on the neuro-muscular and osteo-muscular system.
1980s
In 1982, Javorek defected to the United States and in 1984 became an all-sports strength and conditioning assistant coach at Texas A&M University. He was the Weightlifting coach of Texas A&M Weightlifting Club, but his duties were soon extended to coaching the field events and conditioning for men's and women's Track, Tennis, Basketball, Swimming, volleyball, and assistant for football.
At A&M, Javorek designed the whole conditioning program for the 1986 world fastest 200m sprinter, Floyd Heard; former 10,000m world record holder, Arturo Barrios; javelin thrower Juan de la Garza; Canadian long jump record holder, Ian James; Mexican record triple jumper, Francisco Olivares and several other top athletes. In particular, Randy Barnes, the silver medalist in the shot put at the 1988 Olympics and gold medalist in the shot put at the 1996 Olympics. In 1987, Javorek became head strength and conditioning coach at Johnson County Community College.
1990s
In December 1992, Romania awarded him with its highest coaching honor, the Emeritus Coaching Award. Many of the athletes he worked with have moved on to play professional sports, including Kit Pellow (baseball) and Kareem Rush and Wayne Simien (basketball). Sumya Anani, world champion female boxer, has been coached by Javorek for years. In Javorek’s 20-year career at JCCC, he has been a part of five national championships, 78 Region VI titles, 119 East Jayhawk Conference championships and 63 teams have finished in the top five in national championship play.
2000 and beyond
On March 23, 2002, Javorek was inducted into the Missouri Valley Weightlifting Hall of Fame, and on June 2, 2003, he earned induction into the USA Strength and Conditioning Hall of Fame
He retired in 2011 and is now Professor Emeritus at Johnson County Community College.
Education
Pedagogical Institute Of Physical Education And Sport, Cluj, Romania 1960 - 1964
Course of Study: Physical Education and Sport, Massage, and Basic Physical Therapy.
Degree: Diploma in Physical Education, certified as teacher and coach.
Fully qualified to teach the following: gymnastics, soccer, team handball, volleyball, basketball, track and field, weightlifting, Alpine and Nordic skiing and swimming.
Specialized in massage therapy, physical therapy, and in sport psychology, especially experience in the Schultz Autogenic Training Method (self-hypnosis) and in sport nutrition, emphasizing the use of natural herbs to aid the body in recovery and promotion of strength.
Part-Time continuing education and professional development. Specialized in weightlifting, strength & conditioning and track and field. Graduated in 1968 as a Third Class weightlifting and conditioning coach.
Graduated in 1971 as a Second Class weightlifting and conditioning coach.
Graduated in 1974 as a First Class weightlifting and conditioning coach, the highest coaching qualification in Romania
Additional professional experiences
Invited by South Korean Olympic Committee to train the national weightlifting team and instruct coaches Seoul, Korea October, 1983 - December 1983
United States Olympic Committee, International Exchange Program, Lima, Peru. June, 1984. He instructed national team and 24 coaches in state-of-the-art techniques for Olympic-style weightlifting and conditioning
World Junior Weightlifting Championship, Assistant coach, Fort Lauderdale, FL May 1989
USA Olympic Festival, Raleigh-Durham, North Carolina, July, 1987 Head Coach for the West Team.
USA Olympic Festival, Houston, TX July, 1986, Weightlifting coach for the South Team
Publications
“The Whoop Ass Workout” Javorek’s Bodybuilders Conditioning Muscle & Fitness December 2005 Pages 134 - 142
“Pre-season Conditioning for Volleyball: Uphill, Stairs and Sand Stairs or Shredded Rubber Boxes Training Programs” Performance Volleyball Conditioning Volume 11, Number 2 pages 3–4
Performance Volleyball Conditioning Volume 10, number 5 January 2004, page numbers 6-9
“Hill Work” Athletic Management June/July 2003, page number 58
“King of the Hill” T&C, Training & Conditioning, May/June 2003, page numbers 85 - 90
“Power Thrash II” Muscle & Fitness, May 2002, page numbers 166-221
“Power Thrash” Muscle & Fitness, August 2000, page numbers 174-187
“Big Fun” Muscle & Fitness, March 1999, page numbers 90-98
Adding Variety- A Menu of Pre-season Conditioning-” Performance Volleyball Conditioning Newsletter, Volume 6, Number 2, 1998, page numbers 6-7,10
“The Benefits of Combination Lifts” Strength And Conditioning Journal, Volume 20, Number 3, June 1998, page numbers 53-56
“Dumbbell Power” Muscle & Fitness, November 1998, pages 104-110 – contributor to Timothy C. Fritz article
“Triple Threat” by Jeff O’Connell Muscle & Fitness January 1998 pages 90– 97; an article interviewing conditioning coaches about Javorek’s Complex Exercises
“A Dumbbell Program for Post-game recovery and Strength Maintenance” Performance Conditioning For Soccer Volume 1 Number 1 page number 3, 1996
“Favorite Volleyball Specific Exercises from the Experts: Medicine Ball Squat Jump Setting” Performance Volleyball Conditioning Newsletter, Volume 1, Number 9, page number 8
“Favorite Volleyball Specific Exercises from the Experts: Medicine Ball Three Steps and Spike Imitation” Performance Volleyball Conditioning Newsletter, Volume 2, Number 1, page number 8
“Preparatory Circuit for Cycling” part 2 Performance Conditioning For Cycling Volume 3 Number 6 page numbers 1-2 8-9
“Hill Running and Jump Training” Cross Training Ideas Performance Conditioning For Cycling Volume 3 Number 4 page number 7
“Preseason Preparation for basketball” Coaching Women’s Basketball, Special Issue 1996/29 Volume.... page number....
“Combination of horizontal and vertical transfer reaction”(College Coaches’ Corner) Strength And Conditioning Journal (NSCA) Volume 19, number 4, August 1996, page number 57
“Yearly Plan of Preparation for Basketball and Volleyball Conditioning” Strength And Conditioning Journal (NSCA) Volume 17 Number 3 June 1995 page numbers 68-72
“Specificity in sports conditioning” National Strength And Conditioning (NSCA) Journal, Volume 15, Number 6, November–December 1993, page numbers 31-33
Coaching Volleyball Journal, February–March, 1993, page numbers 26-27.
“Equipment Design: Sand boxes (sand stairs) and their use in developing explosive response” National Strength And Conditioning Association (NSCA) Journal, Volume 13, Number 5, 1991 page numbers 84-87
“Year-Round Conditioning: The summer Conditioning Program.” National Strength And Conditioning Association (NSCA) Journal, Volume 14, Number 1, 1992, page numbers 26-29
“Year-Round Conditioning: The Fall Preparation Phase.” National Strength And Conditioning Association (NSCA) Journal, Volume 14, Number 2, 1992, page numbers 22-24, continued in Volume 14, Number 3, 1992, page numbers 32-38.
"Roundtable: Restoration Part II." National Strength And Conditioning Association (NSCA) Journal, December 1990 January 1991, page numbers 10-20.
"Roundtable: Restoration Part I." National Strength And Conditioning Association (NSCA) Journal, October - November 1990, page numbers 20 - 29.
"Weight-room in the hallway" National Strength And Conditioning Association (NSCA) Journal, October - November 1990, page numbers 45 - 46.
"Six Week Training Program" National Strength And Conditioning Association (NSCA) Journal, August- September 1990, page numbers 62 - 68.
"Dumbbell Power Clean" National Strength And Conditioning Association (NSCA) Journal, February - March 1990, page numbers 17 - 19.
"Steroid-free physical preparation in athletic development" National Strength And Conditioning Association (NSCA) Journal, December 1989-January 1990, page numbers 34 - 37.
"Plyometrics" National Strength And Conditioning Association Journal, April - May 1989, page numbers 52 - 57
"Weight-room Grid" National Strength And Conditioning Association (NSCA) Journal, December 1988, January 1989, page numbers 41 - 42.
"General Conditioning with Complex I and II" National Strength And Conditioning Association (NSCA) Journal, February- March 1988, page numbers 34 - 42.
"Shrugs" National Strength And Conditioning Association Journal, December 1987 - January 1988, page numbers 28 - 33.
Counterpoint”- Reply-National Strength And Conditioning Association Journal, April 1987 Volume 9 Number 2 page numbers 69-70,75
"Methods to Enhance Recovery and Avoid Over-training" National Strength And Conditioning Association Journal, June–July 1987, page numbers 43 - 47.
"Modeling Circle" National Strength And Conditioning Association Journal, August - September 1986, page numbers 32 - 35.
"Teaching of technique in the snatch and clean and jerk" National Strength And Conditioning Association (NSCA) Journal, June -July 1986, page numbers 45 - 51.
"Round Table: Power Clean" National Strength And Conditioning Association ( NSCA ) Journal, December 1984 - January 1985, page numbers 10 - 25.
"Guidelines for prepubescent and adolescent athletes in strength conditioning training", presented at the National Strength And Conditioning Association ( NSCA) Convention, Dallas, TX. 1985. Published in United States Weightlifting Federation (U.S.W.F) Weightlifting Manual 1985.
"Technique Teaching Methods" United States Weightlifting Federation (U.S.W.F) Coaching Manual 1985.
"Weightlifting Manual" United States Weightlifting Federation, 1986, 1987, 1988 contributor.
References
External links
Istvan Javorek's website
Javorek's bio at Johnson County Community College
1943 births
Living people
People from Săcueni
Johnson County Community College people |
```java
package com.yahoo.log;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.logging.Level;
/**
* Note that the log levels defined in VESPA applications are the
* following.
*
* <UL>
* <LI> LogLevel.EVENT (1201)
* <LI> LogLevel.FATAL (1151)
* <LI> LogLevel.ERROR (1101)
* <LI> <em>LogLevel.SEVERE (1000)</em>
* <LI> LogLevel.WARNING (900)
* <LI> LogLevel.INFO (800)
* <LI> LogLevel.CONFIG (700)
* <LI> LogLevel.DEBUG (501)
* <LI> LogLevel.SPAM (299)
* </UL>
*
* <P>
* Note that the EVENT level is somewhat special and you must
* <b>never</b> log one of these messages manually, but use
* the {@link com.yahoo.log.event.Event} class for this.
*
* @author Bjorn Borud
* @author arnej27959
*
* @deprecated Use {@link java.util.logging.Level} instead.
*/
// TODO Vespa 9: move to non-PublicApi package
@Deprecated(since = "7")
public class LogLevel extends Level {
/** A map from the name of the log level to the instance */
private static final Map<String, Level> nameToLevel;
private static final Map<String, Level> uppercasedNameToLevel;
/** A map from the java.util.logging loglevel to VESPA's loglevel */
private static final Map<Level, Level> javaToVespa;
public static final int IntValEVENT = 1201;
public static final int IntValFATAL = 1161;
public static final int IntValERROR = 1101;
public static final int IntValUNKNOWN = 1001;
public static final int IntValSEVERE = 1000;
public static final int IntValWARNING = 900;
public static final int IntValINFO = 800;
public static final int IntValCONFIG = 700;
public static final int IntValDEBUG = 501;
public static final int IntValFINE = 500;
public static final int IntValFINER = 400;
public static final int IntValFINEST = 300;
public static final int IntValSPAM = 299;
// these define the ordering of the Vespa levels logcontrol files.
// it must match the values of the LogLevel enum in <log/log.h>
// for the C++ framework:
// fatal, error, warning, config, info, event, debug, spam, NUM_LOGLEVELS
public static final int LogCtlFATAL = 0;
public static final int LogCtlERROR = 1;
public static final int LogCtlWARNING = 2;
public static final int LogCtlCONFIG = 3;
public static final int LogCtlINFO = 4;
public static final int LogCtlEVENT = 5;
public static final int LogCtlDEBUG = 6;
public static final int LogCtlSPAM = 7;
public static final int LogCtlNumLevels = 8;
// ordinary log levels
public static LogLevel UNKNOWN = new LogLevel("UNKNOWN", IntValUNKNOWN);
public static LogLevel EVENT = new LogLevel("EVENT", IntValEVENT);
public static LogLevel FATAL = new LogLevel("FATAL", IntValFATAL);
public static LogLevel ERROR = new LogLevel("ERROR", IntValERROR);
public static LogLevel DEBUG = new LogLevel("DEBUG", IntValDEBUG);
public static LogLevel SPAM = new LogLevel("SPAM", IntValSPAM);
// overlapping ones, only mentioned for illustration
//
// public static LogLevel WARNING = new LogLevel("WARNING",900);
// public static LogLevel INFO = new LogLevel("INFO",800);
// public static LogLevel CONFIG = new LogLevel("CONFIG",700);
static {
// define mapping from Java log levels to VESPA log
// levels.
javaToVespa = new HashMap<>();
javaToVespa.put(Level.SEVERE, ERROR);
javaToVespa.put(Level.WARNING, WARNING);
javaToVespa.put(Level.INFO, INFO);
javaToVespa.put(Level.CONFIG, CONFIG);
javaToVespa.put(Level.FINE, DEBUG);
javaToVespa.put(Level.FINER, DEBUG);
javaToVespa.put(Level.FINEST, SPAM);
// need the VESPA ones too
javaToVespa.put(FATAL, FATAL);
javaToVespa.put(ERROR, ERROR);
javaToVespa.put(EVENT, EVENT);
javaToVespa.put(DEBUG, DEBUG);
javaToVespa.put(SPAM, SPAM);
// manually enter the valid log levels we shall recognize in VESPA
nameToLevel = new LinkedHashMap<>(16);
nameToLevel.put("fatal", FATAL);
nameToLevel.put("error", ERROR);
nameToLevel.put("warning", WARNING);
nameToLevel.put("config", CONFIG);
nameToLevel.put("info", INFO);
nameToLevel.put("event", EVENT);
nameToLevel.put("debug", DEBUG);
nameToLevel.put("spam", SPAM);
uppercasedNameToLevel = new LinkedHashMap<>(16);
nameToLevel.forEach((name, level) -> uppercasedNameToLevel.put(name.toUpperCase(), level));
}
private LogLevel(String name, int value) {
super(name, value);
}
/**
* Semi-Case sensitive parsing of log levels. <b>Log levels are
* in either all upper case or all lower case. Not mixed
* case. </b>. Returns static instance representing log level or
* the UNKNOWN LogLevel instance.
*
* @param name Name of loglevel in uppercase or lowercase.
* @return Returns the static (immutable) LogLevel instance
* equivalent to the name given.
*
*/
public static Level parse(String name) {
Level l = nameToLevel.get(name);
if (l != null)
return l;
l = uppercasedNameToLevel.get(name);
if (l != null)
return l;
return UNKNOWN;
}
/**
* Static method for mapping Java log level to VESPA log level.
*
* @param level The Java loglevel we want mapped to its VESPA
* counterpart
* @return The VESPA LogLevel instance representing the corresponding
* log level (or nearest normal level numerically if not in map)
*/
public static Level getVespaLogLevel(Level level) {
Level ll = javaToVespa.get(level);
if (ll != null) {
return ll;
}
int lv = level.intValue();
if (lv > WARNING.intValue()) {
return ERROR;
}
if (lv > INFO.intValue()) {
return WARNING;
}
if (lv > DEBUG.intValue()) {
return INFO;
}
if (lv > FINEST.intValue()) {
return DEBUG;
}
return SPAM;
}
/**
* Static method returning a map from Vespa level name to Level
*
* @return a map from Vespa level name to Level
*/
public static Map<String, Level> getLevels() {
return nameToLevel;
}
}
``` |
```xml
import React, { useEffect, useState, useCallback, useRef, useMemo } from 'react';
import canUseDOM from 'dom-lib/canUseDOM';
import pick from 'lodash/pick';
export const mediaQuerySizeMap = {
xs: '(max-width: 575px)',
sm: '(min-width: 576px)',
md: '(min-width: 768px)',
lg: '(min-width: 992px)',
xl: '(min-width: 1200px)',
xxl: '(min-width: 1400px)'
};
interface MediaQuery {
matches: boolean;
media: string;
}
/**
* The type of the query parameter.
*/
export type Query = string | keyof typeof mediaQuerySizeMap;
const matchMedia = (query: string) => {
if (canUseDOM) {
return window.matchMedia(query);
}
return {
matches: false,
media: query
} as MediaQueryList;
};
/**
* React hook that tracks state of a CSS media query.
* @see path_to_url
*/
export function useMediaQueryOld(query: Query | Query[]): boolean[] {
const queries = Array.isArray(query) ? query : [query];
const mediaQueries = useMemo(
() => queries.map(query => mediaQuerySizeMap[query] || query),
// eslint-disable-next-line react-hooks/exhaustive-deps
[...queries]
);
const [mediaQueryArray, setMediaQueryArray] = useState<MediaQuery[]>(() =>
mediaQueries.map(query => pick(matchMedia(query), ['matches', 'media']))
);
function handleChange(event: MediaQueryListEvent) {
setMediaQueryArray((prevMediaQueryArray: MediaQuery[]) => {
return prevMediaQueryArray.map(item => {
return item.media === event.media ? { ...item, matches: event.matches } : item;
});
});
}
useEffect(() => {
const mediaQueryList = mediaQueries.map(query => matchMedia(query));
mediaQueryList.forEach(query => {
query.addEventListener('change', handleChange);
});
return () => {
mediaQueryList.forEach(query => {
query.removeEventListener('change', handleChange);
});
};
}, [mediaQueries]);
return mediaQueryArray.map(query => query.matches);
}
/**
* React hook that tracks state of a CSS media query
* @version 5.48.0
* @unstable Please note that this API is not stable and may change in the future.
* @see path_to_url
*/
export function useMediaQuery(query: Query | Query[]): boolean[] {
const queries = Array.isArray(query) ? query : [query];
const mediaQueries = useMemo(
() => queries.map(query => mediaQuerySizeMap[query] || query),
// eslint-disable-next-line react-hooks/exhaustive-deps
[...queries]
);
const mediaQueryArray = useRef<boolean[]>(mediaQueries.map(query => matchMedia(query).matches));
const subscribe = useCallback(
callback => {
const list = mediaQueries.map(query => matchMedia(query));
const handleChange = (event: MediaQueryListEvent) => {
const index = list.findIndex(item => item.media === event.media);
if (index !== -1) {
// The store snapshot returned by getSnapshot must be immutable. So we need to create a new array.
const nextMediaQueryArray = mediaQueryArray.current.slice();
nextMediaQueryArray[index] = event.matches;
mediaQueryArray.current = nextMediaQueryArray;
}
callback();
};
list.forEach(query => {
query.addEventListener('change', handleChange);
});
return () => {
list.forEach(query => {
query.removeEventListener('change', handleChange);
});
};
},
[mediaQueries]
);
const getSnapshot = useCallback(() => {
return mediaQueryArray.current;
}, []);
const getServerSnapshot = useCallback(() => {
return mediaQueryArray.current;
}, []);
return React['useSyncExternalStore']?.(subscribe, getSnapshot, getServerSnapshot);
}
export default typeof React['useSyncExternalStore'] === 'function'
? useMediaQuery
: useMediaQueryOld;
``` |
Enzo Giudici (24 September 1920 – 4 October 1985) was an Italian academic who specialized in French Renaissance literature, particularly Louise Labé and Maurice Scève. Giudici was also a publicist often compared with fascism.
Biography
Enzo Giudici was born in Mussomeli. He was the son of Isabella Sorce, a teacher, and Paolo Giudici, who was a writer. His mother died when he was 3 years old. At the age of 10, he left Sicily to live with his father in Piacenza, Pavia, Potenza, and Rome.
During his studies, he was close to the .
During World War II, Giudici was not enrolled in the army due to health conditions. In that period, he contributed to Orizzonte, the official newspaper of the Xa MAS. Giudici also contributed to Fronte Unico, a "virulent" fascist weekly publication directed by Vito Videtta, a member of the extremist Pietro Koch's "gang".
In an article of December 1943, Giudici claimed that fascism was the negation of classes and individuals, and was characterized by totalitarianism and corporatism. Giudici also collaborated to "Libro e moschetto," the newspaper of the . In April 1943, Giudici wrote an article in Universalità e nazionalità delle guerre (Universality and nationality of the wars), published by Libro e moschetto. In this article, Giudici wrote: "The present war is together a universal and national war, in which the values and the fate of the world are being determined - through our Italian national conscience. This fight is clearly between two centuries and two ideas, but though it is a fight between peoples, peoples do implement and represent ideas."
In 1944, during the Italian Social Republic, he debated with Roberto Farinacci on reforms in the magazine Repubblica fascista. He wrote an article in the Repubblica Sociale - a monthly review directed by - on "socialized and corporative economy." The same year, Giudici also wrote a book on the socialization of corporations.
In 1946, he was the vice president of the executive board (vicepresidente dell consiglio direttivo) of the newly founded Movimento Italiano di Unità Sociale, which gathered the fascist elit and preceded the MSI.
In 1947, he collaborated with a magazine directed by with an aim to gather "ex fascists leaning to the left".
The Italian journalist had commented on Giudici's "sensitivity" towards the game of chess. Giudici's passion for chess resulted in his travel to chess tournaments, which led the movement for the introduction of the Elo rating system in Italy. Giudici also wrote an article on the figurative use of such in literature.
Giudici died in Rome on 4 October 1985. Following his death, his collection of over 20,000 books was passed on to the university of Salento.
University positions
Teaching assistant at the University of Toulouse 1957-1962.
Professor of French Language and Literature at the university of Salento and at Naples Eastern university(1962–1965).
Professor at the University of Macerata (1966–1982).
Professor at the University of Rome Tor Vergata afterwards.
Studies on the École de Lyon
His "prolific" academic interest centered on a French literary movement of the Renaissance called particularly Louise Labé and Maurice Scève, the possible discoverer of Laura de Noves' possible tomb, highlighting, maybe exaggeratedly, Petrarch's influence. In 1958 he published a critical edition of Scève's minor works and in 1976, "the first proper critical edition" - though considered today partial and dated - of Microcosme, Scève's last work. In 1981, he published an erudite edition of Louise Labé works, considered "solid" and "luxuriant", though it has been since deemed incomplete. His sometimes "exceedingly footnotish" editor work and search for documents have been more appreciated by some specialists, who praise his "density of information", than his literary analyses. In recognition of his contribution the renewal of interest in these poets, he was awarded for this work a prix d'honneur by the .
Essays
Giudici was subject to criticism for his protracted relationship with fascism. In Memorie e pensieri di un cattedratico (Memories and Thoughts of a Professor), he considers such evocations as false and vile confusions of culture with politics. He claims that fascism is a "controversial" term and that he does not trust "contemporary -isms". Though the Italian historian Carlo Vallauri noted that Giudici "never identified himself" with the MSI, an affinity, sometimes considered as the expression of a "new right" "non-conformism", transcures from his later positions on the student movements and on the culture of fascism.
In L' avvento dell'asinocrazia (The Upcoming Donkeycracy) and Contestatori alla sbarra (Protesters at the Bar) he criticizes the student movement, which had started in Italy in 1967. His point of view has been considered by the historian Carlo Vallauri as "the clearer and most organic expression of the wholesome refusal to understand" this movement. The expression avvento dell'asinocrazia was first used in 1968 by Giovanni Sartori in an article published by the Corriere della Sera to characterize the student movement as a "triumph of the donkeys". In La scuola inutile (The ineffective school), initially entitled Asini allo spiedo per il pasto del barone (Jackass on the spit for big shots convenience), Giudici critics not only the "protestive" students, but also the "faint-hearted" political class.
In the late 1970s, Giudici contributed in the Secolo d'Italia, the newspaper of the MSI, to an ongoing debate on the culture of the fascist period. He questioned whether "fascism was only respectful of culture or itself productive of culture" and underlined the link between "fascist culture and the tradition of Risorgimento and ancient Rome". These considerations are developed in Ricerche sulla cultura dell'era fascista (Research on culture of the fascist era), a book published in 1982. and in Riflessioni sulla cultura del periodo fascista – published posthumously by 's Istituto di studi corporativi, a "reference point of studies and strategy for MSI's economical policy" – where Giudici refers to Robert Michels' analysis on Mussolini's syncretism.
In this last book, Giudici blames the fascist antisemitism. The Italian historian Gianni Rossi notes Giudici, though he does not deny or minimize the Mussolinian antisemitism, finds it "reluctant".
Awards
Commander of the Order of Merit of the Italian Republic.
Primevère d'argent de l'.
Works by Giudici
Notes
1920 births
1985 deaths
People from Mussomeli
Literary critics of French
Historians of French literature
Italian essayists
Male essayists
Italian male writers
People of the Italian Social Republic
Historians of fascism
20th-century Italian historians
20th-century essayists
Academic staff of the University of Rome Tor Vergata
Academic staff of the University of Macerata
Italian male non-fiction writers
Academics from Sicily |
Gholam Hossein Nozari (born 1954) is a conservative Iranian politician who served as oil minister from 2007 to 2009. He was nominated secretary general of the OPEC in June 2012.
Early life and education
Nozari was born in Kazeroon, Iran, in 1954. He studied petroleum and earth science engineering at Shahid Chamran University. He received a master's degree in industrial management from Tehran University.
Career
Nozari worked at the National Iranian Oil Company (NIOC). Then he became a member of the fourth Majlis and acted as deputy chairman of the energy commission. In the fifth Majlis, he was a member of the development commission. He has been a member of the central council of the Islamic Republic Party (South Labor Branch). He also served as the member of ad hoc Majlis committee on budget and chairman of assembly of Fars province deputies. He was appointed managing director of the NIOC in March 2006. He was also appointed deputy oil minister.
In August 2007, then oil minister Kazem Vaziri Hamaned was removed by president Mahmoud Ahmedinejad and Nozari was appointed acting oil minister. Then Nazari was named as oil minister by Ahmedinejad, and he was in office from 2007 to 2009. His appointment allowed Ahmedinejad to exert much more control over the oil sector in Iran. In June 2012, Iran nominated Nozari for the secretary-general of OPEC.
References
1954 births
Living people
University of Tehran alumni
People from Kazerun
Government ministers of Iran
Oil ministers of Iran
Islamic Republican Party politicians
National Iranian Oil Company people |
Gulshan (, ) is a village and jamoat in Tajikistan. It is located in Farkhor District in Khatlon Region. The jamoat has a total population of 12,418 (2015).
References
Populated places in Khatlon Region
Jamoats of Tajikistan |
Meridemis hylaeana is a species of moth of the family Tortricidae. It is found in the Democratic Republic of Congo.
References
Moths described in 1940
Archipini
Endemic fauna of the Democratic Republic of the Congo |
```xml
import React, {CSSProperties} from 'react';
import styled from 'styled-components';
import ReactDOM from 'react-dom';
import {appTheme} from '../Style/appTheme';
import {border} from '../Style/layout';
type Props = {
onEnd?: () => void;
className?: string;
style?: CSSProperties;
}
type State = {
}
export class ScrollView extends React.Component<Props, State> {
private rootView;
private bottomView;
private observer: IntersectionObserver;
componentDidMount(): void {
if (this.props.onEnd) this.initIntersectionObserver();
}
componentWillUnmount(): void {
if (this.observer) {
this.observer.unobserve(ReactDOM.findDOMNode(this.bottomView) as HTMLElement);
this.observer.disconnect();
}
}
private initIntersectionObserver() {
const options: IntersectionObserverInit = {
root: ReactDOM.findDOMNode(this.rootView) as HTMLElement,
rootMargin: '100px',
threshold: 0,
};
this.observer = new IntersectionObserver((changes) => {
// targetrootenter
// leave
// path_to_url
if (changes[0].intersectionRect.top) {
this.props.onEnd?.();
}
}, options);
this.observer.observe(ReactDOM.findDOMNode(this.bottomView) as HTMLElement);
}
scrollTop() {
(ReactDOM.findDOMNode(this.rootView) as HTMLElement).scrollTo(0, 0);
}
scrollBottom() {
const el = (ReactDOM.findDOMNode(this.rootView) as HTMLElement);
el.scrollTo(0, el.scrollHeight);
}
scrollBy(y: number) {
(ReactDOM.findDOMNode(this.rootView) as HTMLElement).scrollBy(0, y);
}
render() {
return (
<Root
ref={ref => this.rootView = ref}
className={this.props.className}
style={this.props.style}
>
{this.props.children}
<div ref={ref => this.bottomView = ref}/>
</Root>
);
}
}
const Root = styled.div`
width: 100%;
overflow-y: auto;
overflow-x: hidden;
flex-direction: column;
box-sizing: border-box;
outline: none;
/*
&::-webkit-scrollbar {
width: 10px;
border-left: solid ${border.medium}px ${() => appTheme().border.normal};
overflow: auto;
}
&::-webkit-scrollbar-thumb {
background: ${() => appTheme().bg.primaryHover};
border-radius: 100px;
}
*/
`;
``` |
```xml
import { createConsola } from 'consola'
import type { LogObject } from 'consola'
import { parse } from 'devalue'
import type { ParsedTrace } from 'errx'
import { h } from 'vue'
import { defineNuxtPlugin } from '../nuxt'
// @ts-expect-error virtual file
import { devLogs, devRootDir } from '#build/nuxt.config.mjs'
const devRevivers: Record<string, (data: any) => any> = import.meta.server
? {}
: {
VNode: data => h(data.type, data.props),
URL: data => new URL(data),
}
export default defineNuxtPlugin(async (nuxtApp) => {
if (import.meta.test) { return }
if (import.meta.server) {
nuxtApp.ssrContext!.event.context._payloadReducers = nuxtApp.ssrContext!._payloadReducers
return
}
// Show things in console
if (devLogs !== 'silent') {
const logger = createConsola({
formatOptions: {
colors: true,
date: true,
},
})
nuxtApp.hook('dev:ssr-logs', (logs) => {
for (const log of logs) {
logger.log(normalizeServerLog({ ...log }))
}
})
}
if (typeof window !== 'undefined') {
const nuxtLogsElement = document.querySelector(`[data-nuxt-logs="${nuxtApp._name}"]`)
const content = nuxtLogsElement?.textContent
const logs = content ? parse(content, { ...devRevivers, ...nuxtApp._payloadRevivers }) as LogObject[] : []
await nuxtApp.hooks.callHook('dev:ssr-logs', logs)
}
})
function normalizeFilenames (stack?: ParsedTrace[]) {
if (!stack) {
return ''
}
let message = ''
for (const item of stack) {
const source = item.source.replace(`${devRootDir}/`, '')
if (item.function) {
message += ` at ${item.function} (${source})\n`
} else {
message += ` at ${source}\n`
}
}
return message
}
function normalizeServerLog (log: LogObject) {
log.additional = normalizeFilenames(log.stack as ParsedTrace[])
log.tag = 'ssr'
delete log.stack
return log
}
``` |
Scolopocerus is a genus of leaf-footed bugs in the family Coreidae. There are at least four described species in Scolopocerus.
Species
These four species belong to the genus Scolopocerus:
Scolopocerus granulosus Barber, 1914
Scolopocerus neopacificus Brailovsky, 1989
Scolopocerus secundarius Uhler, 1875
Scolopocerus uhleri Distant, 1881
References
Further reading
External links
Articles created by Qbugbot
Coreini
Coreidae genera |
Professor Christopher Richard James Woodhouse, 6th Baron Terrington (born 20 September 1946), is a British peer and Emeritus Professor of Adolescent Urology, University College London.
Terrington was born in 1946, the elder son of Montague Woodhouse, 5th Baron Terrington, and Lady Davidema Katharine Cynthia Mary Millicent Bulwer-Lytton, a daughter of Victor Bulwer-Lytton, 2nd Earl of Lytton. He was educated at Winchester College and Guy's Hospital Medical School. Throughout his academic career he was an avid coxswain, steering Winchester College, University of London and Leander Club crews.
Terrington became a urological surgeon in 1970. He was senior registrar at the Institute of Urology from 1977 to 1981 and senior lecturer from 1981 until 1997. In the latter year he moved to University College Hospital as Reader in Adolescent Urology, and professor from 2006. He has been Clinical Director of Urology at the same institution since 2001. He was a consultant at St George's Hospital from 1985 to 1995 and has occupied the same position at the Royal Marsden Hospital since 1981 as well as that of honorary consultant at Great Ormond Street Hospital since 1981.
He became a Fellow of the Royal College of Physicians in 1975. In addition, Terrington has been an honorary member of the Australasian Urological Association since 1999, Chairman of the British Journal of Urology since 2000 and President of Genito-Urinary Reconstructive Surgeons (USA) since 2002.
He inherited his title when his father died in 2001. He was an unsuccessful candidate for election as a crossbench hereditary peer in the House of Lords by-election held in May 2008.
Marriage and children
Terrington married Hon. Anna Margaret Philipps, the daughter of Hugo Philipps, 3rd Baron Milford, on 27 February 1975. They have two children:
Hon. Jack Henry Lehmann Woodhouse (born 7 December 1978), heir apparent to the barony.
Hon. Constance Margaret Davina Woodhouse (born 1 January 1982)
Publications
With F. D. Thompson: Disorders of the Kidney and Urinary Tract (1987)
Long-Term Paediatric Urology (1991)
With others: Management of Urological Emergencies (2004)
Arms
References
Burke's Peerage
Who's Who 2009
1946 births
Living people
6
British urologists
People educated at Winchester College
Members of Leander Club
British surgeons
Fellows of the Royal College of Physicians |
Huawen Group () is a publicly listed Chinese holding company in the media sector. It is one of the 500 components of the SZSE Component Index, as well as the sub-index SZSE 300 Index and SZSE 100 Index.
Acquisitions
In 2006, the company acquired the commercial brokerage rights of the Securities Times (a newspaper under state-owned People's Daily) for 30 years.
In 2016, Huawen Media Investment subscribed the new shares of China International Broadcasting Network. (CIBN, traded as .) After the deal, Huawen Media owned a 30.9996% stake, while Global Broadcasting Media Group owned a 34% stake and was the largest shareholder. Global Broadcasting Media Group was also the indirect major shareholder of Huawen Media Investment.
Shareholders
The largest shareholder of the company was () with 11.15% of the shares. Global Broadcasting Asset Management is a subsidiary (58.0344%) of Global Broadcasting Media Group (). Global Broadcasting Media Group is a joint venture (50–50) of state-owned broadcasting company China Radio International with a private company.
References
External links
Mass media companies of China
Companies listed on the Shenzhen Stock Exchange |
An organism () is any biological living system that functions as an individual life form. All organisms are composed of cells. The idea of organism is based on the concept of minimal functional unit of life. Three traits have been proposed to play the main role in qualification as an organism:
noncompartmentability – structure that cannot be divided without its functionality loss,
individuality – the entity has simultaneous holding of genetic uniqueness, genetic homogeneity and autonomy,
distinctness – genetic information has to maintain open-system (a cell).
Organisms include multicellular animals, plants, and fungi; or unicellular microorganisms such as protists, bacteria, and archaea. All types of organisms are capable of reproduction, growth and development, maintenance, and some degree of response to stimuli. Most multicellular organisms differentiate into specialized tissues and organs during their development.
In 2016, a set of 355 genes from the last universal common ancestor (LUCA) of all organisms from Earth was identified.
Etymology
The term "organism" (from Greek ὀργανισμός, organismos, from ὄργανον, organon, i.e. "instrument, implement, tool, organ of sense or apprehension") first appeared in the English language in 1703 and took on its current definition by 1834 (Oxford English Dictionary). It is directly related to the term "organization". There is a long tradition of defining organisms as self-organizing beings, going back at least to Immanuel Kant's 1790 Critique of Judgment.
Definitions
An organism may be defined as an assembly of molecules functioning as a more or less stable whole that exhibits the properties of life. Dictionary definitions can be broad, using phrases such as "any living structure, such as a plant, animal, fungus or bacterium, capable of growth and reproduction". Many definitions exclude viruses and possible synthetic non-organic life forms, as viruses are dependent on the biochemical machinery of a host cell for reproduction. A superorganism is an organism consisting of many individuals working together as a single functional or social unit.
There has been controversy about the best way to define the organism, and from a philosophical point of view, whether such a definition is necessary. Problematic cases include colonial organisms: for instance, a colony of eusocial insects fulfils criteria such as adaptive organisation and germ-soma specialisation. If so, the same argument would include some mutualistic and sexual partnerships as organisms. If group selection occurs, then a group could be viewed as a superorganism, optimised by group adaptation. Another view is that attributes like autonomy, genetic homogeneity and genetic uniqueness should be examined separately rather than demanding that an organism should have all of them; if so, there are multiple dimensions to biological individuality, resulting in several types of organism.
Other views include the idea that an individual is distinguished by its immune response, separating self from foreign; that "anti-entropy", the ability to maintain order, is what distinguishes an organism; or that Shannon's information theory can be used to identify organisms as capable of self-maintaining their information content. Finally, it may be that the concept of the organism is inadequate in biology.
Viruses
Viruses are not typically considered to be organisms because they are incapable of autonomous reproduction, growth or metabolism. Although viruses have a few enzymes and molecules like those in living organisms, they have no metabolism of their own; they cannot synthesize the organic compounds from which they are formed. In this sense, they are similar to inanimate matter. Viruses have their own genes, and they evolve. Thus, an argument that viruses should be classed as living organisms is their ability to undergo evolution and replicate through self-assembly. However, some scientists argue that viruses neither evolve nor self-reproduce. Instead, viruses are evolved by their host cells, meaning that there was co-evolution of viruses and host cells. If host cells did not exist, viral evolution would be impossible. As for reproduction, viruses rely on hosts' machinery to replicate. The discovery of viruses with genes coding for energy metabolism and protein synthesis fuelled the debate about whether viruses are living organisms, but the genes have a cellular origin. Most likely, they were acquired through horizontal gene transfer from viral hosts.
Ancestry
There is strong evidence from genetics that all organisms have a common ancestor. In particular, every living cell makes use of nucleic acids as its genetic material, and uses the same twenty amino acids as the building blocks for proteins. All organisms use the same genetic code (with some extremely rare and minor deviations) to translate nucleic acid sequences into proteins. The universality of these traits strongly suggests common ancestry, because the selection of many of these traits seems arbitrary. Horizontal gene transfer makes it more difficult to study the last universal ancestor. However, the universal use of the same genetic code, same nucleotides, and same amino acids makes the existence of such an ancestor overwhelmingly likely. The first organisms were possibly anaerobic and thermophilic chemolithoautotrophs that evolved within inorganic compartments at geothermal environments.
The last universal common ancestor is the most recent organism from which all organisms now living on Earth descend. Thus, it is the most recent common ancestor of all current life on Earth. The last universal common ancestor lived some 3.5 to 3.8 billion years ago, in the Paleoarchean era. In 2016, a set of 355 genes considered likely to derive directly from the last universal common ancestor was identified.
Human intervention
Modern biotechnology is challenging traditional concepts of organisms and species. Cloning is the process of creating a new multicellular organism, genetically identical to another, with the potential of creating entirely new species of organisms. Cloning is the subject of much ethical debate.
In 2008, the J. Craig Venter Institute assembled a synthetic bacterial genome, Mycoplasma genitalium, by using recombination in yeast of 25 overlapping DNA fragments in a single step. The use of yeast recombination greatly simplifies the assembly of large DNA molecules from both synthetic and natural fragments. Other companies, such as Synthetic Genomics, have already been formed to take advantage of the many commercial uses of custom designed genomes.
See also
Earliest known life forms
References
External links
aims to enumerate all known species.
Organisms
ceb:Organismo |
Follett Johns Thomas (21 October 1863 – 3 January 1942) was an Australian politician.
He was born at Majors Creek, near Araluen in New South Wales, to Richard Uren Thomas and Mary Ann Johns. The family moved to Inverell around 1871 and Thomas attended the public school there before apprenticing to a chemist in Glen Innes. He qualified as a chemist, and also served as an alderman at Glen Innes from 1884 to 1903, as mayor in 1895, 1896, 1902 and 1903. On 30 June 1888 he married Louise Dibley Dawson, with whom he had four children. In 1903 he was elected to the New South Wales Legislative Assembly as the Liberal member for Glen Innes, moving to Gough in 1904. He held the seat until the introduction of proportional representation in 1920, when he was defeated running for Northern Tableland as a Progressive. Thomas died in North Sydney in 1942.
References
1863 births
1942 deaths
Nationalist Party of Australia members of the Parliament of New South Wales
Members of the New South Wales Legislative Assembly
Colony of New South Wales people |
Acraea zitja is a butterfly in the family Nymphalidae. It is found on Madagascar.
Description
A. zitja Bdv. (55 g). Both wings above brick-red with narrow black marginal band, which is more or less proximally prolonged at the veins; the forewing in addition with black costal margin, with a black dot in the cell, a larger one at the end of the cell and free black discal dots in 1 b to 6; hindwing above with some basal dots and with discal dots in 1 c to 7; forewing beneath without dark marginal band but with the extremities of the veins black, otherwise marked as above. The hindwing beneath with reddish ground-colour and with a narrow whitish median band, at the proximal side of which the discal dots are placed; the whitish colour of this band is continued to the distal margin as light lines at each side of the veins; the small transverse light marginal spots are proximally bordered by black streaks, which, however, do not touch in the middle. Madagascar. - ab. radiata Guen. differs in having the light bordering of the veins in the marginal band of the hindwing beneath much broader than in the type-form; the females have a yellow-brown ground-colour. Madagascar. - female ab. calida Btlr. [ now species Acraea calida ] resembles radiata but has, instead of the marginal band of the upper urface, triangular black spots at the extremities of the veins. Madagascar. In ab. rakeli Bdv. the light bordering of the veins is entirely absent in the distal part of the hindwing beneath and also the proximal bordering of the marginal spots is often indistinct; hence the marginal band becomes almost unicolorous. - female ab. fumida Mab. has a grey ground-colour, on both wings relieved with whitish at the discal dots; the marginal band on the underside of the hindwing apparently always agrees with that of rakeli. Madagascar.
Biology
The habitat consists of forest margins, grassland and anthropogenic environments.
Taxonomy
It is a member of the Acraea rahira species group- but see also Pierre & Bernaud, 2014
References
External links
Images representing Acraea zitja at Bold.
Acraea zitja at Pteron
Butterflies described in 1833
zitja
Endemic fauna of Madagascar
Butterflies of Africa |
```sqlpl
-- path_to_url
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 49) FORMAT Pretty;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 10) FORMAT Pretty SETTINGS output_format_pretty_display_footer_column_names_min_rows=9;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT Pretty SETTINGS output_format_pretty_display_footer_column_names=0;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT Pretty;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyNoEscapes;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyNoEscapesMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyNoEscapesMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyCompact SETTINGS output_format_pretty_display_footer_column_names=0;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyCompact;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyCompactNoEscapes;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyCompactMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettyCompactNoEscapesMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettySpace SETTINGS output_format_pretty_display_footer_column_names=0;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettySpace;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettySpaceNoEscapes;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettySpaceMonoBlock;
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 100) FORMAT PrettySpaceNoEscapesMonoBlock;
``` |
Talara is a city in the Talara Province of the Piura Region, in northwestern Peru. It is a port city on the Pacific Ocean with a population of 91,444 as of 2017. Its climate is hot and dry. Due to its oil reserves, and ability to produce aviation fuel, Talara hosted a United States air base during World War II. It was also one of two refueling stations for the Pacific Fleet. There were naval guns on the hills, and submarine nets in the harbor. The Ajax, Achilles and Exeter, three British destroyers, were refuelled there on their way around the Horn to catch the Graf Spee in Rio de la Plata. Talara is also home to a large fishing fleet. The city is served by the Cap. FAP Víctor Montes Arias Airport.
Talara is the westernmost city in all of mainland South America. (A small outlying town, Seccion Dieciocho, is situated slightly further west, and just beyond there, the land itself reaches its westernmost extent at Punta Pariñas.) Talara and some neighbouring cities (Piura and Amotape) served as the backdrop for the short novel Who Killed Palomino Molero? by Mario Vargas Llosa.
Geography
Climate
See also
2005 Northern Peru earthquake
References
External links
Municipalidad de Talara
Talara
Populated places in the Piura Region
Port cities in Peru
Cities in Peru |
```shell
Security news delivered via DNS
Extracting the `public key` from the `private key`
Track SSH log-in attempts
Disabling **USB** storage devices
Keeping `/boot` read-only
``` |
Love is the debut album by the Los Angeles-based rock band Love; released in March 1966 by Elektra Records.
Background
Arthur Lee, who was originally from Memphis, Tennessee, but had lived in Los Angeles since he was five, had been recording since 1963 with his bands, the LAG's and Lee's American Four. He had written and also produced the single "My Diary" for Rosa Lee Brooks in 1964 which featured Jimi Hendrix on guitar. A garage outfit, The Sons Of Adam, which included future Love drummer Michael Stuart, also recorded a Lee composition, "Feathered Fish". However, after viewing a performance by the Byrds, Lee became determined to form a group that joined the newly minted folk-rock sound of the Byrds to his primarily rhythm and blues style.
Singer, songwriter / guitarist Bryan MacLean, whom Lee had met when he was working as a roadie for the Byrds, joined the band just before they changed their name from the Grass Roots to Love, spurred by the release of a single by another group called the Grass Roots.
MacLean had also been playing guitar in bands since about 1963 but picked up music early. Neighbor Frederick Loewe, of the composers Lerner & Loewe, recognized him as a "melodic genius" at the age of three as he doodled on the piano.
Also joining the band was another Memphis native, lead guitarist Johnny Echols. From L.A. was drummer Don Conka. A short time later, Conka was replaced by Alban "Snoopy" Pfisterer. Love's first bassist, Johnny Fleckenstein, went on to join the Standells in 1967. Fleckenstein was replaced by Ken Forssi (formerly of a post-"Wipe Out" lineup of the Surfaris).
Recording and music
Ten of the album's fourteen tracks were recorded at Sunset Sound Recorders in Hollywood on January 24–27, 1966. The remaining four tracks ("A Message to Pretty", "My Flash on You", "Emotions", and "Mushroom Clouds") come from another, undocumented session during that period.
Love features a mixture of folk rock genre, garage rock, and psychedelic rock. The first rock album issued on then-folk giant Elektra Records, the album begins with the group's radical reworking of the Burt Bacharach-Hal David song "My Little Red Book" and also features "Signed D.C." (allegedly a reference to one-time Love drummer Don Conka), along with the poignant "A Message to Pretty".
Release and reception
The album sold approximately 150,000 copies.
In a retrospective review of the album, Richie Unterberger for AllMusic called it "their hardest-rocking early album and their most Byrds-influenced." He also stated, "Arthur Lee's songwriting muse hadn't fully developed at this stage, and in comparison with their second and third efforts, this is the least striking of the LPs featuring their classic lineup, with some similar-sounding folk-rock compositions and stock riffs."
2001 CD reissue
The 2001 CD reissue presents both monaural and stereophonic mixes of the album, as well as an alternate take of "Signed D.C." and "No. Fourteen", the B-side to the "7 and 7 Is" single.
Legacy
The stark instrumental "Emotions" is used uncredited in Haskell Wexler's 1969 film Medium Cool as a recurring theme.
"My Little Red Book" was featured over the final credits of the movie High Fidelity in 2000, and the Beverly Hills, 90210 episode "Alone at the Top" in 1995.
Track listing
Personnel
Love
Arthur Lee – lead vocals, percussion, harmonica. Also drums on "Can't Explain", "No Matter What You Do", "Gazing", and "And More".
Johnny Echols – lead guitar
Bryan MacLean – rhythm guitar, vocals. Lead vocals on "Softly to Me" and "Hey Joe".
Ken Forssi – bass guitar
Alban "Snoopy" Pfisterer – drums
Additional personnel
According to the box set Love Story, the tracks "A Message to Pretty" and "My Flash on You" may feature John Fleckenstein on bass and Don Conka on drums in place of Forssi and Pfisterer, respectively.
Singles
"My Little Red Book" b/w "A Message to Pretty" (Elektra 45603)
"No. Fourteen" (from these sessions, B side of "7 & 7 Is" - Elektra 45605)
"Hey Joe" (B side to rare "¡Que Vida!" single - Elektra 45613)
Release history
References
1966 debut albums
Love (band) albums
Garage rock albums by American artists
Albums produced by Jac Holzman
Albums produced by Mark Abramson
Elektra Records albums
Albums recorded at Sunset Sound Recorders |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.