Documentation missing math functions

Apologies if this is listed somewhere and I keep missing it, but I've been going through the documentation page by page and I can't seem to find the cnl::sqrt function mentioned anywhere (which I realized existed while watching that excellent CppCon 2017 presentation). In addition, on pages listing available functions like the one mentioned below, the abs function doesn't seem to be listed there as well:
https://johnmcfarlane.github.io/cnl/namespacemembers_func.html
In addition, I believe there was some mention of in-progress trig functions in the CppCon 2017 presentation as well, but issue #341 seems to imply those functions aren't available as well.
There's a good chance I'm simply missing these functions in the documentation (such as overly relying on the function listing pages), but thought it may be helpful to write this issue just in case.

As a side note, is there any thorough all-in-one place documentation on rounding capabilities and intentions? Having a bit of trouble piecing together the current supported behavior and options (eg, if it's possible to keep a more consistent size esp with respect to exponents at the cost of [decimal] precision when multiplying and dividing)

All of the definitions in _include/cnl/impl/scaled_integer/extras.h were excluded from the docs due to problems Doxygen had with processing that file. It's no longer excluded and sqrt and abs from that file are showing up in docs.
Within the same file are a few trig functions, however, that are placeholders; they call floating-point functions. They should be usable but I'm hesitant to document something that falls back on FPU support. I do still want to implement such functions in the future but as pointed out in #341, it's not trivial to implement lookup tables without constexpr support in .
Are you looking for a simple equivalent to the existing standard functions such as std::cos or are lookup tables more useful to you? I'd be curious to know roughly what HW/application/toolchain you have in mind (if any). Thanks.
No, rounding isn't especially well documented. Take a look at rounding_integer and the classes ending with _rounding_tag for details of the different rounding modes.
Action: pad out the Doxygen entry for cnl::rounding_integer and include /sa commands for the rounding tags/concept.

All of the definitions in _include/cnl/impl/scaled_integer/extras.h were excluded from the docs due to problems Doxygen had with processing that file. It's no longer excluded and sqrt and abs from that file are showing up in docs.
Within the same file are a few trig functions, however, that are placeholders; they call floating-point functions. They should be usable but I'm hesitant to document something that falls back on FPU support. I do still want to implement such functions in the future but as pointed out in #341, it's not trivial to implement lookup tables without constexpr support in .
Are you looking for a simple equivalent to the existing standard functions such as std::cos or are lookup tables more useful to you? I'd be curious to know roughly what HW/application/toolchain you have in mind (if any). Thanks.
No, rounding isn't especially well documented. Take a look at rounding_integer and the classes ending with _rounding_tag for details of the different rounding modes.
Action: pad out the Doxygen entry for cnl::rounding_integer and include /sa commands for the rounding tags/concept.

Thank you for looking into this, I really appreciate the response and it's nice to know those are all in extras.h as well
As for my needs, I think they may be a bit unique compared to other CNL users. I'm attempting to build a deterministic multiplayer game (with Unreal but building out a separate pure C++ simulation layer including a standalone simple physics engine). World units are essentially in cm, so "decimal" accuracy (not sure for the term for numbers beyond the decimal point) isn't too important but accurate replication across all hardware (cross-platform across PCs and consoles at least) is more important to me.
Essentially, my project more so relies on deterministic behavior while pinpoint accuracy isn't that important (as it shouldn't be noticeable in gameplay). Thus, a lookup table would definitely serve my needs pretty well.

As for a quick question on top- has there been any consideration for recreating floating point-like behavior with CNL, where loss of precision is acceptable while preventing overflows and type size escalations? I actually temporarily reverted back to floats in my project as ran into various odd issues with scaled_integers via CNL v1.x (constantly tweaking power/exponent and size of a scaled_integer and elastic_scaled_integer but finally temporarily gave up once multiplying several fixed point numbers in a row led to a 0 being consistently outputted- suspecting overflow issue without overflow exceptions being thrown)
Worried that my use case may in fact be outside the scope of CNL. However, I'll look into the rounding_integer which may be what I'm looking for, thank you!

Thank you for looking into this, I really appreciate the response and it's nice to know those are all in extras.h as well
As for my needs, I think they may be a bit unique compared to other CNL users. I'm attempting to build a deterministic multiplayer game (with Unreal but building out a separate pure C++ simulation layer including a standalone simple physics engine). World units are essentially in cm, so "decimal" accuracy (not sure for the term for numbers beyond the decimal point) isn't too important but accurate replication across all hardware (cross-platform across PCs and consoles at least) is more important to me.
Essentially, my project more so relies on deterministic behavior while pinpoint accuracy isn't that important (as it shouldn't be noticeable in gameplay). Thus, a lookup table would definitely serve my needs pretty well.

As for a quick question on top- has there been any consideration for recreating floating point-like behavior with CNL, where loss of precision is acceptable while preventing overflows and type size escalations? I actually temporarily reverted back to floats in my project as ran into various odd issues with scaled_integers via CNL v1.x (constantly tweaking power/exponent and size of a scaled_integer and elastic_scaled_integer but finally temporarily gave up once multiplying several fixed point numbers in a row led to a 0 being consistently outputted- suspecting overflow issue without overflow exceptions being thrown)
Worried that my use case may in fact be outside the scope of CNL. However, I'll look into the rounding_integer which may be what I'm looking for, thank you!

Floating-point is actually very effective at "preventing overflows and type size escalations". Knowing the exponent of a value at run-time is a huge advantage which fixed-point must work around.
But losing precision isn't a problem. Simply cast back to the original type with the greater exponent value and less significant bits will be dropped. Your number may end up being flushed when this happens: all significant bits are lost and the value is zero. Again, not a serious problem with floating-point.
Example:
using fp = scaled_integer<elastic_integer<8>, power<-4>>;

// 1/8 stored with 4 fractional digits
auto input = fp{0.125};
print("input={}\n", input);

// 1/64 stored with 8 fractional digits
auto square = input*input;
print("square={}\n", square);

// approximation of 1/64 stored with 4 fractional digits is 0!
auto truncated = fp{square};
print("truncated={}\n", truncated);

Floating-point is actually very effective at "preventing overflows and type size escalations". Knowing the exponent of a value at run-time is a huge advantage which fixed-point must work around.
But losing precision isn't a problem. Simply cast back to the original type with the greater exponent value and less significant bits will be dropped. Your number may end up being flushed when this happens: all significant bits are lost and the value is zero. Again, not a serious problem with floating-point.
Example:
using fp = scaled_integer<elastic_integer<8>, power<-4>>;

// 1/8 stored with 4 fractional digits
auto input = fp{0.125};
print("input={}\n", input);

// 1/64 stored with 8 fractional digits
auto square = input*input;
print("square={}\n", square);

// approximation of 1/64 stored with 4 fractional digits is 0!
auto truncated = fp{square};
print("truncated={}\n", truncated);

Ahhh yup, I've been definitely running into the truncation issue (as I explicitly define the same type every time - eg "fp" here - instead of using auto). I need to work on my numerical supported range a bit more, as I definitely need 64 bits to, say, support whole numbers of [-10 million, 10 million] and "decimal" numbers of around [0, 10000].
However, I do remember there being some odd issue with trying to use a int64_t type for the scaled_integer, eg scaled_integer<uint64_t, power<-24>. If I understand the documentation and examples correctly, that should be 24 bits for fractional/decimal piece, 1 bit for sign, and (64-24-1)=39 bits for the non-fractional piece. However, I ran into issues when trying to do a vector normalize operation (multiply -> adding -> sqrt -> divison) and perhaps other similar operations, with compilation errors similar to the following:
...
2>FixedPointTests.cpp
2>FixedPointVectorTests.cpp
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_digits.h(92,128): error C2504: 'cnl::signed_integer_cannot_have<127>::digits_because_maximum_is<63>': base class undefined
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_digits.h(152): message : see reference to class template instantiation 'cnl::_impl::set_digits_signed<127,void>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_width.h(19): message : see reference to class template instantiation 'cnl::set_digits<T,127,void>' being compiled
2>        with
2>        [
2>            T=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(81): message : see reference to class template instantiation 'cnl::_impl::set_width<Rep,128>' being compiled
2>        with
2>        [
2>            Rep=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(81): message : see reference to alias template instantiation 'cnl::_impl::set_width_t<__int64,128>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(113): message : see reference to function template instantiation 'Rep cnl::_impl::sqrt_solve1<-24>::operator ()<Number>(Rep) const' being compiled
2>        with
2>        [
2>            Rep=__int64,
2>            Number=__int64
2>        ]
...

I'm pretty certain I have to use an int64_t to assure I have the correct range (+/- 10 million with 0-10k fractional) but it seems that this runs into a hard limitation related to the type size escalation (apologies if I'm misremembering the term there).
Is there some way for me to get around this limitation? Or is my numerical range outside the scope of CNL?
Also apologies for sidetracking this issue further. I've been trying to go up and down the documentation + examples trying to figure out how to use CNL for my exact use case (specific numerical range with emphasis on utilizing determinism of integers without too much of a care for precision), and I think this may be the last piece I've been failing to understand to fully utilize the library.

Ahhh yup, I've been definitely running into the truncation issue (as I explicitly define the same type every time - eg "fp" here - instead of using auto). I need to work on my numerical supported range a bit more, as I definitely need 64 bits to, say, support whole numbers of [-10 million, 10 million] and "decimal" numbers of around [0, 10000].
However, I do remember there being some odd issue with trying to use a int64_t type for the scaled_integer, eg scaled_integer<uint64_t, power<-24>. If I understand the documentation and examples correctly, that should be 24 bits for fractional/decimal piece, 1 bit for sign, and (64-24-1)=39 bits for the non-fractional piece. However, I ran into issues when trying to do a vector normalize operation (multiply -> adding -> sqrt -> divison) and perhaps other similar operations, with compilation errors similar to the following:
...
2>FixedPointTests.cpp
2>FixedPointVectorTests.cpp
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_digits.h(92,128): error C2504: 'cnl::signed_integer_cannot_have<127>::digits_because_maximum_is<63>': base class undefined
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_digits.h(152): message : see reference to class template instantiation 'cnl::_impl::set_digits_signed<127,void>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl\_impl\num_traits\set_width.h(19): message : see reference to class template instantiation 'cnl::set_digits<T,127,void>' being compiled
2>        with
2>        [
2>            T=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(81): message : see reference to class template instantiation 'cnl::_impl::set_width<Rep,128>' being compiled
2>        with
2>        [
2>            Rep=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(81): message : see reference to alias template instantiation 'cnl::_impl::set_width_t<__int64,128>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl\_impl\scaled_integer\extras.h(113): message : see reference to function template instantiation 'Rep cnl::_impl::sqrt_solve1<-24>::operator ()<Number>(Rep) const' being compiled
2>        with
2>        [
2>            Rep=__int64,
2>            Number=__int64
2>        ]
...

I'm pretty certain I have to use an int64_t to assure I have the correct range (+/- 10 million with 0-10k fractional) but it seems that this runs into a hard limitation related to the type size escalation (apologies if I'm misremembering the term there).
Is there some way for me to get around this limitation? Or is my numerical range outside the scope of CNL?
Also apologies for sidetracking this issue further. I've been trying to go up and down the documentation + examples trying to figure out how to use CNL for my exact use case (specific numerical range with emphasis on utilizing determinism of integers without too much of a care for precision), and I think this may be the last piece I've been failing to understand to fully utilize the library.

Unfortunately yes, sqrt currently uses an intermediate value which is twice
as wide as the operand. So on MSVC (for which 64-bit integers is the
limit), you must use 32-bit (or narrower) operands. Additionally, there are
other faults with the API of sqrt which make it relatively low-quality. It
is in the backlog though under #341. And I've added #712 to make this
design goal explicit.
In general, while low bits are valuable, it's far more important to avoid
high bits being lost. The former results in precision loss but the latter
results in UB or entirely incorrect results.
So when choosing on an individual type, decide what storage you can afford
(in this case 32-bit if you want to continue using cnl::sqrt but 64-bit
otherwise), then chose a maximum magnitude which you will never exceed
(unless you have a bug), and then allocate all remaining bits to fractions.
If one single range&resolution is not adequate for all your needs, make
more and convert between them when necessary. 24 bits is an entirely
arbitrary choice. If you want to get down to centimeter precision, then you
just need a decimal fixed-point number with 2 fractional digits:
scaled_integer<int32_t, power<-2, 10>>  // range = (21,474,836.48,

-21,474,836.48], resolution = 0.01
On Sat, 9 Jan 2021 at 17:49, Jawad<EMAIL_ADDRESS>wrote:

Ahhh yup, I've been definitely running into the truncation issue (as I
explicitly define the same type every time - eg "fp" here - instead of
using auto). I need to work on my numerical supported range a bit more, as
I definitely need 64 bits to, say, support whole numbers of [-10 million,
10 million] and "decimal" numbers of around [0, 10000].
However, I do remember there being some odd issue with trying to use a
int64_t type for the scaled_integer, eg scaled_integer<uint64_t,
power<-24>. If I understand the documentation and examples correctly,
that should be 24 bits for fractional/decimal piece, 1 bit for sign, and
(64-24-1)=39 bits for the non-fractional piece. However, I ran into issues
when trying to do a vector normalize operation (multiply -> adding -> sqrt
-> divison) and perhaps other similar operations, with compilation errors
similar to the following:
...
2>FixedPointTests.cpp
2>FixedPointVectorTests.cpp
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_digits.h(92,128): error C2504: 'cnl::signed_integer_cannot_have<127>::digits_because_maximum_is<63>': base class undefined
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_digits.h(152): message : see reference to class template instantiation 'cnl::_impl::set_digits_signed<127,void>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_width.h(19): message : see reference to class template instantiation 'cnl::set_digits<T,127,void>' being compiled
2>        with
2>        [
2>            T=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(81): message : see reference to class template instantiation 'cnl::_impl::set_width<Rep,128>' being compiled
2>        with
2>        [
2>            Rep=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(81): message : see reference to alias template instantiation 'cnl::_impl::set_width_t<__int64,128>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(113): message : see reference to function template instantiation 'Rep cnl::_impl::sqrt_solve1<-24>::operator ()(Rep) const' being compiled
2>        with
2>        [
2>            Rep=__int64,
2>            Number=__int64
2>        ]
...
I'm pretty certain I have to use an int64_t to assure I have the correct
range (+/- 10 million with 0-10k fractional) but it seems that this runs
into a hard limitation related to the type size escalation (apologies if
I'm misremembering the term there).
Is there some way for me to get around this limitation? Or is my numerical
range outside the scope of CNL?
Also apologies for sidetracking this issue further. I've been trying to go
up and down the documentation + examples trying to figure out how to use
CNL for my exact use case (specific numerical range with emphasis on
utilizing determinism of integers without too much of a care for
precision), and I think this may be the last piece I've been failing to
understand to fully utilize the library.
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/johnmcfarlane/cnl/issues/697#issuecomment-757342037,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAFTGNYIHGGRLG7OP6V6ZJDSZCJLBANCNFSM4VQYPNIA
.

Unfortunately yes, sqrt currently uses an intermediate value which is twice
as wide as the operand. So on MSVC (for which 64-bit integers is the
limit), you must use 32-bit (or narrower) operands. Additionally, there are
other faults with the API of sqrt which make it relatively low-quality. It
is in the backlog though under #341. And I've added #712 to make this
design goal explicit.
In general, while low bits are valuable, it's far more important to avoid
high bits being lost. The former results in precision loss but the latter
results in UB or entirely incorrect results.
So when choosing on an individual type, decide what storage you can afford
(in this case 32-bit if you want to continue using cnl::sqrt but 64-bit
otherwise), then chose a maximum magnitude which you will never exceed
(unless you have a bug), and then allocate all remaining bits to fractions.
If one single range&resolution is not adequate for all your needs, make
more and convert between them when necessary. 24 bits is an entirely
arbitrary choice. If you want to get down to centimeter precision, then you
just need a decimal fixed-point number with 2 fractional digits:
scaled_integer<int32_t, power<-2, 10>>  // range = (21,474,836.48,

-21,474,836.48], resolution = 0.01
On Sat, 9 Jan 2021 at 17:49, Jawad<EMAIL_ADDRESS>wrote:

Ahhh yup, I've been definitely running into the truncation issue (as I
explicitly define the same type every time - eg "fp" here - instead of
using auto). I need to work on my numerical supported range a bit more, as
I definitely need 64 bits to, say, support whole numbers of [-10 million,
10 million] and "decimal" numbers of around [0, 10000].
However, I do remember there being some odd issue with trying to use a
int64_t type for the scaled_integer, eg scaled_integer<uint64_t,
power<-24>. If I understand the documentation and examples correctly,
that should be 24 bits for fractional/decimal piece, 1 bit for sign, and
(64-24-1)=39 bits for the non-fractional piece. However, I ran into issues
when trying to do a vector normalize operation (multiply -> adding -> sqrt
-> divison) and perhaps other similar operations, with compilation errors
similar to the following:
...
2>FixedPointTests.cpp
2>FixedPointVectorTests.cpp
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_digits.h(92,128): error C2504: 'cnl::signed_integer_cannot_have<127>::digits_because_maximum_is<63>': base class undefined
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_digits.h(152): message : see reference to class template instantiation 'cnl::_impl::set_digits_signed<127,void>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl_impl\num_traits\set_width.h(19): message : see reference to class template instantiation 'cnl::set_digits<T,127,void>' being compiled
2>        with
2>        [
2>            T=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(81): message : see reference to class template instantiation 'cnl::_impl::set_width<Rep,128>' being compiled
2>        with
2>        [
2>            Rep=__int64
2>        ]
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(81): message : see reference to alias template instantiation 'cnl::_impl::set_width_t<__int64,128>' being compiled
2>C:\Program Files (x86)\cnl\include\cnl_impl\scaled_integer\extras.h(113): message : see reference to function template instantiation 'Rep cnl::_impl::sqrt_solve1<-24>::operator ()(Rep) const' being compiled
2>        with
2>        [
2>            Rep=__int64,
2>            Number=__int64
2>        ]
...
I'm pretty certain I have to use an int64_t to assure I have the correct
range (+/- 10 million with 0-10k fractional) but it seems that this runs
into a hard limitation related to the type size escalation (apologies if
I'm misremembering the term there).
Is there some way for me to get around this limitation? Or is my numerical
range outside the scope of CNL?
Also apologies for sidetracking this issue further. I've been trying to go
up and down the documentation + examples trying to figure out how to use
CNL for my exact use case (specific numerical range with emphasis on
utilizing determinism of integers without too much of a care for
precision), and I think this may be the last piece I've been failing to
understand to fully utilize the library.
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/johnmcfarlane/cnl/issues/697#issuecomment-757342037,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAFTGNYIHGGRLG7OP6V6ZJDSZCJLBANCNFSM4VQYPNIA
.

Thank you for the in depth explanation! Unfortunately I'm afraid a fractional range of [-0.48, 0.48] would be far too small, especially when working with rotations (eg, when using radians to calculate multiple rotations at once which would then be used for further calculations immediately after).
However, as it seems like it'll be impossible to go with my intended range with CNL as is due to outside limitations, I'm sure I'll be able to find a workaround such as using two int32_t scaled_integers or some finagling with the world units (eg, break the world into smaller chunks with simple relative units to assure a smaller max numerical range is used with no real harm to upstream systems and experience).
Overall, just want to say truly thank you- both for creating CNL as well as for all the help here! I had somewhat given up on using CNL until months later down the line for another attempt, but this conversation made me far more confident to go back and start using it again.

As a side note, on topic of documentation, I can't seem to find anything specific on cnl::power, especially when the two parameter version would be preferred. Code does mention exponent and radix, but I'm surprised the docs don't go more in depth on such an often used tool. (And I also learned how it worked in terms of bit allocation by looking at one of the commented examples on the intro doc page)

Thank you for the in depth explanation! Unfortunately I'm afraid a fractional range of [-0.48, 0.48] would be far too small, especially when working with rotations (eg, when using radians to calculate multiple rotations at once which would then be used for further calculations immediately after).
However, as it seems like it'll be impossible to go with my intended range with CNL as is due to outside limitations, I'm sure I'll be able to find a workaround such as using two int32_t scaled_integers or some finagling with the world units (eg, break the world into smaller chunks with simple relative units to assure a smaller max numerical range is used with no real harm to upstream systems and experience).
Overall, just want to say truly thank you- both for creating CNL as well as for all the help here! I had somewhat given up on using CNL until months later down the line for another attempt, but this conversation made me far more confident to go back and start using it again.

As a side note, on topic of documentation, I can't seem to find anything specific on cnl::power, especially when the two parameter version would be preferred. Code does mention exponent and radix, but I'm surprised the docs don't go more in depth on such an often used tool. (And I also learned how it worked in terms of bit allocation by looking at one of the commented examples on the intro doc page)

Do you think you could achieve your goals with raw integer arithmetic alone?
On Tue, 12 Jan 2021 at 15:42, Jawad<EMAIL_ADDRESS>wrote:

Thank you for the in depth explanation! Unfortunately I'm afraid a
fractional range of [-0.48, 0.48] would be far too small, especially when
working with rotations (eg, when using radians to calculate multiple
rotations at once which would then be used for further calculations
immediately after).
However, as it seems like it'll be impossible to go with my intended range
with CNL as is due to outside limitations, I'm sure I'll be able to find a
workaround such as using two int32_t scaled_integers or some finagling with
the world units (eg, break the world into smaller chunks with simple
relative units to assure a smaller max numerical range is used with no real
harm to upstream systems and experience).
Overall, just want to say truly thank you- both for creating CNL as well
as for all the help here! I had somewhat given up on using CNL until months
later down the line for another attempt, but this conversation made me far
more confident to go back and start using it again.
As a side note, on topic of documentation, I can't seem to find anything
specific on cnl::power, especially when the two parameter version would
be preferred. Code does mention exponent and radix, but I'm surprised the
docs don't go more in depth on such an often used tool. (And I also learned
how it worked in terms of bit allocation by looking at one of the commented
examples on the intro doc page)
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/johnmcfarlane/cnl/issues/697#issuecomment-758744136,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAFTGN57K26RPQUCAERTHYTSZRUXLANCNFSM4VQYPNIA
.

Do you think you could achieve your goals with raw integer arithmetic alone?
On Tue, 12 Jan 2021 at 15:42, Jawad<EMAIL_ADDRESS>wrote:

Thank you for the in depth explanation! Unfortunately I'm afraid a
fractional range of [-0.48, 0.48] would be far too small, especially when
working with rotations (eg, when using radians to calculate multiple
rotations at once which would then be used for further calculations
immediately after).
However, as it seems like it'll be impossible to go with my intended range
with CNL as is due to outside limitations, I'm sure I'll be able to find a
workaround such as using two int32_t scaled_integers or some finagling with
the world units (eg, break the world into smaller chunks with simple
relative units to assure a smaller max numerical range is used with no real
harm to upstream systems and experience).
Overall, just want to say truly thank you- both for creating CNL as well
as for all the help here! I had somewhat given up on using CNL until months
later down the line for another attempt, but this conversation made me far
more confident to go back and start using it again.
As a side note, on topic of documentation, I can't seem to find anything
specific on cnl::power, especially when the two parameter version would
be preferred. Code does mention exponent and radix, but I'm surprised the
docs don't go more in depth on such an often used tool. (And I also learned
how it worked in terms of bit allocation by looking at one of the commented
examples on the intro doc page)
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/johnmcfarlane/cnl/issues/697#issuecomment-758744136,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAFTGN57K26RPQUCAERTHYTSZRUXLANCNFSM4VQYPNIA
.

Depends on what you're referring to as "raw", but if referring to relying on just integers rather than floating points at all, then I'd say almost definitely yes. Fortunately I can confidently maintain a numerical range, and regarding dealing with "worlds" larger than the intended range, that's something modern game engines/developers deal with when using floating point already at very large position values. The real concerns are more so centered around overall efficiency as well as accuracy of smaller fractional numbers when relevant (eg, anything somewhat trig related).
For instance, a technique previously used for cross-platform determinism in games has been a two integer fixed point type something akin to a fixed_point<int32_t, int32_t>, where two separate integers are used for the non-fractional and fractional pieces respectively. I haven't tested it out myself personally but I'd assume it'd be slower than using CNL, which seems to be optimized far better than the pretty straightforward code I've seen before. However, either way I can't seem to find a significant obstacle that would prevent using pure integer arithmetic (other than time but that's always a fun limitation).
I may be proven wrong a while down the line, but for the moment I'm fairly confident in integer arithmetic =)

Depends on what you're referring to as "raw", but if referring to relying on just integers rather than floating points at all, then I'd say almost definitely yes. Fortunately I can confidently maintain a numerical range, and regarding dealing with "worlds" larger than the intended range, that's something modern game engines/developers deal with when using floating point already at very large position values. The real concerns are more so centered around overall efficiency as well as accuracy of smaller fractional numbers when relevant (eg, anything somewhat trig related).
For instance, a technique previously used for cross-platform determinism in games has been a two integer fixed point type something akin to a fixed_point<int32_t, int32_t>, where two separate integers are used for the non-fractional and fractional pieces respectively. I haven't tested it out myself personally but I'd assume it'd be slower than using CNL, which seems to be optimized far better than the pretty straightforward code I've seen before. However, either way I can't seem to find a significant obstacle that would prevent using pure integer arithmetic (other than time but that's always a fun limitation).
I may be proven wrong a while down the line, but for the moment I'm fairly confident in integer arithmetic =)

The improvements to cnl::sqrt are completed. It no longer uses a wider intermediate integer type.
Capturing doc improvements in #753. An FAQ section was added to the front page with some examples. More to follow.
Closing this now as there are quite a few points raised in this issue and most of them are now captured elsewhere. If anything is outstanding, feel free to open individual issues.
Thanks

rounding_integer and overflow_integer and their tags are now documented. Division is explained in the FAQ. LMK if I missed anything. Math functions yet to come...


[WIP] Run examples on Java21

Fixes #28967 ; fixes #23695
along with other cleanup on examples and java version handling

upgrade gradle 8.3 -> 8.4 which is needed for compiling and run tests with Java21

Use temurin 21 base image as its available now

Setup a few Java21 postcommits

Fix kotlin test

Fix javaVersion to be 1.8/11/17/21

Please add a meaningful description for your change here

Thank you for your contribution! Follow this checklist to help us incorporate your contribution quickly and easily:

[ ] Mention the appropriate issue in your description (for example: addresses #123), if applicable. This will automatically add a link to the pull request in the issue. If you would like the issue to automatically close on merging the pull request, comment fixes #<ISSUE NUMBER> instead.
[ ] Update CHANGES.md with noteworthy changes.
[ ] If this contribution is large, please file an Apache Individual Contributor License Agreement.

See the Contributor Guide for more tips on how to make review process smoother.
To check the build health, please visit https://github.com/apache/beam/blob/master/.test-infra/BUILD_STATUS.md
GitHub Actions Tests Status (on master branch)

See CI.md for more information about GitHub Actions CI or the workflows README to see a list of phrases to trigger workflows.

Run Jpms Direct Java 17 PostCommit

Run Jpms Direct Java 11 PostCommit

Run Jpms Direct Java 11 PostCommit

Run Jpms Direct Java 17 PostCommit

After this change, Java11 and 17 Example on Dataflow Legacy runner with error
java.lang.RuntimeException: org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.util.concurrent.ExecutionError: java.lang.UnsupportedClassVersionError: org/apache/beam/examples/WindowedWordCount$AddTimestampFn has been compiled by a more recent version of the Java Runtime (class file version 55.0), this version of the Java Runtime only recognizes class file versions up to 52.0
java.lang.RuntimeException: org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.util.concurrent.ExecutionError: java.lang.UnsupportedClassVersionError: org/apache/beam/examples/WindowedWordCount$AddTimestampFn has been compiled by a more recent version of the Java Runtime (class file version 61.0), this version of the Java Runtime only recognizes class file versions up to 52.0
this suggests the pipelines are always run on Java8 runtime, likely our precommit test never work as intended

Tested by equivalent gradle command
Java Examples
./gradlew :runners:google-cloud-dataflow-java:examplesJavaRunnerV2IntegrationTest -PdisableSpotlessCheck=true -PdisableCheckStyle=true -PskipCheckerFramework -PtestJavaVersion=21 -Pjava21Home=.../.sdkman/candidates/java/21-zulu

jobId: 2023-10-23_13_51_50-1524320457990904336 2023-10-23_13_51_48-3336529009400839971 2023-10-23_13_51_48-540232565689758221 2023-10-23_13_51_48-7689190307853488284 in project apache-beam-testing
all have "userAgent Apache_Beam_SDK_for_Java/2.52.0-SNAPSHOT(JRE_21_environment)" and passed
JPMS
./gradlew :sdks:java:testing:jpms-test:directRunnerIntegrationTest -PskipCheckerFramework -PtestJavaVersion=21 -Pjava21Home=.../.sdkman/candidates/java/21-zulu

assign set of reviewers

Run Java_PVR_Flink_Batch PreCommit


v2 doesn't work with Yarn 2 with enableGlobalCache

🐛 Bug Report
Have you read the [Contributing Guidelines on issues]
Yes
To Reproduce
npx @docusaurus/init@next init my-website classic
cd my-website
yarn set version berry
echo "enableGlobalCache: true" >> .yarnrc.yml
yarn install
yarn build

Expected behavior
Build the project successfully.
Actual Behavior
5:12:27 AM: Error: Cannot find module './dependencies/ContextElementDependency'
5:12:27 AM: Require stack:
5:12:27 AM: - /opt/build/repo/.yarn/$$virtual/webpack-virtual-fff521a369/3/buildhome/.yarn_cache/cache/webpack-npm-4.44.1-977bccfd33-5.zip/node_modules/webpack/lib/ContextReplacementPlugin.js
5:12:27 AM: - /opt/build/repo/.yarn/$$virtual/@docusaurus-core-virtual-cc39d80259/3/buildhome/.yarn_cache/cache/<EMAIL_ADDRESS>5:12:27 AM: Require stack:
5:12:27 AM: - /opt/build/repo/.yarn/$$virtual/webpack-virtual-fff521a369/3/buildhome/.yarn_cache/cache/webpack-npm-4.44.1-977bccfd33-5.zip/node_modules/webpack/lib/ContextReplacementPlugin.js
5:12:27 AM: - /opt/build/repo/.yarn/$$virtual/@docusaurus-core-virtual-cc39d80259/3/buildhome/.yarn_cache/cache/<EMAIL_ADDRESS>5:12:27 AM:     at Function.Module._resolveFilename (internal/modules/cjs/loader.js:966:15)
5:12:27 AM:     at Function.external_module_.Module._resolveFilename (/opt/build/repo/.pnp.js:19397:54)
5:12:27 AM:     at Module._load (internal/modules/cjs/loader.js:842:27)
5:12:27 AM:     at Function.external_module_.Module._load (/opt/build/repo/.pnp.js:19252:36)
5:12:27 AM:     at Module.require (internal/modules/cjs/loader.js:1026:19)
5:12:27 AM:     at require (internal/modules/cjs/helpers.js:72:18)
5:12:27 AM:     at Object.<anonymous> (/opt/build/repo/.yarn/$$virtual/webpack-virtual-fff521a369/3/buildhome/.yarn_cache/cache/webpack-npm-4.44.1-977bccfd33-5.zip/node_modules/webpack/lib/ContextReplacementPlugin.js:8:34)
5:12:27 AM:     at Module._compile (internal/modules/cjs/loader.js:1138:30)
5:12:27 AM:     at Object.Module._extensions..js (internal/modules/cjs/loader.js:1158:10)
5:12:27 AM:     at Module.load (internal/modules/cjs/loader.js:986:32)
5:12:27 AM:     at Module._load (internal/modules/cjs/loader.js:879:14)
5:12:27 AM:     at Function.external_module_.Module._load (/opt/build/repo/.pnp.js:19252:36)
5:12:27 AM:     at Module.require (internal/modules/cjs/loader.js:1026:19)
5:12:27 AM:     at require (internal/modules/cjs/helpers.js:72:18)
5:12:27 AM:     at Object.<anonymous> (/opt/build/repo/.yarn/$$virtual/@docusaurus-theme-classic-virtual-6301812ffe/3/buildhome/.yarn_cache/cache/@docusaurus-theme-classic-patch-30ba593d9b-5.zip/node_modules/@docusaurus/theme-classic/src/index.js:16:34)
5:12:27 AM:     at Module._compile (internal/modules/cjs/loader.js:1138:30)

Cause
Docusaurus uses importFresh to require presets and plugins.
From https://github.com/yarnpkg/berry/issues/706#issuecomment-576020156:

The problem is that importFresh uses resolveFrom, which creates a whole new module (second parameter in _resolveFilename):
https://github.com/sindresorhus/resolve-from/blob/188ed7da119c788d98272852e8a71fd19195f6cf/index.js#L29-L33
The new module loses information, two in particular:

the file that owns the resolution that we're requiring (ie the .eslintrc.yml file).
the dependency tree that "owns" the resolved entry.

As a result of the second one, the PnP loader tries to regenerate it by finding the closest ancestor PnP hook (.pnp.js) for the issuer. That would usually do the trick, but since importFresh also lost the issuer then the loader fallbacks to finding the closest ancestor for the request itselfy.
Unfortunately, in the case of the global cache, the request is a file within the cache, and the closest ancestor doesn't exist (because the cache doesn't have a .pnp.js file). So the preset is loaded as if it wasn't covered by a PnP dependency tree, hence the "Cannot find module" message (PnP would throw something more detailed).
One last mystery: even if we're loading the preset through the regular Node resolver instead of the PnP resolver, why did the resolution failed? After all, as we can see in the error, we're resolving an absolute path. So it makes sense that it would fail to load its dependencies, but we can't even load it at all - what happens? The answer is that the Node resolver cheats:
https://github.com/nodejs/node/blob/v13.5.0/lib/internal/modules/cjs/loader.js#L136
In order to be faster, they use a special native and internal stat function that isn't exposed to userland code and, more importantly, doesn't support reading from Zip archives ... so when it tries to check whether the file exists, it has no idea that it needs to look inside the archive, and the Node resolution fails.
How to fix?
It's a bit difficult to say because frankly the whole require / require.resolve API is an incredible mess due to the fact that it deals directly with file paths rather than abstract tokens. This is a very bad design, and as a result it's very hard for everyone to know exactly how the API should be used in a perfectly generic way.
I'll need to think some more about this.

Your Environment

Yarn 2 with the environment variable YARN_ENABLE_GLOBAL_CACHE=1

Reproducible Demo
https://github.com/ylemkimon/berry-docusaurus-netlify
https://app.netlify.com/sites/awesome-allen-96f580/deploys/5f3992ee969cb10007a179e2

Thanks, let's track this but currently don't know how to fix it 🤪

Fixed in https://github.com/yarnpkg/berry/pull/1851, update to the latest yarn and it should work :)

thanks
@ylemkimon I'm closing but we can reopen if this does not work for you


Consider adding either Commercial or Open Source identifiers

When looking at this fantastic list of work people have submitted, it's not easy to see what is commercial work requiring the purchasing of a license, and what has been gifted to the community through open sourcing. I think people would find a graphical segregation between these two helpful, as when people are building open source solutions it's problematic to include licensed components into the work.
If it's something that doesn't add too much overhead and maintenance, I think this is something worth considering.

I also found this interesting. What about the projects that are open-source and have a commercial side for companies only? This is the case with Blazorise.

We could have 3 labels:

Free
Free for personal use
Charged (is it the good term?)

@AdrienTorris That's a good idea. 'Charged' is OK in UK English, but I wonder if 'Paid' is a better option for a wider audience whose first language may not be English?

I agree that Paid is the better option.

Let's go for Paid :)


Selecting Medium Wing gives Heavy Wing

I selected the Medium wing option in the dialog with Sumire.
My financial report now lists "Heavy Wing" with the corresponding price of 100,000k
Selecting a Heavy Wing appears to give no Wing; no cost listed in captains quarters report.
After which talking to Sumire again and choosing different options repeatedly did not add a cost to the report.

Per rogueticket-672 this also has the form of:
Changing the aerospace wing (CMD Staff > Sumire) has no effect.
After selecting any option the monthly report still say -75k for the medium wing regardless of what I pick. Not sure if they work for actual extraction as I haven't done that.
Attachment file type: archive
RogueLogs.zip
1.32 MB
Taxen007/20/2020
ok, sometimes it seems to change, I suddenly got charged for a heavy wing (dont remember what I picked before). So maybe some of the options work but are linked to the wrong option
Taxen007/20/2020
picking heavy seems to be the "no support" option


Add containers lib image acquirer

This is a resubmission of #85  based on #87 as an ImageAcquirer

cc @rhdedgar

@rhdedgar Any chance to see this PR getting merged?


Various long-overdue fixes.

Fixes:

Update links and attribution for Vox Pupuli. #11
Remove support for obsolete puppet versions. #13
Use datatypes instead of deprecated validate functions.
Use in-module hiera instead of params subclass.
Add support for RedHat-6 via epel #2 #8 #10
Add support for FreeBSD. #7
Uninstall VMwareTools if installed. #3 #4
Support the vgauthd service added in 2012.
Added pre-commit config and fixed all lint errors.

Thanks, @natemccurdy -- I think I fixed everything you found. Mind taking another look?

Trying to run tests locally and getting errors.  It seems that APL with in-module hiera isn't working, and the Yumrepo resources aren't being loaded.  Not sure why.

YAY!  Running locally, all tests are passing now.
/opt/puppetlabs/puppet/bin/ruby -S rspec spec/classes/openvmtools_init_spec.rb --color

openvmtools
  on a non-supported osfamily, non-vmware platform
    should not contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should not contain Service[vmtoolsd]
  on a supported osfamily, non-vmware platform
    should not contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should not contain Service[vmtoolsd]
  on a supported osfamily, vmware platform, using EPEL
    should contain Class[epel]
    should contain Yumrepo[epel] that comes before Package[open-vm-tools]
    should contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should contain Service[vmtoolsd] with ensure => "running", enable => true, hasstatus => true and require => "[Package[open-vm-tools]{:name=>\"open-vm-tools\"}]"
  on a supported osfamily, vmware platform, non-supported operatingsystem
    should not contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should not contain Service[vmtoolsd]
  on a supported osfamily, vmware platform, default parameters, RedHat
    should contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should contain Service[vmtoolsd] with ensure => "running", enable => true, hasstatus => true and require => "[Package[open-vm-tools]{:name=>\"open-vm-tools\"}]"
  on a supported osfamily, vmware platform, default parameters, Debian
    should contain Package[open-vm-tools]
    should not contain Package[open-vm-tools-desktop]
    should contain Service[open-vm-tools] with ensure => "running", enable => true, hasstatus => false and require => "[Package[open-vm-tools]{:name=>\"open-vm-tools\"}]"
  on a supported osfamily, vmware platform, default parameters, FreeBSD 10
    should contain Package[open-vm-tools-nox11]
    should not contain Package[open-vm-tools]
    should contain Service[vmware_guestd] with ensure => "running", enable => true, hasstatus => true and require => "[Package[open-vm-tools-nox11]{:name=>\"open-vm-tools-nox11\"}]"
  on a supported osfamily, vmware platform, default parameters, FreeBSD 11
    should contain Package[open-vm-tools-nox11]
    should not contain Package[open-vm-tools]
    should contain Service[vmware_guestd] with ensure => "running", enable => true, hasstatus => true and require => "[Package[open-vm-tools-nox11]{:name=>\"open-vm-tools-nox11\"}]"
  on a supported operatingsystem, vmware platform, custom parameters, RedHat
    ensure => absent
      should contain Package[open-vm-tools] with ensure => "absent"
      should contain Service[vmtoolsd] with ensure => "stopped"
    with_desktop => true
      should contain Package[open-vm-tools-desktop] with ensure => "present"
  on a supported operatingsystem, vmware platform, custom parameters, FreeBSD
    ensure => absent
      should contain Package[open-vm-tools-nox11] with ensure => "absent"
      should contain Service[vmware_guestd] with ensure => "stopped"
    with_desktop => true
      should contain Package[open-vm-tools]
      should not contain Package[open-vm-tools-nox11]
      should contain Service[vmware_guestd] with ensure => "running", enable => true, hasstatus => true and require => "[Package[open-vm-tools]{:name=>\"open-vm-tools\"}]"

Finished in 3.11 seconds
34 examples, 0 failures

Gonna try closing/re-opening to see if that kicks of travis-testing again.

@pillarsdotnet Couple things:

Is it possible to split this back out into discrete commits? Having all this in 1 giant commit makes it very difficult to review.
What stops the exec that uninstalls vmware idempotent? Will $facts['vmware_uninstaller'] ever be falsey?

Because of the size of the PR, that gather long list of modifications. I don't think a person can be in confidence enough . To be sure that users of module take care, perhaps can we tag this PR as backward-incompatible  ?

@natemccurdy

Is it possible to split this back out into discrete commits? Having all this in 1 giant commit makes it very difficult to review.

I will do so tonight or tomorrow.

What makes the exec that uninstalls vmware idempotent? Will $facts['vmware_uninstaller'] ever be falsey?

The vmware_uninstaller script is supposed to remove itself.  If it does not, that is a bug.  I can remove this part or add a parameter to make it optional.

@Dan33l

To be sure that users of module take care, perhaps can we tag this PR as backward-incompatible ?

For sure it should be tagged backward-incompatible since it drops support for old Puppet versions.

Separated into individually-reviewable commits; tests are passing.

Some of the changes will be overwritten when we do the first modulesync, but for now, I'm ok leaving them in.

@alexjfisher -- How can I do a modulesync, or simulate the effect of a modulesync?


T & Any and variance

@mark-todd One has to be really careful and diligent with phrasing of these examples. In particular, we should try to avoid using the word "property" if we mean a regular attribute and not a @property, because it makes a huge difference whether we talk about a mutable attribute (⇝ invariant), or a read-only property (⇝ covariant).
Let's take a look at a modified version of Eric's example from earlier:
class Movie:
    info: MovieInfo

    @property
    def metadata(self) -> Metadata:
          return _get_metadata_from_server(...)

T = TypeVar("T")

Now, what is the interface of T & Movie?

info is a mutable attribute. Therefore, Movie is invariant in info, which logically translates to the statement: S <: Movie ⟹ type(S.info) is MovieInfo, i.e. if S is a subtype of Movie, then the type of S.info must be MovieInfo.

Under ④, (T & Movie).info is of type T.info & Movie.info = Any & MovieInfo.
However, a clever type-checker should be able to deduce, even under paradigm ④, that this can be simplified to MovieInfo due to the invariance. (The only alternative is that T and Movie are incompatible)

metadata is a read-only property, so covariant, meaning S <: Movie ⟹ S.metadata <: Movie.metadata.

Under ④, (T & Movie).metadata is of type T.metadata & Movie.metadata = Any & Metadata (*), which is still guaranteed to be a subtype of Metadata, but could have a much wider interface.
Due to covariance, Any & Metadata cannot be simplified away in this case.

So even with ④, exact inference can be made when types are invariant, and in fact this gives an alternative solution for people worried about intersection with Any by simply using invariant types. (Presumably one would want a way to manually mark read-only properties as invariant)
(*) In principal it should be something like Any & property[Metadata], but for technical reasons property isn't even generic yet in typeshed, so let's pretend for the moment it's simple a read-only, covariant attribute...
Originally posted by @randolf-scholz in https://github.com/CarliJoy/intersection_examples/issues/31#issuecomment-1881694200

@randolf-scholz I am not an expert with variance. Could you extend your example for a static function as well as a method and explain what happens with arguments/return values as well?

Here is a summary in tabular form: let A and B be two types that both share an interface .foo (could be attribute/method/...) with types S≔type(A.foo) and T≔type(B.foo). Co-/Conta-/Invaraince just means that if A2 <: A, then we must have A2.foo <: A.foo / A2.foo :> A.foo / A2.foo == A.foo respectively.
Then from basic rules of subtyping it follows then that the type X ≔ (A&B).foo has to satisfy the following conditions in order to satisfy LSP:

X ≔ (A&B).foo
B.foo covariant (<:T)
B.foo invariant (==T)
B.foo contravariant (:>T)

A.foo covariant (<:S)
X <: S and X <: T
X <: S and X == T
X <: S and X :> T

A.foo invariant (==S)
X == S and X <: T
X == S and X == T
X == S and X :> T

A.foo contravariant (:>S)
X :> S and X <: T
X :> S and X == T
X :> S and X :> T

Note: Interfaces are usually considered to have the following variance.

Read-only ↔ covariant (read-only attributes / methods / function return types)
Write-Only ↔contravariant (function argument types / write-only attributes)
Mutable↔invariant (mutable attributes / TypeVars that appear both as inputs and outputs.)

Assuming B is untyped, we want to replace T with Any in the table above. A fundamental assumption of gradual typing is that when we see Any, we assume it is a stand in for whose place an actual type can be substituted which is compatible. This should result in the updated table

X ≔ (A&B).foo
B.foo covariant (<:T)
B.foo invariant (==T)
B.foo contravariant (:>T)

A.foo covariant (<:S)
X <: (S&Any)
X <: S
X <: S

A.foo invariant (==S)
X == S
X == S
X == S

A.foo contravariant (:>S)
X :> S
X :> S
X :> (S&Any)

  Detailed Explanation

First row:

X <: S and X <: T: simply becomes X<:(S&Any), as there are no compatibility constraints
X <: S and X == T: compatibility demands that T<:S, and for any X<:S, it is feasibly possible that T happens to be X, so this becomes X<:S
X <: S and X :> T: compatibility demands T<:S, and for any X<:S it is feasibly possible that T happens to be X, so this also becomes X<:S

Second row: Here, compatibility demands that T==S in all 3 cases, so we get X==S
Third row:

X :> S and X <: T: compatibility demands that S<:T, and for any X :> S, it is feasibly possible that T happens to be X, so this becomes X:>S
X :> S and X == T: compatibility demands that S<:T, and for any X :> S, it is feasibly possible that T happens to be X, so this also becomes X:>S
X :> S and X :> T: this simply becomes X :> (S& Any), as there are no compatibility constraints

Of course, if B is untyped we have no clue about the variance of B.foo, so we need an extra criterion to decide which constraint to pick per row. We can again argue by compatibility: It is feasible, that B is covariant/invariant/contravariant in foo, so our condition should cover all 3 cases:

Row 1: X <: (S&Any) ∧ X <: S ∧ X <: S ⟺ X <: (S&Any)
Row 2: X == S ∧ X == S∧ X == S ⟺ X==S
Row 3: X :> S ∧ X :> S ∧ X :> (S&Any) ⟺ X :> (S&Any)

Therefore, we end up with the following final result:

X ≔ (A&B).foo
B.foo untyped
B.foo co (<:T)
B.foo inv (==T)
B.foo contra (:>T)

A.foo untyped
X==Any
X<:(Any&T)
X==T
X:>(Any&T)

A.foo co (<:S)
X<:(S&Any)
X<:(S&T)
X==T if T<:S else ↯
T<:X<:S if S:>T else ↯

A.foo inv (==S)
X==S
X==S if S<:T else ↯
X==S if S==T else ↯
X==S if S:>T else ↯

A.foo contra (:>S)
X:>(S&Any)
S<:X<:T if S<:T else ↯
X==T if S<:T else ↯
X:>(S&T)

Please let me know if you find any errors in this analysis.

I believe the consistency based rule we are going for does not require we do extra work for Variance with Any that isn't already being covered more simply than this. I'll be including notes on the effective variance we expect in a few examples. IF this needs further discussion, please reopen expanding on that.


Allow to edit palettes like a script

A TextEdit would make it faster to edit palettes. It could look something like this:
NamedColor1 = "fac"
NamedColor2 = "cfa"
NamedColor3 = "abcdef"
NamedColor4 = "rgb(42, 69, 123)"

with all the goodies like syntax highlighting when syntax isn't valid, indicators for how to do this, etc. Although the goodies can be added later on.

After taking a stab at this, I'm starting to think this isn't a good idea.


display fixme field above others

When checking problems it is always useful to read the fixme field first and it should be shown first above the other fields. Right now it will somewhere at the bottom and I need to scroll down every time to read it.
The field 'note' should probably be second since it is also important information that is typically empty anyway.

Good idea. If I remember correctly, this was the original motivation for spelling the key FIXME instead of fixme, but fields give us extra flexibility without requiring capitalization hacks. I think the sorting would be controlled by id-tagging-schema in general, though I’m unsure if it would be straightforward to always put a “more” field on top of all the default fields for all the presets.


Notifications reupload

#1501
Changelog:

Migration to add a new column to the notification_message table
Backend code to send the messages
Frontend code to parse the notification message

 Notifications | Compliance and Exclusion Reporting |5|


Update wasm-request package

[x] TODO Add a requests output that pins to the polyfill

@wolfv There might be versioning mismatch with this approach. If another conda package relies on requests>=1,<2 they simply won't get it.
Do you know if we can work around this?

Ideally we'd match the requests API exactly and respect the same versioning.

looks good to me. I don't know what to do about versioning. I guess any requests usage out of the ordinary would break pretty soon, anyways, right?

Yes. For now it only provides the basic features.

Thanks for the review!


One more question relating to packages

common misconception that higher version == better, rpm -q  --changelog will give better idea

thx


Skip blacklisted titles and companies before iterating through them

Current behaviour:
On the search page, all the jobIds are added to only later be found that some might be blacklisted which wastes time and redundantly goes into job page links. This sometimes adds up to 100s of links with some freelance or job-spamming companies.
Desired behaviour:
Filter blacklisted jobs on the job search page.

This is still needs some attention as sometimes the blacklisted jobs "sneak through"


Update button in settings tool causes crash

Looks like it is still referencing the old editor bridge. Need to remove this.

This has been fixed.


unblock sites

how can i unblock sites i cant find the extras folder

The extras folder is in the same folder as the builder.

i mean if i got hacked

Ye like I said, it is in the same folder as the builder.

what builder i dont have a builder

You mean you got hacked? Then download the files from this repository and find the unblock_sites.py file in the Extras folder.

You mean you got hacked? Then download the files from this repository and find the unblock_sites.py file in the Extras folder.

unblock_sites.py doesnt work

Does it show error?

You mean you got hacked? Then download the files from this repository and find the unblock_sites.py file in the Extras folder.

unblock_sites.py doesnt work

To run it, simply type cmd in the address bar of the Extras folder and then type python unblock_sites.py

To run it, simply type cmd in the address bar of the Extras folder

how i do that

To run it, simply type cmd in the address bar of the Extras folder

how i do that

Didn't I give the instruction?

To run it, simply type cmd in the address bar of the Extras folder

how i do that

Didn't I give the instruction?

video

To run it, simply type cmd in the address bar of the Extras folder

how i do that

Didn't I give the instruction?

video

wha- The instructions are literally crystal clear, try to ask chatGPT if you are having trouble with the instructions.

To run it, simply type cmd in the address bar of the Extras folder

how i do that

Didn't I give the instruction?

video

wha- The instructions are literally crystal clear, try to ask chatGPT if you are having trouble with the instructions.

thanks worked

how do u find the addres of the extras folder

how do u find the addres of the extras folder

how do u find the addres of the extras folder

Darius.#1729
add me on discord and ill show u how to do it


feat(resource): add polly lexicon resource support

Implements https://github.com/rebuy-de/aws-nuke/pull/1045/commits
This takes the upstream commits and cherry-picks them in, then performs a squash commit and reword to conventional commits.  Finally the resource is converted to the libnuke resource standard format.

:tada: This PR is included in version 3.25.0 :tada:
The release is available on GitHub release
Your semantic-release bot :package::rocket:


Request to support cancel any in-progress workflow

Summary
The synchronization feature could set the workflow running limitation. But in some cases, we hope the old workflows could be canceled, then run the latest one only.
Use Cases
Similar to the GitHub Workflows. For a pull-request, it's not necessary to all every single workflow. Run the latest one is good enough. So, I suggest that we could have this one.
Love this enhancement proposal? Give it a 👍. We prioritise the proposals with the most 👍.

similar to https://github.com/argoproj/argo-workflows/issues/8904 and maybe tracked by https://github.com/argoproj/argo-workflows/issues/11849

maybe tracked by #11849

No that issue is mostly a syntactic / naming clarity and does not change existing semantics.

similar to #8904

Yes, I think these are both effectively superseded by #12757.


UNC path does not work

It seems that pub attempts to use the current working directory instead of the specified UNC path.
C:\Work\dart\dart-sdk\bin>C:\Work\dart\dart-sdk\bin\pub.bat --trace install \BA\Media\tmp\Test3\pubspec.yaml
Could not find a file named "pubspec.yaml" in the directory C:\Work\dart\dart-sdk\bin.
---- Log transcript ----
IO  : Spawning cmd /c ver
IO  : Finished ver. Exit code 0.stdout:Microsoft Windows [Version 6.1.7601]Nothing output on stderr.
FINE: Clean up system cache temp directory C:\Users\scheglov\AppData\Roaming\Pub\Cache_temp.
ERR : Could not find a file named "pubspec.yaml" in the directory C:\Work\dart\dart-sdk\bin.
---- End log transcript ----

This issue has been moved to dart-lang/pub#541.


How to embed diffSLIC into a superpixel segmentation model?

Dear author, hello!
Thank you for providing such excellent work!
I hope to embed diffSLIC on the basis of a backbone for training a superpixel segmentation network. Therefore, I have carefully read the paper and code of HCFormer as well as the DiffSLIC.
However, the complex code under the detectron2 framework, as well as the implementation of diffSLIC, has caused me some confusion.
I would like to ask you that how to train diffSLIC? Specifically, which part was trainable?  I would like to ask if this work can be applied to Superpixel_FCN?

embed diffSLIC on the basis of a backbone for training a superpixel segmentation network.

There are many way to embed diffSLIC into a backbone.
For example, the superpixel sampling network style (or SuperpixelFCN style) is below:
pixel_feats = neural_nets(input_image)
diffslic_fn = DiffSLIC(n_spixels=expected_number_of_superpixels, n_iter=k_means_iterations, tau=temperature_for_softmax, stable=True)
clst_feats, p2s_assign, s2p_assign = diffslic_fn(pixel_feats)
# cls_feats are fed into a next process.

The HCFormer style (i.e., the downsampled feature map is used as the superpixel seeds) is as follows:
downsampled_feature = downsampling(input_feature)
# "n_spixels" is not required when "clst_feats" is given in forward function.
diffslic_fn = DiffSLIC(n_spixels=None, n_iter=k_means_iterations, tau=temperature_for_softmax, stable=True)
clst_feats, p2s_assign, s2p_assign = diffslic_fn(input_feature, clst_feats=downsampled_feature)
# cls_feats are fed into a next layer.

In HCFormer, we incorporate the above process into every downsampling layer.
Note that p2s_assign and s2p_assign may be used to decode and encode superpixel features by spixel_upsampling and spixel_downsampling. In HCFormer, only p2s_assign is used to decode the network output.

Specifically, which part was trainable?

diffSLIC has no trainable parameters. Instead, we train neural net's weights through diffSLIC.


only one instance got notify when Multiple instance bind to same element

only one instance got notify when Multiple instance bind to same element

Hi, can you define instance?
If you mean having multiple functions listening to the element, this should work and is covered in the following test case https://github.com/wnr/element-resize-detector/blob/master/test/element-resize-detector_test.js#L198

I created two elementResizeDetectorMakers,each listen to the same  element,only one listener got notified.

I see, thanks for the clarification. This should be possible and I'll look into it. However, please note that you won't get as good performance if you use different instances for the elements - since operations cannot be synchronised then.

I have now analysed this, and have come to the conclusion that this is too complex to support. An element is something globally mutable, and having two instances of systems that want to mutate this is complex in terms of syncing. This is a common limitation, you won't be able to have two React instances rendering to the same div. React ensures that this doesn't happen by defining React globally. element-resize-detector leaves it up to you whether you want to use dependency injection or a singleton pattern to define it globally. Please note that you can still have multiple instances running in the same application, the limitation is that they cannot control the same elements. The complexity price of supporting this is too high compared to the benefits in my opinion.


Limit functionality on Delete

In order to limit the functionality for Delete in Classanadra, limiting the WHERE clause in Delete to support only a single filter

LGTM


Component governance vulnerabilities fix

Description of changes
Component governance vulnerabilities fix
Pull request checklist

[ ] Addresses an existing issue: Fixes #0000
[ ] Added relevant unit test for your changes. (yarn test)
[ ] Verified code coverage for the changes made. Check coverage report at: <rootDir>/test-results/unit/coverage
[ ] Ran precheckin (yarn precheckin)

Codecov Report

Merging #422 (94f44e6) into master (b50d703) will not change coverage.
The diff coverage is n/a.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update b50d703...94f44e6. Read the comment docs.

Codecov Report

Merging #422 (94f44e6) into master (b50d703) will not change coverage.
The diff coverage is n/a.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update b50d703...94f44e6. Read the comment docs.


MSVC linker error fix.(#1040)

hazelcast::client::member::version is exported.
std::ostream& operator<<(std::ostream&, const version&); is exported.

Fixes #1040

Windows test PASSed.

Linux test PASSed.

Windows test PASSed.


python 3.10

Hello!  I cloned and edited alphatims/__init__.py to allow for python 3.10 and built a wheel with it.  It appears to install and work fine.  Would you mind officially allowing python 3.10?
Some key dependencies:
  • Installing llvmlite (0.39.0)
  • Installing numpy (1.22.4)
  • Installing numba (0.56.0)
  • Installing alphatims (1.0.0 alphatims/alphatims-1.0.0-py3-none-any.whl)

have you had a chance to look into allowing python 3.10?

Sorry, seems like I stopped receiving mails from the AlphaTims repo. I updated the versioning to: __python_version__ = ">=3.8,<4", on the dev branch, and will probably make an official new release next week. Thanks for checking this!

Hello there! I wanted to ask if this is officially supported? (if so, I think the readme could be updated to specify the versions allowed!)
Sections like alphaTims can be installed in an existing Python 3.8 environment might be misleading.
Let me know if you would like PR to fix that!
Kindest wishes,
Sebastian

Yes, that is official by now! Mainting docs is always difficult though, feel free to make a PR into the dev branch and replace any of the docs which are faulty (perhaps also the tutorial nbs)! Thanks for pointing it out.


Make morpheme rankings / preverb cache lazy

The spooky-action-at-a-distance where these are initially set to empty
values that calling code can use and make invalid decisions based upon,
unless you call the right thing at startup from tests, has been causing
issues for me for a while.

Codecov Report

Merging #724 (63b208c) into master (ededf36) will decrease coverage by 0.32%.
The diff coverage is 77.77%.

:exclamation: Current head 63b208c differs from pull request most recent head 2f642aa. Consider uploading reports for the commit 2f642aa to get more accurate results

@@            Coverage Diff             @@
##           master     #724      +/-   ##
==========================================
- Coverage   82.17%   81.84%   -0.33%
==========================================
  Files          82       82
  Lines        3085     3057      -28
  Branches      456      453       -3
==========================================
- Hits         2535     2502      -33
- Misses        465      472       +7
+ Partials       85       83       -2

Impacted Files
Coverage Δ

CreeDictionary/API/apps.py
54.54% <0.00%> (-25.05%)
:arrow_down:

...CreeDictionary/management/commands/ensuretestdb.py
81.08% <0.00%> (ø)

CreeDictionary/conftest.py
100.00% <ø> (ø)

...ch_quality/management/commands/runsamplequeries.py
61.53% <ø> (+1.53%)
:arrow_up:

CreeDictionary/API/models.py
83.05% <83.33%> (-0.95%)
:arrow_down:

CreeDictionary/API/search/core.py
91.76% <100.00%> (+2.35%)
:arrow_up:

CreeDictionary/API/search/ranking.py
66.66% <100.00%> (ø)

CreeDictionary/API/search/affix.py
96.66% <0.00%> (-3.34%)
:arrow_down:

...ctionary/DatabaseManager/xml_entry_lemma_finder.py
98.30% <0.00%> (-0.31%)
:arrow_down:

CreeDictionary/DatabaseManager/xml_importer.py
98.75% <0.00%> (+<0.01%)
:arrow_up:

... and 1 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update ededf36...2f642aa. Read the comment docs.


[Better Error] Improve error raised when authentication fails.

This change is

Reviewed 2 of 2 files at r1.
Review status: :shipit: complete! undefined

emploi_store/init.py, line 39 at r1 (raw file):

import requests
from requests.exceptions import HTTPError

please only import modules.

emploi_store/init.py, line 91 at r1 (raw file):

            auth_request.raise_for_status()
        except HTTPError as error:
            raise ValueError('Autentication failed: {}'.format(error))

raise ValueError('Authentication failed') from error

tests/emploi_store_test.py, line 48 at r1 (raw file):

    def test_access_fails(self, mock_requests):
        """Test the access_token method."""
        mock_requests.post.return_value = mock.MagicMock()

hmm, actually this one is useless (mock_requests is a MagicMock so post as well)

tests/emploi_store_test.py, line 49 at r1 (raw file):

        """Test the access_token method."""
        mock_requests.post.return_value = mock.MagicMock()
        mock_requests.post.return_value.status_code = 400

The right thing to mock is actually the side_effect of raise_for_status:
mock_requests.post().raise_for_status.side_effect = exceptions.HTTPError
At this point, please add a TODO to use the requests_mock package for testing.

Comments from Reviewable

Review status: :shipit: complete! undefined

emploi_store/init.py, line 39 at r1 (raw file):
Previously, pcorpet (Pascal Corpet) wrote…
please only import modules.

Done.

emploi_store/init.py, line 91 at r1 (raw file):
Previously, pcorpet (Pascal Corpet) wrote…
raise ValueError('Authentication failed') from error

Actually raise from is only in Python3.

tests/emploi_store_test.py, line 48 at r1 (raw file):
Previously, pcorpet (Pascal Corpet) wrote…
hmm, actually this one is useless (mock_requests is a MagicMock so post as well)

Done.

tests/emploi_store_test.py, line 49 at r1 (raw file):
Previously, pcorpet (Pascal Corpet) wrote…
The right thing to mock is actually the side_effect of raise_for_status:
mock_requests.post().raise_for_status.side_effect = exceptions.HTTPError
At this point, please add a TODO to use the requests_mock package for testing.

Done.

Comments from Reviewable

Reviewed 2 of 2 files at r2.
Review status: :shipit: complete! undefined

tests/emploi_store_test.py, line 54 at r2 (raw file):

        mock_requests.post().raise_for_status.side_effect = http_error

        self.assertRaises(ValueError)

You're not testing much here

Comments from Reviewable

Review status: :shipit: complete! undefined

tests/emploi_store_test.py, line 54 at r2 (raw file):
Previously, pcorpet (Pascal Corpet) wrote…
You're not testing much here

Done.

Comments from Reviewable


Criteria for choosing the RC car

Hi,
This is not really an issue but a query. Did you choose the Traxxas LaTrax Rally car specifically for a particular reason, such as the 3d printed base board would fit well with it, or you knew that it was hackable? I am asking because the Traxxas RC cars are not available in India and importing it costs 3x more. There are other RC cars with similar specs (1:18 scale, 2.4 GHz radio, 4WD), such as this.
The Donkey car is also a relatively affordable option. I would appreciate if you could give any opinion on this, I have never played with RC cars and haven't done any hardware hacking before.

Hi Abhinav,
Thank you for your question.

But you should be able to use other cars, as long as they expose Servo and ESC controls through the standard 3-pin "Servo" connectors.
So anything used in Donkey Car should work.
Our observation is that, once the RC car gets smaller than 1/10 scale, it uses what people call 3-in-1 controller, which combines the radio receiver (RX), the servo controller and the ESC in one unit.
This makes it very difficult to hack, as you cannot simply plug the cables from Servo and ESC to the PCA9685 board.
You can tell the car is using 3-in-1 design by finding the 5-wire cable coming out from the servo, like the one on Amazon you suggested.
Availability of the upgrade/replacement parts is also a good indication that the car is hackable.
I think you will have a better chance if you go for 1/10 scale and look in the hobby section rather than the toy section.
I hope you will find a reasonably priced car for your project, and please share with us if you find a good one.

May I ask which component has signal input and power output? Because I have no idea which component (RC reveiver? PCA9685? Servo Motor Driver? RC Servo? or the RC ESC?) should be connected to the battery.
Thank You!

Battery sends power to ESC.
In normal RC car, ESC connects to RC receiver, sends the power, and the receiver shares the power the steering servo connected to it.
In JetRacer, you have the servo multiplexer in the middle. And you power the Jetson Nano with USB power bank.
Of course you can also power each component in other ways if you are adventurous. :)


Convert timeout string to integer

check-pingdom-credits.rb fails with "CheckPingdomCredits CRITICAL: Check failed to run: can't convert String into time interval” when timeout option is used.  This change enables the use of the timeout option to change the default timeout.

Closing this and taking it over to "The official home for the Sensu community plugins - https://github.com/sensu-plugins"


Test a Like

Same as fediverse-devnet/feditest-tests-fediverse#16, just a Like with object pointing to the existing Note instead of inReplyTo.

Split into this and #149 .


Mark safepoint inactive and nofree

Nightly now gets further, but still fails at an activity mismatch. But hopefully soon we'll be able to see backtraces for that!


[REEF-444] Replace "Activity" with "Task" on http://reef.incubator.apache.org/introduction.html

This addressed the issue by

Updating images from https://cwiki.apache.org/confluence/display/REEF/Website+Artifacts
Replacing text occurrences

JIRA:
REEF-444

This looks good. I will test, merge, and upload to the website.

Yes, I thought the same when I looked at it. Awesome stuff :-)


Atom client

See atom/atom-languageclient for details on how to implement the client in Atom

Fixed by the introduction of https://github.com/mads-hartmann/ide-bash in a separate repo


Tracking implicit dependencies

Originally HoloViews was only targeting matplotlib and as a result we were happy to depend on a few things that matplotlib depended on. Likewise, IPython is now Jupyter and has split into a number of repositories.
Here are some dependencies we need to worry about for people using bokeh without matplotlib:

pyparsing is need for the %%opts magic (included if matplotlib is installed).
Annoyingly you now need conda install nbformat for the NotebookArchive (used to be included).
jinja2 (although this is still a dependency of ``notebook`) so only needed if you want to run unit tests without notebook installed.

I think that is all of them.
Edit: I didn't look carefully enough - it seems nbformat is included with notebook. So I suppose the key point is that notebook is required to run the unit tests.

So, do we need to have two conda packages for HoloViews, one relying only on Param (and numpy?), and the other building on that to add these non-core dependencies?

So, do we need to have two conda packages for HoloViews, one relying only on Param (and numpy?), and the other building on that to add these non-core dependencies?

I suppose so. I just wish conda supported something like extras_require!

Agreed.  I was just talking to the conda people about noarch support, another glaring problem, and it's clear that they are overloaded right now, so I wouldn't expect it to get better soon!


ByteBuffer should have hex bytes initialiser / write method

This is pretty much a companion of #2447 / #2475. The aforementioned bugs/patches introduce the ability to get the hex dump from a ByteBuffer which is awesome.
Next, I'd like to construct/write into a ByteBuffer from a hex dump:

ByteBuffer(hexEncodedBytes: "68 65 6c 6c 6f 20 77 6f 72 6c 64 0a")
buffer.writeHexEncodedBytes("68656c6c6f20776f726c640a")

I'd say it just needs to support the .plain format (i.e. 2 hex-digit values with whitespace ignored)

Super basic test:
var buffer = ByteBuffer(hexEncodedBytes: "68 65 6c 6c 6f 20 77 6f 72 6c 64 0a")
buffer.writeHexEncodedBytes("68656c6c6f20776f726c64")
buffer.writeHexEncodedBytes("")
buffer.writeHexEncodedBytes("0a")
XCTAssertEqual(ByteBuffer(string: "hello world\nhello world\n"), buffer)

another one:
var allBytes = ByteBuffer()
for x in UInt8.min ... UInt8.max {
    buffer.writeInteger(x)
}

let allBytesHex = allBytes.hexDump(format: .plain)
let allBytesDecoded = ByteBuffer(hexEncodedBytes: allBytesHex)

XCTAssertEqual(allBytes, allBytesDecoded)

I have taken a look and would like to pick this up after https://github.com/apple/swift-nio/issues/2734.

Of course this should also parse the .compat format suggested in #2825

Happy if someone else is eager to give it a go. I have started looking at it but no real progress. It feels overly ambitious to try and start working on a second PR when my first has taken quite a while.

I did re-request review on your other PR. Remember to click the  :recycle  (re-request) review once you addressed the changed suggested/requested. I'm sure @FranzBusch & @Lukasa just missed that you pushed updates to your existing PR.
Separately, if you're up for it, you can totally have multiple PRs open at the same time, shouldn't slow things down.

The "good for newcomers" in this repo are the hardest thing every 😅 (which I VERY much enjoy).
Experimenting with the below and seeing if writing that to the buffer is the right outcome for writing a hex encoded string to buffer.
extension String {
    var hexData: some Sequence<UInt8> {
        sequence(state: self, next: { remainder in
            guard remainder.count >= 2 else { return nil }
            let nextTwo = remainder.prefix(2)
            remainder.removeFirst(2)
            return UInt8(nextTwo, radix: 16) // compatible
        })
    }
}

TLDR: Thanks for the push. Working on it!

The "good for newcomers" in this repo are the hardest thing every 😅 (which I VERY much enjoy).
Experimenting with the below and seeing if writing that to the buffer is the right outcome for writing a hex encoded string to buffer.
extension String {
    var hexData: some Sequence<UInt8> {
        sequence(state: self, next: { remainder in
            guard remainder.count >= 2 else { return nil }
            let nextTwo = remainder.prefix(2)
            remainder.removeFirst(2)
            return UInt8(nextTwo, radix: 16) // compatible
        })
    }
}

TLDR: Thanks for the push. Working on it!

Awesome, FWIW, you can use
extension String {
   var hexData: some Sequence<UInt8> {
       return ByteBuffer(string: .self).hexDump(format: .plain).utf8
   }
}

to get a sequence of UInt8s. String's .utf8 gives you a UTF8View which is a Sequence<UInt8>

@weissi please take a look at the PR when you fidn the time

I think this can be closed now

Can this be closed?


Err before starting invalid services

Even if the data referenced in a job specification for a service does not exist, Pachyderm will still try to create the service.  This will obviously create a confusing situation.  The commit referenced in a specification could be completely phony and yet Pachyderm will still try to create the service.
@sjezewski and I think that we should check that the referenced commits exist and error if it does not.

I believe this is now fixed because we need to create subvenance references in the inputs when we create the pipeline (or service). It is possible to reference branches that don't exist, but that's by design and creates the branches, you can't references repos that don't exist and you can't reference commits directly at all.


[CARBONDATA-4331] Fix Wrong Projection name displayed if MV create query has alias

Why is this PR needed?
MV query displays incorrect projection name if mv has alias
What changes were proposed in this PR?
Map the user query output list with mv output list and replace with user  query output list while rewrite
Does this PR introduce any user interface change?

No

Is any new testcase added?

Yes

Build Failed  with Spark 3.1, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_3.1/659/

Build Failed  with Spark 2.3.4, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbonPRBuilder2.3/6269/

Build Failed  with Spark 2.4.5, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_2.4.5/4525/

Build Success with Spark 3.1, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_3.1/660/

Build Failed  with Spark 2.4.5, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_2.4.5/4528/

Build Success with Spark 2.3.4, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbonPRBuilder2.3/6273/

Build Success with Spark 3.1, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_3.1/663/

Build Success with Spark 2.3.4, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbonPRBuilder2.3/6276/

Build Success with Spark 2.4.5, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_2.4.5/4531/

Build Failed  with Spark 2.4.5, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbon_PR_Builder_2.4.5/4532/

Build Success with Spark 2.3.4, Please check CI http://<IP_ADDRESS>:12602/job/ApacheCarbonPRBuilder2.3/6277/


Website Blacklisted

express.dhl are blacklisted. Is a Website From DHL Company

Thank you for this @Auraya83.
We don't list the domain express.dhl.
Closing.


Bump debian release for eks go 1.20.14-16, 1.21.8-9, 1.22.1-1

Issue #, if available:
Description of changes:
By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.

/lgtm

/approve


Don't use [*]Names fields in data

Currently, getting data related to module uploads is done like so:
{
  package(name: "eggs") {
    packageUploadNames
  }
}

As you can see, if you want to get the uploads, one must query again using the names.
"Names" should be removed, including for users with the packageNames fields and instead allow these fields to directly query the packages and package uploads.

[x] Direct queries to packages have been added.

[ ] Direct query to users added too.

To summarise:
There should not be a seperate query for packageUploads like the following:
{
  packageUploads(name<EMAIL_ADDRESS>{}
}

Instead:
{
  packages(name: "eggs") {
    uploads(name: "0.1.0") {}
  }
}

The packageNames field on the packages object would be removed in favour of this. We should also support querying a certain amount of uploads and potentially pagination of them.
This same process should be applied to the packageNames field on the user object as well.

I might change the issue name and description to reflect this.

@zorbyte https://github.com/nestdotland/api/commit/f606dc1109d90fe8a38ba4bfbda2f58f6c0fb4f5 has been merged. It adds:
{
  packages(name: "eggs") {
    uploads(name: "0.1.0") {
      name
    }
  }
}

and
{
  packages(name: "eggs") {
    uploads {
      name
    }
  }
}

And removes the global query for uploads

@zorbyte Can we close this for now we have https://github.com/nestdotland/api/pull/32 merged.


Tutorial interactivo - Crear un clúster

katacoda.com is now closed to the public and content is no longer available.

es page: https://kubernetes.io/es/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive/

en page: https://kubernetes.io/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive/

/language es
/triage accepted

Hi @jihoon-seo, I think Interactive tutorial environment for k8s is also showing same result here - https://kubernetes.io/id/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive/

@utkarsh-singh1 it seems that to make the interactive tutorial in those pages work, someone has to update those pages to be synced with the English page.

@jihoon-seo , Will raising an issue with the link - https://kubernetes.io/id/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive/ can be helpful?

@utkarsh-singh1 it would be great! And other pages that have the same issue too.

@jihoon-seo I have checked the other pages, it seems pages translated in Spanish and Indonesian have these issue right now.


CWL_THROTTLING_EXCEPTION on Provision Step

Before opening, please confirm:

[X] I have checked to see if my question is addressed in the FAQ.
[X] I have searched for duplicate or closed issues.
[X] I have read the guide for submitting questions.
[X] I have removed any sensitive information from my code snippets and submission.

App Id
d1dqg4zhpoydyx
AWS Region
us-east-1
Amplify Hosting feature
Deployments
Question
The Provision step of my deployment keeps failing, with this error message being displayed in the console:
[CWL_THROTTLING_EXCEPTION: The maximum request rate permitted by Amazon CloudWatch Logs has been exceeded for your account. Error message: Rate exceeded]
I looked at CloudTrail and found that there are a lot of requests to the CreateLogStream API. (It should be noted, however, that this does not seem to be greater than the quota which is 50 TPS by default.) If the error is correct, I think there are two options to fix this:

Increase the quota
Reduce logging

I tried increasing the quota to 100, and this allowed the subsequent build to succeed. However, the next one failed for the same reason, so this does not seem to be a long-term fix.
I think reducing logging would be best, especially because the CreateLogStream requests seem to be resulting in ResourceAlreadyCreatedException. However, I do not see any options in the build or Amplify settings to control this.
Please advise.

Hi @gnewfield thank you for opening this issue. Has this happened to you consistently, and are you still currently experiencing this?


"About" page needs a lot more content

credits, more info about the system

It has a decent amount of content now, it just needs to be a little friendlier.  Closing this issue, see #52 instead.


Bar Plot issues

I need the bar plot to be same as what I get from pandas
Pandas plot image:

Dataframe image:

What I get from hvplot - saving as html

I need to move <80% to the left most, I am not able to change ylim even though I give a tuple as params, would love to select ea or ca from legend and need to change order of EA and CA bar. Need to show EA first then CA.
My current plot code:
hvplot.save((df_counts.hvplot.bar(y = ['EA','CA'], ylim = (0, 1.2 * df_counts.max().max()), width=1000, height=500, title='Availability_' + str(month_name[int(month)]), ylabel='Count of sites' , xlabel='Availability')), 'Bar1.html')

Could someone help me correct this?
The whole reason why I want to use hvplot is because of the dynamic plot and not static plots like pandas.

Even simpler example:

default seems to be sorting alphabetically

Duplicate of https://github.com/pyviz/hvplot/issues/208


Design to support NTS

This issue is to discuss the way in which we should start integrating NTS.

Changes to prepare for NTS
The PR here is a proposal on how to proceed with NTS. Some ideas behind this PR:

It should, at least for a while, be possible to support both Mapsui.Geometries and NTS. Also there will be other types of things which will need specific renderers which are not geometrie, like Rasters, VectorTiles. So we need some abstraction that allows for those different types.
To allow flexibility I have chosen for a solution where the Geometry was removed from the IFeature and an IGeometryFeature was introduced with a Geometry field. The core classes use the IFeature while specific layers use IGeometry. Later an INtsFeature could be introduced with it's own layers and renderers.
Where to make the cut? In classes where IGeometryFeature is used we can have type save Geometries, that's nice. But since the core classes use IFeature we need to do some casting somewhere. In some situations this can be prevented using generics, but not everywhere. The currently version compiles and seems to function correctly (after quickly clicking to through all the samples) but there may be better ways to make the cut. More thought will help.

Some things that have changed

Removed Geometry from IFeature
Add IGeometryFeature with a Geometry
The IProvider now has a generic argument public interface IProvider <out T> where T : IFeature
The ILayer has no generic argument. Not sure if it should.

More changes to come

MPoint and MRect for all core classes: Currently the Mapsui.Geometries Point and BoundingBox are used in many many places. Often this does not relate to geometries at all, like in the Widgets. In other cases it is an extent of a geometry but not a geometry itself. Instead of replacing them with NTS Point and BoundingBox I propose to replace them with two new Mapsui specific classes. I was thinking of calling them MPoint and MRect. A first step would be to copy the current Point and BoundingBox and replace them. We will need to add extension method converters both ways (ToMPoint, ToMRect and ToGeometry).
We will need to split the Mapsui project into two parts:

The Mapsui core which has no dependency on Mapsui.Geometry or NTS, and instead uses MPoint and MRect
The other (have no name for it yet) that depends on Mapsui.Geometries which will hold most of the current layers.
And perhaps the TileLayer could go into it's own project.

A new Mapsui.Nts project will have a dependency on Mapsui core only.
Some classes that need to stay in Mapsui core (and will need to make use of MPoint and MRect).

Map
Viewport
Navigator
ViewportLimiters
MapInfo
Widgets
Everything related to UI

Quad should stay and perhaps should be called MQuad, or perhaps be merged with MRect.
Raster should not be derived from IGeometry and should be a field in a IRasterFeature

Some other changes
Some other changes were made that were not directly related but complicated the necessary changes:

The IFeatures interface was removed, and I would like to remove the Features class as well. It was based on the old DataTable class that was once used in SharpMap. The List and other collections suffice.
All XAML rendering was removed!

If you move to the new concept of renderers for special classes, you could keep the complete rendering in the core of Mapsui. You could make a special renderer for raster maps and Mapsui even doesn't know what a raster map is. And each type of layer could be optimized for rendering if you like this.
You want to use NTS for your geometries in your special layer? No problem. You want to use the old geometries for your layer? Also, no problem. Mapsui didn't have to know anything about geometries. You want to pre render parts of your layer by converting geometries into Skia paths? No problem.
With this concept Mapsui is very flexible.
So move all special cases in the renderer out to their own special renderers and add them at startup to the known renderers.

@charlenni I think this is roughly what I had in mind, to move more in the direction of the custom style renderers. But you also say 'you could keep the complete rendering in the core of Mapsui'. What do you mean with this? I would think everything becomes like a special case, so it goes more in the opposite direction.
Flexibility comes at a price
I would also like to add we should be careful adding flexibility because it could make the code hard to understand and could impact performance. Nevertheless I think we should move in that direction.

The core rendering is to go through the list of layers and check, which renderer is needed. Then call this renderer. The renderer itself should go into a project with Skia support, the rest could stay in the Mapsui core project.

And if you think about changes in this area: I found two days ago a nice article about drawing in the background with Skia. The author suggested dividing the drawing process in two processes: rendering and painting. He first renders all layers to SKPictures, which store all painting commands. This could be done on any thread you want and has to be done only, if something on this layer has changed. It could even be done on a thread per layer. In another step, the stored painting commands are painted to the canvas, which has to be done on UI thread. Perhaps this speed up Mapsui a little.
We started a discussion about this at #1084.

Status update
In steps the dependency of Mapsui.Geometries is reduced. Where possible MRect and MPoint are used. A lot of code in Mapsui is moved to Mapui.Core. All tiling is now independent of Mapsui.Geometries and moved to Mapui.Layers.Tiling and a part to Mapui.Layers.ArcGIS. Next WMS and the GeoTiffProvider should be moved out of the Mapsui project. It looks like this is not a lot of work. What remains all has a strong dependency on Mapsui.Geometries and will need a straight port to NTS. That will be a lot of work. It involves many renderers and samples. Perhaps some samples could be made geometryless first.  At some point all that will be moved to a Mapsui.Layers.Nts folder and Mapsui.Core will be renamed to Mapsui again. That would complete the port to NTS. I may create a Mapsui.Layers.Wms and Mapsui.Layers.Wfs project.

Status update after cleaning samples and tests
IGeometryFeature has been removed and I have gone through all use of GeometryFeature. In the samples and tests I could replace it in many cases with PointFeature. This left to do:

Improve projections. In the current solution different IProjection implementations are used. There should be only one. The current ProjectingProvider only projects IGeometry. It should project all types of features. This will allow us to remove move GeometryFeatures (and replace it with PointFeatures). A complication at the moment that projection from a MemoryProvider needs a copy of the feature. So for that a generic copy method would be needed. I don't see a good generic solution for that. I now am thinking of a ProjectingProvider that does not copy and solve the problem for projecting of MemoryProviders in some other way. A way to iterate over all coordinates could be by using a:  IFeature.Visitor(Action<IFeature, ref double x, ref double y);
Move things into Layers and move Mapsui.Core back to Mapsui.
Migratie to NTS.

Status update
Wrapped up Projections. Next up is to reorganize the project structure.

Status update
Done:

Improve projections: Done months ago actually. I am fairly happy with the result.
Moved all files depending on Mapsui.Geometries to Mapsui.GeometryLayer, removed Mapsui.Geometry dependency from Mapsui and moved all Mapsui.Core code back to Mapsui.

Todo:

Port everything in Mapsui.GeometryLayers into a new Mapsui.Nts project.

Status update
Straight port of Mapsui.Geometries to NTS is in progress on a branch and in large part still only local on my machine. More than half way there.
Done:

Rendering
Shapefile
All tests

Half done:

WPF editing
Xamarin.Forms editing

The problem with editing is that the NTS Geometries have no default constructor and there seems to be no way to alter the Coordinates. So, when a vertex is added a new geometry needs to be created from what was already there. There are also some other quirky things, like a polygon needs at least three points, but you have to start with one with editing, so you have to keep track of those first few points yourself in a separate array. It is possible to set the X, Y values of the Coordinates, so the Geometries are mutable.
Todo:

WFS provider

Status update
The current branch is ready to be merged https://github.com/Mapsui/Mapsui/pull/1454. Mapsui.Geometries has been removed so everything is ported. As far as I am aware everything works. The tests are green and I have gone through all samples. I could not test WFS because the current sample does not work. I have probably introduced bugs but we find out in the coming period. After the merge this phase is completed.

Status update
#1454 was merged. For problems following from this merge please create new issues.


fix(helm): use nindent

Helm's indent function doesn't prepend a newline, so the generated YAML is currently malformed if .Values.resources is provided.
Ref: http://masterminds.github.io/sprig/strings.html

I can probably add this fix to https://github.com/jetstack/google-cas-issuer/pull/96

@MaesterZ thanks!


Faker::Address.uk_postcode can generate invalid postcodes.

This is the regex I've been using to validate them:
/^([A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}|GIR 0AA)$/
Which seems to be the correct one, as taken from StackOverflow
Faker generated BI56 3QX for me, which when you search in Google Maps is not recognised.

Please note that uk_postcode is deprecated... use postcode instead after setting Faker::Config.locale = 'en-gb'