egg changed the topic of #principia to: Logs: https://esper.irclog.whitequark.org/principia | <scott_manley> anyone that doubts the wisdom of retrograde bop needs to get the hell out | https://xkcd.com/323/ | <egg> calculating the influence of lamont on Pluto is a bit silly…
<queqiao-> ⟨Quadrupole⟩ ⟪badgermasher⟫ Brute force is to just hack out the […] ⮪ That's _the_ way of getting into a dynamically stable area, and I don't think there is a more elegant solution. Otoh the insertion burn is only around 2 km/s, which is not that bad.
UmbralRaptor is now known as JanskyRaptor
_whitelogger has joined #principia
_whitelogger has joined #principia
queqiao- has quit [Remote host closed the connection]
queqiao- has joined #principia
Hypergolic_Skunk has joined #principia
<queqiao-> ⟨Rad⟩ Where is the Earth-Moon L2 located?
<JanskyRaptor> Using https://en.wikipedia.org/wiki/Lagrange_point#Physical_and_mathematical_details I get ~61500 km from the Moon's center of mass
<queqiao-> ⟨Transparent_Elemental⟩ I wonder whether lagrange points have something in common with saddle points of lagrange function 🤔
<queqiao-> ⟨Soviet Onion⟩ ⟪Transparent_Elemental⟫ I wonder whether lagrange points have […] ⮪ 🤷
<queqiao-> By Lagrange function, you mean Lagrangian ?
<queqiao-> ⟨Al2Me6⟩ I thought they meant Lagrange multipliers
<queqiao-> ⟨Transparent_Elemental⟩ yes, pretty sure the function used in lagrange multipliers is sometimes also called lagrangian or lagrange function
<queqiao-> ⟨von Kerman⟩ Principia is crashing 😦 "Log file created at: 2022/02/16 21:36:24
<queqiao-> Running on machine: DESKTOP-CPB658A
<queqiao-> Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu threadid file:line] msg
<queqiao-> @ 00007FFEADC7443F google::LogMessageFatal::~LogMessageFatal [0x00007FFEADC7443E+46]
<queqiao-> ⟨Paculino (ŝi/ri/she/they)⟩ Is that the entire log?
<queqiao-> ⟨von Kerman⟩ The entire FATAL log
<queqiao-> ⟨von Kerman⟩ Crash happens consistently on a specific file save. An earlier backup is working so far.
<queqiao-> ⟨von Kerman⟩ * save file.
<queqiao-> ⟨von Kerman⟩ There are more bad things happening in the ERROR log though.
<queqiao-> ⟨von Kerman⟩ "E0216 21:36:24.482192 6912 interface.cpp:698] [C:\Users\phl\Projects\GitHub\Principia\Google\protobuf\src\google\protobuf\io\coded_stream.cc:192] A protocol message was rejected because it was too big (more than 536870912 bytes). To increase the limit (or to disable these warnings), see CodedInputStream::SetTotalBytesLimit() in net/proto2/io/public/coded_stream.h."
<queqiao-> ⟨Paculino (ŝi/ri/she/they)⟩ I may be wrong, but it might be better to upload the entire principia log and KSP log if each is under the discord limit, just in case
<queqiao-> ⟨siimav⟩ Your save size is > 512MB? 😱
<queqiao-> ⟨von Kerman⟩ No, 63
<queqiao-> ⟨von Kerman⟩ Not happy with this size either
<queqiao-> ⟨von Kerman⟩ No, 63MB
<queqiao-> ⟨egg⟩ ⟪von Kerman⟫ Principia is crashing 😦 `Log file […] ⮪ Corrupted save file.
<queqiao-> ⟨lamont⟩ ⟪Transparent_Elemental⟫ yes, pretty sure the function used in […] ⮪ those are all related, but different
<queqiao-> ⟨lamont⟩ the lagrangian is a function of your variables and lagrange multipliers.
<queqiao-> ⟨lamont⟩ a lagrange function is an extension of lagrange multipliers to a continuous function and that lands you in the potrayagin minimum principle neighborhood of the calculus of variations, which is where PVG lives.
<JanskyRaptor> Lagrangians are easy, just remember that Lenergy = Tinetic - Votential
<JanskyRaptor> It's a perfectly straightforward function of qosition and pomentum
<queqiao-> ⟨Transparent_Elemental⟩ ⟪lamont⟫ a lagrange function is an extension of […] ⮪ lagrangian is somehow not continuous?
<JanskyRaptor> We're in classical land, so I'd hope that they are
<queqiao-> ⟨Transparent_Elemental⟩ I know of lagrange function as it is understood in calculus of variations, but I meant the one that's constructed out of original function and multipliers times constraints
<queqiao-> ⟨lamont⟩ lagrange multipliers are not continuous
<queqiao-> ⟨Transparent_Elemental⟩ at least in literature that I've read that one was frequently called just the lagrange function
<queqiao-> ⟨lamont⟩ right
<queqiao-> ⟨lamont⟩ lagrange functions are not directly related to the lagrangian they are a continuous extension of the scalar lagrange multipliers
<queqiao-> ⟨lamont⟩ and when dealing with lagrange functions you deal with a [pseudo-]hamiltonian which is a constant of the motion and do not construction a lagrangian
<queqiao-> ⟨lamont⟩ the primer vector and primer rate vector in primer vector theory are the costate functions or lagrange functions which are continuous functions analogus to lagrange multipliers.
<queqiao-> ⟨lamont⟩ and since its continuous it might be sometimes referred to as an infinite-dimensional lagrange multiplier problem
<queqiao-> ⟨lamont⟩ and the PMP is a way of reducing the infinite-dimensional continuous problem down to a finite dimensional rootfinding problem
<_whitenotifier-1f03> [Principia] von-Kerman opened issue #3331: Game crashes when loading a savefile - https://github.com/mockingbirdnest/Principia/issues/3331
<queqiao-> ⟨lamont⟩ (pretty sure anyway)
<queqiao-> ⟨Transparent_Elemental⟩ this is a bit over my head right now 🤔 not that I understand very well the theory behind lagrangian anyway
<queqiao-> ⟨lamont⟩ voodoo crazy russian math is how i put it
<queqiao-> ⟨egg⟩ Amusingly I have never touched a Lagrangian.
<queqiao-> ⟨egg⟩ (only Hamiltonians)
<queqiao-> ⟨Transparent_Elemental⟩ it always was kind of elusive problem as it offers an insight into dual problems and their relationship with non-linear problems, yet the actual computation is basically pointless as there are more efficient methods
<queqiao-> ⟨lamont⟩ the direct method is better, except it involves solvers considerably more sophisticated than just rootfinders.
<queqiao-> ⟨lamont⟩ that's sort of why PVG exists because small dimensional root finding problems can easily be solved by something like levenburg marquardt which have robust C# implementations, so if you do the work to construct the indirect problem then its pretty easy. doing the direct route you need interior point solvers and much higher dimensional problems and sparse array support and half a dozen C++ libraries (although alglib is now growing...
<queqiao-> ... better interior point and SQP solvers and growing better sparse array support).
<queqiao-> ⟨Transparent_Elemental⟩ yeah, I can imagine why more advanced optimization books don't offer actual algorithms like they used to for derivative tests, lagrange multipliers for contrained non-linear problems and simplex method for LPs
<JanskyRaptor> lamont: Is the voodoo part in part because Landow thinks that a lot of "rigour" is just wasting everyone's time on trivialities?
<JanskyRaptor> *Landau
<queqiao-> ⟨lamont⟩ voodoo is because i have a hard time wrapping my own nogging around it
<queqiao-> ⟨lamont⟩ * noggin
<queqiao-> ⟨Transparent_Elemental⟩ at least now I know that a semi-definite matrix is a convex cone, awesome
<queqiao-> ⟨lamont⟩ yeah if you can get a convex problem then you're golden but lots of them are just generalized NLP problems that can't easily be convexified
<queqiao-> ⟨lamont⟩ (although there's now some convex optimization approaches to the launch problem that have been recently published, a few of the papers are new enough that sci-h*b doesn't have them.
Hypergolic_Skunk has quit [Quit: Connection closed for inactivity]
<_whitenotifier-1f03> [Principia] pleroy commented on issue #3331: Game crashes when loading a savefile - https://github.com/mockingbirdnest/Principia/issues/3331#issuecomment-1042389004
<queqiao-> ⟨Al2Me6⟩ Would it be possible to implement some kind of checksumming?
<queqiao-> ⟨sichelgaita⟩ Sure, and it would be easy, but you wouldn't like the result: the checksum would tell you that the save is corrupted, which we already know. The question you meant to ask is: would it be possible to implement some kind of error correction? That sounds like another deep, deep hole.
<queqiao-> ⟨lpg⟩ would be convenient if could say the save is corrupted in a way that doesn't involve killing the game
<queqiao-> ⟨egg⟩ reporting errors without crashing the game ? what is this nonsense
<queqiao-> ⟨siimav⟩ Pretty sure the "reporting" part doesn't happen most of the time
<queqiao-> ⟨egg⟩ it is reported to the user! the user knows that it crashed
<queqiao-> ⟨siimav⟩ Hmm, I still find the "reported" part debatable
<queqiao-> ⟨egg⟩ (more seriously, propagating hard errors from the C++ layer is an unmaintainable mess; we’ve done this once, and I don’t think we want to touch that again.)
<queqiao-> ⟨siimav⟩ Ship some external error reporter program with Principia that you can start up on crashes.
<queqiao-> ⟨lpg⟩ would a checksum check have to belong to the c++ layer?
Rokker has quit [Ping timeout: 192 seconds]
Rokker has joined #principia
<queqiao-> ⟨sichelgaita⟩ I don't think that the C++/C# separation is very relevant here. The conundrum is this: you have half-wedged Principia objects, you can bring up an error window, but where do you go from there? There might be threads running and burning memory that nobody can access, for instance. And KSP keeps calling the Principia hooks, how are they supposed to react? We could pepper the code with "if (principia_is_wedged)" but that...
<queqiao-> ... would be awfully hard to maintain and test, and I don't see how we could ever recover anyway. I should also mention that we've got a dozen reports about the "apocalypse" error where people said "I just want to close that window and continue"; we would get more of these.
<queqiao-> ⟨siimav⟩ My angle on this is that a lot of people do not even realise that it was Principia that crashed the game and blame KSP and/or mods in general.
<queqiao-> ⟨siimav⟩ If someone asks for logs then they would get useless information unless they also ask whether Principia is present and how to find your logs.
<queqiao-> ⟨Al2Me6⟩ What about this: before crashing, spawn a separate process that just pops up a dialog box saying Principia crashed.
<queqiao-> ⟨siimav⟩ For example - opening the default browser with some predefined URL is pretty much 1 line in C#.
<queqiao-> ⟨Serina⟩ ⟪Al2Me6⟫ What about this: before crashing, spawn […] ⮪ O.o how does it know it's about to crash?