In most of these discussions, there is no one "true" answer. There are engineering tradeoffs. There are design decisions, about what will be most easy for people to work with, least likely for someone to screw up and break the whole system. There is inertia of existing systems, that would cost a lot of money to rewrite, and tradeoffs of what will be the lowest cost solution.
There is a simple explanation in the introduction:
In short, the theorem states that no rank-order voting system can be
designed that always satisfies these three "fairness" criteria:
1. If every voter prefers alternative X over alternative Y, then the
group prefers X over Y.
2. If every voter's preference between X and Y remains unchanged, then
the group's preference between X and Y will also remain unchanged
(even if voters' preferences between other pairs like X and Z, Y and
Z, or Z and W change).
3. There is no "dictator": no single voter possesses the power to
always determine the group's preference.
A "rank-order voting system" is one in which all voters order the possible choices, from most preferred to least preferred. The idea is that based on everyone's votes, and some set of rules on how to evaluate those votes, you can come up with a decision for the entire group that respects those preferences, in some way that is considered fair.
All of these requirements listed above seem like fairly simple requirements for a voting system to have; if there's unanimous agreement about the ordering of two of the choices, then the voting system should order them that way. If a voter changes preferences about one choice C (maybe changing between them being ranked above or below D, or above or below one of A or B), without changing their ordering between choices A and B, that shouldn't affect the outcome of the A/B ordering that the voting system gives you. And finally, there is not dictator; no single voter is able to always determine the group ordering unilaterally.
The first requirement seems pretty obvious; if everyone is unanimous that we should pick one option over another, then the group should pick that option.
The second is a little trickier; but it basically states that there shouldn't be able to be "spoiler"; someone whose ordering in people's preferences affects the ordering of to other choices. Think about, say, the 2000 election, with Bush and Gore and a couple of third party candidates; now, that used just single choices per voter rather than a ranking, but imagine it used a ranking. So let's say Bush and Gore are fairly close, but 51% of voters prefer Gore over Bush. Their preferences for other candidates should not affect the fact that Gore wins over Bush. If I rank candidates Nader > Gore > Bush, that should not change the Gore/Bush result compared to if I ranked the candidates Gore > Bush > Nader.
And the last is pretty trivially desirable; generally a democracy wants to democratically make a choice, in which everyone's vote has the same weight in affecting the final outcome.
The fact that these conditions are impossible to achieve together is fairly profound, and means that almost any voting system will have serious flaws under certain circumstances.
Displaying characters on the screen, and giving the ability to select text, is indeed quite a difficult and complex question in the face of full support of the world's written languages.
Glyphs vary in width. There are combining characters. There are ligatures (and in some languages, ligatures are necessary for the text to be readable, not just stylistic). There is contextual reordering of characters. There's bi-directional text, which can switch direction mid-sentence when quoting some Roman text in Hebrew or vice versa. There's vertical text. There are a number of fonts, font weights, font styles, font sizes, font features like alternative characters, language dependent selection of glyphs, and so on, plus fallback if the user doesn't have the designated fonts or fonts that cover the given Unicode range installed. There's line breaking, which can't always operate on spaces because not all languages include spaces between words. There's justification of text, distributing the spacing between characters to make a block of text even on both sides.
All of this complexity exists regardless of the encoding that you use. Simply picking a fixed width encoding will not do anything about the vast majority of the complexity; and the fixed width encoding will cause problems of its own (size bloat of strings in memory), as well as leading people astray in thinking that maybe they can get away with making some of the same assumptions that apply to ASCII on a fixed-width terminal (and even there, assuming that 1 character equals 1 unit of width fails in the case of tabs), when in fact they can't and most text handling beyond simply appending strings together is best handled by dedicated libraries that have had hundreds of developer-years of effort put into solving all of these problems.
We have not yet developed writing systems for all of the world's languages. So there is no practical bound you can put, because it is possible that in a future development of a writing system, there will either be entirely new characters invented, or new combinations of existing characters and diacritics.
In addition, since the existing Unicode standard does not impose a bound, and implementations support stacking of large numbers of diacritics, people have used combinations of extremely large numbers of diacritics as a stylistic device, for example: http://stackoverflow.com/a/1732454/69755. Since examples like this exist in the wild, they need to be supported properly, and so the fundamental string types and operations in string handling libraries should be able to handle it.
Yes, we have to live with what was created, but given 128-bits is boil the ocean territory and someone has to type this stuff, I don't see a compelling argument for unbounded.
But why bother with a fixed width 128 bit encoding? We have perfectly fine variable-width encodings, that take up 8 bits per character for the most common set of characters encoded, the ASCII range (even for CJK text, the fact that most markup languages like HTML and XML use ASCII means that actually, the bulk of documents fall within the ASCII range), and can handle arbitrarily complex stacks of diacritics.
How would it be helpful to waste a huge amount of space for the vast majority of text, impose additional limitations on the number of combining characters, just for the benefit of fixed-width encoding of graphemes, which even in itself is not all that helpful since for most applications, you are either going to need to scan through the text linearly, or you could use byte offsets in the variable width encoding just as well as you could use grapheme offsets in a fixed width encoding?
I used 128-bit as a max. I just don't like some unbounded thing when we know that there is a practical max. I wouldn't call something perfectly fine when getting the number of characters actually displayed on the screen is a chore.
What's wrong with unbounded? The amount of text you're rendering is unbounded (except by resource constraints). Combining diacritics are just another kind of text, that happen to lay out vertically rather than horizontally even in horizontal layout.
What do you mean by "getting the number of characters actually displayed on the screen"? Do you mean number of glyphs? Number of grapheme clusters? The number of glyphs is dependent on your text rendering system and fonts; even with plain ASCII, you may have multiple codepoints rendered as a single glyph, such as in ligatures like "ffi" in certain fonts. The number of grapheme clusters can be computed by the given algorithm along with some tables of character properties; it's not particularly simple, but trying to represent languages that were originally hand-written on a computer is not simple: http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries
Why would you want constant time access to code points? What can you do with constant time access to code points that is actually correct?
Every time someone tries to promote UTF-16, UTF-32, or some imagined encoding like UTF-24, they bring up constant time access to code points, but I have never heard of a reason why you would want that.
Pretty much every use case I have ever heard for constant-time access can be handled just as well by constant-time access at the code unit (byte in UTF-8, 16 bit value in UTF-16, 32 bit value in UTF-32) level. Matching text exactly? Matching works just as well at the code unit level. Doing any kind of fuzzy or regular expression match? You're going to need to iterate over each item anyhow to normalize it or classify it. Need to store offsets? That works just fine at the code unit level.
Most of the other suggestions I've heard for what to do with constant-time access to code points is incorrect when you consider combining characters, normalization, different character widths, need for linguistically appropriate word splitting, etc. If you're doing something that doesn't take these into account, why are you using Unicode instead of just ASCII?
In addition, for the ASCII range, UTF-24 would take up 3 times the space as UTF-8, and the vast majority of text processed is actually in the ASCII range due to verbose markup formats like HTML, XML, etc. Plus if you do anything with the code points in UTF-24, you need to do a bunch of bit-fiddling to move them into 32 bit alignment, so as far as actually decoding the individual code points, it's pretty much a wash with UTF-8.
> UTF-24 would take up 3 times the space as UTF-8, and the vast majority of text processed is actually in the ASCII range due to verbose markup formats like HTML, XML, etc
Sounds like these "verbose" markup formats are the real problem in taking up too much space, not the Unicode transformation formats.
I think that moving the world away from HTML and XML as markup languages is likely to be considerably harder than simply defaulting to using UTF-8 in any new code for which there isn't already a natural encoding to choose based on the platform or APIs you're developing on.
Furthermore, even beyond the markup, the vast majority of written content is in the Roman alphabet, of which most characters are in the ASCII range, and those that aren't fit into 2 bytes of UTF-8. 55% of text on the web is in English, then languages using the Roman script or other scripts in the 2-byte UTF-8 range make up 21 of the next 25 most commonly used languages on the internet; of the top 25 languages, only Chinese, Japanese, Korean, and Thai are in ranges that require 3 bytes in UTF-8 for the majority of their characters (https://en.wikipedia.org/wiki/Languages_used_on_the_Internet).
So for the vast majority of text that is processed, UTF-8 is dramatically more efficient than a hypothetical UTF-24 or the real UTF-32. Now, you might say "well, it should all compress away anyhow", but when dealing with text in RAM, it is generally not compressed (and that would make handling it far more complex than just using UTF-8), and memory capacity, latency, and bandwidth can all be important.
Trying to deal with text as fixed-width characters is simply incorrect. Almost every non-trivial means of handling text needs to support arbitrary length strings, needs to deal with clusters of more than one codepoint as a single unit, and needs to iterate over the characters linearly at least once (and can then store byte offsets for random access later on). Dramatically increasing storage requirements of text for the non-benefit of being able to deal with fixed-width codepoints just doesn't make sense.
Okay. But that's the world in which we live. Complaining about the real problem being "things people put in strings" rather than the actual encoding format isn't going to solve any problems people actually have.
> What can you do with constant time access to code points that is actually correct?
Compute an offset into a string in one part of your code, and then pass a representation of that offset to another part of your code that then accesses that part of the string and does something with it.
It is theoretically possible to produce an abstract representation of such an offset that would allow constant-time access into a non-uniformly-represented string, but no programming language that I know of has this feature. Even Common Lisp, which is probably the most flexible and future-proof language ever designed, requires that offsets into strings be integers. (Actually, it's even worse than that: Common Lisp requires that strings be arrays of characters, which is truly ironic if you think about it.)
But as lambda points out, that offset could be measured in code units rather than code points. You still don't need random access into variable-width data.
Read what I wrote more carefully. You have to take that offset, represent it somehow, and then pass that representation off to another part of the code, which then uses that representation to access the part of the string that was found earlier. How do you do that without forcing a re-scan when the only facility that the language provides for accessing a character in a string requires you to represent the location of that character as an integer?
Actually, you can do it in C because you can use a raw pointer, but that is fraught with all manner of other perils.
Just use the octet index instead of the code point index. To use UTF-8-based strings, you do need to distinguish between octet indexes (calling them iterators is probably saner to most people) and character indexes.
With UCS-4 (and UCS-2 as implemented in practice), the iterator representation and character index are the same, which makes retrofitting those implementations to use UTF-8-based strings impossible. But for new environments, where UCS-2-backwards-compatibility isn't a requirement, it's not hard to make a string API that properly exposes the difference between iterators and character indexes, which is why newer environments are gravitating towards UTF-8 strings.
This discussion is about what encoding is best to choose for the low-level string types in languages and libraries, as that's what the original article was about.
If your language already uses a Unicode-compatible string type, you should probably use that.
If you are designing a new language, rewriting a language's basic string primitives, or writing an API or application in a language that doesn't have a well-standardized Unicode string type like C or C++, then it is probably better to pick UTF-8; if your app is necessarily single platform and tied to a platform API, choose that API's encoding, but for anything cross platform, the encoding is going to differ between the platforms so choosing UTF-8 and then transcoding at the API boundaries on the different platforms is fine.
By the way, most languages do have the concept of a byte array, and you can provide UTF-8 string operations on top of that; but as I said, in general, you should be using the language's native string type unless you have a very good reason not to.
The original article that we're discussing does mention one of those very good reasons; in Python, it uses an 8-bit Latin-1 encoding if the characters can fit, upgrades to 16-bit UCS-2 if they can fit in that range, and finally upgrades to 32-bit UTF-32 if they don't fit in the UCS-2 range. But that means that if you're appending strings, and one of them contains an emoji (for instance, in a web templating system that encounters an emoji in a comment), that can mean that all of a sudden your string has to grow to four times its original size, which can cause serious problems; so one workaround for that may be to actually write everything out to a UTF-8 encoded string (which in Python can be represented as a byte array) rather than trying to append strings together and hitting that behavior.
Furthermore, several languages already do use UTF-8 as their internal string type; Rust, Go, and Ruby all use UTF-8 as their default or only string type.
And by the way, Rust and Go both use slices to handle the use case you describe; a slice is represented as a pointer to the first byte of interest, and a number representing how many bytes it extends. I don't know about in Go, but in Rust the API guarantees that all string slices created from a string begin and end on proper codepoint boundaries. Go: https://blog.golang.org/slices, Rust: https://doc.rust-lang.org/std/primitive.str.html.
I think we're in violent agreement here. Keep in mind that the question I was responding to was:
> Why would you want constant time access to code points?
And the answer is: because you might want to compute an offset into a string in one place in your code, and then use that offset to access the string at that offset somewhere else in your code in constant time.
But you don't need constant time access to code points for that, you just need constant time access to code units, which UTF-8 can do just fine. That's why I had asked that question; every reason I have ever seen given for wanting constant time access by code point can either be done simply by indexing by code unit, or is misguided as it assumes that a single code point is an interesting unit of processing on its own.
A code point (http://unicode.org/glossary/#code_point) is a value in the range from 0x0 to 0x10FFFF. In a fixed-width type, you need at least 21 bits to represent that, which is why 32 bits is the most common form for representing any arbitrary code point; but if you don't mind the alignment issues, you could even pack it to 24 bits or even 21 bits if you don't mind a little bit twiddling to extract it.
A code unit (http://unicode.org/glossary/#code_unit) is the smallest unit of encoding in the encoding that you are using. In UTF-8, that's a single byte; in UTF-16, it's two bytes, in UTF-32, four bytes.
In order to be able to have constant time offsets, you only need to store a code unit index, not a code point index.
The thing is, individual code points are not really all that interesting from the perspective of text processing. Almost all meaningful processing of them could potentially involve multiple code points, splitting on arbitrary code point boundaries without regards to higher level semantics can cause all kinds of problems, etc. So a desire to have constant time indexing by code points is misguided.
All offsets can be stored by code unit (byte in UTF-8). That gives you all of the constant time access to given points of interest in a string that constant time indexing by code point would have given you.
> (And yes, I know that UTF-8 is self-synchronizing. But that doesn't help with the problem I'm talking about, and if you think it does then you haven't understood the problem.)
I would like to retract this, and apologize for the snarky tone. I had mis-remembered the design of UTF-8, and so pretty much everything I said was wrong (well, not all of it was wrong, but the parts that weren't were exactly what you were saying).
I'd edit or delete my comment if I could, but the deadline has passed so this is the best I can do.
> But you don't need constant time access to code points for that, you just need constant time access to code units
Well, sort of. What you really want is constant-time access to (semantically meaningful) substrings. Not all code points are semantically meaningful, but the situation is even worse for code units. A pointer to a random code point may or may not designate the boundary of a semantically meaningful substring. But whatever problems that causes, the situation for code units is even worse, because a pointer to a random code unit may or may not designate the start of a code point, and even if it does then you still have the previous problem that a random code point may or may not designate yada yada yada. (And yes, I know that UTF-8 is self-synchronizing. But that doesn't help with the problem I'm talking about, and if you think it does then you haven't understood the problem.)
What you really want is constant-time dereferencing of designators for semantically meaningful substrings. But no language AFAIK actually has that. The fundamental problem is that most languages have painted themselves into a corner by carving into stone the fact that strings can be dereferenced by integers. Once you've done that, you're pretty much screwed. It's not that you can't make it work, it's just that it requires an awful lot of machinery. You basically need to build an index for every string you construct, and that can get very expensive. Fixed-width representations are a less-than-perfect-but-still-not-entirely-unreasonable engineering solution to this problem.
Notice he said code units, not code points. Code units are fixed size. So for example, in Java, you have 16-bit code units, and have constant time indexing into them.
So you could use a BreakIterator [1] to iterate through grapheme clusters. The iterator returns the index to the cluster though, not the cluster itself. The index is in terms of code units, not in terms of grapheme clusters.
Why couldn't the string implementation simply provide a string offset class? Internally, it could be represented as a byte offset but at the point of use it wouldn't have to know that.
Yes, this is the Right Thing. But don't forget the question I was responding to:
> Why would you want constant time access to code points?
The answer is: because you might want to compute an offset into a string in one place in your code, and then pass that offset to another place in your code which then accesses the string at that offset in constant time.
My point is that to make this work you must have string offset be an abstract class, not an integer.
It only has to be an abstract class if you want to prevent the existence of invalid offsets, but the same is true if you have constant width code points. For instance, INT_MAX is not a valid offset into almost any string.
> Why would you want constant time access to code points? What can you do with constant time access to code points that is actually correct?
Well, it makes it easier to avoid putting an ellipsis in the middle of a multi-byte character, which could crash the user's phone when something else tries to display your now-invalid string.
Note that my question included "...that is actually correct" as a condition.
Truncating between code points to insert an ellipsis is not correct. Not all characters have the same width, even in a fixed-width font; for instance, combining characters have zero width. Truncating between a base character and a following combining character makes no sense. If you're truncating the word "exposé" to fit into six characters, it makes no sense to count that as 7 characters, truncate the accent, and wind up with "expose...". (Yes, normally that will be represented as a pre-composed character, but there are base-character/diacritic combinations that have no pre-composed character, so you will necessarily get a combining diacritic).
Truncating based on character count can also mean that you exceed your width requirement; CJK characters are twice the width of most alphabetic characters.
Additionally, most text is displayed using variable width fonts, where truncation should depend on the precise sum of the widths of characters, but even text that isn't can have the previous two issues. These mean that to do truncation properly, you need to iterate over the characters counting width until you exceed your required width in order to truncate, then truncate at the previous grapheme boundary, which requires walking through the string in order and can be done just as efficiently in a variable width encoding as in fixed.
I collected up a number of nits like this, plus some more meaningful transcription errors, into a branch, and have sent a pull request: https://github.com/tdop/tdop.github.io/pull/2
Can you link to the scanned PDF and your GitHub repo? I've noticed a few places with mismatched brackets, such as "(....]", and wanted to check to see if they were mismatched in the original or if that's just a transcription error.
Let's work out how that would work, in a simplified model of the world.
Let's say you have a 1000mAh battery at 10V that weighs 100g (these numbers have all been made round for purposes of easier arithmetic). Everything else on your drone is weightless, and your motors have perfect efficiency. To keep this aloft, you need to overcome 9.8 m/s^2 that is applied by Earth's gravity; but since we're simplifying things, let's just round that to 10 m/s^2. 10 m/s^2 * 100g is 1 N, which means it requires 1 W of power to keep that battery aloft (resist the force of gravity). 1Ah * 10 V = 10 Wh, so that means you could stay aloft for 10 h (remember, these numbers are unrealistic, we have ignored any kind of efficiency, or the weight of the rest of the drone, etc).
So, lets use two batteries. Now we have 20 Wh of energy available, but we're holding up 200g of battery, which requires 2 W of power to stay aloft, so again, we can stay aloft for just 10 h.
And remember, all of this was ignoring any notion of efficiency or the weight of any other part of the craft to support this. As you increase the weight, motors will need to get more powerful to be able to actually keep it aloft, which means they need to get bigger, which is extra weight that you need to support that isn't giving you any extra energy. So the real world is actually even worse than our idealized model; as you add on more battery, only a fraction of the increase in weight adds more energy, so you will actually see shorter flight times.
Now, of course, there are designs for which increasing the amount of battery can lead to increased flight times. If the power supplied by the motors is sufficient to sustain the extra weight, so they don't need to be scaled up, then increasing the amount of battery relative to the rest of the weight of the craft can lead to higher efficiency as there is less relative "dead weight" (weight besides the batteries, that is not carrying energy). But that can only take you so far, which is why the flight times of drones plateau at a certain point and you can't fix it by just adding more battery.
This is why you don't see electric helicopters carrying people. The energy to weight ratio for batteries is too low; only fossil fuels have a sufficient energy density.
I agree with your general idea, more than half an hour is not posible with the current technology. But I think this conversion is wrong:
> let's just round that to 10 m/s^2. 10 m/s^2 100g is 1 N, which means it requires 1 W of power to keep that battery aloft*
To transform some force into power, you need to multiply it by a speed (m/s). My favorite example is that a brick resting on a table can "hover" without spending any power (for a weird definition of "hovering").
I think the correct calculation involves the density of the air, to estimate the speed of the air that must be pushed down.
Adding that factor in will mean adding in even more fake, hand-wavy numbers, but doesn't really change the end result; whatever value you end up with, if you double the weight of the batteries, you will need to displace twice as much air (or move it twice as fast) to compensate, which means you'll need to use up twice as much energy, leaving you with the same flight time in the end.
Nope. We're pretty much limited by battery technology on that front; you need bigger batteries to provide more power, but those bigger batteries mean more weight, which means more power needed just to stay aloft. For a battery powered multicopter, I think an hour or so is about the highest you can get (I don't think I've seen any that claim over 40 minutes), and as you point out, most drones are closer to the 15 to 20 minute range.
Of course, there are other designs like fixed wing planes which can be a bit more efficient though more complicated to navigate in confined spaces and without the ability to hover, and you can use internal combustion engines which can get you much longer flight times due to the higher energy density of their power source. But I don't think you're going to find any of the affordable, battery powered multicopters that get you anything over an hour (and even then, I would set my expectations at more like a half-hour for anything affordable in realistic conditions).
> Stalker is a small, silent UAS used by Special Operations Forces since 2006 to perform intelligence, surveillance and reconnaissance missions. In a recent wind tunnel test, the UAS demonstrated 48 hours of continuous flight powered by this innovative laser system.
> Demonstrated net positive power to Stalker in flight, at ranges up to 600 meters.
> The beam director tracked the receiver for long periods, with centimeter accuracy at 500 meters, despite turbulence and aircraft maneuvers.
This is genuinely awesome and I'm excited to see it's applications in future products.
HOWEVER: I don't think it's ready for 'consumer grade' things just yet.
It's one thing to have it in a controlled wind-tunnel for 48 hours, it's completely different than having it outside and in variable wind, dirt, dust, other objects, etc.
Honestly, I can't imagine my luddite brother or father wrapping their minds around this just yet: "So, I point the laser at this? Why can't I just use a flashlight? Can I use the laser to charge my phone?"
Definitely feasible if your mothership is a dirigible using gas turbines to power itself, using laser spotbeams to target drones below for providing remote power.
I don't know that the energy density of solar cells work for their weight. Electric motors require a pretty high current. Even if you are supplementing another power source, I think you'll still be losing more than you are gaining for that application. You are probably fine with fixed wing, but multicopter designs will draw significantly more power.
I wonder why more remote-operated drones like this aren't being designed with gasoline motors rather than electric. I remember flying all kinds of tiny gas-powered RC planes as a kid, and it's not obvious to me that the benefits of electric out-weigh the multiple-orders-of-magnitude reduction in flight time. In fact, what are the principal advantages of electric UAVs over gas-powered?
Most quadcopters aren't gas-powered because they rely on rapidly adjusting the speed of brushless motors attached to fixed-pitch props to control their attitude.
A few hobbyists have built gas quads with variable-pitch rotors, but the amount of mechanical complexity and hassle involved makes a similar nitro-powered single-rotor helicopter more appealing for most hobby applications (stunt flying etc).
As more novel designs that don't rely on precise motor speed control (for example, this one) come into play, I think gas motors will make a minor resurgence as people rediscover the energy density (and therefore flight time) they can achieve.
However, for most hobbyists, electric just makes more sense. It's usually quieter, works indoors, is generally a lot less of a pain in the ass to deal with (no need for starters, glow plugs, choke, adjusting mixture, engine maintenance, etc.), and is usually less heavily regulated.
Why not hybrid? Have an onboard gas generator to recharge the batteries. As soon as the gas runs out, the drone has X min of battery flight time left to get back to solid ground. No need for mechanical complexity.
There's an MIT spinoff called Top Flight that was working on a hybrid quadcopter, IIRC. I think the main reason you don't see them in the hobbyist space is size floor (you need a pretty big machine to make the weight overhead of the motor, generator, and charge circuitry work out) and money.
Hell, you could have a small buffer ultra capacitor or battery providing the motors with electricity while a gas engine at constant RPM recharges it. The whole system would have to have a very high conversion efficiency though...
I think you could just use the simplest form of CVT: a variable-diameter pulley under each rotor. You'd still pay a pretty big cost in terms of mechanical complexity, though, which makes the swashplate system more appealing as offers a lot of additional advantages in terms of thrust vectoring.
For multirotors it's just very difficult and impractical to power them with gasoline engines. If you were to build a gas powered multirotor, you'd have to have a central engine connected to each motor by means of some complicated mechanical linkage. This would also mean you could no longer control the speeds of the motors individually, so you'd have to achieve lateral movement by pitching the propellers, like on a helicopter. All these things mean that it simply doesn't make sense to build a non-electric multirotor, it'd be massively expensive and inefficient you'd be better off going back to a helicopter.
In terms of fixed wing drones, the benefit of electric over gas is mainly ease of use I believe. It's a lot simpler for someone to charge a battery and just plug it in than it is for them to fill up canisters, refuel the engine and cope with the complexities of tweaking and starting an engine. That extra effort and learning curve isn't worth it for the slightly longer slight time.
For aerial mapping the go-to option is normally fixed wing drones, they can easily achieve 30-40 minutes of flight time and this is normally enough for those kind of applications.
PWM motors can control their rotation very precisely unlike IC motors. That is one reason you see multicopter designs nowadays. You can quickly alter the torque. I didn't see how this design alters pitch or roll, but I know there were some coaxial experimental designs that can alter the torque in a single rotation to affect those axis. That is simply not possible with something powered by burning fuel. It might be possible to have a mixed system, using an internal combustion engine for primary lift and electronically controlled steering, but that would be a more complex system and the benefit isn't abundantly clear.
Size, noise, maintenance, predictability, simplicity, cost. Haven't seen a power/weight trade study of batteries vs engine+generator+fuel, but it may be closer than you think. There's a lot involved in a ICE power plant, and even if it did win, it'd have to be a pretty big machine compared to your average multirotor due to minimum scale on gasoline engine components.
There might be a market for large endurance multirotors, but apparently it's not obviously attractive.
The solution is to allow the drone to hot-swap the battery. You would put a bunch of batteries along the drone's planned flight path and it would automatically detect these batteries and replace its own emptying battery with the one placed on the ground.
Potentially, if autonomous drones really take off, there could be a countrywide system of solar-powered charging stations that would supply drones with standardized batteries. Such infrastructure would be almost completely self-sufficient and allow drones to fly any distance.
In fact, this model also works for electric cars, manned or unmanned. There's no reason why Tesla Supercharger stations cannot provide a fully charged battery to swap into your car. Of course you'd have to deposit your own battery first so that you cannot get a battery for free.