int main()
{
Span sp = Span(5);
Span sp1 = Span(10000);
Span sp2 = Span(10000);
Span sp3 = Span(10);
Span sp4 = Span(1);
srand(time(NULL));
sp.addNumber(5);
sp.addNumber(3);
sp.addNumber(17);
sp.addNumber(9);
sp.addNumber(11);
std::cout << sp.shortestSpan() << std::endl;
std::cout << sp.longestSpan() << std::endl;
sp1.RandInterval(9000);
std::cout << sp1.shortestSpan() << std::endl;
std::cout << sp1.longestSpan() << std::endl;
sp2.Interval(42, 9000);
std::cout << sp2.shortestSpan() << std::endl;
std::cout << sp2.longestSpan() << std::endl;
sp3.RandInterval(9000);
std::cout << sp3.shortestSpan() << std::endl;
std::cout << sp3.longestSpan() << std::endl;
sp4.addNumber(5);
sp4.addNumber(6);
std::cout << sp4.shortestSpan() << std::endl;
std::cout << sp4.longestSpan() << std::endl;
return (0);
}
bool IPAddress::TryParse(RCString s, IPAddress& ip) {
uint8_t buf[16];
if (CCheck(::inet_pton(AF_INET, s, buf))) {
ip = IPAddress(Span(buf, 4));
return true;
}
if (CCheck(::inet_pton(AF_INET6, s, buf))) {
ip = IPAddress(Span(buf, 16));
return true;
}
return false;
}
// ----------------------------------------------------------------------------
// Draws all of the spans for 2 edges
// ----------------------------------------------------------------------------
void drawSpansBetweenEdges(std::shared_ptr<TransferMap> & map, Edge & e1, Edge & e2)
{
// Calculate differences between the y coordinates
float e1ydiff = (float)(e1.p2[1] - e1.p1[1]);
if (e1ydiff == 0.0f) return;
float e2ydiff = (float)(e2.p2[1] - e2.p1[1]);
if (e2ydiff == 0.0f) return;
// Calculate differences between the x coordinates
float e1xdiff = (float)(e1.p2[0] - e1.p1[0]);
float e2xdiff = (float)(e2.p2[0] - e2.p1[0]);
// Calculate factors to use for interpolation
// with the edges and the step values to increase
// them by after drawing each span
float factor1 = (float)(e2.p1[1] - e1.p1[1]) / e1ydiff;
float factorStep1 = 1.0f / e1ydiff;
float factor2 = 0.0f;
float factorStep2 = 1.0f / e2ydiff;
// Loop through the lines between the edges and draw spans
for(int y = e2.p1[1]; y < e2.p2[1]; y++)
{
// Draw the span
auto m1 = interp(*e1.m1, *e1.m2, factor1);
auto m2 = interp(*e2.m1, *e2.m2, factor2);
drawSpan(map, Span(m1, e1.p1[0] + (int)(e1xdiff * factor1),
m2, e2.p1[0] + (int)(e2xdiff * factor2)), y);
// Increase factors
factor1 += factorStep1;
factor2 += factorStep2;
}
}
int main()
{
srand(std::time(0));
try
{
Span sp = Span(5);
sp.addNumber(5);
sp.addNumber(3);
sp.addNumber(17);
sp.addNumber(9);
sp.addNumber(11);
std::cout << sp.shortestSpan() << std::endl;
std::cout << sp.longestSpan() << std::endl;
Span big(10000);
big.initAll(randNumber);
std::cout << big.shortestSpan() << std::endl;
std::cout << big.longestSpan() << std::endl;
Span sp2(1);
std::cout << sp2.shortestSpan() << std::endl;
}
catch (std::exception & e)
{
std::cout << e.what() << std::endl;
}
}
// Preset Load
bool SweepSettings::Load(QSettings &s)
{
mode = (OperationalMode)(s.value("Mode", (int)Mode()).toInt());
start = s.value("Sweep/Start", Start().Val()).toDouble();
stop = s.value("Sweep/Stop", Stop().Val()).toDouble();
center = s.value("Sweep/Center", Center().Val()).toDouble();
span = s.value("Sweep/Span", Span().Val()).toDouble();
step = s.value("Sweep/Step", Step().Val()).toDouble();
rbw = s.value("Sweep/RBW", RBW().Val()).toDouble();
vbw = s.value("Sweep/VBW", VBW().Val()).toDouble();
auto_rbw = s.value("Sweep/AutoRBW", AutoRBW()).toBool();
auto_vbw = s.value("Sweep/AutoVBW", AutoVBW()).toBool();
native_rbw = s.value("Sweep/NativeRBW", NativeRBW()).toBool();
refLevel.Load(s, "Sweep/RefLevel");
div = s.value("Sweep/Division", Div()).toDouble();
attenuation = s.value("Sweep/Attenuation", Atten()).toInt();
gain = s.value("Sweep/Gain", Gain()).toInt();
preamp = s.value("Sweep/Preamp", Preamp()).toInt();
sweepTime = s.value("Sweep/SweepTime", SweepTime().Val()).toDouble();
processingUnits = s.value("Sweep/ProcessingUnits", ProcessingUnits()).toInt();
detector = s.value("Sweep/Detector", Detector()).toInt();
rejection = s.value("Sweep/Rejection", Rejection()).toBool();
tgSweepSize = s.value("Sweep/TgSweepSize", tgSweepSize).toInt();
tgHighRangeSweep = s.value("Sweep/TgHighRangeSweep", tgHighRangeSweep).toBool();
tgPassiveDevice = s.value("Sweep/TgPassiveDevice", tgPassiveDevice).toBool();
UpdateProgram();
return true;
}
VFPProdProperties::ADB VFPProdProperties::bhp(const std::vector<int>& table_id,
const Wells& wells,
const ADB& qs,
const ADB& thp_arg,
const ADB& alq) const {
const int nw = wells.number_of_wells;
//Short-hands for water / oil / gas phases
//TODO enable support for two-phase.
assert(wells.number_of_phases == 3);
const ADB& w = subset(qs, Span(nw, 1, BlackoilPhases::Aqua*nw));
const ADB& o = subset(qs, Span(nw, 1, BlackoilPhases::Liquid*nw));
const ADB& g = subset(qs, Span(nw, 1, BlackoilPhases::Vapour*nw));
return bhp(table_id, w, o, g, thp_arg, alq);
}
Point CCurve::NearestPoint(const Span& p, double *d)const
{
double best_dist = 0.0;
Point best_point = Point(0, 0);
bool best_point_valid = false;
Point prev_p = Point(0, 0);
bool prev_p_valid = false;
bool first_span = true;
for(std::list<CVertex>::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++)
{
const CVertex& vertex = *It;
if(prev_p_valid)
{
double dist;
Point near_point = Span(prev_p, vertex, first_span).NearestPoint(p, &dist);
first_span = false;
if(!best_point_valid || dist < best_dist)
{
best_dist = dist;
best_point = near_point;
best_point_valid = true;
}
}
prev_p = vertex.m_p;
prev_p_valid = true;
}
if(d)*d = best_dist;
return best_point;
}
void NewtonIterationBlackoilInterleaved::formInterleavedSystem(const std::vector<ADB>& eqs,
const Eigen::SparseMatrix<double, Eigen::RowMajor>& A,
Mat& istlA) const
{
const int np = eqs.size();
// Find sparsity structure as union of basic block sparsity structures,
// corresponding to the jacobians with respect to pressure.
// Use addition to get to the union structure.
Eigen::SparseMatrix<double> structure = eqs[0].derivative()[0];
for (int phase = 0; phase < np; ++phase) {
structure += eqs[phase].derivative()[0];
}
Eigen::SparseMatrix<double, Eigen::RowMajor> s = structure;
// Create ISTL matrix with interleaved rows and columns (block structured).
assert(np == 3);
istlA.setSize(s.rows(), s.cols(), s.nonZeros());
istlA.setBuildMode(Mat::row_wise);
const int* ia = s.outerIndexPtr();
const int* ja = s.innerIndexPtr();
for (Mat::CreateIterator row = istlA.createbegin(); row != istlA.createend(); ++row) {
int ri = row.index();
for (int i = ia[ri]; i < ia[ri + 1]; ++i) {
row.insert(ja[i]);
}
}
const int size = s.rows();
Span span[3] = { Span(size, 1, 0),
Span(size, 1, size),
Span(size, 1, 2*size) };
for (int row = 0; row < size; ++row) {
for (int col_ix = ia[row]; col_ix < ia[row + 1]; ++col_ix) {
const int col = ja[col_ix];
MatrixBlockType block;
for (int p1 = 0; p1 < np; ++p1) {
for (int p2 = 0; p2 < np; ++p2) {
block[p1][p2] = A.coeff(span[p1][row], span[p2][col]);
}
}
istlA[row][col] = block;
}
}
}
void View::dfs(
const std::vector<Atom>::const_iterator & now,
const std::vector<Atom>::const_iterator & end,
std::vector<Span> & deque,
const std::vector<int> & groups,
std::vector<Column> & newCols,
const std::vector<Text_token> & tokens,
const std::string & text
) {
if (now == end) {
unsigned p, q, k, h;
for (unsigned i = 0; i < newCols.size(); ++i) {
newCols[i].spans.push_back(
Span(
"",
deque[groups[i << 1]].from,
deque[groups[(i << 1) + 1] - 1].to
)
);
for (unsigned j = groups[i << 1]; j < groups[(i << 1) + 1]; ++j) {
if (j > groups[i << 1]) {
q = query(tokens, deque[j-1].to - 1);
p = query(tokens, deque[j].from);
for (k = q + 1; k < p; ++k) {
for (h = tokens[k-1].to; h < tokens[k].from; ++h)
newCols[i].spans.back().value.push_back(text[h]);
newCols[i].spans.back().value += tokens[k].value;
}
for (h = tokens[p-1].to; h < tokens[p].from; ++h)
newCols[i].spans.back().value.push_back(text[h]);
}
newCols[i].spans.back().value += deque[j].value;
}
}
} else {
unsigned p, q;
if (!deque.empty())
q = query(tokens, deque.back().to - 1);
for (
std::vector<Span>::const_iterator i = now->column.spans.begin();
i != now->column.spans.end();
++i
) {
p = query(tokens, i->from);
if (
deque.empty()
|| p - q > (now - 1)->interval_from
&& p - q - 1 <= (now - 1)->interval_to
) {
deque.push_back(*i);
dfs(now + 1, end, deque, groups, newCols, tokens, text);
deque.pop_back();
}
}
}
}
Statman::Statman(uintptr_t start, Size_type num_bytes)
{
if(num_bytes < 0)
throw Stats_exception{"Creating Statman: A negative number of bytes has been given"};
Size_type num_stats_in_span = num_bytes / sizeof(Stat);
num_bytes_ = sizeof(Stat) * num_stats_in_span;
stats_ = Span(reinterpret_cast<Stat*>(start), num_stats_in_span);
}
void
RasterCallback(const int y,
const int count,
const FT_Span * const spans,
void * const user)
{
Spans *sptr = (Spans *)user;
for (int i = 0; i < count; ++i)
sptr->push_back(Span(spans[i].x, y, spans[i].len, spans[i].coverage));
}
IPAddress IPAddress::Parse(RCString ipString) {
uint8_t buf[16];
if (CCheck(::inet_pton(AF_INET, ipString, buf)))
return IPAddress(Span(buf, 4));
if (CCheck(::inet_pton(AF_INET6, ipString, buf)))
return IPAddress(Span(buf, 16));
/*!!!R
#if UCFG_USE_REGEX
# if UCFG_WIN32
if (regex_search(ipString, *s_reDomainName)) {
# else
if (regex_search(ipString.c_str(), s_reDomainName)) {
# endif
IPAddress r;
r.AddressFamily = Ext::AddressFamily(AF_DOMAIN_NAME);
r.m_domainname = ipString;
return r;
}
#endif */
Throw(HRESULT_FROM_WIN32(DNS_ERROR_INVALID_IP_ADDRESS));
}
void CCurve::GetSpans(std::list<Span> &spans)const
{
const Point *prev_p = NULL;
for(std::list<CVertex>::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++)
{
const CVertex& vertex = *It;
if(prev_p)
{
spans.push_back(Span(*prev_p, vertex));
}
prev_p = &(vertex.m_p);
}
}
size_t IPAddress::GetHashCode() const {
size_t r = std::hash<uint16_t>()((uint16_t)get_AddressFamily());
switch ((int)get_AddressFamily()) {
case AF_INET:
r += std::hash<uint32_t>()(*(uint32_t*)&m_sin.sin_addr);
break;
case AF_INET6:
r += hash_value(Span((const uint8_t*)&m_sin6.sin6_addr, 16));
break;
default:
Throw(ExtErr::UnknownHostAddressType);
}
return r;
}
void CCurve::GetBox(CBox2D &box)
{
Point prev_p = Point(0, 0);
bool prev_p_valid = false;
for(std::list<CVertex>::iterator It = m_vertices.begin(); It != m_vertices.end(); It++)
{
CVertex& vertex = *It;
if(prev_p_valid)
{
Span(prev_p, vertex).GetBox(box);
}
prev_p = vertex.m_p;
prev_p_valid = true;
}
}
void View::extract_regex(string regex,
vector<int> groups,
vector<string> column_names,
string text) {
vector<vector<int> > result = findall(regex.c_str(), text.c_str());
columns.clear();
for (int col = 0; col < groups.size(); col++) {
columns.push_back(Column(column_names[col]));
for (int i = 0; i < result.size(); i++) {
int from = result[i][groups[col]*2]
,to = result[i][groups[col]*2+1];
columns[col].spans.push_back(Span(text.substr(from, to-from), from, to));
}
}
}
int main()
{
std::srand(time(0));
Span sp = Span(10000);
try
{
while (1)
sp.addNumber(rand());
}
catch(std::exception &e)
{
std::cout << e.what() << std::endl;
}
std::cout << sp.shortestSpan() << std::endl;
std::cout << sp.longestSpan() << std::endl;
}
CIsect Plane::intersect(const Ray& ray)
{
float angle = dot(mNormal, ray.getDir());
if (fabs(angle) < FLOAT_ZERO)
{
return CIsect(false);
}
float t = (-(dot(ray.getOrg(), mNormal) + mD) / angle);
if (t > 0.f)
{
CIsect res(true, t, this, getNormal(ray, t));
res.Dst.push_back(t);
res.InsideIntervals.push_back(Span(t, t));
return res;
}
return CIsect(false);
}
double CCurve::GetArea()const
{
double area = 0.0;
Point prev_p = Point(0, 0);
bool prev_p_valid = false;
for(std::list<CVertex>::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++)
{
const CVertex& vertex = *It;
if(prev_p_valid)
{
area += Span(prev_p, vertex).GetArea();
}
prev_p = vertex.m_p;
prev_p_valid = true;
}
return area;
}
void Table::GetValueRects(int zoom, Draw& w, int x, int& y, int cx, Vector<ValueRect>& vr)
const {
int zfw = DocZoomLn(zoom, GetFrameWidth());
int li = 0;
cx -= 2 * zfw + DocZoom(zoom, GetLm()) + DocZoom(zoom, GetRm());
y += zfw;
while(li < GetRows()) {
Vector<Line> line;
int span = 0;
for(;;) {
int k = li + line.GetCount();
if(k >= GetRows() || line.GetCount() && !KeepLine(k) && span <= 0)
break;
span = max((line.Add() = GetLine(zoom, k, cx, NULL)).span, span);
span--;
}
y += Span(line);
RectLines(zoom, w, x, y, li, line, vr);
li += line.GetCount();
}
y += zfw;
}
int Table::GetHeight(int zoom, int cx) const {
int cy = 0;
int ln = 0;
cx -= DocZoomLn(zoom, GetFrameWidth()) + DocZoomLn(zoom, GetFrameWidth()) +
DocZoom(zoom, GetLm()) + DocZoom(zoom, GetRm());
cy += 2 * DocZoomLn(zoom, GetFrameWidth());
while(ln < GetRows()) {
Vector<Line> line;
int span = 0;
for(;;) {
int k = ln + line.GetCount();
if(ln + line.GetCount() >= GetRows() ||
line.GetCount() && !KeepLine(k) && span <= 0)
break;
span = max((line.Add() = GetLine(zoom, k, cx, NULL)).span, span);
span--;
}
cy += Span(line);
ln += line.GetCount();
}
return cy;
}
bool Table::Paint(int zoom, Draw& w, int x, int y, int cx, int ymax, PaintInfo& pi) const {
int j;
Vector<Line> header;
int zfw = DocZoomLn(zoom, GetFrameWidth());
int tcx = cx - 2 * zfw - DocZoom(zoom, GetLm()) - DocZoom(zoom, GetRm());
bool breakpage = pi.line != pi.oline;
int pgcy = ymax - y;
pi.oline = pi.line;
if(pi.line) {
int m = min(GetHeaderRows(), cell.GetCount());
for(j = 0; j < m; j++)
header.Add() = GetLine(zoom, j, tcx, NULL);
}
int hdrcy = Span(header);
if(hdrcy > ymax - y) {
header.Clear();
hdrcy = 0;
}
int hg = hdrcy;
int yp = y;
y += zfw;
bool was = false;
if(y >= ymax) {
pi.ypos = y;
return true;
}
while(pi.line < GetRows() && y < ymax) {
Vector<Line> line;
Vector<int> *yl = &pi.yl;
int span = 0;
bool nospan = true;
for(;;) {
int k = pi.line + line.GetCount();
if(k >= GetRows() || line.GetCount() && !KeepLine(k) && span <= 0)
break;
span = max((line.Add() = GetLine(zoom, k, tcx, yl)).span, span);
if(span) nospan = false;
yl = NULL;
span--;
}
hg += Span(line);
int lhg = line.Top().height;
if(hg + y + zfw > ymax) {
if((!breakpage ||
lhg > style.breakcy && ymax - (y + hg - lhg) - zfw > style.breakpgcy)
&& nospan && line.GetCount() && hg + y + zfw - lhg <= ymax) {
int yy = y + hdrcy;
PaintLines(zoom, w, x, yy, 0, header, 0);
yy = y + hdrcy;
int i;
for(i = 0; i < line.GetCount() - 1; i++) {
DrawLine(zoom, w, x, yy, pi.line++, line[i], ymax, NULL);
yy += line[i].height;
}
DrawLine(zoom, w, x, yy, pi.line, line[i], ymax, &pi.yl);
breakpage = was = true;
y = ymax;
}
if(breakpage) {
FrameTab(zoom, w, was, x, y, yp, cx);
pi.ypos = y;
return true;
}
}
y += hg;
int yy = y;
PaintLines(zoom, w, x, yy, pi.line, line, &pi.yl);
PaintLines(zoom, w, x, yy, 0, header, 0);
pi.yl.Clear();
header.Clear();
hg = 0;
breakpage = was = true;
pi.line += line.GetCount();
}
FrameTab(zoom, w, was, x, y, yp, cx);
pi.ypos = y + zfw;
return false;
}
TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
{
//TRACE_FUNCTION;
auto ps = lex.start_span();
Token tok;
switch( GET_TOK(tok, lex) )
{
case TOK_INTERPOLATED_TYPE:
return mv$(tok.frag_type());
// '!' - Only ever used as part of function prototypes, but is kinda a type... not allowed here though
case TOK_EXCLAM:
return TypeRef( Span(tok.get_pos()), TypeData::make_Bang({}) );
// '_' = Wildcard (type inferrence variable)
case TOK_UNDERSCORE:
return TypeRef(Span(tok.get_pos()));
// 'unsafe' - An unsafe function type
case TOK_RWORD_UNSAFE:
// 'extern' - A function type with an ABI
case TOK_RWORD_EXTERN:
// 'fn' - Rust function
case TOK_RWORD_FN:
PUTBACK(tok, lex);
return Parse_Type_Fn(lex);
case TOK_RWORD_IMPL:
return Parse_Type_ErasedType(lex, allow_trait_list);
// '<' - An associated type cast
case TOK_LT:
case TOK_DOUBLE_LT: {
PUTBACK(tok, lex);
auto path = Parse_Path(lex, PATH_GENERIC_TYPE);
return TypeRef(TypeRef::TagPath(), lex.end_span(mv$(ps)), mv$(path));
}
//
case TOK_RWORD_FOR: {
auto hrls = Parse_HRB(lex);
switch(LOOK_AHEAD(lex))
{
case TOK_RWORD_UNSAFE:
case TOK_RWORD_EXTERN:
case TOK_RWORD_FN:
return Parse_Type_Fn(lex, hrls);
default:
return Parse_Type_Path(lex, hrls, true);
}
}
// <ident> - Either a primitive, or a path
case TOK_IDENT:
if( lex.lookahead(0) == TOK_EXCLAM )
{
lex.getToken();
// TODO: path macros
return TypeRef(TypeRef::TagMacro(), Parse_MacroInvocation(ps, mv$(tok.str()), lex));
}
// or a primitive
//if( auto ct = coretype_fromstring(tok.str()) )
//{
// return TypeRef(TypeRef::TagPrimitive(), Span(tok.get_pos()), ct);
//}
PUTBACK(tok, lex);
return Parse_Type_Path(lex, {}, allow_trait_list);
// - Fall through to path handling
// '::' - Absolute path
case TOK_DOUBLE_COLON:
// 'self' - This relative path
case TOK_RWORD_SELF:
// 'super' - Parent relative path
case TOK_RWORD_SUPER:
// ':path' fragment
case TOK_INTERPOLATED_PATH:
PUTBACK(tok, lex);
return Parse_Type_Path(lex, {}, allow_trait_list);
// HACK! Convert && into & &
case TOK_DOUBLE_AMP:
lex.putback(Token(TOK_AMP));
// '&' - Reference type
case TOK_AMP: {
AST::LifetimeRef lifetime;
// Reference
tok = lex.getToken();
if( tok.type() == TOK_LIFETIME ) {
lifetime = AST::LifetimeRef(/*lex.point_span(), */lex.get_ident(::std::move(tok)));
tok = lex.getToken();
}
bool is_mut = false;
if( tok.type() == TOK_RWORD_MUT ) {
is_mut = true;
}
else {
PUTBACK(tok, lex);
}
return TypeRef(TypeRef::TagReference(), lex.end_span(mv$(ps)), ::std::move(lifetime), is_mut, Parse_Type(lex, false));
}
// '*' - Raw pointer
case TOK_STAR:
// Pointer
switch( GET_TOK(tok, lex) )
{
case TOK_RWORD_MUT:
// Mutable pointer
return TypeRef(TypeRef::TagPointer(), lex.end_span(mv$(ps)), true, Parse_Type(lex, false));
case TOK_RWORD_CONST:
// Immutable pointer
return TypeRef(TypeRef::TagPointer(), lex.end_span(mv$(ps)), false, Parse_Type(lex, false));
default:
throw ParseError::Unexpected(lex, tok, {TOK_RWORD_CONST, TOK_RWORD_MUT});
}
throw ParseError::BugCheck("Reached end of Parse_Type:STAR");
// '[' - Array type
case TOK_SQUARE_OPEN: {
// Array
TypeRef inner = Parse_Type(lex);
if( GET_TOK(tok, lex) == TOK_SEMICOLON ) {
// Sized array
AST::Expr array_size = Parse_Expr(lex);
GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
return TypeRef(TypeRef::TagSizedArray(), lex.end_span(mv$(ps)), mv$(inner), array_size.take_node());
}
else if( tok.type() == TOK_SQUARE_CLOSE )
{
return TypeRef(TypeRef::TagUnsizedArray(), lex.end_span(mv$(ps)), mv$(inner));
}
else {
throw ParseError::Unexpected(lex, tok/*, "; or ]"*/);
}
}
// '(' - Tuple (or lifetime bounded trait)
case TOK_PAREN_OPEN: {
DEBUG("Tuple");
if( GET_TOK(tok, lex) == TOK_PAREN_CLOSE )
return TypeRef(TypeRef::TagTuple(), lex.end_span(mv$(ps)), {});
PUTBACK(tok, lex);
TypeRef inner = Parse_Type(lex, true);
if( LOOK_AHEAD(lex) == TOK_PAREN_CLOSE )
{
// Type in parens, NOT a tuple
GET_CHECK_TOK(tok, lex, TOK_PAREN_CLOSE);
return inner;
}
else
{
::std::vector<TypeRef> types;
types.push_back( mv$(inner) );
while( GET_TOK(tok, lex) == TOK_COMMA )
{
if( GET_TOK(tok, lex) == TOK_PAREN_CLOSE )
break;
else
PUTBACK(tok, lex);
types.push_back( Parse_Type(lex) );
}
CHECK_TOK(tok, TOK_PAREN_CLOSE);
return TypeRef(TypeRef::TagTuple(), lex.end_span(mv$(ps)), mv$(types)); }
}
default:
throw ParseError::Unexpected(lex, tok);
}
throw ParseError::BugCheck("Reached end of Parse_Type");
}
TypeRef Parse_Type_Fn(TokenStream& lex, ::AST::HigherRankedBounds hrbs)
{
auto ps = lex.start_span();
TRACE_FUNCTION;
Token tok;
::std::string abi = "";
bool is_unsafe = false;
GET_TOK(tok, lex);
// `unsafe`
if( tok.type() == TOK_RWORD_UNSAFE )
{
is_unsafe = true;
GET_TOK(tok, lex);
}
// `exern`
if( tok.type() == TOK_RWORD_EXTERN )
{
if( GET_TOK(tok, lex) == TOK_STRING ) {
abi = tok.str();
if( abi == "" )
ERROR(lex.point_span(), E0000, "Empty ABI");
GET_TOK(tok, lex);
}
else {
abi = "C";
}
}
// `fn`
CHECK_TOK(tok, TOK_RWORD_FN);
::std::vector<TypeRef> args;
bool is_variadic = false;
GET_CHECK_TOK(tok, lex, TOK_PAREN_OPEN);
while( LOOK_AHEAD(lex) != TOK_PAREN_CLOSE )
{
if( LOOK_AHEAD(lex) == TOK_TRIPLE_DOT ) {
GET_TOK(tok, lex);
is_variadic = true;
break;
}
// Handle `ident: `
if( (lex.lookahead(0) == TOK_IDENT || lex.lookahead(0) == TOK_UNDERSCORE) && lex.lookahead(1) == TOK_COLON ) {
GET_TOK(tok, lex);
GET_TOK(tok, lex);
}
args.push_back( Parse_Type(lex) );
if( GET_TOK(tok, lex) != TOK_COMMA ) {
PUTBACK(tok, lex);
break;
}
}
GET_CHECK_TOK(tok, lex, TOK_PAREN_CLOSE);
// `-> RetType`
TypeRef ret_type = TypeRef(TypeRef::TagUnit(), Span(tok.get_pos()));
if( GET_TOK(tok, lex) == TOK_THINARROW )
{
ret_type = Parse_Type(lex, false);
}
else {
PUTBACK(tok, lex);
}
return TypeRef(TypeRef::TagFunction(), lex.end_span(mv$(ps)), mv$(hrbs), is_unsafe, mv$(abi), mv$(args), is_variadic, mv$(ret_type));
}
Span()
{
Span(0, 0);
}
static Span fill() { return Span(100, Span::PERCENT); }
void Expand_TestHarness(::AST::Crate& crate)
{
// Create the following module:
// ```
// mod `#test` {
// extern crate std;
// extern crate test;
// fn main() {
// self::test::test_main_static(&::`#test`::TESTS);
// }
// static TESTS: [test::TestDescAndFn; _] = [
// test::TestDescAndFn { desc: test::TestDesc { name: "foo", ignore: false, should_panic: test::ShouldPanic::No }, testfn: ::path::to::foo },
// ];
// }
// ```
// ---- main function ----
auto main_fn = ::AST::Function { Span(), {}, ABI_RUST, false, false, false, TypeRef(TypeRef::TagUnit(), Span()), {} };
{
auto call_node = NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("test_main_static") }),
::make_vec1(
NEWNODE(_UniOp, ::AST::ExprNode_UniOp::REF,
NEWNODE(_NamedValue, ::AST::Path("", { ::AST::PathNode("test#"), ::AST::PathNode("TESTS") }))
)
)
);
main_fn.set_code( mv$(call_node) );
}
// ---- test list ----
::std::vector< ::AST::ExprNodeP> test_nodes;
for(const auto& test : crate.m_tests)
{
// HACK: Don't emit should_panic tests
if( test.panic_type != ::AST::TestDesc::ShouldPanic::No )
continue ;
::AST::ExprNode_StructLiteral::t_values desc_vals;
// `name: "foo",`
desc_vals.push_back({ {}, "name", NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("StaticTestName") }),
::make_vec1( NEWNODE(_String, test.name) )
) });
// `ignore: false,`
desc_vals.push_back({ {}, "ignore", NEWNODE(_Bool, test.ignore) });
// `should_panic: ShouldPanic::No,`
{
::AST::ExprNodeP should_panic_val;
switch(test.panic_type)
{
case ::AST::TestDesc::ShouldPanic::No:
should_panic_val = NEWNODE(_NamedValue, ::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("No") }));
break;
case ::AST::TestDesc::ShouldPanic::Yes:
should_panic_val = NEWNODE(_NamedValue, ::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("Yes") }));
break;
case ::AST::TestDesc::ShouldPanic::YesWithMessage:
should_panic_val = NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("YesWithMessage") }),
make_vec1( NEWNODE(_String, test.expected_panic_message) )
);
break;
}
desc_vals.push_back({ {}, "should_panic", mv$(should_panic_val) });
}
auto desc_expr = NEWNODE(_StructLiteral, ::AST::Path("test", { ::AST::PathNode("TestDesc")}), nullptr, mv$(desc_vals));
::AST::ExprNode_StructLiteral::t_values descandfn_vals;
descandfn_vals.push_back({ {}, ::std::string("desc"), mv$(desc_expr) });
auto test_type_var_name = test.is_benchmark ? "StaticBenchFn" : "StaticTestFn";
descandfn_vals.push_back({ {}, ::std::string("testfn"), NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode(test_type_var_name) }),
::make_vec1( NEWNODE(_NamedValue, AST::Path(test.path)) )
) });
test_nodes.push_back( NEWNODE(_StructLiteral, ::AST::Path("test", { ::AST::PathNode("TestDescAndFn")}), nullptr, mv$(descandfn_vals) ) );
}
auto* tests_array = new ::AST::ExprNode_Array(mv$(test_nodes));
size_t test_count = tests_array->m_values.size();
auto tests_list = ::AST::Static { ::AST::Static::Class::STATIC,
TypeRef(TypeRef::TagSizedArray(), Span(),
TypeRef(Span(), ::AST::Path("test", { ::AST::PathNode("TestDescAndFn") })),
::std::shared_ptr<::AST::ExprNode>( new ::AST::ExprNode_Integer(test_count, CORETYPE_UINT) )
),
::AST::Expr( mv$(tests_array) )
};
// ---- module ----
auto newmod = ::AST::Module { ::AST::Path("", { ::AST::PathNode("test#") }) };
// - TODO: These need to be loaded too.
// > They don't actually need to exist here, just be loaded (and use absolute paths)
newmod.add_ext_crate(false, "std", "std", {});
newmod.add_ext_crate(false, "test", "test", {});
newmod.add_item(false, "main", mv$(main_fn), {});
newmod.add_item(false, "TESTS", mv$(tests_list), {});
crate.m_root_module.add_item(false, "test#", mv$(newmod), {});
crate.m_lang_items["mrustc-main"] = ::AST::Path("", { AST::PathNode("test#"), AST::PathNode("main") });
}
CIsect Cylinder::intersect(const Ray& ray)
{
const Vec3D& origin = ray.getOrg();
const Vec3D& direction = ray.getDir();
const Vec3D& CO = origin - mBottom;
const Vec3D& u = direction - mAxis * (dot(direction, mAxis));
const Vec3D& v = CO - mAxis * (dot(CO, mAxis));
CIsect res = CIsect(true);
// Let a, b and c be coefficients of some square equation
const float a = dot(u, u);
float root = 0.f;
float closest = -1.f;
float rayExit = -1.f;
if (fabs(a) > FLOAT_ZERO)
{
const float b = 2 * dot(u, v);
const float c = dot(v, v) - mRadius2;
float D = b * b - 4 * a * c;
// Complete miss
if (D < 0.f)
{
return CIsect(false);
}
D = sqrtf(D);
// Calculate roots and take closest
float denom = 1 / (2 * a);
root = (-b - D) * denom;
if (root >= 0.f)
{
Vec3D toBottom = ray.apply(root) - mBottom;
Vec3D toTop = ray.apply(root) - mTop;
if (dot(mAxis, toBottom) > 0.f && dot(mAxis, toTop) < 0.f)
{
res.Dst.push_back(root);
closest = root;
}
}
root = (-b + D) * denom;
if (root > 0.f)
{
// Awful copy paste :(
Vec3D toBottom = ray.apply(root) - mBottom;
Vec3D toTop = ray.apply(root) - mTop;
if (dot(mAxis, toBottom) > 0.f && dot(mAxis, toTop) < 0.f)
{
res.Dst.push_back(root);
if (closest < 0.f)
{
root = closest;
}
else if (root < closest)
{
rayExit = closest;
closest = root;
}
else
{
rayExit = root;
}
}
}
}
// dot(va, (q - p1)) = 0 t = (dot(va, p1) - dot(va, p)) / dot(va, v)
// Find intersection with caps
// Bottom one
float axisToDir = dot(mAxis, direction);
if (fabs(axisToDir) < FLOAT_ZERO)
{
if (closest > 0.f)
{
res.Distance = closest;
res.Object = this;
res.Normal = getNormal(ray, closest);
if (rayExit < 0.f)
{
res.InsideIntervals.push_back(Span(0.f, closest));
res.Dst.insert(res.Dst.begin(), 0.f);
}
else
{
res.InsideIntervals.push_back(Span(closest, rayExit));
}
return res;
}
return CIsect(false);
}
float axisToOrg = dot(mAxis, origin);
//root = (dot(mAxis, mBottom) - axisToOrg) / axisToDir;
float CODotAxis = dot(CO, mAxis);
root = -CODotAxis / axisToDir;
if (root > 0.f)
{
Vec3D toBottom = ray.apply(root) - mBottom;
if (dot(toBottom, toBottom) < mRadius2)
{
res.Dst.push_back(root);
// Awful copy paste :(
if (closest < 0.f)
{
closest = root;
}
else if (root < closest)
{
rayExit = closest;
closest = root;
}
else
{
rayExit = root;
}
}
}
// Top one
//root = (dot(mAxis, mTop) - axisToOrg) / axisToDir;
float CTDotAxis = dot(origin - mTop, -mAxis);
root = CTDotAxis / axisToDir;
if (root > 0.f)
{
// Awful copy paste :(
Vec3D toTop = ray.apply(root) - mTop;
if (dot(toTop, toTop) < mRadius2)
{
res.Dst.push_back(root);
if (closest < 0.f)
{
closest = root;
}
else if (root < closest)
{
rayExit = closest;
closest = root;
}
else
{
rayExit = root;
}
}
}
if (closest >= 0.f)
{
res.Distance = closest;
res.Object = this;
res.Normal = getNormal(ray, closest);
if (rayExit < 0.f)
{
res.InsideIntervals.push_back(Span(0.f, closest));
res.Dst.insert(res.Dst.begin(), 0.f);
}
else
{
res.InsideIntervals.push_back(Span(closest, rayExit));
}
return res;
}
return CIsect(false);
}
int KBlocksAIPlanner::process(KBlocks_PieceType_Detail pieceValue)
{
// board size
int w = mpField->getWidth();
int h = mpField->getHeight();
// piece bound
Spans p_Col_Height = Spans(w);
// board rect
Lines b_Col_maxHeight = Lines(w);
// board info - max height per column
for (int x = 0; x < w; x++) {
int y = 0;
for (y = 0; y < h; y++) {
if (mpField->getCell(x, y)) {
break;
}
}
b_Col_maxHeight[x] = y;
}
// init next_states list
mNextPieceValues.clear();
// init piece state
KBlocksPiece piece;
piece.fromValue(pieceValue);
int loopCount = piece.getRotationCount();
// scan all possible rotation
for (int rotation = 0; rotation < loopCount; rotation++) {
// piece info - min/max height per column
piece.setRotation(rotation);
// scan all possible x position - put piece on board
for (int x = 0; x < w; x++) {
bool invalidPos = false;
piece.setPosX(x);
piece.setPosY(0);
// init
for (int i = 0; i < w; i++) {
p_Col_Height[i] = Span(h, -1);
}
for (int i = 0; i < KBlocksPiece_CellCount; i++) {
int cx = piece.getCellPosX(i);
int cy = piece.getCellPosY(i);
if (mpField->getCell(cx, cy)) {
invalidPos = true;
break;
}
if (p_Col_Height[cx].min > cy) {
p_Col_Height[cx].min = cy;
}
if (p_Col_Height[cx].max < cy) {
p_Col_Height[cx].max = cy;
}
}
if (invalidPos) {
continue;
}
// get response height
int y = h;
for (int px = 0; px < w; px++) {
if (p_Col_Height[px].min == h) {
continue;
}
int dy = b_Col_maxHeight[px] - 1 - p_Col_Height[px].max;
if (dy < y) {
y = dy;
}
}
if ((y < 0) || (y >= h)) {
continue;
}
// state
piece.setPosY(y);
// insert to list
mNextPieceValues.push_back(piece);
}
}
return (int)(mNextPieceValues.size());
}
const Span State::span() const {
return Span(_frontier);
}
