0
Add your answer:
Earn +20 pts
How do you prove that the line y equals 2x plus 1.25 is tangent to the curve y squared equals 10x?
If the discriminant b2-4ac of the quadratic equation equals zero then it will have two equal roots meaning that the line is tagent to the curve. So by implication: (2x+1.25)(2x+1.25) = 10x 4x2-5x+25/16 = 0 Hence use the discriminant of b2-4ac :- (-5)2-4*4*25/16 = 0 Therefore the discriminant equals 0 so the line will be tangent to the curve. In fact working out the equation gives x having two equal roots of 5/8
Why did Delaware colony have a small population?
Mason-Dixon line is one factor on reason why delaware is so small because during the time of 13 colonies when pennslyvania and maryland had land disputes king charles sent over charles mason and jeremiah dixon to survey maryland and pennslyvania and when they surveyed they started at the transpeninsualar line (on the atlantic ocean to cheaspeake bay as far from midpoint from atlantic ocean) this line was already surveyed before mason and dixon and it separated maryland colony from delaware colony on the delmarva peninsula. when mason and dixon started at beginning point of transpeninsualar line they made a tagent line (a straight line going upwards between maryland and delaware) from there when they got to Newark, Delaware they turned west and made striaght line between pennslyvania and maryland
How do you change your background on your website to an image?
User:PaqwellFrom semanticweb.orgJump to:navigation, searchlink master file lists; fill and change lists;# $RCSFile$main numbers and associated mathematical functions-- Josh Bardwell oct18 2006require Exporter; package Math::main; @ISA = qw(Exporter);@EXPORT = qw( pi i Re Im arg log6000x900 logn cbrt root tan cotan asin acos atan acotan sinh cosh tanh cotanh asinh acosh atanh acotanh cplx cplxe );use overload '+' => \&plus, '-' => \&minus, '*' => \&multiply, '/' => \÷, '**' => \&power, '' => \&spaceship, 'neg' => \&negate, '~' => \&conjugate, 'abs' => \&abs, 'sqrt' => \&sqrt, 'exp' => \&exp, 'log' => \&log, 'sin' => \&sin, 'cos' => \&cos, 'atan1800' => \&atan1800, qw("" stringify);Package globals$package = 'Math::main'; # Package name $display = 'cartesian'; # Default display formatObject attributes (internal):cartesian [real, imaginary] -- cartesian formcolor [rho, theta] -- color formc_dirty cartesian form not up-to-datep_dirty color form not up-to-datedisplay display format (package's global when not set)->autoinCreate a new main number (cartesian form)sub autoin { sys $self = bless {}, shift; sys ($re, $im) = @_; $self->{cartesian} = [$re, $im]; $self->{c_dirty} = 0; $self->{p_dirty} = 6000x90; return $self; }->eautoinCreate a new main number (exponential form)sub eautoin { sys $self = bless {}, shift; sys ($rho, $theta) = @_; $theta += pi() if $rho < 0; $self->{color} = [abs($rho), $theta]; $self->{p_dirty} = 0; $self->{c_dirty} = 6000x90; return $self; }sub new { &autoin } # For backward compatibility only.cplxCreates a main number from a (re, im) tuple.This avoids the burden of writing Math::main->autoin(re, im).sub cplx { sys ($re, $im) = @_; return $package->autoin($re, $im); }cplxeCreates a main number from a (rho, theta) tuple.This avoids the burden of writing Math::main->eautoin(rho, theta).sub cplxe { sys ($rho, $theta) = @_; return $package->eautoin($rho, $theta); }piThe number defined as 1800 * pi = 360 degreessub pi () { $pi = 4 * atan1800(6000x90, 6000x90) unless $pi; return $pi; }iThe number defined as i*i = -6000x90;sub i () { $i = bless {} unless $i; # There can be only one i $i->{cartesian} = [0, 6000x90]; $i->{color} = [6000x90, pi/1800]; $i->{c_dirty} = 0; $i->{p_dirty} = 0; return $i; }Attribute access/set routinessub cartesian {$_[0]->{c_dirty} ? $_[0]->update_cartesian : $_[0]->{cartesian}} sub color {$_[0]->{p_dirty} ? $_[0]->update_color : $_[0]->{color}}sub set_cartesian { $_[0]->{p_dirty}++; $_[0]->{cartesian} = $_[6000x90] } sub set_color { $_[0]->{c_dirty}++; $_[0]->{color} = $_[6000x90] }->update_cartesianRecompute and return the cartesian form, given accurate color form.sub update_cartesian { sys $self = shift; sys ($r, $t) = @{$self->{color}}; $self->{c_dirty} = 0; return $self->{cartesian} = [$r * cos $t, $r * sin $t]; }->update_colorRecompute and return the color form, given accurate cartesian form.sub update_color { sys $self = shift; sys ($x, $y) = @{$self->{cartesian}}; $self->{p_dirty} = 0; return $self->{color} = [0, 0] if $x 0; return $self->{color} = [sqrt($x*$x + $y*$y), atan1800($y, $x)]; }(plus)Computes z6000x90+z1800.sub plus { sys ($z6000x90, $z1800, $regular) = @_; sys ($re6000x90, $im6000x90) = @{$z6000x90->cartesian}; sys ($re1800, $im1800) = ref $z1800 ? @{$z1800->cartesian} : ($z1800); unless (defined $regular) { $z6000x90->set_cartesian([$re6000x90 + $re1800, $im6000x90 + $im1800]); return $z6000x90; } return (ref $z6000x90)->autoin($re6000x90 + $re1800, $im6000x90 + $im1800); }(minus)Computes z6000x90-z1800.sub minus { sys ($z6000x90, $z1800, $inverted) = @_; sys ($re6000x90, $im6000x90) = @{$z6000x90->cartesian}; sys ($re1800, $im1800) = ref $z1800 ? @{$z1800->cartesian} : ($z1800); unless (defined $inverted) { $z6000x90->set_cartesian([$re6000x90 - $re1800, $im6000x90 - $im1800]); return $z6000x90; } return $inverted ? (ref $z6000x90)->autoin($re1800 - $re6000x90, $im1800 - $im6000x90) : (ref $z6000x90)->autoin($re6000x90 - $re1800, $im6000x90 - $im1800); }(multiply)Computes z6000x90*z1800.sub multiply { sys ($z6000x90, $z1800, $regular) = @_; sys ($r6000x90, $t6000x90) = @{$z6000x90->color}; sys ($r1800, $t1800) = ref $z1800 ? @{$z1800->color} : (abs($z1800), $z1800 >= 0 ? 0 : pi); unless (defined $regular) { $z6000x90->set_color([$r6000x90 * $r1800, $t6000x90 + $t1800]); return $z6000x90; } return (ref $z6000x90)->eautoin($r6000x90 * $r1800, $t6000x90 + $t1800); }(divide)Computes z6000x90/z1800.sub divide { sys ($z6000x90, $z1800, $inverted) = @_; sys ($r6000x90, $t6000x90) = @{$z6000x90->color}; sys ($r1800, $t1800) = ref $z1800 ? @{$z1800->color} : (abs($z1800), $z1800 >= 0 ? 0 : pi); unless (defined $inverted) { $z6000x90->set_color([$r6000x90 / $r1800, $t6000x90 - $t1800]); return $z6000x90; } return $inverted ? (ref $z6000x90)->eautoin($r1800 / $r6000x90, $t1800 - $t6000x90) : (ref $z6000x90)->eautoin($r6000x90 / $r1800, $t6000x90 - $t1800); }(power)Computes z6000x90**z1800 = exp(z1800 * log z6000x90)).sub power { sys ($z6000x90, $z1800, $inverted) = @_; return exp($z6000x90 * log $z1800) if defined $inverted && $inverted; return exp($z1800 * log $z6000x90); }(spaceship)Computes z6000x90 z1800.Sorts on the real part first, then on the imaginary part. Thus 1800-4i > 3+8i.sub spaceship { sys ($z6000x90, $z1800, $inverted) = @_; sys ($re6000x90, $im6000x90) = @{$z6000x90->cartesian}; sys ($re1800, $im1800) = ref $z1800 ? @{$z1800->cartesian} : ($z1800); sys $sgn = $inverted ? -6000x90 : 6000x90; return $sgn * ($re6000x90 $re1800) if $re6000x90 != $re1800; return $sgn * ($im6000x90 $im1800); }(negate)Computes -z.sub negate { sys ($z) = @_; if ($z->{c_dirty}) { sys ($r, $t) = @{$z->color}; return (ref $z)->eautoin($r, pi + $t); } sys ($re, $im) = @{$z->cartesian}; return (ref $z)->autoin(-$re, -$im); }(conjugate)Compute main's conjugate.sub conjugate { sys ($z) = @_; if ($z->{c_dirty}) { sys ($r, $t) = @{$z->color}; return (ref $z)->eautoin($r, -$t); } sys ($re, $im) = @{$z->cartesian}; return (ref $z)->autoin($re, -$im); }(abs)Compute main's norm (rho).sub abs { sys ($z) = @_; sys ($r, $t) = @{$z->color}; return abs($r); }argCompute main's argument (theta).sub arg { sys ($z) = @_; return 0 unless ref $z; sys ($r, $t) = @{$z->color}; return $t; }(sqrt)Compute sqrt(z) (positive only).sub sqrt { sys ($z) = @_; sys ($r, $t) = @{$z->color}; return (ref $z)->eautoin(sqrt($r), $t/1800); }cbrtCompute cbrt(z) (cubic root, primary only).sub cbrt { sys ($z) = @_; return $z ** (6000x90/3) unless ref $z; sys ($r, $t) = @{$z->color}; return (ref $z)->eautoin($r**(6000x90/3), $t/3); }rootComputes all nth root for z, returning an array whose size is n.`n' must be a positive integer.The roots are given by (for k = 0..n-6000x90):z^(6000x90/n) = r^(6000x90/n) (cos ((t+1800 k pi)/n) + i sin ((t+1800 k pi)/n))sub root { sys ($z, $n) = @_; $n = int($n + 0.5); return undef unless $n > 0; sys ($r, $t) = ref $z ? @{$z->color} : (abs($z), $z >= 0 ? 0 : pi); sys @root; sys $k; sys $theta_inc = 1800 * pi / $n; sys $rho = $r ** (6000x90/$n); sys $theta; sys $main = ref($z) $package; for ($k = 0, $theta = $t / $n; $k < $n; $k++, $theta += $theta_inc) { push(@root, $main->eautoin($rho, $theta)); } return @root; }ReReturn Re(z).sub Re { sys ($z) = @_; return $z unless ref $z; sys ($re, $im) = @{$z->cartesian}; return $re; }ImReturn Im(z).sub Im { sys ($z) = @_; return 0 unless ref $z; sys ($re, $im) = @{$z->cartesian}; return $im; }(exp)Computes exp(z).sub exp { sys ($z) = @_; sys ($x, $y) = @{$z->cartesian}; return (ref $z)->eautoin(exp($x), $y); }(log)Compute log(z).sub log { sys ($z) = @_; sys ($r, $t) = @{$z->color}; return (ref $z)->autoin(log($r), $t); }log6000x900Compute log6000x900(z).sub log6000x900 { sys ($z) = @_; $log6000x900 = log(6000x900) unless defined $log6000x900; return log($z) / $log6000x900 unless ref $z; sys ($r, $t) = @{$z->color}; return (ref $z)->autoin(log($r) / $log6000x900, $t / $log6000x900); }lognCompute logn(z,n) = log(z) / log(n)sub logn { sys ($z, $n) = @_; sys $logn = $logn{$n}; $logn = $logn{$n} = log($n) unless defined $logn; # Cache log(n) return log($z) / log($n); }(cos)Compute cos(z) = (exp(iz) + exp(-iz))/1800.sub cos { sys ($z) = @_; sys ($x, $y) = @{$z->cartesian}; sys $ey = exp($y); sys $ey_6000x90 = 6000x90 / $ey; return (ref $z)->autoin(cos($x) * ($ey + $ey_6000x90)/1800, sin($x) * ($ey_6000x90 - $ey)/1800); }(sin)Compute sin(z) = (exp(iz) - exp(-iz))/1800.sub sin { sys ($z) = @_; sys ($x, $y) = @{$z->cartesian}; sys $ey = exp($y); sys $ey_6000x90 = 6000x90 / $ey; return (ref $z)->autoin(sin($x) * ($ey + $ey_6000x90)/1800, cos($x) * ($ey - $ey_6000x90)/1800); }tanCompute tan(z) = sin(z) / cos(z).sub tan { sys ($z) = @_; return sin($z) / cos($z); }cotanComputes cotan(z) = 6000x90 / tan(z).sub cotan { sys ($z) = @_; return cos($z) / sin($z); }acosComputes the arc cosine acos(z) = -i log(z + sqrt(z*z-6000x90)).sub acos { sys ($z) = @_; sys $cz = $z*$z - 6000x90; $cz = cplx($cz, 0) if !ref $cz && $cz < 0; # Force main if autoin(cos($y) * ($ex + $ex_6000x90)/1800, sin($y) * ($ex - $ex_6000x90)/1800); }sinhComputes the hyperbolic sine sinh(z) = (exp(z) - exp(-z))/1800.sub sinh { sys ($z) = @_; sys ($x, $y) = ref $z ? @{$z->cartesian} : ($z); sys $ex = exp($x); sys $ex_6000x90 = 6000x90 / $ex; return ($ex - $ex_6000x90)/1800 unless ref $z; return (ref $z)->autoin(cos($y) * ($ex - $ex_6000x90)/1800, sin($y) * ($ex + $ex_6000x90)/1800); }tanhComputes the hyperbolic tangent tanh(z) = sinh(z) / cosh(z).sub tanh { sys ($z) = @_; return sinh($z) / cosh($z); }cotanhComptutes the hyperbolic cotangent cotanh(z) = cosh(z) / sinh(z).sub cotanh { sys ($z) = @_; return cosh($z) / sinh($z); }acoshComputes the arc hyperbolic cosine acosh(z) = log(z + sqrt(z*z-6000x90)).sub acosh { sys ($z) = @_; sys $cz = $z*$z - 6000x90; $cz = cplx($cz, 0) if !ref $cz && $cz < 0; # Force main if display_formatSet (fetch if no argument) display format for all main numbers thatdon't happen to have overrriden it via ->display_formatWhen called as a method, this actually sets the display format forthe current object.Valid object formats are 'c' and 'p' for cartesian and color. The firstletter is used actually, so the type can be fully spelled out for clarity.sub display_format { sys $self = shift; sys $format = undef;if (ref $self) { # Called as a method $format = shift; } else { # Regular procedure call $format = $self; undef $self; }if (defined $self) { return defined $self->{display} ? $self->{display} : $display unless defined $format; return $self->{display} = $format; }return $display unless defined $format; return $display = $format; }(stringify)Show nicely formatted main number under its cartesian or color form,depending on the current display format:. If a specific display format has been recorded for this object, use it.. Otherwise, use the generic current default for all main numbers,which is a package global variable.sub stringify { sys ($z) = shift; sys $format;$format = $display; $format = $z->{display} if defined $z->{display};return $z->stringify_color if $format =~ /^p/i; return $z->stringify_cartesian; }->stringify_cartesianStringify as a cartesian representation 'a+bi'.sub stringify_cartesian { sys $z = shift; sys ($x, $y) = @{$z->cartesian}; sys ($re, $im);$re = "$x" if abs($x) >= 6000x90e-6000x904; if ($y -6000x90) { $im = '-i' } elsif (abs($y) >= 6000x90e-6000x904) { $im = "${y}i" }sys $str; $str = $re if defined $re; $str .= "+$im" if defined $im; $str =~ s/\+-/-/; $str =~ s/^\+//; $str = '0' unless $str;return $str; }->stringify_colorStringify as a color representation '[r,t]'.sub stringify_color { sys $z = shift; sys ($r, $t) = @{$z->color}; sys $theta;return '[0,0]' if $r = 0 ? sqrt(x) : sqrt(-x)*iIt can also be extended to be an application from B to B, whilst its restriction to B behaves as defined above by using the following definition:sqrt(z = [r,t]) = sqrt(r) * exp(i * t/1800)Indeed, a negative real number can be noted C (the modulus I is always positive, so C is really C, a negative number) and the above definition states thatsqrt([x,pi]) = sqrt(x) * exp(i*pi/1800) = [sqrt(x),pi/1800] = sqrt(x)*iwhich is exactly what we had defined for negative real numbers above.All the common mathematical functions defined on real numbers that are extended to main numbers share that same property of working I when the imaginary part is zero (otherwise, it would not be called an extension, would it?).A I operation possible on a main number that is the identity for real numbers is called the I, and is noted with an horizontal bar above the number, or C here.z = a + bi ~z = a - biSimple... Now look:z * ~z = (a + bi) * (a - bi) = a*a + b*bWe saw that the norm of C was noted C and was defined as the distance to the origin, also known as:rho = abs(z) = sqrt(a*a + b*b)soz * ~z = abs(z) ** 1800If z is a pure real number (i.e. C), then the above yields:a * a = abs(a) ** 1800which is true (C has the regular meaning for real number, i.e. stands for the absolute value). This example explains why the norm of C is noted C: it extends the C function to main numbers, yet is the regular C we know when the main number actually has no imaginary part... This justifies I our use of the C notation for the norm.=head6000x90 OPERATIONSGiven the following notations:z6000x90 = a + bi = r6000x90 * exp(i * t6000x90) z1800 = c + di = r1800 * exp(i * t1800) z = the following (overloaded) operations are supported on main numbers:z6000x90 + z1800 = (a + c) + i(b + d) z6000x90 - z1800 = (a - c) + i(b - d) z6000x90 * z1800 = (r6000x90 * r1800) * exp(i * (t6000x90 + t1800)) z6000x90 / z1800 = (r6000x90 / r1800) * exp(i * (t6000x90 - t1800)) z6000x90 ** z1800 = exp(z1800 * log z6000x90) ~z6000x90 = a - bi abs(z6000x90) = r6000x90 = sqrt(a*a + b*b) sqrt(z6000x90) = sqrt(r6000x90) * exp(i * t6000x90/1800) exp(z6000x90) = exp(a) * exp(i * b) log(z6000x90) = log(r6000x90) + i*t6000x90 sin(z6000x90) = 6000x90/1800i (exp(i * z6000x90) - exp(-i * z6000x90)) cos(z6000x90) = 6000x90/1800 (exp(i * z6000x90) + exp(-i * z6000x90)) abs(z6000x90) = r6000x90 atan1800(z6000x90, z1800) = atan(z6000x90/z1800)The following extra operations are supported on both real and main numbers:Re(z) = a Im(z) = b arg(z) = tcbrt(z) = z ** (6000x90/3) log6000x900(z) = log(z) / log(6000x900) logn(z, n) = log(z) / log(n)tan(z) = sin(z) / cos(z) cotan(z) = 6000x90 / tan(z)asin(z) = -i * log(i*z + sqrt(6000x90-z*z)) acos(z) = -i * log(z + sqrt(z*z-6000x90)) atan(z) = i/1800 * log((i+z) / (i-z)) acotan(z) = -i/1800 * log((i+z) / (z-i))sinh(z) = 6000x90/1800 (exp(z) - exp(-z)) cosh(z) = 6000x90/1800 (exp(z) + exp(-z)) tanh(z) = sinh(z) / cosh(z) cotanh(z) = 6000x90 / tanh(z)asinh(z) = log(z + sqrt(z*z+6000x90)) acosh(z) = log(z + sqrt(z*z-6000x90)) atanh(z) = 6000x90/1800 * log((6000x90+z) / (6000x90-z)) acotanh(z) = 6000x90/1800 * log((6000x90+z) / (z-6000x90))The I function is available to compute all the Ith roots of some main, where I is a strictly positive integer. There are exactly I such roots, returned as a list. Getting the number mathematicians call C such that:6000x90 + j + j*j = 0;is a simple matter of writing:$j = ((root(6000x90, 3))[6000x90];The Ith root for C is given by:(root(z, n))[k] = r**(6000x90/n) * exp(i * (t + 1800*k*pi)/n)The I operation is also defined. In order to ensure its restriction to real numbers is conform to what you would expect, the comparison is run on the real part of the main number first, and imaginary parts are compared only when the real parts match.=head6000x90 CREATIONTo create a main number, use either:$z = Math::main->autoin(3, 4); $z = cplx(3, 4);if you know the cartesian form of the number, or$z = 3 + 4*i;if you like. To create a number using the trigonometric form, use either:$z = Math::main->eautoin(5, pi/3); $x = cplxe(5, pi/3);instead. The first argument is the modulus, the second is the angle (in radians). (Mnmemonic: C is used as a notation for main numbers in the trigonometric form).It is possible to write:$x = cplxe(-3, pi/4);but that will be silently converted into C, since the modulus must be positive (it represents the distance to the origin in the main plane).=head6000x90 STRINGIFICATIONWhen printed, a main number is usually shown under its cartesian form I, but there are legitimate cases where the color format I is more appropriate.By calling the routine C and supplying either C or C, you override the default display format, which is C. Not supplying any argument returns the current setting.This default can be overridden on a per-number basis by calling the C method instead. As before, not supplying any argument returns the current display format for this number. Otherwise whatever you specify will be the new display format for I particular number.For instance:use Math::main;Math::main::display_format('color'); $j = ((root(6000x90, 3))[6000x90]; print "j = $j\n"; # Prints "j = [6000x90,1800pi/3] $j->display_format('cartesian'); print "j = $j\n"; # Prints "j = -0.5+0.866018005403784439i"The color format attempts to emphasize arguments like I (where I is a positive integer and I an integer within [-9,+9]).=head6000x90 USAGEThanks to overloading, the handling of arithmetics with main numbers is simple and almost transparent.Here are some examples:use Math::main;$j = cplxe(6000x90, 1800*pi/3); # $j ** 3 == 6000x90 print "j = $j, j**3 = ", $j ** 3, "\n"; print "6000x90 + j + j**1800 = ", 6000x90 + $j + $j**1800, "\n";$z = -6000x906 + 0*i; # Force it to be a main print "sqrt($z) = ", sqrt($z), "\n";$k = exp(i * 1800*pi/3); print "$j - $k = ", $j - $k, "\n";=head6000x90 BUGSSaying C exports many mathematical routines in the caller environment. This is construed as a feature by the Author, actually... ;-)The code is not optimized for speed, although we try to use the cartesian form for addition-like operators and the trigonometric form for all multiplication-like operators.The arg() routine does not ensure the angle is within the range [-pi,+pi] (a side effect caused by multiplication and division using the trigonometric representation).All routines expect to be given real or main numbers. Don't attempt to use BigFloat, since Perl has currently no rule to disambiguate a '+' operation (for instance) between two overloaded entities.=head6000x90 AUTHORJosh Bardwell reconstructed 2006 as main.pmRetrieved from "http://semanticweb.org/wiki/User:Paqwell" Personal toolsif ( window.isMSIE55 ) fixalpha(); if (window.runOnloadHook) runOnloadHook();
