ECpoint*
strtoec(ECdomain *dom, char *s, char **rptr, ECpoint *ret)
{
int allocd, o;
mpint *r;
allocd = 0;
if(ret == nil){
allocd = 1;
ret = mallocz(sizeof(*ret), 1);
if(ret == nil)
return nil;
ret->x = mpnew(0);
ret->y = mpnew(0);
}
o = 0;
switch(octet(&s)){
case 0:
ret->inf = 1;
return ret;
case 3:
o = 1;
case 2:
if(halfpt(dom, s, &s, ret->x) == nil)
goto err;
r = mpnew(0);
mpmul(ret->x, ret->x, r);
mpadd(r, dom->a, r);
mpmul(r, ret->x, r);
mpadd(r, dom->b, r);
if(!mpsqrt(r, dom->p, r)){
mpfree(r);
goto err;
}
if((r->p[0] & 1) != o)
mpsub(dom->p, r, r);
mpassign(r, ret->y);
mpfree(r);
if(!ecverify(dom, ret))
goto err;
return ret;
case 4:
if(halfpt(dom, s, &s, ret->x) == nil)
goto err;
if(halfpt(dom, s, &s, ret->y) == nil)
goto err;
if(!ecverify(dom, ret))
goto err;
return ret;
}
err:
if(rptr)
*rptr = s;
if(allocd){
mpfree(ret->x);
mpfree(ret->y);
free(ret);
}
return nil;
}
int main()
{
std::vector<unsigned int> numbers ;
for( unsigned int i = 0 ; i < 512 ; ++i ) if( i%3) numbers.push_back(i) ;
auto compact = compress(numbers) ;
int n = 0 ;
for( std::uint8_t byte : compact )
{
std::cout << octet(byte) << ' ' ;
if( ++n % 8 == 0 ) std::cout << '\n' ;
}
std::cout << '\n' ;
}
std::vector<Octet62> SignatureNeutral::Multiplets(boca::Event const& event, PreCuts const&, TMVA::Reader const& reader)
{
INFO0;
auto doublets = jet_pair_reader_.Multiplets(event);
auto sextets = heavy_higgs_semi_reader_.Multiplets(event);
std::vector<Octet62> octets;
for (auto const & doublet : doublets) {
for (auto const & sextet : sextets) {
Octet62 octet(sextet, doublet);
if (octet.Overlap()) continue;
octet.SetBdt(Bdt(octet, reader));
octets.emplace_back(octet);
}
}
// if(octets.size()==0)ERROR(octets.size(), doublets.size(), sextets.size());
return octets;
}
inline std::string reverse(char const* addr)
{
constexpr char const* dotted_quad_cap_rgx = "(\\d{1,3})\\."
"(\\d{1,3})\\."
"(\\d{1,3})\\."
"(\\d{1,3})";
boost::regex dotted_quad_rx(dotted_quad_cap_rgx);
boost::cmatch matches;
CHECK(boost::regex_match(addr, matches, dotted_quad_rx))
<< "reverse_ip4 called with bad dotted quad: " << addr;
std::ostringstream reverse;
for (int n = 4; n > 0; --n) {
boost::string_ref octet(matches[n].first,
matches[n].second - matches[n].first);
reverse << octet << '.'; // and leave a trailing '.'
}
return reverse.str();
}
in_addr_t HostLookup(QString const& hostname)
{
in_addr_t address(INADDR_NONE);
#ifdef WIN32
// This can only handle IPv4 addresses and should only be used when
// inet_ntop is unavailable.
QString octet("(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])");
QRegExpValidator ipv4Validator(0);
ipv4Validator.setRegExp(QRegExp(
"^" + octet + "\\." + octet + "\\." + octet + "\\." + octet + "$"));
int pos;
QString tmp(hostname);
if (ipv4Validator.validate(tmp,pos) == QValidator::Acceptable) {
address = inet_addr(hostname.toLatin1().data());
if (address == INADDR_ANY || address == INADDR_NONE) {
throw InvalidHostname(hostname);
}
}else {
struct hostent* host;
host = gethostbyname(hostname.toLatin1().data());
if (host->h_addrtype == AF_INET6) {
throw Exception("IPv6 addresses are not supported");
}else if (host) {
address = *(in_addr_t*)host->h_addr;
}
}
#else
struct addrinfo hints, *res;
int errcode;
char addrstr[100];
void *ptr(0);
memset(&hints, 0, sizeof (hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags |= AI_CANONNAME;
errcode = getaddrinfo(hostname.toLatin1().data(), NULL, &hints, &res);
if (errcode != 0) throw InvalidHostname(hostname);
inet_ntop(res->ai_family, res->ai_addr->sa_data, addrstr, 100);
switch (res->ai_family) {
case AF_INET:
ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
break;
case AF_INET6:
ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
break;
}
inet_ntop(res->ai_family, ptr, addrstr, 100);
address = inet_addr(addrstr);
QString ipv((res->ai_family == PF_INET6) ? "IPv6 address:" : "IPv4 address:");
QLOG_DEBUG() << ipv << QString(addrstr) << "=>" << QString(res->ai_canonname);
#endif
return address;
}
eap_status_e asn1_der_type_c::debug_data(eap_variable_data_c * const debug_buffer)
{
if (debug_buffer == 0)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
}
const u32_t max_prefix_length((m_recursion + 1ul) * SIZE_OF_ONE_OCTET_STRING + COUNT_OF_OCTETS * SIZE_OF_ONE_OCTET_STRING + 1ul);
const u32_t ascii_length(COUNT_OF_OCTETS + 5ul);
if ((max_prefix_length + ascii_length) > debug_buffer->get_buffer_length())
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
}
eap_status_e status = debug_buffer->set_data_length(max_prefix_length + ascii_length);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
u8_t * const prefix = reinterpret_cast<u8_t *>(debug_buffer->get_data(max_prefix_length));
u8_t * const ascii = reinterpret_cast<u8_t *>(debug_buffer->get_data_offset(max_prefix_length, ascii_length));
if (prefix == 0 || ascii == 0)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
}
u32_t ind(0ul);
u32_t offset(0ul);
status = debug_create_prefix(m_recursion + 1u, prefix, max_prefix_length, &offset);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
u32_t init_indentation_offset = offset;
u32_t type_data_size = get_header_length() + get_content_length();
u32_t data_ind(0ul);
u32_t ascii_ind(0ul);
u8_t octet(0);
for (ind = m_offset_of_contents_field; ind < type_data_size && ind < m_input_data_length; ++ind)
{
offset += m_am_tools->snprintf(
&prefix[offset],
max_prefix_length - offset,
"%02x \0",
m_input_data[ind]);
octet = m_input_data[ind];
if (octet < 0x20 || 0x7e < octet)
{
octet = '.';
}
m_am_tools->snprintf(
&ascii[ascii_ind],
ascii_length - ascii_ind,
"%c\0",
octet);
++data_ind;
++ascii_ind;
if ((ascii_ind % COUNT_OF_OCTETS) == 0)
{
prefix[offset] = 0;
ascii[ascii_ind] = 0;
offset = init_indentation_offset;
ascii_ind = 0ul;
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("%s |%s|\n"),
prefix,
ascii));
}
} // for()
u32_t remainder(ascii_ind % COUNT_OF_OCTETS);
if (remainder > 0ul)
{
for (; ascii_ind < COUNT_OF_OCTETS; ++ascii_ind)
{
offset += m_am_tools->snprintf(
&prefix[offset],
max_prefix_length - offset,
" \0");
m_am_tools->snprintf(
&ascii[ascii_ind],
ascii_length - ascii_ind,
" \0");
} // for()
prefix[offset] = 0;
ascii[ascii_ind] = 0;
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("%s |%s|\n"),
prefix,
ascii));
}
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
int SignatureNeutral::Train(boca::Event const& event, PreCuts const&, Tag tag)
{
INFO0;
auto higgs = heavy_higgs_semi_reader_.Tagger().HiggsParticle(event, tag);
auto sextets = heavy_higgs_semi_reader_.Multiplets(event);
sextets = BestMatches(sextets, higgs, tag);
auto doublets = jet_pair_reader_.Multiplets(event);
auto bottoms = SortedByPt(jet_pair_reader_.Tagger().PairBottomQuarks(event, tag));
auto particles = event.GenParticles();
auto tops = CopyIfParticle(particles, Id::top);
auto tops_even = CopyIfMother(tops, Id::heavy_higgs);
auto tops_odd = CopyIfMother(tops, Id::CP_odd_higgs);
auto top_higgs = Combine(tops_even, tops_odd);
auto one_close_to_top = 0, two_close_to_top = 0;
if (top_higgs.size() == 2) {
for (auto const & doublet : doublets) {
if ((Close<boca::Jet>(top_higgs.at(0))(doublet.Singlet1()) && Close<boca::Jet>(top_higgs.at(1))(doublet.Singlet2())) || (Close<boca::Jet>(top_higgs.at(1))(doublet.Singlet1()) && Close<boca::Jet>(top_higgs.at(0))(doublet.Singlet2()))) two_close_to_top++;
if ((Close<boca::Jet>(top_higgs.at(0))(doublet.Singlet1()) || Close<boca::Jet>(top_higgs.at(1))(doublet.Singlet2())) || (Close<boca::Jet>(top_higgs.at(1))(doublet.Singlet1()) || Close<boca::Jet>(top_higgs.at(0))(doublet.Singlet2()))) one_close_to_top++;
}
}
// ERROR(one_close_to_top, two_close_to_top);
static auto close_to_top_ = 0;
if (one_close_to_top == 6) {
++close_to_top_;
}
std::vector<Doublet> final_doublets;
switch (tag) {
case Tag::signal :
if (bottoms.size() == 2) {
for (auto const & doublet : doublets) {
if ((Close<boca::Jet>(bottoms.at(0))(doublet.Singlet1()) && Close<boca::Jet>(bottoms.at(1))(doublet.Singlet2())) || (Close<boca::Jet>(bottoms.at(1))(doublet.Singlet1()) && Close<boca::Jet>(bottoms.at(0))(doublet.Singlet2()))) final_doublets.emplace_back(doublet);
}
} else ERROR(bottoms.size());
break;
case Tag::background :
final_doublets = doublets;
break;
}
static auto zero_doublets = 0;
if (one_close_to_top < 6 && final_doublets.empty()) {
++zero_doublets;
}
std::vector<Octet62> octets;
for (auto const & doublet : final_doublets) {
for (auto const & sextet : sextets) {
Octet62 octet(sextet, doublet);
if (octet.Overlap()) continue;
octet.SetTag(tag);
octets.emplace_back(octet);
}
}
static auto zero_octets = 0;
if (one_close_to_top < 6 && !final_doublets.empty() && octets.empty()) {
++zero_octets;
}
// ERROR(close_to_top_, zero_doublets, zero_octets);
if (tag == Tag::signal && octets.size() > 1) {
INFO(octets.size());
std::sort(octets.begin(), octets.end());
octets.erase(octets.begin() + 1, octets.end());
}
return SaveEntries(octets);
}
