The only problem with his explanation is that he's using variable names that are incredibly confusing and unhelpful. This demonstrates the value of picking sensible, easy to understand variable names in your code.
Dumbed down/explanation version as translated by yours truly: The missile simulates where it is and how to reach the target with its guidance system. If it senses that its simulated position is different from its current position, it adjusts the simulation to make it more accurate. Example: The simulation says “oh move this fin clockwise to go left” The missile follows the simulations command but uh oh! It went RIGHT! “DAMN IT I WAS WRONG” says the system, so it fixes itself to not FUCK UP next time.
1:36 that series of repeated "error" messages at the end, as if it broke something somewhere in your software you can feel the rising, confusion-induced (and confusion-inducing) panic rising as the meme goes on
It is extremely alarming how this explanation takes into account a scenario where the space the missile IS is a greater value than the space where it isn't.
The missile knows where you are at all times; It knows this, because it knows where you aren't. By subtracting where you are from where you aren't - or where you aren't from where you are, whichever is greater, it obtains a difference or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the missile from a position where you are from a position where you aren't and arriving at a position where you weren't, you now are. Consequently, the position where you are, is now the position where you weren't and it follows that the position that you were, is now the position that you aren't. In the event that the position that you are in, is not the position that you weren't, the system has acquired a variation. The variation being the difference being the variation between where you are and where you weren't. If variation is considered to be a significant factor, it too, may be corrected by the GEA, however, the missile must also know where you were. The missile guidance computer scenario works as follows:- Because a variation has modified some of the information the missile has obtained, it is not sure just where you are, however, it is sure where you weren't (within reason) and it knows where you were. It now subtracts where you should be, from where you weren't, or vice versa and by differentiating this from the algebraic sum of where you shouldn't be and where you were it is able to obtain the deviation and its variation, which is called error.
class MissileGuidanceSystem: def __init__(self): # Initialize the missile guidance system with no known positions self.current_position = None self.previous_position = None def update_position(self, new_position): # Update the current and previous positions of the missile self.previous_position = self.current_position self.current_position = new_position def calculate_deviation(self): # Calculate the deviation between the current and previous positions if self.current_position is None or self.previous_position is None: return "Error: Unable to calculate deviation without previous positions." deviation = abs(self.current_position - self.previous_position) return deviation def correct_position(self, target_position): # Calculate the correction command to move the missile towards the target position if self.current_position is None: return "Error: Unable to correct position without current position." correction = target_position - self.current_position return f"Correction command: Move {correction} units towards the target position." # Example usage: missile_system = MissileGuidanceSystem() # Update the missile's position missile_system.update_position(100) missile_system.update_position(110) # Calculate the deviation between the current and previous positions deviation = missile_system.calculate_deviation() # Provide a correction command to move the missile towards a target position correction_command = missile_system.correct_position(120) # Display the results print("Deviation:", deviation) print(correction_command)
It's spoken in this way to essentially demonstrate the control logic code, but in spoken form. But it then also simplifies the variable names for a non-programmer audience. It essentially makes it useless for both experts and normal people in equal measure. People listen to this and mostly commonly assume they are just too dumb to understand it. But it's just terrible.
It’s basically saying (after replaying and pausing the video to many times) (Position.a-Missile is where it is now. AKA current position. Remember that) that it knows where it is (I), because it knows “where it isn’t” (S).Then it subtracts the s-I, or I-s to get (d) ( “where it isn’t” is everywhere except for its CURRENT position) The missile knows where to go by use it (d) to make commands (Position .b is where it is CURRENTLY)Then after it moves let say 2 inches, it’s no longer at pos.a And remember how I said “where it isn’t is everywhere except for its CURRENT position” well the missile is now in the place we USED to call “where the missile isn’t”. Another way to think of it is. Image a perfectly round kittie pool. Inside is a rubber duck. The water around rubber duck is where it isn’t (a) The duck is where it is (d) The duck moved an inch. The duck in now in a (a)=where it is’t
This whole video is a nonsense meme made to confuse people to show how you can overcomplicate an explenation. Nobody knows this for some reason and thinks it is a real explenation.
The missile knows where it is at all times. It knows this because it knows where it isn't. By subtracting where it is from where it isn't, or where it isn't from where it is (whichever is greater), it obtains a difference, or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the missile from a position where it is to a position where it isn't, and arriving at a position where it wasn't, it now is. Consequently, the position where it is, is now the position that it wasn't, and it follows that the position that it was, is now the position that it isn't. In the event that the position that it is in is not the position that it wasn't, the system has acquired a variation, the variation being the difference between where the missile is, and where it wasn't. If variation is considered to be a significant factor, it too may be corrected by the GEA. However, the missile must also know where it was. The missile guidance computer scenario works as follows. Because a variation has modified some of the information the missile has obtained, it is not sure just where it is. However, it is sure where it isn't, within reason, and it knows where it was. It now subtracts where it should be from where it wasn't, or vice-versa, and by differentiating this from the algebraic sum of where it shouldn't be, and where it was, it is able to obtain the deviation and its variation, which is called error.
I feel like I'm right on the edge of understanding, but I also feel like it would help to have a 60 year old balding guy with glasses and a whiteboard explain it to me 🤷🏼
1:23 That should not a include a question mark, much less two. Punctuation has a structure for a reason, and all of you need to stop using question marks simply because you lack any self-confidence such that you don’t know how to post a declarative statement that you’re unsure of. Jesus!
Simple explanation: The LGS/CGS (Laser guidance system/cord guidance system) on the vehicle is connected with a cord attached to the missile, depending on where the LGS/CGS is aiming, that data is sent to the missile via the cord, Then the missile redirects itself towards the position your aiming at. Me=smort.
But won't knowing where it isn't make it more accurate? Like if it has a command on where it needs to go from start, just like a script/ programming, it needs to know that it isn't there. In theory, you need to know that you aren't somewhere to be somewhere, which makes more sense in the relm of programing
@@panickal If the missile knows the target location but not its current location, then it will just travel straight until it hits its target, which is likely to be never. An example would be a missile traveling right past its target.
The ironic part is that what he is saying is actually codeable
I feel like because he says it in a way that's pretty much codeable right away, it is close to incomprehensible for most people lol.
Well yeah because he’s just describing the code of the missile
ruclips.net/video/c94bALAgENM/видео.htmlsi=4rTPpPK2hfw_sXdK this dude coded it in JS
The only problem with his explanation is that he's using variable names that are incredibly confusing and unhelpful. This demonstrates the value of picking sensible, easy to understand variable names in your code.
Probably because someone coded the computer systems in the missile.
abs(where it isn't - where it is) = abs(n't) = absent. QUICK MATH
Absinthe tend to do that to ya.
That is true only if (where it is=n't/(n't-1))
quick maffs
Wait but wouldn't |n't| be yes? Like a positive version of n't.
Wait
We always get caught up in where the missile is, but we never bothered to ask how the missile is.
duh, it knows how it isnt and then subtracts how it is from how it isnt, or how it isnt from how it is (whichever is greater)
@@bartekcalinski1221This reply is gold 😂😂😂
Well
The missile knows how it is because it knows how it wasnt,
Dumbed down/explanation version as translated by yours truly:
The missile simulates where it is and how to reach the target with its guidance system.
If it senses that its simulated position is different from its current position, it adjusts the simulation to make it more accurate.
Example: The simulation says “oh move this fin clockwise to go left”
The missile follows the simulations command but uh oh! It went RIGHT! “DAMN IT I WAS WRONG” says the system, so it fixes itself to not FUCK UP next time.
Thank you
🤓
NOW it makes sense for me, thank you from the deepest of my heart
@@Jannur-j9tsmh get fish reacted 🐠 🐟 🎣 🍣🐡🍤🐙🦑🦐🦞🦀🐬🐳🐋🦭
how fast it is for each calibration?
Ah yes I fully understand and am not confused whatsoever
you should know what you understand by understanding what you dont understand
1:36 that series of repeated "error" messages at the end, as if it broke something somewhere in your software
you can feel the rising, confusion-induced (and confusion-inducing) panic rising as the meme goes on
It is extremely alarming how this explanation takes into account a scenario where the space the missile IS is a greater value than the space where it isn't.
Bro gave up halfway in. 😂
Okay but does the missile know where I am?
Yes.
It knows where you aren’t, so that’s a start.
What is your radar cross section
@@B4nanafr3dYou win XD
The missile knows where you are at all times; It knows this, because it knows where you aren't. By subtracting where you are from where you aren't - or where you aren't from where you are, whichever is greater, it obtains a difference or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the missile from a position where you are from a position where you aren't and arriving at a position where you weren't, you now are. Consequently, the position where you are, is now the position where you weren't and it follows that the position that you were, is now the position that you aren't. In the event that the position that you are in, is not the position that you weren't, the system has acquired a variation. The variation being the difference being the variation between where you are and where you weren't. If variation is considered to be a significant factor, it too, may be corrected by the GEA, however, the missile must also know where you were. The missile guidance computer scenario works as follows:- Because a variation has modified some of the information the missile has obtained, it is not sure just where you are, however, it is sure where you weren't (within reason) and it knows where you were. It now subtracts where you should be, from where you weren't, or vice versa and by differentiating this from the algebraic sum of where you shouldn't be and where you were it is able to obtain the deviation and its variation, which is called error.
Telling my kids this was Oppenheimer
i got lost in the first sentence when "where it is" was used as an operand in the equation to find out where it is
Short explanation: Missile goes nyooom.
You forgot the part where it goes: fwiiiish kaBOOM
class MissileGuidanceSystem:
def __init__(self):
# Initialize the missile guidance system with no known positions
self.current_position = None
self.previous_position = None
def update_position(self, new_position):
# Update the current and previous positions of the missile
self.previous_position = self.current_position
self.current_position = new_position
def calculate_deviation(self):
# Calculate the deviation between the current and previous positions
if self.current_position is None or self.previous_position is None:
return "Error: Unable to calculate deviation without previous positions."
deviation = abs(self.current_position - self.previous_position)
return deviation
def correct_position(self, target_position):
# Calculate the correction command to move the missile towards the target position
if self.current_position is None:
return "Error: Unable to correct position without current position."
correction = target_position - self.current_position
return f"Correction command: Move {correction} units towards the target position."
# Example usage:
missile_system = MissileGuidanceSystem()
# Update the missile's position
missile_system.update_position(100)
missile_system.update_position(110)
# Calculate the deviation between the current and previous positions
deviation = missile_system.calculate_deviation()
# Provide a correction command to move the missile towards a target position
correction_command = missile_system.correct_position(120)
# Display the results
print("Deviation:", deviation)
print(correction_command)
dude just implemented the copypasta guidance algorithm, love it
@@evlli2342 I love it too
Appreciate this a lot, thanks.
@@Fellow3DHuman legit from chatgpt 🤣
@@nictibbetts obviously, I don't know dirt about code.
Watching someone write this out and try to follow along somehow makes it 10x more funny.
I lost it at how you stopped drawing for a while after 0:58
I understood everything except the part that came after when you said now listen to this.
I need an explanation on a expelantion of an explenation of this explenation
I have more questions than before
import numpy as np
class MissileGuidanceSystem:
def __init__(self, initial_position, target_position):
self.position = np.array(initial_position, dtype=float)
self.target_position = np.array(target_position, dtype=float)
self.previous_position = np.copy(self.position)
self.velocity = np.zeros_like(self.position)
self.kp = 0.1 # Proportional gain
self.ki = 0.01 # Integral gain
self.kd = 0.05 # Derivative gain
self.integral = np.zeros_like(self.position)
self.previous_error = np.zeros_like(self.position)
def update_position(self, delta_time):
# Calculate where it isn't
not_position = self.target_position
# Calculate the error (deviation)
error = not_position - self.position
# Integral of the error
self.integral += error * delta_time
# Derivative of the error
derivative = (error - self.previous_error) / delta_time
# PID control
corrective_command = (self.kp * error +
self.ki * self.integral +
self.kd * derivative)
# Update velocity and position
self.velocity += corrective_command * delta_time
self.previous_position = np.copy(self.position)
self.position += self.velocity * delta_time
# Update previous error
self.previous_error = np.copy(error)
# Calculate the new deviation
new_error = not_position - self.position
# Calculate the variation
variation = new_error - error
return self.position, error, variation
def run_simulation(self, duration, delta_time):
time_steps = int(duration / delta_time)
trajectory = []
for _ in range(time_steps):
pos, dev, var = self.update_position(delta_time)
trajectory.append((pos.copy(), dev.copy(), var.copy()))
print(f"Position: {pos}, Deviation: {dev}, Variation: {var}")
return trajectory
# Example usage
initial_position = [0.0, 0.0, 0.0]
target_position = [100.0, 100.0, 100.0]
duration = 10.0 # Simulation duration in seconds
delta_time = 0.1 # Time step in seconds
missile = MissileGuidanceSystem(initial_position, target_position)
trajectory = missile.run_simulation(duration, delta_time)
It's spoken in this way to essentially demonstrate the control logic code, but in spoken form. But it then also simplifies the variable names for a non-programmer audience. It essentially makes it useless for both experts and normal people in equal measure.
People listen to this and mostly commonly assume they are just too dumb to understand it. But it's just terrible.
GEA is Guidance Equalizing Apparatus
thanks !
Definitely not confusing
Now this makes a bit more sense
Very much so
you know the original video is schizo when the guy explaining starts drawing lines through his explanation
The most understandable thing:
It’s basically saying (after replaying and pausing the video to many times)
(Position.a-Missile is where it is now. AKA current position. Remember that) that it knows where it is (I), because it knows “where it isn’t” (S).Then it subtracts the s-I, or I-s to get (d) ( “where it isn’t” is everywhere except for its CURRENT position)
The missile knows where to go by use it (d) to make commands
(Position .b is where it is CURRENTLY)Then after it moves let say 2 inches, it’s no longer at pos.a
And remember how I said “where it isn’t is everywhere except for its CURRENT position” well the missile is now in the place we USED to call “where the missile isn’t”.
Another way to think of it is.
Image a perfectly round kittie pool.
Inside is a rubber duck.
The water around rubber duck is where it isn’t (a)
The duck is where it is (d)
The duck moved an inch.
The duck in now in a
(a)=where it is’t
This whole video is a nonsense meme made to confuse people to show how you can overcomplicate an explenation. Nobody knows this for some reason and thinks it is a real explenation.
This is the best missile video
dead reckoning explained in hard way be like:
0:34 Position it is = position it wasn't
0:46 Position it is ≠ position it wasnt
😵💫⁉️❓️❓️
This actually really helped me understand. I mean that.
More understandable than all lecture in school.
The missile knows where it is at all times. It knows this because it knows where it isn't. By subtracting where it is from where it isn't, or where it isn't from where it is (whichever is greater), it obtains a difference, or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the missile from a position where it is to a position where it isn't, and arriving at a position where it wasn't, it now is. Consequently, the position where it is, is now the position that it wasn't, and it follows that the position that it was, is now the position that it isn't.
In the event that the position that it is in is not the position that it wasn't, the system has acquired a variation, the variation being the difference between where the missile is, and where it wasn't. If variation is considered to be a significant factor, it too may be corrected by the GEA. However, the missile must also know where it was.
The missile guidance computer scenario works as follows. Because a variation has modified some of the information the missile has obtained, it is not sure just where it is. However, it is sure where it isn't, within reason, and it knows where it was. It now subtracts where it should be from where it wasn't, or vice-versa, and by differentiating this from the algebraic sum of where it shouldn't be, and where it was, it is able to obtain the deviation and its variation, which is called error.
I feel like I'm right on the edge of understanding, but I also feel like it would help to have a 60 year old balding guy with glasses and a whiteboard explain it to me 🤷🏼
💕 Love this, just love the... acceleration.
A B C
B C A
C B A
Yes
Why did I come here thinking this would be about the Charli Morgan song...
Now I get it.
Pretty much From the Depths missile manual guidance system via LUA tutorial (Simplified)
ahhh yes a fellow unity dev
Ah yah that makes sense
i am the missile
Nice background, dude.
Where it it
Ok you lost me at the end
#include
#include
class Missile {
private:
double currentPosition;
double targetPosition;
double previousPosition;
public:
Missile(double startPos, double targetPos)
: currentPosition(startPos), targetPosition(targetPos), previousPosition(startPos) {}
void updatePosition() {
double whereItIsnt = targetPosition;
double deviation = std::abs(currentPosition - whereItIsnt);
std::cout
Ahah good show.
Math be like
Science
Ah yes
I'm sorry can you repeat that
It’s not rocket science my dude
1:23 That should not a include a question mark, much less two. Punctuation has a structure for a reason, and all of you need to stop using question marks simply because you lack any self-confidence such that you don’t know how to post a declarative statement that you’re unsure of. Jesus!
???
@@oflatt Now that's an appropriate use of a question mark, in series even. We are making progress. Baby steps!
¿
Simple explanation: The LGS/CGS (Laser guidance system/cord guidance system) on the vehicle is connected with a cord attached to the missile, depending on where the LGS/CGS is aiming, that data is sent to the missile via the cord, Then the missile redirects itself towards the position your aiming at. Me=smort.
"The bullet knows where it is, because it knows where it isn't"
- This Gay Probably
Y'all think he is just waffling but what he says is actually makes sense lol. cOnTrOL ThEOry biach!
Did Kamala write this?? 😉
real coding
Pᵣₒmₒˢᵐ
It's funny audio but quite stupid concept, missile only needs to know where it needs to go, not where it isn't in world space.
it needs to know where it is, to go where it needs to though
@@k_otey Missile only cares for how to hit its target in relative/local space
But won't knowing where it isn't make it more accurate? Like if it has a command on where it needs to go from start, just like a script/ programming, it needs to know that it isn't there. In theory, you need to know that you aren't somewhere to be somewhere, which makes more sense in the relm of programing
Thats qhy soviet misslea suck. They don't do the complex thinking.
@@panickal If the missile knows the target location but not its current location, then it will just travel straight until it hits its target, which is likely to be never. An example would be a missile traveling right past its target.
best missile knowing where is
Its almost as if philosophical logic dictates reality and not some bs physical laws