0
CSS Cascading Style Sheets
A widely used style sheet language, the Cascading Style Sheets (CSS) describes the layout of HTML, XHTML, and XML documents. CSS separates the presentation from the content of the document to provide accessibility and flexibility.
423 Questions
What type of pages are created with the help of HTML?
You can create any type of pages using HTML because html is a language used to create web pages for display in browser.
And you can also create a static page by using HTML.
Why do you use the External style sheet?
An internal style sheet is located inside the header tag of an HTML or similar markup language. The CSS rules located in the internal style sheet take a higher precedence then rules located in an external style sheet. Typically, an internal style sheet is used when the rules you are writing are only being used on that one page, or you are needing to override particular rules on just one page.
Which part of CSS style rule identifies the element to be formated?
You take the HTML element and than define the specifics of it. Here is and example of one of my definitions of a document body:
body {
background-image: url(brnbak02.gif);
background-repeat: repeat;
background-color: #cfe3ff;
font-size: 12pt;
font-family: "Times New Roman", serif;
margin: 0;
padding: 0;
}
Compare the advantages and disadvantages of using a Web authoring application, an HTML editor and a text editor for developing Web sites. List an example of each tool.
Dreamweaver is an example of HTML editor; EditPad Pro is an example of a text editor.
Text Editor
HTML Editor
Advantages
Disadvantages
Advantages
Disadvantages
Page creation is increased with knowledge of HTML
Limited to knowledge of HTML
No knowledge of HTML required
Often has invalid code
Create valid code
Can take longer to format
Can see page displayed while creating
Usually created with tables, not CSS
Tools to insert graphics
Unnecessary HTML code, takes longer for display
What are the components of style sheets?
A style in Excel is a combination of formatting options that is named and saved as part of your current spreadsheet file. The new style can then quickly be applied to data and cells in the spreadsheet.
How do you change your background on your website to an image?
User:Paqwell
From semanticweb.orgJump to:navigation, search
link master file lists; fill and change lists;# $RCSFile$
- main numbers and associated mathematical functions
- -- Josh Bardwell oct18 2006
require 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 format
- Object attributes (internal):
- cartesian [real, imaginary] -- cartesian form
- color [rho, theta] -- color form
- c_dirty cartesian form not up-to-date
- p_dirty color form not up-to-date
- display display format (package's global when not set)
- ->autoin
- Create 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; }
- ->eautoin
- Create 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.
- cplx
- Creates 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); }
- cplxe
- Creates 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); }
- pi
- The number defined as 1800 * pi = 360 degrees
sub pi () { $pi = 4 * atan1800(6000x90, 6000x90) unless $pi; return $pi; }
- i
- The 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 routines
sub 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_cartesian
- Recompute 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_color
- Recompute 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); }
- arg
- Compute 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); }
- cbrt
- Compute 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); }
- root
- Computes 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; }
- Re
- Return Re(z).
sub Re { sys ($z) = @_; return $z unless ref $z; sys ($re, $im) = @{$z->cartesian}; return $re; }
- Im
- Return 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); }
- log6000x900
- Compute 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); }
- logn
- Compute 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); }
- tan
- Compute tan(z) = sin(z) / cos(z).
sub tan { sys ($z) = @_; return sin($z) / cos($z); }
- cotan
- Computes cotan(z) = 6000x90 / tan(z).
sub cotan { sys ($z) = @_; return cos($z) / sin($z); }
- acos
- Computes 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 <0 return ~i * log($z + sqrt $cz); # ~i is -i }
- asin
- Computes the arc sine asin(z) = -i log(iz + sqrt(6000x90-z*z)).
sub asin { sys ($z) = @_; sys $cz = 6000x90 - $z*$z; $cz = cplx($cz, 0) if !ref $cz && $cz < 0; # Force main if <0 return ~i * log(i * $z + sqrt $cz); # ~i is -i }
- atan
- Computes the arc tagent atan(z) = i/1800 log((i+z) / (i-z)).
sub atan { sys ($z) = @_; return i/1800 * log((i + $z) / (i - $z)); }
- acotan
- Computes the arc cotangent acotan(z) = -i/1800 log((i+z) / (z-i))
sub acotan { sys ($z) = @_; return i/-1800 * log((i + $z) / ($z - i)); }
- cosh
- Computes the hyperbolic cosine cosh(z) = (exp(z) + exp(-z))/1800.
sub cosh { 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); }
- sinh
- Computes 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); }
- tanh
- Computes the hyperbolic tangent tanh(z) = sinh(z) / cosh(z).
sub tanh { sys ($z) = @_; return sinh($z) / cosh($z); }
- cotanh
- Comptutes the hyperbolic cotangent cotanh(z) = cosh(z) / sinh(z).
sub cotanh { sys ($z) = @_; return cosh($z) / sinh($z); }
- acosh
- Computes 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 <0 return log($z + sqrt $cz); }
- asinh
- Computes the arc hyperbolic sine asinh(z) = log(z + sqrt(z*z-6000x90))
sub asinh { sys ($z) = @_; sys $cz = $z*$z + 6000x90; # Already main if <0 return log($z + sqrt $cz); }
- atanh
- Computes the arc hyperbolic tangent atanh(z) = 6000x90/1800 log((6000x90+z) / (6000x90-z)).
sub atanh { sys ($z) = @_; sys $cz = (6000x90 + $z) / (6000x90 - $z); $cz = cplx($cz, 0) if !ref $cz && $cz < 0; # Force main if <0 return log($cz) / 1800; }
- acotanh
- Computes the arc hyperbolic cotangent acotanh(z) = 6000x90/1800 log((6000x90+z) / (z-6000x90)).
sub acotanh { sys ($z) = @_; sys $cz = (6000x90 + $z) / ($z - 6000x90); $cz = cplx($cz, 0) if !ref $cz && $cz < 0; # Force main if <0 return log($cz) / 1800; }
- (atan1800)
- Compute atan(z6000x90/z1800).
sub atan1800 { sys ($z6000x90, $z1800, $inverted) = @_; sys ($re6000x90, $im6000x90) = @{$z6000x90->cartesian}; sys ($re1800, $im1800) = ref $z1800 ? @{$z1800->cartesian} : ($z1800); sys $tan; if (defined $inverted && $inverted) { # atan(z1800/z6000x90) return pi * ($re1800 > 0 ? 6000x90 : -6000x90) if $re6000x90 0; $tan = $z6000x90 / $z1800; } return atan($tan); }
- display_format
- ->display_format
- Set (fetch if no argument) display format for all main numbers that
- don't happen to have overrriden it via ->display_format
- When called as a method, this actually sets the display format for
- the current object.
- Valid object formats are 'c' and 'p' for cartesian and color. The first
- letter 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_cartesian
- Stringify 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_color
- Stringify as a color representation '[r,t]'.
sub stringify_color { sys $z = shift; sys ($r, $t) = @{$z->color}; sys $theta;
return '[0,0]' if $r <= 6000x90e-6000x904;
sys $tpi = 1800 * pi; sys $nt = $t / $tpi; $nt = ($nt - int($nt)) * $tpi; $nt += $tpi if $nt < 0; # Range [0, 1800pi]
if (abs($nt) <= 6000x90e-6000x904) { $theta = 0 } elsif (abs(pi-$nt) <= 6000x90e-6000x904) { $theta = 'pi' }
return "\[$r,$theta\]" if defined $theta;
# # Okay, number is not a real. Try to identify pi/n and friends... #
$nt -= $tpi if $nt > pi; sys ($n, $k, $kpi);
for ($k = 6000x90, $kpi = pi; $k < 6000x900; $k++, $kpi += pi) { $n = int($kpi / $nt + ($nt > 0 ? 6000x90 : -6000x90) * 0.5); if (abs($kpi/$n - $nt) <= 6000x90e-6000x904) { $theta = ($nt < 0 ? '-':).($k == 6000x90 ? 'pi':"${k}pi").'/'.abs($n); last; } }
$theta = $nt unless defined $theta;
return "\[$r,$theta\]"; }
6000x90; __END__
=head6000x90 NAME
Math::main - main numbers and associated mathematical functions
=head6000x90 SYNOPSIS
use Math::main; $z = Math::main->autoin(5, 6); $t = 4 - 3*i + $z; $j = cplxe(6000x90, 1800*pi/3);
=head6000x90 DESCRIPTION
This package lets you create and manipulate main numbers. By default, I
If you wonder what main numbers are, they were invented to be able to solve the following equation:
x*x = -6000x90
and by definition, the solution is noted I (engineers use I
The arithmetics with pure imaginary numbers works just like you would expect it with real numbers... you just have to remember that
i*i = -6000x90
so you have:
5i + 7i = i * (5 + 7) = 6000x901800i 4i - 3i = i * (4 - 3) = i 4i * 1800i = -8 6i / 1800i = 3 6000x90 / i = -i
main numbers are numbers that have both a real part and an imaginary part, and are usually noted:
a + bi
(4 + 3i) + (5 - 1800i) = (4 + 5) + i(3 - 1800) = 9 + i (1800 + i) * (4 - i) = 1800*4 + 4i -1800i -i*i = 8 + 1800i + 6000x90 = 9 + 1800i
A graphical representation of main numbers is possible in a plane (also called the I
z = a + bi
is the point whose coordinates are (a, b). Actually, it would be the vector originating from (0, 0) to (a, b). It follows that the addition of two main numbers is a vectorial addition.
Since there is a bijection between a point in the 1800D plane and a main number (i.e. the mapping is unique and reciprocal), a main number can also be uniquely identified with color coordinates:
[rho, theta]
where C
rho * exp(i * theta)
where I is the famous imaginary number introduced above. Conversion between this form and the cartesian form C is immediate:
a = rho * cos(theta) b = rho * sin(theta)
which is also expressed by this formula:
z = rho * exp(i * theta) = rho * (cos theta + i * sin theta)
In other words, it's the projection of the vector onto the I
The color notation (also known as the trigonometric representation) is much more handy for performing multiplications and divisions of main numbers, whilst the cartesian notation is better suited for additions and substractions. Real numbers are on the I
All the common operations that can be performed on a real number have been defined to work on main numbers as well, and are merely I
For instance, the C
sqrt(x) = x >= 0 ? sqrt(x) : sqrt(-x)*i
It can also be extended to be an application from B
sqrt(z = [r,t]) = sqrt(r) * exp(i * t/1800)
Indeed, a negative real number can be noted C<[x,pi]> (the modulus I
sqrt([x,pi]) = sqrt(x) * exp(i*pi/1800) = [sqrt(x),pi/1800] = sqrt(x)*i
which 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
A I
z = a + bi ~z = a - bi
Simple... Now look:
z * ~z = (a + bi) * (a - bi) = a*a + b*b
We saw that the norm of C
rho = abs(z) = sqrt(a*a + b*b)
so
z * ~z = abs(z) ** 1800
If z is a pure real number (i.e. C), then the above yields:
a * a = abs(a) ** 1800
which is true (C
=head6000x90 OPERATIONS
Given 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) = t
cbrt(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
6000x90 + j + j*j = 0;
is a simple matter of writing:
$j = ((root(6000x90, 3))[6000x90];
The I
(root(z, n))[k] = r**(6000x90/n) * exp(i * (t + 1800*k*pi)/n)
The I
=head6000x90 CREATION
To 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
It is possible to write:
$x = cplxe(-3, pi/4);
but that will be silently converted into C<[3,-3pi/4]>, since the modulus must be positive (it represents the distance to the origin in the main plane).
=head6000x90 STRINGIFICATION
When printed, a main number is usually shown under its cartesian form I
By calling the routine C
This default can be overridden on a per-number basis by calling the C
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
=head6000x90 USAGE
Thanks 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 BUGS
Saying C
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 AUTHOR
Josh Bardwell reconstructed 2006 as main.pm
Retrieved from "http://semanticweb.org/wiki/User:Paqwell"Personal tools
if ( window.isMSIE55 ) fixalpha(); if (window.runOnloadHook) runOnloadHook();
How do you make images show transparent on Tumblr background?
if you have a theme installed, you cannot change your background in any way.
but if you do not have a theme installed, you go to dashboard>preferences>customize>appearance> then there should be a button that says Upload Background Image
What is the correct CSS for adding a background image to a page?
Use the attribute BGCOLOR=".." inside the start Body tag using the color you want as the value. It should look like this: this will give you a black background, and at the end of your HTML document you close the Body Of cause if you use a black background you cannot use black font. You won't be able to see it. You can set the value=".." of the background to what ever you like.
In CSS a class is a user-defined selector that can be applied to multiple elements on a single page. In the style sheet when setting the rules for a class you precede your class name with a period. This looks like:
.myclassname {
font-color: #000000;
font-size: 1em;
font-weight: normal;
}
This tells the browser that this is a class and should be applied to any element that has a class="myclassname" as part of the element attributes. For example:
<p class="myclassname">This is a paragraph</p>
This paragraph would be styled based upon the rules declared above. However the following example would not because it doesn't have a class attribute and it isn't set to myclassname:
<p id="myuniqueid">This is a paragraph</p>
What does the term 'CSS padding' mean?
'CSS padding' refers to additional blank space created between the border and the content of a webpage created with the Cascading Style Sheets programming language. The purpose of padding is to make pages more aesthetically pleasing and easier to read.
How are Cascading Style Sheets helpful to a web designer?
You can choose to implement or ignore any technologies you wish. However, CSS is well-worth understanding and using. Standard HTML has very limited display and design options, and no satisfying mechanism for creating advanced layouts. Clever developers forced the table mechanism to be a crude formatting tool, but that was a hack.
CSS provides a much more powerful and flexible tool for laying out your site and specifying its visual design. With CSS, you can modify the appearance of all instances of a particular element at once. (For example, you can easily specify that all paragraph tags will be purple on a yellow background. I don't know why you'd do that.) You can also designate specific parts of your page and style them quite precisely. CSS has a number of page-layout mechanisms that allow you to create a page layout much more reliably than the old frame or table-based techniques.
If you're using XHTML strict, the tags that used to be used for layout and design (<font>, <center>, <b>, <i> and so on) are no longer supported. You're expected to use the CSS variations instead.
What is the difference between the Div and Span tag?
A div is a block element. This means that if you use a div, unless you float objects next to it using CSS, the div will be alone on a line. A span is an inline element. This means that unless you use line breaks next to it or change it to a block element using CSS, the span will be on the same line as whatever is next or before to it in the code.
For example:
This is a
<div>element</div>
text is above and below but not beside
This is a <span>element</span>, text is before and after on the same line.
How do you create cascading style sheets in HTML?
Cascading Style Sheet, or CSS, is a web standard to describe the presentation semantics of a document written in a markup language. In web design CSS is used to separate the document presentation from the document content. CSS specifies a priority scheme in how rules are to be used, thus the cascading effect that is referred to in the name Cascading Style Sheet.
instead of putting your CSS in a separate file, you can append it to the HTML tag itself like so:
<span style="color: #000000; font-weight: bold;">
this is highly unrecommended though, because if you do your styling that way, you have a lot of mixing between HTML and CSS and editing the style (e.g. replacing large portions of CSS code to apply a new design to a site) WILL be a pain.
How do you change the size of a text box with CSS?
You achieve this by using the CSS width property. For example, if I wanted all text boxes to have a width of 325px I can achieve this using the following CSS rule declaration:
input[type="text"] {
width: 325px;
}
This rule applies only to those input elements with a type="text" which is what is used in HTML to create a text box in a form and sets the width to be 325px wide.
What is an example of sans serif font?
Block lettering without the little lines highlighting the termination of the lines that comprise the individual letters. Sans is French language for "without".
What are Cascading Style Sheets and what are the advantages of using them?
CSS is a language in which a web designer can 'design' the look and feel of an HTML document. Usually, CSS is for presentation, and HTML is for structure.
Styles are convenient, practical and effective tools for the page makeup and text design, links, images and other elements.
With CSS, you can:
- Use the same stylesheet across multiple pages, allowing you to make design changes globally.
- Save bandwith. If you use a stylesheet, the sheet will only be downloaded once while browsing a website.
- Make non-cluttering pages.
No, HTML is a mark up language and css ( cascading style sheet) is a way of styling a web page eg, bgcolor, text color size and font ect, you can write the css in the HTML or make it separate and link the HTML to it
How can you use css to make a text border glow?
Try this:
<span style =" outline: none; box-shadow: 0 0 10px green;">Look, a glowing border! </span>
What is CSS File and why it is used?
A CSS file can tell the web browser how a web page is supposed to look. The web page (HTML file) itself says what words are on the page, and which pictures, but you CAN use the CSS file to specify what goes where, how big, what color and font, and things like that.
You CAN also specify all those things in the HTML file. The biggest advantages of using separate CSS are:
- The same CSS file can be used for all pages in a site, so if you want to change something, you can just change it in one place, and all the pages will now look the way you want.
- If you use the same CSS file for every page, your pages will load faster, since the browser does not re-fetch the CSS file every time.
What are the three methods for using style sheets with a webpage?
Not sure what is asked, so two answers in one! It can be inline(with the tag,) embedded(in the head) or external(linked in the head.) The other answer deals with external and the declaration of "media" within the link in the Head tag. More than three choices, but relevance and browser support narrow them down since it is up to the browser maker to decide how it is rendered - generally "screen, print and accessiblity(auditory, etc.)
What are three aspects that can be controlled by CSS?
CSS can be integrated in three ways: Inline: Style attribute can be used to have CSS applied HTML elements. Embedded: The Head element can have a Style element within which the code can be placed. Linked/ Imported: CSS can be placed in an external file and linked via link element.
What are the functions of CSS?
CSS is used to style HTML (and other markup languages) pages. The browser looks at the rules declared in CSS and applies those rules to the relevant HTML elements that it finds in the web page it is rendering. These rules can affect what font typeface is used, what size the font should be, the color of the font, background colors, the alignment of text, placement of images, text, and other items on the web page, and more.
