SRL Archive - SRL Archives

{*******************************************************************************
function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
By: Abyssal
Description: Returns the third side of the triangle.
*******************************************************************************}
function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  if(NeedHypot)then
    Result := Sqrt((Sqr(a) + Sqr(bHypot)));
  if(not(NeedHypot))then
    Result := Sqrt((Sqr(bHypot) - Sqr(a)));
end;

Set boolean "NeedHypot" if the hypothesis is the variable being solved for. Example:

Pythag(3, 4, True);

If you have the hypothesis and are solving for a different side (doesn't matter which), "NeedHypot" becomes false, and the hypotenuse is put into "b", hence the weird naming scheme. Example:

Pythag(4, 5, False);

Test it!

program PythagTest;

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  if(NeedHypot)then
    Result := Sqrt((Sqr(a) + Sqr(bHypot)));
  if(not(NeedHypot))then
    Result := Sqrt((Sqr(bHypot) - Sqr(a)));
end;

begin
  Writeln(Pythag(4, 5, False));
  Writeln(Pythag(3, 4, True));
end.

This would of been handy in year 8 maths xD.

:D YAY PYTHAGORAS! :p

Hey Bobbo! You know what :P? Just kidding, however it does simplify the process. I mean, that's what includes are really about.

@99, no kidding. He's pretty much my idol.

I like his math, but not his philosophy (He killed peoples D: lol)

@Abby xD
Lol no i didnt mean like that i meant to say would of been usefull if you released it last year then i could like use it :).

Never seen you before, but I like your name :p

Also don't we already have something like this? (Hypot(X, Y: Extended): Extended;), Although yours has an extra feature.

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  if(NeedHypot)then
    Result := Hypot(a, bHypot)
  else
    Result := Sqrt((Sqr(bHypot) - Sqr(a)));
end;

~NS

Shortened even more:

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result := Hypot(a, bHypot)
  if(not(NeedHypot))then
    Result := Sqrt((Sqr(bHypot) - Sqr(a)));
end;

Just being picky :p

Nice. Haven't seen you around here Abyssal in a long time :)

Shortened even more:

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result := Hypot(a, bHypot);
  if(not(NeedHypot))then Result := Sqrt((Sqr(bHypot) - Sqr(a)));
end;

>.> Just to prove that shortening this does nothing.

Can't wait to see what you do in the future, Abyssal ;D

It really doesn't matter if you shorten it lol

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  if NeedHypot then Result := Hypot(a, bHypot) else Result := Sqrt(Sqr(bHypot) - Sqr(a));
end;

~NS

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result:= Sqrt(abs(Sqr(bHypot) + (Integer(NeedHypot) * 2 - 1) * sqr(a)));
end;

I win.

From: bullzeye95

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result:= Sqrt(abs(Sqr(bHypot) + (Integer(NeedHypot) * 2 - 1) * sqr(a)));
end;

I win.

No, you lost the game because you're breathing manually.

From: bullzeye95

function Pythag(a, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result:= Sqrt(abs(Sqr(bHypot) + (Integer(NeedHypot) * 2 - 1) * sqr(a)));
end;

I win.

Ah, taking advantage of the fact that False = 0 and True = 1 (by default). I approve.

Oh. Wow. Haha, I prefer slightly longer code and readability ;).

Yeah, JAD, I'm hoping to make a reappearance for a while.

Nadeem, yeah, unless you were around back during Kaitnieks days I'll probably be stranger to most, heh.

From: Abyssal
Oh. Wow. Haha, I prefer slightly longer code and readability ;).

+1.

*hypotenuse :D

program New;

Const
aHypot=34;
bHypot=38;
NeedHypot=True;

function Pythag(aHypot, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result:= Sqrt(abs(Sqr(bHypot) + (Integer(NeedHypot) * 2 - 1) * sqr(aHypot)));
end;

begin
WriteLn(Pythag(aHypot, bHypot, NeedHypot));
end.

I WIN!

From: Simtoon

program New;

Const
aHypot=34;
bHypot=38;
NeedHypot=True;

function Pythag(aHypot, bHypot: Extended; NeedHypot: Boolean): Extended;
begin
  Result:= Sqrt(abs(Sqr(bHypot) + (Integer(NeedHypot) * 2 - 1) * sqr(aHypot)));
end;

begin
WriteLn(Pythag(aHypot, bHypot, NeedHypot));
end.

I WIN!

Uuuhm… Why do you win? :p
you added some consts? :P

Oh wow… its Abyssal! You made me proud of myself when I first joined :D

What did I say, Zephyrs? :)

@Tara, heh, thanks.

From: Abyssal
What did I say, Zephyrs? :)

@Tara, heh, thanks.

Not much apparently :p
http://www.villavu.com/forum/showthread.php?p=132189#post132189

Haha :).

Glad to be back.

sin, cos,tan
please?

From: jakeyboy29
sin, cos,tan
please?

You mean the sine, cose, and tan functions that are built into SCAR?

You could make one using the sine and the cosine rule, so it can work with angles aswell :)

Sine law is easy :p Cosine law, never heard of..

http://en.wikipedia.org/wiki/Cosine_law

It is really simple :)

Oh you mean the law of sines and cosines?

I'd have to pull out my Algebra notes from this year, forgot some of it, but I can look into it :)

D=. i wish i had this in summer school (we dont do pythag or trig till sophomore maths here)

EDIT: Oh nvm ;)

Also Nauman, if you make a function for the Sine/Cosine law, remember that giving input as 2 points is just stupid since computers can form a right triangle from 2 points, so remember to make it input the side lengths and angles…

From: n3ss3s
EDIT: Oh nvm ;)

Also Nauman, if you make a function for the Sine/Cosine law, remember that giving input as 2 points is just stupid since computers can form a right triangle from 2 points, so remember to make it input the side lengths and angles…

Who said I was making it ;). And yes I shall bear that in mind, if I happen to at some stage make a Cosine Law'er..

function CosineLaw(a, b, c: Extended; len: Boolean): Extended;
//a^2 = b^2 + c^2 - 2bcCosA
begin
  if (len) then
    Result := Sqrt(Sqr(b) + Sqr(c) - (2 * b * c * Cos(a)))
  else
    Result := ArcCos((Sqr(c) + Sqr(b) - Sqr(a)) / (2 * b * c));
end;

function SineLaw(a, b, ang: Extended; len: Boolean): Extended;
// (a / sin A) = (b / Sin B)
begin
  if (len) then
    Result := (sin(a) * b) / (Sin(ang))
  else
    Result := ArcSin((a * Sin(ang)) / b );
end;

Assuming you can entrust the user to pass the correct variables, it works.
For CosineLaw, a is the length opposite the angle you wish to work out or the angle opposite the side you wish to work out.
For SineLaw, a is either the angle or length you have that's opposite the length or angle you're trying to work out while b and ang are the opposite angle/length pair you have.
Angles in all cases refer to radians rather than degrees, but not hard to alter it.

Not hard to implement and pretty much useless here since it's all about points and points mean right angle triangles :)