In photos: Ten cool tech features on display at the 2019 LA Auto Show
by Petrina GentileTechnology is transforming the auto industry. Here’s a glimpse of what to expect when it comes to technology in cars of the future – innovative features on display at this year’s LA Auto Show.
Have you ever wanted to relive your favorite drive – something along California’s famed Pacific Coast Highway or BC’s picturesque Sea to Sky highway? Now you can – without leaving the comfort of your home thanks to technology in this Karma SC2 concept. Attach a smartphone to the rear-view mirror to wirelessly charge and its no longer a regular phone. It uses the cameras and lidars around the vehicle to act as a rear-view mirror and record the drive ahead. You can later replay the drive using the built-in projector on the vehicle’s front windshield and project the images directly onto the garage door.
Have you ever lost your car keys? Now, you don’t need to worry about finding your keys with Ford’s new “phone as a key” technology. Download an app onto your smartphone and your cell becomes the key. Not only can you lock or unlock the doors with your phone, you can raise the liftgate, start, and drive the vehicle without a traditional key in sight. Don’t worry – if you’re using valet there’s no need to hand over your cell to a stranger – you can give them a temporary passcode to enter and drive the vehicle. This technology is in the 2020 Lincoln Corsair and will appear in Ford’s new Mustang Mach E SUV.
Other manufacturers are opting to skip the cell phone in lieu of a key option for something even easier. This Karma concept has sensors built into the driver’s seat. The sensors are programmed to recognize the driver’s height and weight so it instinctively knows when the driver is behind the wheel and will start the vehicle automatically and let the driver take off – no key necessary.
In the future, how will you know if a vehicle is self-driving or being piloted by a driver? This Lexus LF-30 concept has the solution to warn other drivers when a vehicle is in the self-driving mode. If the lights at the front appear in bright blue the vehicle is in autonomous mode – when it’s not, the driver is in control of the wheel. It’s a smart way to let other drivers sharing the road know if technology or a human is in control of the wheel.
There’s no need for driving enthusiasts to worry about the autonomous future. It doesn’t mean the end of driving. Many manufacturers are planning to give drivers the option to take the wheel. In this Infiniti Qs Inspiration concept, the steering wheel and pedals disappear into the dashboard and floor when not in use and in the self-driving mode. When the driver takes control, the steering wheel and the pedals extend out for a more engaging drive.
Rear-seat riders are usually left in the cold when it comes to controlling the radio or climate control system of a vehicle. They have little input or say once the front passengers pick their favorite tunes and set the temperature. But that changes because of the artificial intelligence in this Lexus LF-30 concept.It takes the infotainment system and projects it onto the rear roof so passengers in the back seat can change the temperature or radio simply by using hand gestures.
Say goodbye to side-view mirrors. In the future, cameras will replace them. Images of vehicles approaching on both sides of a vehicle will be projected onto a high-tech dashboard in the cabin. Several manufacturers are offering up many versions of the side-view cameras. This one on this Hyundai concept pops out when you’re driving and hides away when you’re parked, providing a seamless, sleek profile.
Door hands may be a thing of the past in the future. This ID. Space Vizzion concept from Volkswagen doesn’t have traditional door handles – in its place, is an illuminated light image of a door handle that’s flush with the side of the vehicle. To open, simply touch once and apply a bit of pressure and voila - the door opens easily.
The ID. Space Vizzion concept also has another cool tech feature that allows drivers to get around town easier and in a more environmentally-friendly way. In this case, the cargo area hides two electric skate boards complete with two helmets and a remote control so you can alter the speed of your electric skate board while you’re navigating crowded city streets. This multi-mode transportation system may be the future of mobility.
Don’t expect to see traditional buttons and dials for the radio volume or climate control in future cars. Expect a streamlined, clean and high-tech cabin with digital commands to perform a number of functions. You can change the flow and location of air vents in this concept, for example, by simply touching and dragging the circular icons anywhere on the dashboard to tailor the air flow to the perfect spot.
Stay on top of all our Drive stories. We have a Drive newsletter covering car reviews, innovative new cars and the ups and downs of everyday driving. Sign up today .


High-performance solvers, such as Z3, contain many tightly integrated, handcrafted heuristic combinations of algorithmic proof methods. While these heuristic combinations tend to be highly tuned for known classes of problems, they may easily perform very badly on new classes of problems. This issue is becoming increasingly pressing as solvers begin to gain the attention of practitioners in diverse areas of science and engineering. In many cases, changes to the solver heuristics can make a tremendous difference.
In this tutorial we show how to create custom strategies using the basic building blocks available in Z3. Z3Py and Z3 4.0 implement the ideas proposed in this article.
Please send feedback, comments and/or corrections to<EMAIL_ADDRESS>Your comments are very valuable.
Z3 implements a methodology for orchestrating reasoning engines where "big" symbolic reasoning steps are represented as functions known as tactics, and tactics are composed using combinators known as tacticals. Tactics process sets of formulas called Goals.
When a tactic is applied to some goal G, four different outcomes are possible. The tactic succeeds in showing G to be satisfiable (i.e., feasible); succeeds in showing G to be unsatisfiable (i.e., infeasible); produces a sequence of subgoals; or fails. When reducing a goal G to a sequence of subgoals G1, ..., Gn, we face the problem of model conversion. A model converter construct a model for G using a model for some subgoal Gi.
In the following example, we create a goal g consisting of three formulas, and a tactic t composed of two built-in tactics: simplify and solve-eqs. The tactic simplify apply transformations equivalent to the ones found in the command simplify. The tactic solver-eqs eliminate variables using Gaussian elimination. Actually, solve-eqs is not restricted only to linear arithmetic. It can also eliminate arbitrary variables. Then, combinator Then applies simplify to the input goal and solve-eqs to each subgoal produced by simplify. In this example, only one subgoal is produced.
In the example above, variable x is eliminated, and is not present the resultant goal.
In Z3, we say a clause is any constraint of the form Or(f_1, ..., f_n). The tactic split-clause will select a clause Or(f_1, ..., f_n) in the input goal, and split it n subgoals. One for each subformula f_i.
Z3 comes equipped with many built-in tactics. The command describe_tactics() provides a short description of all built-in tactics.
Z3Py comes equipped with the following tactic combinators (aka tacticals):
The following example demonstrate how to use these combinators.
In the tactic split_solver, the tactic solve-eqs discharges all but one goal. Note that, this tactic generates one goal: the empty goal which is trivially satisfiable (i.e., feasible)
The list of subgoals can be easily traversed using the Python for statement.
A tactic can be converted into a solver object using the method solver(). If the tactic produces the empty goal, then the associated solver returns sat. If the tactic produces a single goal containing False, then the solver returns unsat. Otherwise, it returns unknown.
In the example above, the tactic bv_solver implements a basic bit-vector solver using equation solving, bit-blasting, and a propositional SAT solver. Note that, the command Tactic is suppressed. All Z3Py combinators automatically invoke Tactic command if the argument is a string. Finally, the command solve_using is a variant of the solve command where the first argument specifies the solver to be used.
In the following example, we use the solver API directly instead of the command solve_using. We use the combinator With to configure our little solver. We also include the tactic aig which tries to compress Boolean formulas using And-Inverted Graphs.
The tactic smt wraps the main solver in Z3 as a tactic.
Now, we show how to implement a solver for integer arithmetic using SAT. The solver is complete only for problems where every variable has a lower and upper bound.
Tactics can be combined with solvers. For example, we can apply a tactic to a goal, produced a set of subgoals, then select one of the subgoals and solve it using a solver. The next example demonstrates how to do that, and how to use model converters to convert a model for a subgoal into a model for the original goal.
Probes (aka formula measures) are evaluated over goals. Boolean expressions over them can be built using relational operators and Boolean connectives. The tactic FailIf(cond) fails if the given goal does not satisfy the condition cond. Many numeric and Boolean measures are available in Z3Py. The command describe_probes() provides the list of all built-in probes.
In the following example, we build a simple tactic using FailIf. It also shows that a probe can be applied directly to a goal.
Z3Py also provides the combinator (tactical) If(p, t1, t2) which is a shorthand for:
OrElse(Then(FailIf(Not(p)), t1), t2)
The combinator When(p, t) is a shorthand for:
If(p, t, 'skip')
The tactic skip just returns the input goal. The following example demonstrates how to use the If combinator.


Pozdrav,
Naja Čuljević
Mob.: +382 67 312 206
SAT-TRAKT DOO PODGORICA | Kralja Nikole 128 | 81000 Podgorica | Tel: +382 20 212 105 | Fax: +382 20 212 108 |
www.sattrakt.co.me
This e-mail and any attachments are CONFIDENTIAL and intended solely for the use of the individual(s) to whom it is addressed.
It can contain proprietary confidential information and/or be subject to legal privilege and/or subject to a non-disclosure Agreement.
Unauthorized use, disclosure or copying is strictly prohibited.
If you are not the/an addressee and are in possession of this e-mail, please notify us immediately.
Please consider the environment before printing this e-mail


Why is mental health important?
How to get professional help
Mental Health Disorders
Mental Health Evaluation
Return to home page


MVDWSN - Multiple Visible Declarations With Same Name
Multiple declarations with the same name must not be simultaneously visible except for overloaded methods.
Wrong
void index () {
return;
}
void func () {
int index;
}
}
Tip: Rename members (or variables) with clashing names.
Right
void index () {
return;
}
void func () {
int anIndex;
}
}


|
| ( $* ) [Owl_sparse_complex] |
Shorthand for mul_scalar x a , i.e., x $* a
|
| ( $* ) [Owl_sparse_real] |
Shorthand for mul_scalar x a , i.e., x $* a
|
| ( $* ) [Owl_dense_complex] |
Shorthand for mul_scalar x a , i.e., x $* a
|
| ( $* ) [Owl_dense_real] |
Shorthand for mul_scalar x a , i.e., x $* a
|
| ( *$ ) [Owl_sparse_complex] |
Shorthand for mul_scalar x a , i.e., x *$ a
|
| ( *$ ) [Owl_sparse_real] |
Shorthand for mul_scalar x a , i.e., x *$ a
|
| ( *$ ) [Owl_dense_complex] |
Shorthand for mul_scalar x a , i.e., x *$ a
|
| ( *$ ) [Owl_dense_real] |
Shorthand for mul_scalar x a , i.e., x *$ a
|
| ( **@ ) [Owl_sparse_complex] |
Shorthand for power x a , i.e., x **@ a
|
| ( **@ ) [Owl_sparse_real] |
Shorthand for power x a , i.e., x **@ a
|
| ( **@ ) [Owl_dense_complex] |
Shorthand for power x a , i.e., x **@ a
|
| ( **@ ) [Owl_dense_real] |
Shorthand for power x a , i.e., x **@ a
|
| ( *@ ) [Owl_sparse_complex] |
Shorthand for mul x y , i.e., x *@ y
|
| ( *@ ) [Owl_sparse_real] |
Shorthand for mul x y , i.e., x *@ y
|
| ( *@ ) [Owl_dense_complex] |
Shorthand for mul x y , i.e., x *@ y
|
| ( *@ ) [Owl_dense_real] |
Shorthand for mul x y , i.e., x *@ y
|
| ($+) [Owl_dense_complex] |
Shorthand for add_scalar x a , i.e., a $+ x
|
| ($+) [Owl_dense_real] |
Shorthand for add_scalar x a , i.e., a $+ x
|
| ($-) [Owl_dense_complex] |
Shorthand for sub_scalar x a , i.e., a -$ x
|
| ($-) [Owl_dense_real] |
Shorthand for sub_scalar x a , i.e., a -$ x
|
| ($/) [Owl_sparse_complex] |
Shorthand for div_scalar x a , i.e., x $/ a
|
| ($/) [Owl_sparse_real] |
Shorthand for div_scalar x a , i.e., x $/ a
|
| ($/) [Owl_dense_complex] |
Shorthand for div_scalar x a , i.e., x $/ a
|
| ($/) [Owl_dense_real] |
Shorthand for div_scalar x a , i.e., x $/ a
|
| ($@) [Owl_sparse_complex] |
Shorthand for dot x y , i.e., x $@ y
|
| ($@) [Owl_sparse_real] |
Shorthand for dot x y , i.e., x $@ y
|
| ($@) [Owl_dense_complex] |
Shorthand for dot x y , i.e., x $@ y
|
| ($@) [Owl_dense_real] |
Shorthand for dot x y , i.e., x $@ y
|
| (+$) [Owl_dense_complex] |
Shorthand for add_scalar x a , i.e., x +$ a
|
| (+$) [Owl_dense_real] |
Shorthand for add_scalar x a , i.e., x +$ a
|
| (+@) [Owl_sparse_complex] |
Shorthand for add x y , i.e., x +@ y
|
| (+@) [Owl_sparse_real] |
Shorthand for add x y , i.e., x +@ y
|
| (+@) [Owl_dense_complex] |
Shorthand for add x y , i.e., x +@ y
|
| (+@) [Owl_dense_real] |
Shorthand for add x y , i.e., x +@ y
|
| (-$) [Owl_dense_complex] |
Shorthand for sub_scalar x a , i.e., x -$ a
|
| (-$) [Owl_dense_real] |
Shorthand for sub_scalar x a , i.e., x -$ a
|
| (-@) [Owl_sparse_complex] |
Shorthand for sub x y , i.e., x -@ y
|
| (-@) [Owl_sparse_real] |
Shorthand for sub x y , i.e., x -@ y
|
| (-@) [Owl_dense_complex] |
Shorthand for sub x y , i.e., x -@ y
|
| (-@) [Owl_dense_real] |
Shorthand for sub x y , i.e., x -@ y
|
| (/$) [Owl_sparse_complex] |
Shorthand for div_scalar x a , i.e., x /$ a
|
| (/$) [Owl_sparse_real] |
Shorthand for div_scalar x a , i.e., x /$ a
|
| (/$) [Owl_dense_complex] |
Shorthand for div_scalar x a , i.e., x /$ a
|
| (/$) [Owl_dense_real] |
Shorthand for div_scalar x a , i.e., x /$ a
|
| (/@) [Owl_sparse_complex] |
Shorthand for div x y , i.e., x /@ y
|
| (/@) [Owl_sparse_real] |
Shorthand for div x y , i.e., x /@ y
|
| (/@) [Owl_dense_complex] |
Shorthand for div x y , i.e., x /@ y
|
| (/@) [Owl_dense_real] |
Shorthand for div x y , i.e., x /@ y
|
| (<<) [Owl_dense_real] |
Shorthand for copy_to y x , i.e., x << y
|
| (<=@) [Owl_sparse_complex] |
Shorthand for equal_or_smaller x y , i.e., x <=@ y
|
| (<=@) [Owl_sparse_real] |
Shorthand for equal_or_smaller x y , i.e., x <=@ y
|
| (<=@) [Owl_dense_complex] |
Shorthand for equal_or_smaller x y , i.e., x <=@ y
|
| (<=@) [Owl_dense_real] |
Shorthand for equal_or_smaller x y , i.e., x <=@ y
|
| (<>@) [Owl_sparse_complex] |
Shorthand for is_unequal x y , i.e., x <>@ y
|
| (<>@) [Owl_sparse_real] |
Shorthand for is_unequal x y , i.e., x <>@ y
|
| (<>@) [Owl_dense_complex] |
Shorthand for is_unequal x y , i.e., x <>@ y
|
| (<>@) [Owl_dense_real] |
Shorthand for is_unequal x y , i.e., x <>@ y
|
| (<@) [Owl_sparse_complex] |
Shorthand for is_smaller x y , i.e., x <@ y
|
| (<@) [Owl_sparse_real] |
Shorthand for is_smaller x y , i.e., x <@ y
|
| (<@) [Owl_dense_complex] |
Shorthand for is_smaller x y , i.e., x <@ y
|
| (<@) [Owl_dense_real] |
Shorthand for is_smaller x y , i.e., x <@ y
|
| (=@) [Owl_sparse_complex] |
Shorthand for is_equal x y , i.e., x =@ y
|
| (=@) [Owl_sparse_real] |
Shorthand for is_equal x y , i.e., x =@ y
|
| (=@) [Owl_dense_complex] |
Shorthand for is_equal x y , i.e., x =@ y
|
| (=@) [Owl_dense_real] |
Shorthand for is_equal x y , i.e., x =@ y
|
| (>=@) [Owl_sparse_complex] |
Shorthand for equal_or_greater x y , i.e., x >=@ y
|
| (>=@) [Owl_sparse_real] |
Shorthand for equal_or_greater x y , i.e., x >=@ y
|
| (>=@) [Owl_dense_complex] |
Shorthand for equal_or_greater x y , i.e., x >=@ y
|
| (>=@) [Owl_dense_real] |
Shorthand for equal_or_greater x y , i.e., x >=@ y
|
| (>>) [Owl_dense_real] |
Shorthand for copy_to x y , i.e., x >> y
|
| (>@) [Owl_sparse_complex] |
Shorthand for is_greater x y , i.e., x >@ y
|
| (>@) [Owl_sparse_real] |
Shorthand for is_greater x y , i.e., x >@ y
|
| (>@) [Owl_dense_complex] |
Shorthand for is_greater x y , i.e., x >@ y
|
| (>@) [Owl_dense_real] |
Shorthand for is_greater x y , i.e., x >@ y
|
| (@=) [Owl_dense_real] |
Shorthand for concat_vertical x y , i.e., x @= y
|
| (@@) [Owl_sparse_complex] |
Shorthand for map f x , i.e., f @@ x
|
| (@@) [Owl_sparse_real] |
Shorthand for map f x , i.e., f @@ x
|
| (@@) [Owl_dense_complex] |
Shorthand for map f x , i.e., f @@ x
|
| (@@) [Owl_dense_real] |
Shorthand for map f x , i.e., f @@ x
|
| (@||) [Owl_dense_real] |
Shorthand for concat_horizontal x y , i.e., x @|| y
|
| _sgd_basic [Owl_optimise] |
Stochastic Gradient Descent (SGD) algorithm
b : batch size
s : step size
t : stop criteria
l : loss function
g : gradient function of the loss function
r : regularisation function
o : gradient fucntion of the regularisation function
a : weight on the regularisation term, common setting is 0.0001
i : whether to include intercept or not, default value is false
p : model parameters (k * m), each column is a classifier. So we have m classifier of k features.
x : data matrix (n x k), each row is a data point. So we have n datea points of k features each.
y : labeled data (n x m), n data points and each is labeled with m classifiers
|
| _triplet2crs [Owl_sparse_complex] |
|
A |
| abs [Owl_maths] |
|
| abs [Owl_sparse_complex] |
|
| abs [Owl_sparse_real] |
abs x returns a new matrix where each element has the absolute value of
that in the original matrix x .
|
| abs [Owl_dense_complex] |
|
| abs [Owl_dense_real] |
abs x returns a new matrix where each element has the absolute value of
that in the original matrix x .
|
| abs2 [Owl_dense_complex] |
|
| absdev [Owl_stats] |
|
| acos [Owl_maths] |
|
| acosh [Owl_maths] |
|
| acot [Owl_maths] |
|
| acre [Owl_const.CGSM] |
|
| acre [Owl_const.CGS] |
|
| acre [Owl_const.MKS] |
|
| acre [Owl_const.SI] |
|
| add [Owl_sparse_complex] |
|
| add [Owl_sparse_real] |
add x y adds two matrices x and y .
|
| add [Owl_dense_complex] |
|
| add [Owl_dense_real] |
add x y adds two matrices x and y .
|
| add_diag [Owl_dense_complex] |
|
| add_diag [Owl_dense_real] |
add_diag x a adds a constant a to all the diagonal elements in x .
|
| add_scalar [Owl_dense_complex] |
|
| add_scalar [Owl_dense_real] |
add_scalar x a adds every element in x by a constant factor a .
|
| airy_Ai [Owl_maths] |
|
| airy_Ai_deriv [Owl_maths] |
|
| airy_Ai_scaled [Owl_maths] |
|
| airy_Bi [Owl_maths] |
|
| airy_Bi_deriv [Owl_maths] |
|
| airy_Bi_scaled [Owl_maths] |
|
| airy_zero_Ai [Owl_maths] |
|
| airy_zero_Bi [Owl_maths] |
|
| angle_restrict_pos [Owl_maths] |
|
| angle_restrict_symm [Owl_maths] |
|
| angstrom [Owl_const.CGSM] |
|
| angstrom [Owl_const.CGS] |
|
| angstrom [Owl_const.MKS] |
|
| angstrom [Owl_const.SI] |
|
| area [Owl_plot] |
|
| array_iter2 [Owl_utils] |
|
| array_iter3 [Owl_utils] |
|
| array_map2i [Owl_utils] |
|
| array_sum [Owl_utils] |
|
| asin [Owl_maths] |
|
| asinh [Owl_maths] |
|
| astronomical_unit [Owl_const.CGSM] |
|
| astronomical_unit [Owl_const.CGS] |
|
| astronomical_unit [Owl_const.MKS] |
|
| astronomical_unit [Owl_const.SI] |
|
| atan [Owl_maths] |
|
| atanh [Owl_maths] |
|
| atanint [Owl_maths] |
|
| atto [Owl_const.Prefix] |
|
| autocorr [Owl_plot] |
|
| autocorrelation [Owl_stats] |
|
| average [Owl_sparse_complex] |
|
| average [Owl_sparse_real] |
average x returns the average value of all the elements in x .
|
| average [Owl_dense_complex] |
|
| average [Owl_dense_real] |
average x returns the average value of all the elements in x .
|
| average_cols [Owl_sparse_complex] |
|
| average_cols [Owl_sparse_real] |
average_cols x returns the average value of all column vectors in x .
|
| average_cols [Owl_dense_complex] |
|
| average_cols [Owl_dense_real] |
average_cols x returns the average value of all column vectors in x .
|
| average_rows [Owl_sparse_complex] |
|
| average_rows [Owl_sparse_real] |
average_rows x returns the average value of all row vectors in x .
|
| average_rows [Owl_dense_complex] |
|
| average_rows [Owl_dense_real] |
average_rows x returns the average value of all row vectors in x .
|
| avogadro [Owl_const.Prefix] |
|
B |
| bar [Owl_plot] |
|
| bar [Owl_const.CGSM] |
|
| bar [Owl_const.CGS] |
|
| bar [Owl_const.MKS] |
|
| bar [Owl_const.SI] |
|
| barn [Owl_const.CGSM] |
|
| barn [Owl_const.CGS] |
|
| barn [Owl_const.MKS] |
|
| barn [Owl_const.SI] |
|
| bernoulli [Owl_stats.Pdf] |
|
| bernoulli [Owl_stats.Rnd] |
|
| bessel_I0 [Owl_maths] |
|
| bessel_I0_scaled [Owl_maths] |
|
| bessel_I1 [Owl_maths] |
|
| bessel_I1_scaled [Owl_maths] |
|
| bessel_In [Owl_maths] |
|
| bessel_In_array [Owl_maths] |
|
| bessel_In_scaled [Owl_maths] |
|
| bessel_In_scaled_array [Owl_maths] |
|
| bessel_Inu [Owl_maths] |
|
| bessel_Inu_scaled [Owl_maths] |
|
| bessel_J0 [Owl_maths] |
|
| bessel_J1 [Owl_maths] |
|
| bessel_Jn [Owl_maths] |
|
| bessel_Jn_array [Owl_maths] |
|
| bessel_Jnu [Owl_maths] |
|
| bessel_K0 [Owl_maths] |
|
| bessel_K0_scaled [Owl_maths] |
|
| bessel_K1 [Owl_maths] |
|
| bessel_K1_scaled [Owl_maths] |
|
| bessel_Kn [Owl_maths] |
|
| bessel_Kn_array [Owl_maths] |
|
| bessel_Kn_scaled [Owl_maths] |
|
| bessel_Kn_scaled_array [Owl_maths] |
|
| bessel_Knu [Owl_maths] |
|
| bessel_Knu_scaled [Owl_maths] |
|
| bessel_Y0 [Owl_maths] |
|
| bessel_Y1 [Owl_maths] |
|
| bessel_Yn [Owl_maths] |
|
| bessel_Yn_array [Owl_maths] |
|
| bessel_Ynu [Owl_maths] |
|
| bessel_i0_scaled [Owl_maths] |
|
| bessel_i1_scaled [Owl_maths] |
|
| bessel_il_array_scaled [Owl_maths] |
|
| bessel_il_scaled [Owl_maths] |
|
| bessel_j0 [Owl_maths] |
|
| bessel_j1 [Owl_maths] |
|
| bessel_j2 [Owl_maths] |
|
| bessel_jl [Owl_maths] |
|
| bessel_jl_array [Owl_maths] |
|
| bessel_jl_steed_array [Owl_maths] |
|
| bessel_k0_scaled [Owl_maths] |
|
| bessel_k1_scaled [Owl_maths] |
|
| bessel_kl_array_scaled [Owl_maths] |
|
| bessel_kl_scaled [Owl_maths] |
|
| bessel_lnKnu [Owl_maths] |
|
| bessel_y0 [Owl_maths] |
|
| bessel_y1 [Owl_maths] |
|
| bessel_y2 [Owl_maths] |
|
| bessel_yl [Owl_maths] |
|
| bessel_yl_array [Owl_maths] |
|
| bessel_zero_J0 [Owl_maths] |
|
| bessel_zero_J1 [Owl_maths] |
|
| bessel_zero_Jnu [Owl_maths] |
|
| beta [Owl_stats.Pdf] |
|
| beta [Owl_stats.Rnd] |
|
| beta_P [Owl_stats.Cdf] |
|
| beta_Pinv [Owl_stats.Cdf] |
|
| beta_Q [Owl_stats.Cdf] |
|
| beta_Qinv [Owl_stats.Cdf] |
|
| beta_inc [Owl_maths] |
|
| betaf [Owl_maths] |
|
| bidiag [Owl_linalg] |
|
| binary [Owl_sparse_complex] |
|
| binary [Owl_sparse_real] |
binary m n creates an m by n random matrix where 10% ~ 15% elements are 1.
|
| binomial [Owl_stats.Pdf] |
|
| binomial [Owl_stats.Rnd] |
|
| binomial_P [Owl_stats.Cdf] |
|
| binomial_Q [Owl_stats.Cdf] |
|
| bivariate_gaussian [Owl_stats.Pdf] |
bivariate_gaussian x y sigma_x sigma_y rho returns the probability
density p(x,y) at (x,y) for a bivariate Gaussian distribution with standard
deviations sigma_x, sigma_y and correlation coefficient rho.
|
| bivariate_gaussian [Owl_stats.Rnd] |
bivariate_gaussian sigma_x sigma_y rho returns a pair of correlated
gaussian variates, with mean zero, correlation coefficient rho -1, 1 and
standard deviations sigma_x and sigma_y in the x and y directions.
|
| block [Owl_types.Dense_complex] |
|
| block [Owl_types.Dense_real] |
|
| bohr_magneton [Owl_const.CGSM] |
|
| bohr_magneton [Owl_const.MKS] |
|
| bohr_magneton [Owl_const.SI] |
|
| bohr_radius [Owl_const.CGSM] |
|
| bohr_radius [Owl_const.CGS] |
|
| bohr_radius [Owl_const.MKS] |
|
| bohr_radius [Owl_const.SI] |
|
| boltzmann [Owl_const.CGSM] |
|
| boltzmann [Owl_const.CGS] |
|
| boltzmann [Owl_const.MKS] |
|
| boltzmann [Owl_const.SI] |
|
| boxplot [Owl_plot] |
|
| btu [Owl_const.CGSM] |
|
| btu [Owl_const.CGS] |
|
| btu [Owl_const.MKS] |
|
| btu [Owl_const.SI] |
|
C |
| calorie [Owl_const.CGSM] |
|
| calorie [Owl_const.CGS] |
|
| calorie [Owl_const.MKS] |
|
| calorie [Owl_const.SI] |
|
| canadian_gallon [Owl_const.CGSM] |
|
| canadian_gallon [Owl_const.CGS] |
|
| canadian_gallon [Owl_const.MKS] |
|
| canadian_gallon [Owl_const.SI] |
|
| carat [Owl_const.CGSM] |
|
| carat [Owl_const.CGS] |
|
| carat [Owl_const.MKS] |
|
| carat [Owl_const.SI] |
|
| cauchy [Owl_stats.Pdf] |
|
| cauchy [Owl_stats.Rnd] |
|
| cauchy_P [Owl_stats.Cdf] |
|
| cauchy_Pinv [Owl_stats.Cdf] |
|
| cauchy_Q [Owl_stats.Cdf] |
|
| cauchy_Qinv [Owl_stats.Cdf] |
|
| centi [Owl_const.Prefix] |
|
| central_moment [Owl_stats] |
|
| chi [Owl_maths] |
|
| chisq [Owl_stats.Pdf] |
|
| chisq [Owl_stats.Rnd] |
|
| chisq_P [Owl_stats.Cdf] |
|
| chisq_Pinv [Owl_stats.Cdf] |
|
| chisq_Q [Owl_stats.Cdf] |
|
| chisq_Qinv [Owl_stats.Cdf] |
|
| cholesky [Owl_linalg] |
|
| choose [Owl_stats] |
choose x n draw n samples from x without replecement.
|
| ci [Owl_maths] |
|
| clausen [Owl_maths] |
|
| clone [Owl_sparse_complex] |
|
| clone [Owl_sparse_real] |
clone x makes an exact copy of matrix x .
|
| clone [Owl_dense_complex] |
|
| clone [Owl_dense_real] |
clone x returns a copy of matrix x .
|
| col [Owl_sparse_complex] |
|
| col [Owl_sparse_real] |
col x j returns the column j of x .
|
| col [Owl_dense_complex] |
|
| col [Owl_dense_real] |
col x j returns the column j of x .
|
| col_num [Owl_sparse_complex] |
|
| col_num [Owl_sparse_real] |
col_num x returns the number of columns in matrix x .
|
| col_num [Owl_dense_complex] |
|
| col_num [Owl_dense_real] |
col_num x returns the number of columns in matrix x .
|
| col_num_nz [Owl_sparse_complex] |
|
| col_num_nz [Owl_sparse_real] |
col_num_nz x returns the number of non-zero columns in matrix x .
|
| cols [Owl_sparse_complex] |
|
| cols [Owl_sparse_real] |
Similar to rows , cols x a returns the columns (specified in array a )
of x in a new sparse matrix.
|
| cols [Owl_dense_complex] |
|
| cols [Owl_dense_real] |
Similar to rows , cols x a returns the columns (specified in array a )
of x in a new dense matrix.
|
| combination [Owl_maths] |
|
| combination_iterator [Owl_maths] |
|
| concat_horizontal [Owl_dense_complex] |
|
| concat_horizontal [Owl_dense_real] |
concat_horizontal x y concats two matrices x and y horizontally,
therefore their row numbers must be the same.
|
| concat_vertical [Owl_dense_complex] |
|
| concat_vertical [Owl_dense_real] |
concat_vertical x y concats two matrices x and y vertically,
therefore their column numbers must be the same.
|
| constant_rate [Owl_optimise] |
|
| contour [Owl_plot] |
|
| copy_col_to [Owl_dense_complex] |
|
| copy_col_to [Owl_dense_real] |
copy_col_to v x j copies an 1 by n column vector v to the j th
column in an m by n matrix x .
|
| copy_row_to [Owl_dense_complex] |
|
| copy_row_to [Owl_dense_real] |
copy_row_to v x i copies an 1 by n row vector v to the i th row
in an m by n matrix x .
|
| copy_to [Owl_dense_complex] |
|
| copy_to [Owl_dense_real] |
copy_to x y copies the elements of x to y .
|
| correlation [Owl_stats] |
|
| cos [Owl_maths] |
|
| cos [Owl_dense_complex] |
|
| cosh [Owl_maths] |
|
| cot [Owl_maths] |
|
| covariance [Owl_stats] |
|
| create [Owl_pretty.Context] |
|
| create [Owl_plot] |
|
| create [Owl_dense_complex] |
|
| create [Owl_dense_real] |
create m n a creates an m by n matrix and all the elements of x are
initialised with the value a .
|
| csc [Owl_maths] |
|
| cup [Owl_const.CGSM] |
|
| cup [Owl_const.CGS] |
|
| cup [Owl_const.MKS] |
|
| cup [Owl_const.SI] |
|
| curie [Owl_const.CGSM] |
|
| curie [Owl_const.CGS] |
|
| curie [Owl_const.MKS] |
|
| curie [Owl_const.SI] |
|
D |
| data [Owl_types.Dense_complex] |
|
| data [Owl_types.Dense_real] |
|
| dawson [Owl_maths] |
|
| day [Owl_const.CGSM] |
|
| day [Owl_const.CGS] |
|
| day [Owl_const.MKS] |
|
| day [Owl_const.SI] |
|
| dc_mat_to_matptr [Owl_foreign] |
|
| dc_matptr_to_mat [Owl_foreign] |
|
| debye [Owl_const.MKS] |
|
| debye [Owl_const.SI] |
|
| debye_1 [Owl_maths] |
|
| debye_2 [Owl_maths] |
|
| debye_3 [Owl_maths] |
|
| debye_4 [Owl_maths] |
|
| debye_5 [Owl_maths] |
|
| debye_6 [Owl_maths] |
|
| deca [Owl_const.Prefix] |
|
| deci [Owl_const.Prefix] |
|
| decr_rate [Owl_optimise] |
|
| density [Owl_sparse_complex] |
|
| density [Owl_sparse_real] |
density x returns the density of non-zero element.
|
| det [Owl_linalg] |
det x computes the determinant of a matrix x from its LU decomposition.
|
| diag [Owl_sparse_complex] |
|
| diag [Owl_sparse_real] |
diag x returns the diagonal elements of x .
|
| diag [Owl_dense_complex] |
|
| diag [Owl_dense_real] |
diag x returns the diagonal elements of x .
|
| dilog [Owl_maths] |
|
| dir_2d [Owl_stats.Rnd] |
|
| dir_2d_trig_method [Owl_stats.Rnd] |
|
| dir_3d [Owl_stats.Rnd] |
|
| dir_nd [Owl_stats.Rnd] |
|
| dirichlet [Owl_stats.Pdf] |
|
| dirichlet [Owl_stats.Rnd] |
|
| dirichlet_lnpdf [Owl_stats.Pdf] |
|
| div [Owl_sparse_complex] |
|
| div [Owl_sparse_real] |
div x y performs an element-wise division, so both x and y
must have the same dimensions.
|
| div [Owl_dense_complex] |
|
| div [Owl_dense_real] |
div x y performs an element-wise division, so both x and y
must have the same dimensions.
|
| div_scalar [Owl_sparse_complex] |
|
| div_scalar [Owl_sparse_real] |
div_scalar x a divides every element in x by a constant factor a .
|
| div_scalar [Owl_dense_complex] |
|
| div_scalar [Owl_dense_real] |
div_scalar x a divides every element in x by a constant factor a .
|
| dot [Owl_sparse_complex] |
|
| dot [Owl_sparse_real] |
dot x y calculates the dot product of an m by n matrix x and
another n by p matrix y .
|
| dot [Owl_dense_complex] |
|
| dot [Owl_dense_real] |
dot x y calculates the dot product of an m by n matrix x and
another n by p matrix y .
|
| double_factorial [Owl_maths] |
|
| dr_allocate_col_vecptr [Owl_foreign] |
|
| dr_allocate_row_vecptr [Owl_foreign] |
|
| dr_allocate_vecptr [Owl_foreign] |
|
| dr_col_vec_to_mat [Owl_foreign] |
|
| dr_mat_to_matptr [Owl_foreign] |
|
| dr_matptr_to_mat [Owl_foreign] |
|
| draw_circle [Owl_plot] |
|
| draw_cols [Owl_sparse_complex] |
|
| draw_cols [Owl_sparse_real] |
draw_cols x m draws m cols randomly from x .
|
| draw_cols [Owl_dense_complex] |
|
| draw_cols [Owl_dense_real] |
draw_cols x m draws m cols randomly from x .
|
| draw_line [Owl_plot] |
|
| draw_rect [Owl_plot] |
|
| draw_rows [Owl_sparse_complex] |
|
| draw_rows [Owl_sparse_real] |
draw_rows x m draws m rows randomly from x .
|
| draw_rows [Owl_dense_complex] |
|
| draw_rows [Owl_dense_real] |
draw_rows x m draws m rows randomly from x .
|
| dyne [Owl_const.CGSM] |
|
| dyne [Owl_const.CGS] |
|
| dyne [Owl_const.MKS] |
|
| dyne [Owl_const.SI] |
|
E |
| ecdf [Owl_plot] |
|
| ecdf [Owl_stats] |
ecdf x returns (x',f) which are the empirical cumulative distribution
function f of x at points x' .
|
| elastic [Owl_optimise] |
Elastic net regularisation and its gradient
"a" is the weight on l1 regularisation term.
|
| elastic_grad [Owl_optimise] |
|
| electron_charge [Owl_const.CGSM] |
|
| electron_charge [Owl_const.MKS] |
|
| electron_charge [Owl_const.SI] |
|
| electron_magnetic_moment [Owl_const.CGSM] |
|
| electron_magnetic_moment [Owl_const.MKS] |
|
| electron_magnetic_moment [Owl_const.SI] |
|
| electron_volt [Owl_const.CGSM] |
|
| electron_volt [Owl_const.CGS] |
|
| electron_volt [Owl_const.MKS] |
|
| electron_volt [Owl_const.SI] |
|
| ellint_D [Owl_maths] |
|
| ellint_Dcomp [Owl_maths] |
|
| ellint_E [Owl_maths] |
|
| ellint_Ecomp [Owl_maths] |
|
| ellint_F [Owl_maths] |
|
| ellint_Kcomp [Owl_maths] |
|
| ellint_P [Owl_maths] |
|
| ellint_Pcomp [Owl_maths] |
|
| ellint_RC [Owl_maths] |
|
| ellint_RD [Owl_maths] |
|
| ellint_RF [Owl_maths] |
|
| ellint_RJ [Owl_maths] |
|
| ellipsis_default [Owl_pretty.Context] |
|
| empty [Owl_dense_complex] |
|
| empty [Owl_dense_real] |
empty m n creates an m by n matrix without initialising the values of
elements in x .
|
| equal_or_greater [Owl_sparse_complex] |
|
| equal_or_greater [Owl_sparse_real] |
equal_or_greater x y returns true if all the elements in x are not
smaller than the corresponding elements in y .
|
| equal_or_greater [Owl_dense_complex] |
|
| equal_or_greater [Owl_dense_real] |
equal_or_greater x y returns true if all the elements in x are not
smaller than the corresponding elements in y .
|
| equal_or_smaller [Owl_sparse_complex] |
|
| equal_or_smaller [Owl_sparse_real] |
equal_or_smaller x y returns true if all the elements in x are not
greater than the corresponding elements in y .
|
| equal_or_smaller [Owl_dense_complex] |
|
| equal_or_smaller [Owl_dense_real] |
equal_or_smaller x y returns true if all the elements in x are not
greater than the corresponding elements in y .
|
| erg [Owl_const.CGSM] |
|
| erg [Owl_const.CGS] |
|
| erg [Owl_const.MKS] |
|
| erg [Owl_const.SI] |
|
| error_bar [Owl_plot] |
|
| eta [Owl_maths] |
|
| eta_int [Owl_maths] |
|
| exa [Owl_const.Prefix] |
|
| exists [Owl_sparse_complex] |
|
| exists [Owl_sparse_real] |
exists f x checks all the elements in x using f .
|
| exists [Owl_dense_complex] |
|
| exists [Owl_dense_real] |
exists f x checks all the elements in x using f .
|
| exists_nz [Owl_sparse_complex] |
|
| exists_nz [Owl_sparse_real] |
exists_nz f x is similar to exists but only checks non-zero elements.
|
| exp [Owl_maths] |
|
| exp [Owl_dense_complex] |
|
| exp [Owl_dense_real] |
exp x applies exp function to each element in matrix x .
|
| exp_mult [Owl_maths] |
|
| expint_3 [Owl_maths] |
|
| expint_E1 [Owl_maths] |
|
| expint_E1_scaled [Owl_maths] |
|
| expint_E2 [Owl_maths] |
|
| expint_E2_scaled [Owl_maths] |
|
| expint_Ei [Owl_maths] |
|
| expint_Ei_scaled [Owl_maths] |
|
| expm1 [Owl_maths] |
|
| exponential [Owl_regression] |
Exponential regression: exponential x y fits the measurements x and the
observations y into a exponential model: y = a * exp^(-lambda * x) + b .
|
| exponential [Owl_stats.Pdf] |
exponential x mu returns the probability density at x
|
| exponential [Owl_stats.Rnd] |
exponential mu return a random value that follows exponential distribution.
|
| exponential_P [Owl_stats.Cdf] |
|
| exponential_Pinv [Owl_stats.Cdf] |
|
| exponential_Q [Owl_stats.Cdf] |
|
| exponential_Qinv [Owl_stats.Cdf] |
|
| exppow [Owl_stats.Pdf] |
|
| exppow [Owl_stats.Rnd] |
|
| exppow_P [Owl_stats.Cdf] |
|
| exppow_Q [Owl_stats.Cdf] |
|
| exprel [Owl_maths] |
|
| eye [Owl_sparse_complex] |
|
| eye [Owl_sparse_real] |
eye m creates an m by m identity matrix.
|
| eye [Owl_dense_complex] |
|
| eye [Owl_dense_real] |
eye m creates an m by m identity matrix.
|
F |
| factorial [Owl_maths] |
|
| faraday [Owl_const.CGSM] |
|
| faraday [Owl_const.MKS] |
|
| faraday [Owl_const.SI] |
|
| fathom [Owl_const.CGSM] |
|
| fathom [Owl_const.CGS] |
|
| fathom [Owl_const.MKS] |
|
| fathom [Owl_const.SI] |
|
| fdist [Owl_stats.Pdf] |
|
| fdist [Owl_stats.Rnd] |
|
| fdist_P [Owl_stats.Cdf] |
|
| fdist_Pinv [Owl_stats.Cdf] |
|
| fdist_Q [Owl_stats.Cdf] |
|
| fdist_Qinv [Owl_stats.Cdf] |
|
| femto [Owl_const.Prefix] |
|
| fermi_dirac_0 [Owl_maths] |
|
| fermi_dirac_1 [Owl_maths] |
|
| fermi_dirac_2 [Owl_maths] |
|
| fermi_dirac_3half [Owl_maths] |
|
| fermi_dirac_half [Owl_maths] |
|
| fermi_dirac_inc_0 [Owl_maths] |
|
| fermi_dirac_int [Owl_maths] |
|
| fermi_dirac_m1 [Owl_maths] |
|
| fermi_dirac_mhalf [Owl_maths] |
|
| fft [Owl_fft] |
fft x performs an FFT operation on matrix x .
|
| fft2 [Owl_fft] |
fft2 x performns a two-dimensional FFT on a real matrix x .
|
| fft2_complex [Owl_fft] |
fft2_complex x is similar to fft2 x but is performed on complex matrices.
|
| fft_complex [Owl_fft] |
fft_complex x is similar to fft x but is performed on complex matrices.
|
| fftshift [Owl_fft] |
fftshift x shifts the zero frequency component in the middle.
|
| filter [Owl_sparse_complex] |
|
| filter [Owl_sparse_real] |
Similar to filteri , but the coordinates of the elements are not passed to
the function f : float -> bool .
|
| filter [Owl_dense_complex] |
|
| filter [Owl_dense_real] |
Similar to filteri , but the coordinates of the elements are not passed to
the function f : float -> bool .
|
| filter_array [Owl_utils] |
|
| filter_cols [Owl_dense_complex] |
|
| filter_cols [Owl_dense_real] |
Similar to filteri_cols except that the column indices are not passed to f .
|
| filter_nz [Owl_sparse_complex] |
|
| filter_nz [Owl_sparse_real] |
filter_nz f x is similar to filteri_nz except that the coordinates of
matrix elements are not passed to f .
|
| filter_rows [Owl_dense_complex] |
|
| filter_rows [Owl_dense_real] |
Similar to filteri_rows except that the row indices are not passed to f .
|
| filteri [Owl_sparse_complex] |
|
| filteri [Owl_sparse_real] |
filteri f x uses f : int -> int -> float -> bool to filter out certain
elements in x .
|
| filteri [Owl_dense_complex] |
|
| filteri [Owl_dense_real] |
filteri f x uses f : int -> int -> float -> bool to filter out certain
elements in x .
|
| filteri_array [Owl_utils] |
|
| filteri_cols [Owl_dense_complex] |
|
| filteri_cols [Owl_dense_real] |
filteri_cols f x uses function f : int -> mat -> bool to check each
column in x , then returns an int array containing the indices of those
columns which satisfy the function f .
|
| filteri_nz [Owl_sparse_complex] |
|
| filteri_nz [Owl_sparse_real] |
filteri_nz f x is similar to filter f x but only applies f to
non-zero elements in x .
|
| filteri_rows [Owl_dense_complex] |
|
| filteri_rows [Owl_dense_real] |
filteri_rows f x uses function f : int -> mat -> bool to check each
row in x , then returns an int array containing the indices of those rows
which satisfy the function f .
|
| fine_structure [Owl_const.Prefix] |
|
| first_quartile [Owl_stats] |
first_quartile x returns the first quartile of x , i.e., 25 percentiles.
|
| flat [Owl_stats.Pdf] |
|
| flat [Owl_stats.Rnd] |
flat a b draws a random number from the interval [a,b) with a uniform
distribution.
|
| flat_P [Owl_stats.Cdf] |
|
| flat_Pinv [Owl_stats.Cdf] |
|
| flat_Q [Owl_stats.Cdf] |
|
| flat_Qinv [Owl_stats.Cdf] |
|
| fluid_ounce [Owl_const.CGSM] |
|
| fluid_ounce [Owl_const.CGS] |
|
| fluid_ounce [Owl_const.MKS] |
|
| fluid_ounce [Owl_const.SI] |
|
| fold [Owl_sparse_complex] |
|
| fold [Owl_sparse_real] |
fold f a x folds all the elements in x with the function
f : 'a -> float -> 'a .
|
| fold [Owl_dense_complex] |
|
| fold [Owl_dense_real] |
fold f a x folds all the elements in x with the function
f : 'a -> float -> 'a .
|
| fold_cols [Owl_sparse_complex] |
|
| fold_cols [Owl_sparse_real] |
fold_cols f a x folds all the columns in x using function f .
|
| fold_cols [Owl_dense_complex] |
|
| fold_cols [Owl_dense_real] |
fold_cols f a x folds all the columns in x using function f .
|
| fold_cols_nz [Owl_sparse_complex] |
|
| fold_cols_nz [Owl_sparse_real] |
fold_cols_nz f a x is similar to fold_cols but only folds non-zero
columns in x using function f .
|
| fold_nz [Owl_sparse_complex] |
|
| fold_nz [Owl_sparse_real] |
fold_nz f a x is similar to fold f a x but only applies to non-zero
rows in x .
|
| fold_rows [Owl_sparse_complex] |
|
| fold_rows [Owl_sparse_real] |
fold_rows f a x folds all the rows in x using function f .
|
| fold_rows [Owl_dense_complex] |
|
| fold_rows [Owl_dense_real] |
fold_rows f a x folds all the rows in x using function f .
|
| fold_rows_nz [Owl_sparse_complex] |
|
| fold_rows_nz [Owl_sparse_real] |
fold_rows_nz f a x is similar to fold_rows but only folds non-zero
rows in x using function f .
|
| foot [Owl_const.CGSM] |
|
| foot [Owl_const.CGS] |
|
| foot [Owl_const.MKS] |
|
| foot [Owl_const.SI] |
|
| footcandle [Owl_const.CGSM] |
|
| footcandle [Owl_const.CGS] |
|
| footcandle [Owl_const.MKS] |
|
| footcandle [Owl_const.SI] |
|
| footlambert [Owl_const.CGSM] |
|
| footlambert [Owl_const.CGS] |
|
| footlambert [Owl_const.MKS] |
|
| footlambert [Owl_const.SI] |
|
| for_all [Owl_sparse_complex] |
|
| for_all [Owl_sparse_real] |
for_all f x checks all the elements in x , the function returns true
if and only if all the elements pass the check of function f .
|
| for_all [Owl_dense_complex] |
|
| for_all [Owl_dense_real] |
for_all f x checks all the elements in x , the function returns true
if and only if all the elements pass the check of function f .
|
| for_all_nz [Owl_sparse_complex] |
|
| for_all_nz [Owl_sparse_real] |
for_all_nz f x is similar to for_all_nz but only checks non-zero elements.
|
G |
| gamma [Owl_stats.Pdf] |
|
| gamma [Owl_stats.Rnd] |
|
| gamma [Owl_maths] |
|
| gamma_P [Owl_stats.Cdf] |
|
| gamma_Pinv [Owl_stats.Cdf] |
|
| gamma_Q [Owl_stats.Cdf] |
|
| gamma_Qinv [Owl_stats.Cdf] |
|
| gamma_inc [Owl_maths] |
|
| gamma_inc_P [Owl_maths] |
|
| gamma_inc_Q [Owl_maths] |
|
| gammainv [Owl_maths] |
|
| gammastar [Owl_maths] |
|
| gauss [Owl_const.MKS] |
|
| gauss [Owl_const.SI] |
|
| gaussian [Owl_stats.Pdf] |
gaussian_pdf x sigma returns the probability density at x
|
| gaussian [Owl_stats.Rnd] |
gaussian ~sigma:s () returns the value of a random variable that
follows Normal distribution of sigma = s .
|
| gaussian [Owl_dense_complex] |
|
| gaussian [Owl_dense_real] |
gaussian m n creates an m by n matrix where all the elements in x
follow a Gaussian distribution with specified sigma.
|
| gaussian_P [Owl_stats.Cdf] |
|
| gaussian_Pinv [Owl_stats.Cdf] |
|
| gaussian_Q [Owl_stats.Cdf] |
|
| gaussian_Qinv [Owl_stats.Cdf] |
|
| gaussian_tail [Owl_stats.Pdf] |
gaussian_tail_pdf x a sigma returns the probability density at x given
a gaussian tail distribution of N(a, sigma)
|
| gaussian_tail [Owl_stats.Rnd] |
gaussian_tail a x sigma returns a random value of a gaussian tail
distribution.
|
| geometric [Owl_stats.Pdf] |
|
| geometric [Owl_stats.Rnd] |
|
| geometric_P [Owl_stats.Cdf] |
|
| geometric_Q [Owl_stats.Cdf] |
|
| get [Owl_sparse_complex] |
|
| get [Owl_sparse_real] |
get x i j returns the value of element (i,j) of x .
|
| get [Owl_dense_complex] |
|
| get [Owl_dense_real] |
get x i j returns the value of element (i,j) of x .
|
| get_suffix [Owl_utils] |
|
| gibbs_sampling [Owl_stats] |
TODO: gibbs_sampling f p n is Gibbs sampler.
|
| giga [Owl_const.Prefix] |
|
| gradient_descent [Owl_optimise] |
|
| gram_force [Owl_const.CGSM] |
|
| gram_force [Owl_const.CGS] |
|
| gram_force [Owl_const.MKS] |
|
| gram_force [Owl_const.SI] |
|
| grav_accel [Owl_const.CGSM] |
|
| grav_accel [Owl_const.CGS] |
|
| grav_accel [Owl_const.MKS] |
|
| grav_accel [Owl_const.SI] |
|
| gravitational_constant [Owl_const.CGSM] |
|
| gravitational_constant [Owl_const.CGS] |
|
| gravitational_constant [Owl_const.MKS] |
|
| gravitational_constant [Owl_const.SI] |
|
| gsl_matrix_alloc [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_complex_equal [Ffi_bindings.Bindings.Dense_complex] |
|
| gsl_matrix_complex_isneg [Ffi_bindings.Bindings.Dense_complex] |
|
| gsl_matrix_complex_isnonneg [Ffi_bindings.Bindings.Dense_complex] |
|
| gsl_matrix_complex_isnull [Ffi_bindings.Bindings.Dense_complex] |
|
| gsl_matrix_complex_ispos [Ffi_bindings.Bindings.Dense_complex] |
|
| gsl_matrix_equal [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_get_col [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_isneg [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_isnonneg [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_isnull [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_ispos [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_max [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_max_index [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_min [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_matrix_min_index [Ffi_bindings.Bindings.Dense_real] |
|
| gsl_spblas_dgemm [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_add [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_alloc [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_alloc_nzmax [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_compcol [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_d2sp [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_equal [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_get [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_memcpy [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_minmax [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_scale [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_set [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_set_zero [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_sp2d [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_spmatrix_transpose_memcpy [Ffi_bindings.Bindings.Sparse_real] |
|
| gsl_vector_alloc [Ffi_bindings.Bindings.Dense_real] |
|
| gumbel1 [Owl_stats.Pdf] |
|
| gumbel1 [Owl_stats.Rnd] |
|
| gumbel1_P [Owl_stats.Cdf] |
|
| gumbel1_Pinv [Owl_stats.Cdf] |
|
| gumbel1_Q [Owl_stats.Cdf] |
|
| gumbel1_Qinv [Owl_stats.Cdf] |
|
| gumbel2 [Owl_stats.Pdf] |
|
| gumbel2 [Owl_stats.Rnd] |
|
| gumbel2_P [Owl_stats.Cdf] |
|
| gumbel2_Pinv [Owl_stats.Cdf] |
|
| gumbel2_Q [Owl_stats.Cdf] |
|
| gumbel2_Qinv [Owl_stats.Cdf] |
|
H |
| heatmap [Owl_plot] |
|
| hectare [Owl_const.CGSM] |
|
| hectare [Owl_const.CGS] |
|
| hectare [Owl_const.MKS] |
|
| hectare [Owl_const.SI] |
|
| hecto [Owl_const.Prefix] |
|
| hinge2_grad [Owl_optimise] |
|
| hinge2_loss [Owl_optimise] |
squared hinge loss function
|
| hinge_grad [Owl_optimise] |
|
| hinge_loss [Owl_optimise] |
hinge loss function
|
| histogram [Owl_plot] |
|
| histogram [Owl_stats] |
|
| horizontal_default [Owl_pretty.Context] |
|
| horsepower [Owl_const.CGSM] |
|
| horsepower [Owl_const.CGS] |
|
| horsepower [Owl_const.MKS] |
|
| horsepower [Owl_const.SI] |
|
| hour [Owl_const.CGSM] |
|
| hour [Owl_const.CGS] |
|
| hour [Owl_const.MKS] |
|
| hour [Owl_const.SI] |
|
| hypergeometric [Owl_stats.Pdf] |
|
| hypergeometric [Owl_stats.Rnd] |
|
| hypergeometric_P [Owl_stats.Cdf] |
|
| hypergeometric_Q [Owl_stats.Cdf] |
|
| hypot [Owl_maths] |
|
| hzeta [Owl_maths] |
|
I |
| ifft [Owl_fft] |
ifft x performs the inverse operation of FFT on x .
|
| ifft2 [Owl_fft] |
ifft2 x performs the inverse operation of FFT on x , i.e., the inverse
function of both fft2 and fft2_complex .
|
| ifftshift [Owl_fft] |
ifftshift x undoes the results of fftshift x , it is the inverse operation
of fftshift .
|
| im [Owl_dense_complex] |
re x returns the complex parts of all the elements in x as a separate matrix.
|
| inch [Owl_const.CGSM] |
|
| inch [Owl_const.CGS] |
|
| inch [Owl_const.MKS] |
|
| inch [Owl_const.SI] |
|
| inch_of_mercury [Owl_const.CGSM] |
|
| inch_of_mercury [Owl_const.CGS] |
|
| inch_of_mercury [Owl_const.MKS] |
|
| inch_of_mercury [Owl_const.SI] |
|
| inch_of_water [Owl_const.CGSM] |
|
| inch_of_water [Owl_const.CGS] |
|
| inch_of_water [Owl_const.MKS] |
|
| inch_of_water [Owl_const.SI] |
|
| inv [Owl_linalg] |
A general square matrix A has an LU decomposition into upper and lower triangular matrices,
P A = L U where P is a permutation matrix, L is unit lower triangular matrix and U is upper triangular matrix.
|
| is_equal [Owl_sparse_complex] |
|
| is_equal [Owl_sparse_real] |
is_equal x y returns true if two matrices x and y are equal.
|
| is_equal [Owl_dense_complex] |
|
| is_equal [Owl_dense_real] |
is_equal x y returns true if two matrices x and y are equal.
|
| is_greater [Owl_sparse_complex] |
|
| is_greater [Owl_sparse_real] |
is_greater x y returns true if all the elements in x are greater than
the corresponding elements in y .
|
| is_greater [Owl_dense_complex] |
|
| is_greater [Owl_dense_real] |
is_greater x y returns true if all the elements in x are greater than
the corresponding elements in y .
|
| is_negative [Owl_sparse_complex] |
|
| is_negative [Owl_sparse_real] |
is_negative x returns true if all the elements in x are negative.
|
| is_negative [Owl_dense_complex] |
|
| is_negative [Owl_dense_real] |
is_negative x returns true if all the elements in x are negative.
|
| is_nonnegative [Owl_sparse_complex] |
|
| is_nonnegative [Owl_sparse_real] |
is_nonnegative returns true if all the elements in x are non-negative.
|
| is_nonnegative [Owl_dense_complex] |
|
| is_nonnegative [Owl_dense_real] |
is_nonnegative returns true if all the elements in x are non-negative.
|
| is_posdef [Owl_linalg] |
is_posdef x checks whether x is a positive semi-definite matrix.
|
| is_positive [Owl_sparse_complex] |
|
| is_positive [Owl_sparse_real] |
is_positive x returns true if all the elements in x are positive.
|
| is_positive [Owl_dense_complex] |
|
| is_positive [Owl_dense_real] |
is_positive x returns true if all the elements in x are positive.
|
| is_smaller [Owl_sparse_complex] |
|
| is_smaller [Owl_sparse_real] |
is_smaller x y returns true if all the elements in x are smaller than
the corresponding elements in y .
|
| is_smaller [Owl_dense_complex] |
|
| is_smaller [Owl_dense_real] |
is_smaller x y returns true if all the elements in x are smaller than
the corresponding elements in y .
|
| is_unequal [Owl_sparse_complex] |
|
| is_unequal [Owl_sparse_real] |
is_unequal x y returns true if there is at least one element in x is
not equal to that in y .
|
| is_unequal [Owl_dense_complex] |
|
| is_unequal [Owl_dense_real] |
is_unequal x y returns true if there is at least one element in x is
not equal to that in y .
|
| is_zero [Owl_sparse_complex] |
|
| is_zero [Owl_sparse_real] |
is_zero x returns true if all the elements in x are zeros.
|
| is_zero [Owl_dense_complex] |
|
| is_zero [Owl_dense_real] |
is_zero x returns true if all the elements in x are zeros.
|
| iter [Owl_sparse_complex] |
|
| iter [Owl_sparse_real] |
iter f x is the same as as iteri f x except the coordinates of the
current element is not passed to the function f : float -> 'a
|
| iter [Owl_dense_complex] |
|
| iter [Owl_dense_real] |
iter f x is the same as as iteri f x except the coordinates of the
current element is not passed to the function f : float -> 'a
|
| iter_cols [Owl_sparse_complex] |
|
| iter_cols [Owl_sparse_real] |
Similar to iteri_cols except col number is not passed to f .
|
| iter_cols [Owl_dense_complex] |
|
| iter_cols [Owl_dense_real] |
Similar to iteri_cols except col number is not passed to f .
|
| iter_cols_nz [Owl_sparse_complex] |
|
| iter_cols_nz [Owl_sparse_real] |
Similar to iteri_cols_nz except that column numbers are not passed to f .
|
| iter_nz [Owl_sparse_complex] |
|
| iter_nz [Owl_sparse_real] |
Similar to iter_nz except the coordinates of elements are not passed to f .
|
| iter_rows [Owl_sparse_complex] |
|
| iter_rows [Owl_sparse_real] |
Similar to iteri_rows except row number is not passed to f .
|
| iter_rows [Owl_dense_complex] |
|
| iter_rows [Owl_dense_real] |
Similar to iteri_rows except row number is not passed to f .
|
| iter_rows_nz [Owl_sparse_complex] |
|
| iter_rows_nz [Owl_sparse_real] |
Similar to iteri_rows_nz except that row numbers are not passed to f .
|
| iteri [Owl_sparse_complex] |
|
| iteri [Owl_sparse_real] |
iteri f x iterates all the elements in x and applies the user defined
function f : int -> int -> float -> 'a .
|
| iteri [Owl_dense_complex] |
|
| iteri [Owl_dense_real] |
iteri f x iterates all the elements in x and applies the user defined
function f : int -> int -> float -> 'a .
|
| iteri_cols [Owl_sparse_complex] |
|
| iteri_cols [Owl_sparse_real] |
iteri_cols f x iterates every column in x and applies function
f : int -> spmat -> unit to each of them.
|
| iteri_cols [Owl_dense_complex] |
|
| iteri_cols [Owl_dense_real] |
iteri_cols f x iterates every column in x and applies function
f : int -> mat -> unit to each of them.
|
| iteri_cols_nz [Owl_sparse_complex] |
|
| iteri_cols_nz [Owl_sparse_real] |
iteri_cols_nz f x is similar to iteri_cols but only applies f to
non-zero columns in x .
|
| iteri_nz [Owl_sparse_complex] |
|
| iteri_nz [Owl_sparse_real] |
iteri_nz f x iterates all the non-zero elements in x by applying the
function f : int -> int -> float -> 'a .
|
| iteri_rows [Owl_sparse_complex] |
|
| iteri_rows [Owl_sparse_real] |
iteri_rows f x iterates every row in x and applies function
f : int -> spmat -> unit to each of them.
|
| iteri_rows [Owl_dense_complex] |
|
| iteri_rows [Owl_dense_real] |
iteri_rows f x iterates every row in x and applies function
f : int -> mat -> unit to each of them.
|
| iteri_rows_nz [Owl_sparse_complex] |
|
| iteri_rows_nz [Owl_sparse_real] |
iteri_rows_nz f x is similar to iteri_rows but only applies f to
non-zero rows in x .
|
J |
| jb_test [Owl_stats] |
jb_test ~alpha x returns a test decision for the null hypothesis that the
data x comes from a normal distribution with an unknown mean and variance,
using the Jarque-Bera test.
|
| joule [Owl_const.CGSM] |
|
| joule [Owl_const.CGS] |
|
| joule [Owl_const.MKS] |
|
| joule [Owl_const.SI] |
|
K |
| kendall_tau [Owl_stats] |
|
| kilo [Owl_const.Prefix] |
|
| kilometers_per_hour [Owl_const.CGSM] |
|
| kilometers_per_hour [Owl_const.CGS] |
|
| kilometers_per_hour [Owl_const.MKS] |
|
| kilometers_per_hour [Owl_const.SI] |
|
| kilopound_force [Owl_const.CGSM] |
|
| kilopound_force [Owl_const.CGS] |
|
| kilopound_force [Owl_const.MKS] |
|
| kilopound_force [Owl_const.SI] |
|
| kmeans [Owl_optimise] |
K-means clustering algorithm
x is the row-based data points and c is the number of clusters.
|
| kmeans [Owl_regression] |
K-means clustering: kmeans x c divides x which is a row-based matrix
into c clusters.
|
| knot [Owl_const.CGSM] |
|
| knot [Owl_const.CGS] |
|
| knot [Owl_const.MKS] |
|
| knot [Owl_const.SI] |
|
| kurtosis [Owl_stats] |
kurtosis x return the Pearson's kurtosis of x .
|
L |
| l1 [Owl_optimise] |
L1 regularisation and its subgradient
|
| l1_grad [Owl_optimise] |
|
| l2 [Owl_optimise] |
L2 regularisation and its grandient
|
| l2_grad [Owl_optimise] |
|
| laguerre_1 [Owl_maths] |
|
| laguerre_2 [Owl_maths] |
|
| laguerre_3 [Owl_maths] |
|
| laguerre_n [Owl_maths] |
|
| lambert [Owl_const.CGSM] |
|
| lambert [Owl_const.CGS] |
|
| lambert [Owl_const.MKS] |
|
| lambert [Owl_const.SI] |
|
| lambert_w0 [Owl_maths] |
|
| lambert_w1 [Owl_maths] |
|
| landau [Owl_stats.Pdf] |
|
| landau [Owl_stats.Rnd] |
|
| laplace [Owl_stats.Pdf] |
|
| laplace [Owl_stats.Rnd] |
|
| laplace_P [Owl_stats.Cdf] |
|
| laplace_Pinv [Owl_stats.Cdf] |
|
| laplace_Q [Owl_stats.Cdf] |
|
| laplace_Qinv [Owl_stats.Cdf] |
|
| lasso [Owl_regression] |
LASSO regression: in lasso ~i ~a x y , i : whether or not to include
intercept bias in parameters, the default is true ; a : the weight on the
regularisation term; x is the measurements, and y is the observations.
|
| lasso_regression [Owl_optimise] |
Lasso regression
i : whether to include intercept bias in parameters
a : weight on the regularisation term
TODO: how to choose a automatically
|
| legend_off [Owl_plot] |
|
| legend_on [Owl_plot] |
|
| legendre_P1 [Owl_maths] |
|
| legendre_P2 [Owl_maths] |
|
| legendre_P3 [Owl_maths] |
|
| legendre_Pl [Owl_maths] |
|
| legendre_Pl_array [Owl_maths] |
|
| legendre_Q0 [Owl_maths] |
|
| legendre_Q1 [Owl_maths] |
|
| legendre_Ql [Owl_maths] |
|
| levy [Owl_stats.Rnd] |
|
| levy_skew [Owl_stats.Rnd] |
|
| light_year [Owl_const.CGSM] |
|
| light_year [Owl_const.CGS] |
|
| light_year [Owl_const.MKS] |
|
| light_year [Owl_const.SI] |
|
| linear [Owl_regression] |
Linear regression: linear ~i x y fits the measurements x and the
observations y into a linear model.
|
| linspace [Owl_sparse_real] |
linspace a b n linearly divides the interval [a,b] into n pieces by
creating an m by 1 row vector.
|
| linspace [Owl_dense_real] |
linspace a b n linearly divides the interval [a,b] into n pieces by
creating an m by 1 row vector.
|
| liter [Owl_const.CGSM] |
|
| liter [Owl_const.CGS] |
|
| liter [Owl_const.MKS] |
|
| liter [Owl_const.SI] |
|
| ln [Owl_maths] |
|
| ln1p [Owl_maths] |
|
| ln_abs [Owl_maths] |
|
| ln_combination [Owl_maths] |
|
| ln_double_factorial [Owl_maths] |
|
| ln_factorial [Owl_maths] |
|
| lnbeta [Owl_maths] |
|
| lncosh [Owl_maths] |
|
| lngamma [Owl_maths] |
|
| lnpoch [Owl_maths] |
|
| lnsinh [Owl_maths] |
|
| load [Owl_sparse_complex] |
|
| load [Owl_sparse_real] |
load f loads a sparse matrix from file f .
|
| load [Owl_dense_complex] |
|
| load [Owl_dense_real] |
load f loads a sparse matrix from file f .
|
| load_txt [Owl_dense_real] |
load_txt f load a text file f into a matrix.
|
| log [Owl_maths] |
|
| log [Owl_dense_complex] |
|
| log [Owl_dense_real] |
log x applies log function to each element in matrix x .
|
| log10 [Owl_maths] |
|
| log10 [Owl_dense_complex] |
|
| log10 [Owl_dense_real] |
log10 x applies log10 function to each element in matrix x .
|
| log2 [Owl_maths] |
|
| log_grad [Owl_optimise] |
|
| log_loss [Owl_optimise] |
|
| logarithmic [Owl_stats.Pdf] |
|
| logarithmic [Owl_stats.Rnd] |
|
| logistic [Owl_regression] |
Logistic regression: in logistic ~i x y , i : whether or not to include
intercept bias in parameters, the default is true ; ; x is the
measurements, and y is the observations.
|
| logistic [Owl_stats.Pdf] |
|
| logistic [Owl_stats.Rnd] |
|
| logistic_P [Owl_stats.Cdf] |
|
| logistic_Pinv [Owl_stats.Cdf] |
|
| logistic_Q [Owl_stats.Cdf] |
|
| logistic_Qinv [Owl_stats.Cdf] |
|
| logistic_regression [Owl_optimise] |
Logistic regression
i : whether to include intercept bias in parameters
a : weight on the regularisation term
note that the values in y are either +1 or 0.
|
| lognormal [Owl_stats.Pdf] |
|
| lognormal [Owl_stats.Rnd] |
|
| lognormal_P [Owl_stats.Cdf] |
|
| lognormal_Pinv [Owl_stats.Cdf] |
|
| lognormal_Q [Owl_stats.Cdf] |
|
| lognormal_Qinv [Owl_stats.Cdf] |
|
| lsc [Owl_pretty.Toplevel] |
|
| lumen [Owl_const.CGSM] |
|
| lumen [Owl_const.CGS] |
|
| lumen [Owl_const.MKS] |
|
| lumen [Owl_const.SI] |
|
| lux [Owl_const.CGSM] |
|
| lux [Owl_const.CGS] |
|
| lux [Owl_const.MKS] |
|
| lux [Owl_const.SI] |
|
M |
| map [Owl_sparse_complex] |
|
| map [Owl_sparse_real] |
map f x is similar to mapi f x except the coordinates of the
current element is not passed to the function f : float -> float
|
| map [Owl_dense_complex] |
|
| map [Owl_dense_real] |
map f x is similar to mapi f x except the coordinates of the
current element is not passed to the function f : float -> float
|
| map_array [Owl_utils] |
|
| map_at_col [Owl_dense_complex] |
|
| map_at_col [Owl_dense_real] |
map_at_col f x i is similar to mapi_at_col except that the coordinates
of an element is not passed to f .
|
| map_at_row [Owl_dense_complex] |
|
| map_at_row [Owl_dense_real] |
map_at_row f x i is similar to mapi_at_row except that the coordinates
of an element is not passed to f .
|
| map_by_col [Owl_dense_complex] |
|
| map_by_col [Owl_dense_real] |
map_by_col f x i is similar to mapi_by_col except that the column
indices are not passed to f .
|
| map_by_row [Owl_dense_complex] |
|
| map_by_row [Owl_dense_real] |
map_by_row f x i is similar to mapi_by_row except that the row indices
are not passed to f .
|
| map_cols [Owl_sparse_complex] |
|
| map_cols [Owl_sparse_real] |
Similar to mapi_cols except column number is not passed to f .
|
| map_cols [Owl_dense_complex] |
|
| map_cols [Owl_dense_real] |
Similar to mapi_cols except column number is not passed to f .
|
| map_cols_nz [Owl_sparse_complex] |
|
| map_cols_nz [Owl_sparse_real] |
Similar to mapi_cols_nz , but columns numbers are not passed to f .
|
| map_nz [Owl_sparse_complex] |
|
| map_nz [Owl_sparse_real] |
Similar to mapi_nz except the coordinates of elements are not passed to f .
|
| map_rows [Owl_sparse_complex] |
|
| map_rows [Owl_sparse_real] |
Similar to mapi_rows except row number is not passed to f .
|
| map_rows [Owl_dense_complex] |
|
| map_rows [Owl_dense_real] |
Similar to mapi_rows except row number is not passed to f .
|
| map_rows_nz [Owl_sparse_complex] |
|
| map_rows_nz [Owl_sparse_real] |
Similar to mapi_rows_nz , but row numbers are not passed to f .
|
| mapi [Owl_sparse_complex] |
|
| mapi [Owl_sparse_real] |
mapi f x maps each element in x to a new value by applying
f : int -> int -> float -> float .
|
| mapi [Owl_dense_complex] |
|
| mapi [Owl_dense_real] |
mapi f x maps each element in x to a new value by applying
f : int -> int -> float -> float .
|
| mapi_array [Owl_utils] |
|
| mapi_at_col [Owl_dense_complex] |
|
| mapi_at_col [Owl_dense_real] |
mapi_at_col f x j creates a new matrix by applying function f only to
the j th column in matrix x .
|
| mapi_at_row [Owl_dense_complex] |
|
| mapi_at_row [Owl_dense_real] |
mapi_at_row f x i creates a new matrix by applying function f only to
the i th row in matrix x .
|
| mapi_by_col [Owl_dense_complex] |
|
| mapi_by_col [Owl_dense_real] |
mapi_by_col f x applies f to each column of x , then uses the returned
column vectors to assemble a new matrix.
|
| mapi_by_row [Owl_dense_complex] |
|
| mapi_by_row [Owl_dense_real] |
mapi_by_row f x applies f to each row of x , then uses the returned
row vectors to assemble a new matrix.
|
| mapi_cols [Owl_sparse_complex] |
|
| mapi_cols [Owl_sparse_real] |
mapi_cols f x maps every column in x to a type 'a value by applying
function f : int -> spmat -> 'a .
|
| mapi_cols [Owl_dense_complex] |
|
| mapi_cols [Owl_dense_real] |
mapi_cols f x maps every column in x to a type 'a value by applying
function f : int -> mat -> 'a .
|
| mapi_cols_nz [Owl_sparse_complex] |
|
| mapi_cols_nz [Owl_sparse_real] |
mapi_cols_nz f x applies f only to the non-zero columns in x .
|
| mapi_nz [Owl_sparse_complex] |
|
| mapi_nz [Owl_sparse_real] |
mapi_nz f x is similar to mapi f x but only applies f to non-zero
elements in x .
|
| mapi_rows [Owl_sparse_complex] |
|
| mapi_rows [Owl_sparse_real] |
mapi_rows f x maps every row in x to a type 'a value by applying
function f : int -> spmat -> 'a to each of them.
|
| mapi_rows [Owl_dense_complex] |
|
| mapi_rows [Owl_dense_real] |
mapi_rows f x maps every row in x to a type 'a value by applying
function f : int -> mat -> 'a to each of them.
|
| mapi_rows_nz [Owl_sparse_complex] |
|
| mapi_rows_nz [Owl_sparse_real] |
mapi_rows_nz f x applies f only to the non-zero rows in x .
|
| mass_electron [Owl_const.CGSM] |
|
| mass_electron [Owl_const.CGS] |
|
| mass_electron [Owl_const.MKS] |
|
| mass_electron [Owl_const.SI] |
|
| mass_muon [Owl_const.CGSM] |
|
| mass_muon [Owl_const.CGS] |
|
| mass_muon [Owl_const.MKS] |
|
| mass_muon [Owl_const.SI] |
|
| mass_neutron [Owl_const.CGSM] |
|
| mass_neutron [Owl_const.CGS] |
|
| mass_neutron [Owl_const.MKS] |
|
| mass_neutron [Owl_const.SI] |
|
| mass_proton [Owl_const.CGSM] |
|
| mass_proton [Owl_const.CGS] |
|
| mass_proton [Owl_const.MKS] |
|
| mass_proton [Owl_const.SI] |
|
| mat_struct [Ffi_bindings.Bindings.Dense_complex] |
|
| mat_struct [Ffi_bindings.Bindings.Dense_real] |
|
| mat_struct [Owl_types.Dense_complex] |
|
| mat_struct [Owl_types.Dense_real] |
|
| max [Owl_stats] |
|
| max [Owl_sparse_complex] |
|
| max [Owl_sparse_real] |
max x returns the maximum value of all elements in x .
|
| max [Owl_dense_real] |
max x returns the maximum value of all elements in x .
|
| max_cols [Owl_dense_real] |
min_cols x returns the minimum value in each column along with their coordinates.
|
| max_i [Owl_stats] |
|
| max_rows [Owl_dense_real] |
max_rows x returns the maximum value in each row along with their coordinates.
|
| mblk_struct [Owl_types.Dense_complex] |
|
| mblk_struct [Owl_types.Dense_real] |
|
| mdata [Owl_types.Dense_complex] |
|
| mdata [Owl_types.Dense_real] |
|
| mean [Owl_stats] |
|
| median [Owl_stats] |
median x returns the median of x .
|
| mega [Owl_const.Prefix] |
|
| mesh [Owl_plot] |
|
| meshgrid [Owl_dense_real] |
meshgrid a1 b1 a2 b2 n1 n2 is similar to the meshgrid function in
Matlab.
|
| meshup [Owl_dense_real] |
meshup x y creates mesh grids by using two row vectors x and y .
|
| meter_of_mercury [Owl_const.CGSM] |
|
| meter_of_mercury [Owl_const.CGS] |
|
| meter_of_mercury [Owl_const.MKS] |
|
| meter_of_mercury [Owl_const.SI] |
|
| metric_ton [Owl_const.CGSM] |
|
| metric_ton [Owl_const.CGS] |
|
| metric_ton [Owl_const.MKS] |
|
| metric_ton [Owl_const.SI] |
|
| metropolis_hastings [Owl_stats] |
TODO: metropolis_hastings f p n is Metropolis-Hastings MCMC algorithm.
|
| micro [Owl_const.Prefix] |
|
| micron [Owl_const.CGSM] |
|
| micron [Owl_const.CGS] |
|
| micron [Owl_const.MKS] |
|
| micron [Owl_const.SI] |
|
| mil [Owl_const.CGSM] |
|
| mil [Owl_const.CGS] |
|
| mil [Owl_const.MKS] |
|
| mil [Owl_const.SI] |
|
| mile [Owl_const.CGSM] |
|
| mile [Owl_const.CGS] |
|
| mile [Owl_const.MKS] |
|
| mile [Owl_const.SI] |
|
| miles_per_hour [Owl_const.CGSM] |
|
| miles_per_hour [Owl_const.CGS] |
|
| miles_per_hour [Owl_const.MKS] |
|
| miles_per_hour [Owl_const.SI] |
|
| milli [Owl_const.Prefix] |
|
| min [Owl_stats] |
|
| min [Owl_sparse_complex] |
|
| min [Owl_sparse_real] |
min x returns the minimum value of all elements in x .
|
| min [Owl_dense_real] |
min x returns the minimum value of all elements in x .
|
| min_cols [Owl_dense_real] |
min_cols x returns the minimum value in each column along with their coordinates.
|
| min_i [Owl_stats] |
|
| min_rows [Owl_dense_real] |
min_rows x returns the minimum value in each row along with their coordinates.
|
| minmax [Owl_stats] |
|
| minmax [Owl_sparse_complex] |
|
| minmax [Owl_sparse_real] |
minmax x returns both the minimum and minimum values in x .
|
| minmax [Owl_dense_real] |
minmax x returns both the minimum and minimum values in x .
|
| minmax_i [Owl_stats] |
|
| minute [Owl_const.CGSM] |
|
| minute [Owl_const.CGS] |
|
| minute [Owl_const.MKS] |
|
| minute [Owl_const.SI] |
|
| molar_gas [Owl_const.CGSM] |
|
| molar_gas [Owl_const.CGS] |
|
| molar_gas [Owl_const.MKS] |
|
| molar_gas [Owl_const.SI] |
|
| msize [Owl_types.Dense_complex] |
|
| msize [Owl_types.Dense_real] |
|
| mul [Owl_sparse_complex] |
|
| mul [Owl_sparse_real] |
mul x y performs an element-wise multiplication, so both x and y
must have the same dimensions.
|
| mul [Owl_dense_complex] |
|
| mul [Owl_dense_real] |
mul x y performs an element-wise multiplication, so both x and y
must have the same dimensions.
|
| mul_scalar [Owl_sparse_complex] |
|
| mul_scalar [Owl_sparse_real] |
mul_scalar x a multiplies every element in x by a constant factor a .
|
| mul_scalar [Owl_dense_complex] |
|
| mul_scalar [Owl_dense_real] |
mul_scalar x a multiplies every element in x by a constant factor a .
|
| multinomial [Owl_stats.Pdf] |
|
| multinomial [Owl_stats.Rnd] |
|
| multinomial_lnpdf [Owl_stats.Pdf] |
|
N |
| nano [Owl_const.Prefix] |
|
| nautical_mile [Owl_const.CGSM] |
|
| nautical_mile [Owl_const.CGS] |
|
| nautical_mile [Owl_const.MKS] |
|
| nautical_mile [Owl_const.SI] |
|
| neg [Owl_sparse_complex] |
|
| neg [Owl_sparse_real] |
neg x returns a new matrix where each element has the negative value of
that in the original matrix x .
|
| neg [Owl_dense_complex] |
|
| neg [Owl_dense_real] |
neg x returns a new matrix where each element has the negative value of
that in the original matrix x .
|
| negative_binomial [Owl_stats.Pdf] |
|
| negative_binomial [Owl_stats.Rnd] |
|
| negative_binomial_P [Owl_stats.Cdf] |
|
| negative_binomial_Q [Owl_stats.Cdf] |
|
| newton [Owl_const.CGSM] |
|
| newton [Owl_const.CGS] |
|
| newton [Owl_const.MKS] |
|
| newton [Owl_const.SI] |
|
| nnz [Owl_sparse_complex] |
|
| nnz [Owl_sparse_real] |
nnz x returns the number of non-zero elements in matrix x .
|
| nnz_cols [Owl_sparse_complex] |
|
| nnz_cols [Owl_sparse_real] |
nnz_cols x returns the number of non-zero cols in matrix x .
|
| nnz_rows [Owl_sparse_complex] |
|
| nnz_rows [Owl_sparse_real] |
nnz_rows x returns the number of non-zero rows in matrix x .
|
| nonlinear [Owl_regression] |
Nonlinear regression: nonlinear f p x y fits the measurements x and the
observations y into a user-defined nonlinear model.
|
| noreg [Owl_optimise] |
No regularisation and its gradient
|
| noreg_grad [Owl_optimise] |
|
| normlise_pdf [Owl_stats] |
|
| not_exists [Owl_sparse_complex] |
|
| not_exists [Owl_sparse_real] |
not_exists f x checks all the elements in x , the function returns
true only if all the elements fail to satisfy f : float -> bool .
|
| not_exists [Owl_dense_complex] |
|
| not_exists [Owl_dense_real] |
not_exists f x checks all the elements in x , the function returns
true only if all the elements fail to satisfy f : float -> bool .
|
| not_exists_nz [Owl_sparse_complex] |
|
| not_exists_nz [Owl_sparse_real] |
not_exists_nz f x is similar to not_exists but only checks non-zero elements.
|
| nuclear_magneton [Owl_const.CGSM] |
|
| nuclear_magneton [Owl_const.MKS] |
|
| nuclear_magneton [Owl_const.SI] |
|
| numel [Owl_sparse_complex] |
|
| numel [Owl_sparse_real] |
numel x returns the number of elements in matrix x .
|
| numel [Owl_dense_complex] |
|
| numel [Owl_dense_real] |
numel x returns the number of elements in matrix x .
|
| numerical_gradient [Owl_optimise] |
a numberical way of calculating gradient.
x is a k x m matrix containing m classifiers of k features.
|
O |
| of_array [Owl_dense_complex] |
|
| of_array [Owl_dense_real] |
of_array x m n converts a float array x into an m by n matrix.
|
| of_arrays [Owl_dense_complex] |
|
| of_arrays [Owl_dense_real] |
of_arrays x converts an array of m float arrays (of length n ) in to
an m by n matrix.
|
| of_dense [Owl_sparse_complex] |
|
| of_dense [Owl_sparse_real] |
of_dense x returns a sparse matrix from the dense matrix x .
|
| ols [Owl_regression] |
Ordinary Least Square regression: in ols ~i x y , i : whether or not to
include intercept bias in parameters, the default is true ; ; x is the
measurements, and y is the observations.
|
| ols_regression [Owl_optimise] |
Ordinary Least Square regression
i : whether to include intercept bias in parameters
|
| ones [Owl_sparse_complex] |
|
| ones [Owl_sparse_real] |
ones m n creates an m by n matrix where all the elements are ones.
|
| ones [Owl_dense_complex] |
|
| ones [Owl_dense_real] |
ones m n creates an m by n matrix where all the elements are ones.
|
| optimal_rate [Owl_optimise] |
|
| ounce_mass [Owl_const.CGSM] |
|
| ounce_mass [Owl_const.CGS] |
|
| ounce_mass [Owl_const.MKS] |
|
| ounce_mass [Owl_const.SI] |
|
| output [Owl_plot] |
|
| owner [Owl_types.Dense_complex] |
|
| owner [Owl_types.Dense_real] |
|
P |
| pareto [Owl_stats.Pdf] |
|
| pareto [Owl_stats.Rnd] |
|
| pareto_P [Owl_stats.Cdf] |
|
| pareto_Pinv [Owl_stats.Cdf] |
|
| pareto_Q [Owl_stats.Cdf] |
|
| pareto_Qinv [Owl_stats.Cdf] |
|
| parsec [Owl_const.CGSM] |
|
| parsec [Owl_const.CGS] |
|
| parsec [Owl_const.MKS] |
|
| parsec [Owl_const.SI] |
|
| pascal [Owl_stats.Pdf] |
|
| pascal [Owl_stats.Rnd] |
|
| pascal_P [Owl_stats.Cdf] |
|
| pascal_Q [Owl_stats.Cdf] |
|
| pearson_r [Owl_stats] |
|
| percentile [Owl_stats] |
percentile x p returns the p percentile of the data x .
|
| permutation [Owl_maths] |
|
| permutation_iterator [Owl_maths] |
|
| permutation_matrix [Owl_sparse_complex] |
|
| permutation_matrix [Owl_sparse_real] |
permutation_matrix m returns an m by m permutation matrix.
|
| peta [Owl_const.Prefix] |
|
| phot [Owl_const.CGSM] |
|
| phot [Owl_const.CGS] |
|
| phot [Owl_const.MKS] |
|
| phot [Owl_const.SI] |
|
| pi [Owl_maths] |
|
| pico [Owl_const.Prefix] |
|
| pie [Owl_plot] |
|
| pint [Owl_const.CGSM] |
|
| pint [Owl_const.CGS] |
|
| pint [Owl_const.MKS] |
|
| pint [Owl_const.SI] |
|
| plancks_constant_h [Owl_const.CGSM] |
|
| plancks_constant_h [Owl_const.CGS] |
|
| plancks_constant_h [Owl_const.MKS] |
|
| plancks_constant_h [Owl_const.SI] |
|
| plancks_constant_hbar [Owl_const.CGSM] |
|
| plancks_constant_hbar [Owl_const.CGS] |
|
| plancks_constant_hbar [Owl_const.MKS] |
|
| plancks_constant_hbar [Owl_const.SI] |
|
| plot [Owl_plot] |
|
| plot3d [Owl_plot] |
plot3d is just an alias of surf function.
|
| plot_fun [Owl_plot] |
|
| poch [Owl_maths] |
|
| pochrel [Owl_maths] |
|
| point [Owl_const.CGSM] |
|
| point [Owl_const.CGS] |
|
| point [Owl_const.MKS] |
|
| point [Owl_const.SI] |
|
| poise [Owl_const.CGSM] |
|
| poise [Owl_const.CGS] |
|
| poise [Owl_const.MKS] |
|
| poise [Owl_const.SI] |
|
| poisson [Owl_stats.Pdf] |
|
| poisson [Owl_stats.Rnd] |
|
| poisson_P [Owl_stats.Cdf] |
|
| poisson_Q [Owl_stats.Cdf] |
|
| polar_of_rect [Owl_maths] |
|
| polynomial [Owl_regression] |
polynomial regression: polynomial x y d fits the measurements x and the
observations y into a polynomial model.
|
| pound_force [Owl_const.CGSM] |
|
| pound_force [Owl_const.CGS] |
|
| pound_force [Owl_const.MKS] |
|
| pound_force [Owl_const.SI] |
|
| pound_mass [Owl_const.CGSM] |
|
| pound_mass [Owl_const.CGS] |
|
| pound_mass [Owl_const.MKS] |
|
| pound_mass [Owl_const.SI] |
|
| poundal [Owl_const.CGSM] |
|
| poundal [Owl_const.CGS] |
|
| poundal [Owl_const.MKS] |
|
| poundal [Owl_const.SI] |
|
| pow [Owl_maths] |
|
| power [Owl_sparse_complex] |
|
| power [Owl_sparse_real] |
power x a calculates the power of a of each element in x .
|
| power [Owl_dense_complex] |
|
| power [Owl_dense_real] |
power x a calculates the power of a of each element in x .
|
| pp_cmat [Owl_pretty.Toplevel] |
|
| pp_cmat [Owl_pretty] |
|
| pp_complex_el_default [Owl_pretty] |
fprintf ppf "(%G, %Gi)" el.re el.im
|
| pp_cvec [Owl_pretty.Toplevel] |
|
| pp_cvec [Owl_pretty] |
|
| pp_dsmat [Owl_dense_complex] |
|
| pp_dsmat [Owl_dense_real] |
pp_spmat x pretty prints matrix x with headings.
|
| pp_float_el_default [Owl_pretty] |
fprintf ppf "%G" el
|
| pp_fmat [Owl_pretty.Toplevel] |
|
| pp_fmat [Owl_pretty] |
|
| pp_fvec [Owl_pretty.Toplevel] |
|
| pp_fvec [Owl_pretty] |
|
| pp_imat [Owl_pretty.Toplevel] |
|
| pp_imat [Owl_pretty] |
|
| pp_int32_el [Owl_pretty] |
fprintf ppf "%ld" el
|
| pp_ivec [Owl_pretty.Toplevel] |
|
| pp_ivec [Owl_pretty] |
|
| pp_labeled_cmat [Owl_pretty] |
|
| pp_labeled_cvec [Owl_pretty] |
|
| pp_labeled_fmat [Owl_pretty] |
|
| pp_labeled_fvec [Owl_pretty] |
|
| pp_labeled_imat [Owl_pretty] |
|
| pp_labeled_ivec [Owl_pretty] |
|
| pp_labeled_rcvec [Owl_pretty] |
|
| pp_labeled_rfvec [Owl_pretty] |
|
| pp_labeled_rivec [Owl_pretty] |
|
| pp_lcmat [Owl_pretty] |
|
| pp_lcvec [Owl_pretty] |
|
| pp_lfmat [Owl_pretty] |
|
| pp_lfvec [Owl_pretty] |
|
| pp_limat [Owl_pretty] |
|
| pp_livec [Owl_pretty] |
|
| pp_mat_gen [Owl_pretty] |
pp_mat_gen
?pp_open ?pp_close ?pp_head ?pp_foot ?pp_end_row ?pp_end_col
?pp_left ?pp_right ?pad pp_el ppf mat
|
| pp_ocmat [Owl_pretty] |
|
| pp_ocvec [Owl_pretty] |
|
| pp_ofmat [Owl_pretty] |
|
| pp_ofvec [Owl_pretty] |
|
| pp_oimat [Owl_pretty] |
|
| pp_oivec [Owl_pretty] |
|
| pp_omat [Owl_pretty] |
pp_omat ppf pp_el mat prints matrix mat to formatter ppf
in OCaml-style using the element printer pp_el .
|
| pp_ovec [Owl_pretty] |
pp_ovec ppf pp_el vec prints the column vector vec to formatter
ppf in OCaml-style using the element printer pp_el .
|
| pp_rcvec [Owl_pretty.Toplevel] |
|
| pp_rcvec [Owl_pretty] |
|
| pp_rfvec [Owl_pretty.Toplevel] |
|
| pp_rfvec [Owl_pretty] |
|
| pp_rivec [Owl_pretty.Toplevel] |
|
| pp_rivec [Owl_pretty] |
|
| pp_rlcvec [Owl_pretty] |
|
| pp_rlfvec [Owl_pretty] |
|
| pp_rlivec [Owl_pretty] |
|
| pp_rocvec [Owl_pretty] |
|
| pp_rofvec [Owl_pretty] |
|
| pp_roivec [Owl_pretty] |
|
| pp_rovec [Owl_pretty] |
pp_rovec ppf pp_el vec prints the row vector vec to formatter
ppf in OCaml-style using the element printer pp_el .
|
| pp_spmat [Owl_sparse_complex] |
|
| pp_spmat [Owl_sparse_real] |
pp_spmat x pretty prints matrix x with headings.
|
| print [Owl_sparse_complex] |
|
| print [Owl_sparse_real] |
print x pretty prints matrix x without headings.
|
| print [Owl_dense_complex] |
|
| print [Owl_dense_real] |
print x pretty prints matrix x without headings.
|
| printers [Owl_toplevel] |
|
| proton_magnetic_moment [Owl_const.CGSM] |
|
| proton_magnetic_moment [Owl_const.MKS] |
|
| proton_magnetic_moment [Owl_const.SI] |
|
| psi [Owl_maths] |
|
| psi [Owl_const.CGSM] |
|
| psi [Owl_const.CGS] |
|
| psi [Owl_const.MKS] |
|
| psi [Owl_const.SI] |
|
| psi_1 [Owl_maths] |
|
| psi_1_pint [Owl_maths] |
|
| psi_1piy [Owl_maths] |
|
| psi_int [Owl_maths] |
|
| psi_n [Owl_maths] |
|
Q |
| qr [Owl_linalg] |
qr x calculates QR decomposition for an m by n matrix x as
x = Q R .
|
| qr_lssolve [Owl_linalg] |
|
| qr_sqsolve [Owl_linalg] |
|
| quart [Owl_const.CGSM] |
|
| quart [Owl_const.CGS] |
|
| quart [Owl_const.MKS] |
|
| quart [Owl_const.SI] |
|
R |
| rad [Owl_const.CGSM] |
|
| rad [Owl_const.CGS] |
|
| rad [Owl_const.MKS] |
|
| rad [Owl_const.SI] |
|
| range [Owl_utils] |
|
| rank [Owl_stats] |
rank x translates each element in x to its ranking.
|
| rayleigh [Owl_stats.Pdf] |
|
| rayleigh [Owl_stats.Rnd] |
|
| rayleigh_P [Owl_stats.Cdf] |
|
| rayleigh_Pinv [Owl_stats.Cdf] |
|
| rayleigh_Q [Owl_stats.Cdf] |
|
| rayleigh_Qinv [Owl_stats.Cdf] |
|
| re [Owl_dense_complex] |
re x returns the real parts of all the elements in x as a separate matrix.
|
| rect_of_polar [Owl_maths] |
|
| replace_col [Owl_dense_complex] |
|
| replace_col [Owl_dense_real] |
replace_col v x j uses the column vector v to replace the j th column
in the matrix x .
|
| replace_row [Owl_dense_complex] |
|
| replace_row [Owl_dense_real] |
replace_row v x i uses the row vector v to replace the i th row in
the matrix x .
|
| reset [Owl_sparse_complex] |
|
| reset [Owl_sparse_real] |
reset x resets all the elements in x to 0 .
|
| reshape [Owl_dense_complex] |
|
| reshape [Owl_dense_real] |
reshape m n x creates a new m by n matrix from the m' by n'
matrix x .
|
| ridge [Owl_regression] |
Ridge regression: in ridge ~i ~a x y , i : whether or not to include
intercept bias in parameters, the default is true ; a : the weight on the
regularisation term; x is the measurements, and y is the observations.
|
| ridge_regression [Owl_optimise] |
Ridge regression
i : whether to include intercept bias in parameters
a : weight on the regularisation term
TODO: how to choose a automatically
|
| roentgen [Owl_const.CGSM] |
|
| roentgen [Owl_const.CGS] |
|
| roentgen [Owl_const.MKS] |
|
| roentgen [Owl_const.SI] |
|
| row [Owl_sparse_complex] |
|
| row [Owl_sparse_real] |
row x i returns the row i of x .
|
| row [Owl_dense_complex] |
|
| row [Owl_dense_real] |
row x i returns the row i of x .
|
| row_num [Owl_sparse_complex] |
|
| row_num [Owl_sparse_real] |
row_num x returns the number of rows in matrix x .
|
| row_num [Owl_dense_complex] |
|
| row_num [Owl_dense_real] |
row_num x returns the number of rows in matrix x .
|
| row_num_nz [Owl_sparse_complex] |
|
| row_num_nz [Owl_sparse_real] |
row_num_nz x returns the number of non-zero rows in matrix x .
|
| rows [Owl_sparse_complex] |
|
| rows [Owl_sparse_real] |
rows x a returns the rows (defined in an int array a ) of x .
|
| rows [Owl_dense_complex] |
|
| rows [Owl_dense_real] |
rows x a returns the rows (defined in an int array a ) of x .
|
| runs_test [Owl_stats] |
runs_test ~alpha ~v x returns a test decision for the null hypothesis that
the data x comes in random order, against the alternative that they do not,
by runnign Wald–Wolfowitz runs test.
|
| rydberg [Owl_const.CGSM] |
|
| rydberg [Owl_const.CGS] |
|
| rydberg [Owl_const.MKS] |
|
| rydberg [Owl_const.SI] |
|
S |
| same_shape [Owl_dense_complex] |
|
| same_shape [Owl_dense_real] |
same_shape x y returns true if two matrics have the same shape.
|
| sample [Owl_stats] |
sample x n draw n samples from x with replacement.
|
| save [Owl_sparse_complex] |
|
| save [Owl_sparse_real] |
save x f saves the matrix x to a file with the name f .
|
| save [Owl_dense_complex] |
|
| save [Owl_dense_real] |
save x f saves the matrix x to a file with the name f .
|
| save_txt [Owl_dense_real] |
save_txt x f save the matrix x into a text file f .
|
| scatter [Owl_plot] |
|
| sec [Owl_maths] |
|
| seed [Owl_stats] |
seed x sets x as seed for the internal random number generator.
|
| sem [Owl_stats] |
sem x calculates the standard error of x , also referred to as standard
error of the mean.
|
| semidef [Owl_dense_real] |
semidef n returns an random n by n positive semi-definite matrix.
|
| sequential [Owl_dense_complex] |
|
| sequential [Owl_dense_real] |
sequential m n creates an m by n matrix.
|
| set [Owl_sparse_complex] |
|
| set [Owl_sparse_real] |
set x i j a sets the element (i,j) of x to value a .
|
| set [Owl_dense_complex] |
|
| set [Owl_dense_real] |
set x i j a sets the element (i,j) of x to value a .
|
| set_background_color [Owl_plot] |
|
| set_dim_defaults [Owl_pretty.Context] |
|
| set_font_size [Owl_plot] |
|
| set_foreground_color [Owl_plot] |
|
| set_output [Owl_plot] |
|
| set_page_size [Owl_plot] |
|
| set_pen_size [Owl_plot] |
|
| set_title [Owl_plot] |
|
| set_xlabel [Owl_plot] |
|
| set_xrange [Owl_plot] |
|
| set_ylabel [Owl_plot] |
|
| set_yrange [Owl_plot] |
|
| set_zlabel [Owl_plot] |
|
| set_zrange [Owl_plot] |
|
| sgd [Owl_optimise] |
wrapper of the _sgd_basic fucntion
|
| shape [Owl_sparse_complex] |
|
| shape [Owl_sparse_real] |
If x is an m by n matrix, shape x returns (m,n) , i.e., the size
of two dimensions of x .
|
| shape [Owl_dense_complex] |
|
| shape [Owl_dense_real] |
If x is an m by n matrix, shape x returns (m,n) , i.e., the size
of two dimensions of x .
|
| shi [Owl_maths] |
|
| shuffle [Owl_stats] |
shuffle x return a new array of the shuffled x .
|
| shuffle [Owl_sparse_complex] |
|
| shuffle [Owl_sparse_real] |
shuffle x shuffles all the elements in x by first shuffling along the
rows then shuffling along columns.
|
| shuffle [Owl_dense_complex] |
|
| shuffle [Owl_dense_real] |
shuffle x shuffles all the elements in x by first shuffling along the
rows then shuffling along columns.
|
| shuffle_cols [Owl_sparse_complex] |
|
| shuffle_cols [Owl_sparse_real] |
shuffle_cols x shuffles all the columns in matrix x .
|
| shuffle_cols [Owl_dense_complex] |
|
| shuffle_cols [Owl_dense_real] |
shuffle_cols x shuffles all the columns in matrix x .
|
| shuffle_rows [Owl_sparse_complex] |
|
| shuffle_rows [Owl_sparse_real] |
shuffle_rows x shuffles all the rows in matrix x .
|
| shuffle_rows [Owl_dense_complex] |
|
| shuffle_rows [Owl_dense_real] |
shuffle_rows x shuffles all the rows in matrix x .
|
| si [Owl_maths] |
|
| sigmoid [Owl_maths] |
|
| sigmoid [Owl_dense_real] |
sigmoid x applies sigmoid function to each element in matrix x .
|
| sin [Owl_maths] |
|
| sin [Owl_dense_complex] |
|
| sinc [Owl_maths] |
|
| sinh [Owl_maths] |
|
| size1 [Owl_types.Dense_complex] |
|
| size1 [Owl_types.Dense_real] |
|
| size2 [Owl_types.Dense_complex] |
|
| size2 [Owl_types.Dense_real] |
|
| skew [Owl_stats] |
|
| softmax_grad [Owl_optimise] |
|
| softmax_loss [Owl_optimise] |
softmax loss function
|
| solar_mass [Owl_const.CGSM] |
|
| solar_mass [Owl_const.CGS] |
|
| solar_mass [Owl_const.MKS] |
|
| solar_mass [Owl_const.SI] |
|
| sort [Owl_stats] |
|
| sp_data [Owl_types.Sparse_real] |
|
| sp_i [Owl_types.Sparse_real] |
|
| sp_nz [Owl_types.Sparse_real] |
|
| sp_nzmax [Owl_types.Sparse_real] |
|
| sp_p [Owl_types.Sparse_real] |
|
| sp_size1 [Owl_types.Sparse_real] |
|
| sp_size2 [Owl_types.Sparse_real] |
|
| sp_tree [Owl_types.Sparse_real] |
|
| sp_type [Owl_types.Sparse_real] |
|
| sp_work [Owl_types.Sparse_real] |
|
| spearman_rho [Owl_stats] |
|
| speed_of_light [Owl_const.CGSM] |
|
| speed_of_light [Owl_const.CGS] |
|
| speed_of_light [Owl_const.MKS] |
|
| speed_of_light [Owl_const.SI] |
|
| spmat_struct [Ffi_bindings.Bindings.Sparse_real] |
|
| spmat_struct [Owl_types.Sparse_real] |
|
| sqrt [Owl_maths] |
|
| square_grad [Owl_optimise] |
|
| square_loss [Owl_optimise] |
least square loss function
|
| stairs [Owl_plot] |
|
| standard_gas_volume [Owl_const.CGSM] |
|
| standard_gas_volume [Owl_const.CGS] |
|
| standard_gas_volume [Owl_const.MKS] |
|
| standard_gas_volume [Owl_const.SI] |
|
| std [Owl_stats] |
std x calculates the standard deviation of x .
|
| std_atmosphere [Owl_const.CGSM] |
|
| std_atmosphere [Owl_const.CGS] |
|
| std_atmosphere [Owl_const.MKS] |
|
| std_atmosphere [Owl_const.SI] |
|
| stefan_boltzmann_constant [Owl_const.CGSM] |
|
| stefan_boltzmann_constant [Owl_const.CGS] |
|
| stefan_boltzmann_constant [Owl_const.MKS] |
|
| stefan_boltzmann_constant [Owl_const.SI] |
|
| stem [Owl_plot] |
|
| stilb [Owl_const.CGSM] |
|
| stilb [Owl_const.CGS] |
|
| stilb [Owl_const.MKS] |
|
| stilb [Owl_const.SI] |
|
| stokes [Owl_const.CGSM] |
|
| stokes [Owl_const.CGS] |
|
| stokes [Owl_const.MKS] |
|
| stokes [Owl_const.SI] |
|
| stride [Owl_types.Dense_complex] |
|
| stride [Owl_types.Dense_real] |
|
| sub [Owl_sparse_complex] |
|
| sub [Owl_sparse_real] |
sub x y subtracts the matrix x from y .
|
| sub [Owl_dense_complex] |
|
| sub [Owl_dense_real] |
sub x y subtracts the matrix x from y .
|
| sub_scalar [Owl_dense_complex] |
|
| sub_scalar [Owl_dense_real] |
sub_scalar x a subtracts every element in x by a constant factor a .
|
| subplot [Owl_plot] |
|
| sum [Owl_sparse_complex] |
|
| sum [Owl_sparse_real] |
sum x returns the summation of all the elements in x .
|
| sum [Owl_dense_complex] |
|
| sum [Owl_dense_real] |
sum x returns the summation of all the elements in x .
|
| sum_cols [Owl_sparse_complex] |
|
| sum_cols [Owl_sparse_real] |
sum_cols returns the summation of all the column vectors in x .
|
| sum_cols [Owl_dense_complex] |
|
| sum_cols [Owl_dense_real] |
sum_cols returns the summation of all the column vectors in x .
|
| sum_rows [Owl_sparse_complex] |
|
| sum_rows [Owl_sparse_real] |
sum_rows x returns the summation of all the row vectors in x .
|
| sum_rows [Owl_dense_complex] |
|
| sum_rows [Owl_dense_real] |
sum_rows x returns the summation of all the row vectors in x .
|
| surf [Owl_plot] |
|
| svd [Owl_linalg] |
svd x calculates the singular value decomposition of x , and returns a
tuple (u,s,v) .
|
| svm [Owl_regression] |
Support Vector Machine regression: in svm ~i p x y , i : whether or not
to include intercept bias in parameters, the default is true ; p : the
initial guess of the model; x is the measurements, and y is the observations.
|
| svm_regression [Owl_optimise] |
Support Vector Machine regression
i : whether to include intercept bias in parameters
note that the values in y are either +1 or -1.
|
| swap_cols [Owl_dense_complex] |
|
| swap_cols [Owl_dense_real] |
swap_cols x j j' swaps the column j with column j' of x .
|
| swap_rows [Owl_dense_complex] |
|
| swap_rows [Owl_dense_real] |
swap_rows x i i' swaps the row i with row i' of x .
|
| symm_tridiag_solve [Owl_linalg] |
|
| symmtd [Owl_linalg] |
|
| synchrotron_1 [Owl_maths] |
|
| synchrotron_2 [Owl_maths] |
|
T |
| t_score [Owl_stats] |
|
| t_test [Owl_stats] |
t_test ~mu ~alpha ~side x returns a test decision of one-sample t-test
which is a parametric test of the location parameter when the population
standard deviation is unknown.
|
| t_test_paired [Owl_stats] |
t_test_paired ~alpha ~side x y returns a test decision for the null
hypothesis that the data in x – y comes from a normal distribution with
mean equal to zero and unknown variance, using the paired-sample t-test.
|
| t_test_unpaired [Owl_stats] |
t_test_unpaired ~alpha ~side ~equal_var x y returns a test decision for
the null hypothesis that the data in vectors x and y comes from
independent random samples from normal distributions with equal means and
equal but unknown variances, using the two-sample t-test.
|
| tablespoon [Owl_const.CGSM] |
|
| tablespoon [Owl_const.CGS] |
|
| tablespoon [Owl_const.MKS] |
|
| tablespoon [Owl_const.SI] |
|
| tan [Owl_maths] |
|
| taylorcoeff [Owl_maths] |
|
| tda [Owl_types.Dense_complex] |
|
| tda [Owl_types.Dense_real] |
|
| tdist [Owl_stats.Pdf] |
|
| tdist [Owl_stats.Rnd] |
|
| tdist_P [Owl_stats.Cdf] |
|
| tdist_Pinv [Owl_stats.Cdf] |
|
| tdist_Q [Owl_stats.Cdf] |
|
| tdist_Qinv [Owl_stats.Cdf] |
|
| teaspoon [Owl_const.CGSM] |
|
| teaspoon [Owl_const.CGS] |
|
| teaspoon [Owl_const.MKS] |
|
| teaspoon [Owl_const.SI] |
|
| tera [Owl_const.Prefix] |
|
| texpoint [Owl_const.CGSM] |
|
| texpoint [Owl_const.CGS] |
|
| texpoint [Owl_const.MKS] |
|
| texpoint [Owl_const.SI] |
|
| text [Owl_plot] |
|
| therm [Owl_const.CGSM] |
|
| therm [Owl_const.CGS] |
|
| therm [Owl_const.MKS] |
|
| therm [Owl_const.SI] |
|
| third_quartile [Owl_stats] |
third_quartile x returns the third quartile of x , i.e., 75 percentiles.
|
| thomson_cross_section [Owl_const.CGSM] |
|
| thomson_cross_section [Owl_const.CGS] |
|
| thomson_cross_section [Owl_const.MKS] |
|
| thomson_cross_section [Owl_const.SI] |
|
| to_array [Owl_dense_complex] |
|
| to_array [Owl_dense_real] |
to_array x flattens an m by n matrix x then returns x as an
float array of length (numel x) .
|
| to_arrays [Owl_dense_complex] |
|
| to_arrays [Owl_dense_real] |
to arrays x returns an array of float arrays, wherein each row in x
becomes an array in the result.
|
| to_dense [Owl_sparse_complex] |
|
| to_dense [Owl_sparse_real] |
to_dense x converts x into a dense matrix.
|
| ton [Owl_const.CGSM] |
|
| ton [Owl_const.CGS] |
|
| ton [Owl_const.MKS] |
|
| ton [Owl_const.SI] |
|
| torr [Owl_const.CGSM] |
|
| torr [Owl_const.CGS] |
|
| torr [Owl_const.MKS] |
|
| torr [Owl_const.SI] |
|
| trace [Owl_sparse_complex] |
|
| trace [Owl_sparse_real] |
trace x returns the sum of diagonal elements in x .
|
| trace [Owl_dense_complex] |
|
| trace [Owl_dense_real] |
trace x returns the sum of diagonal elements in x .
|
| transport_2 [Owl_maths] |
|
| transport_3 [Owl_maths] |
|
| transport_4 [Owl_maths] |
|
| transport_5 [Owl_maths] |
|
| transpose [Owl_sparse_real] |
transpose x transposes an m by n matrix to n by m one.
|
| transpose [Owl_dense_complex] |
|
| transpose [Owl_dense_real] |
transpose x transposes an m by n matrix to n by m one.
|
| tridiag_solve [Owl_linalg] |
|
| troy_ounce [Owl_const.CGSM] |
|
| troy_ounce [Owl_const.CGS] |
|
| troy_ounce [Owl_const.MKS] |
|
| troy_ounce [Owl_const.SI] |
|
U |
| uk_gallon [Owl_const.CGSM] |
|
| uk_gallon [Owl_const.CGS] |
|
| uk_gallon [Owl_const.MKS] |
|
| uk_gallon [Owl_const.SI] |
|
| uk_ton [Owl_const.CGSM] |
|
| uk_ton [Owl_const.CGS] |
|
| uk_ton [Owl_const.MKS] |
|
| uk_ton [Owl_const.SI] |
|
| unified_atomic_mass [Owl_const.CGSM] |
|
| unified_atomic_mass [Owl_const.CGS] |
|
| unified_atomic_mass [Owl_const.MKS] |
|
| unified_atomic_mass [Owl_const.SI] |
|
| uniform [Owl_stats.Rnd] |
uniform returns a random float number within [0,1) , including 0
but excluding 1.
|
| uniform [Owl_sparse_complex] |
|
| uniform [Owl_sparse_real] |
uniform m n creates an m by n matrix where 10% ~ 15% elements
follow a uniform distribution in (0,1) interval.
|
| uniform [Owl_dense_complex] |
|
| uniform [Owl_dense_real] |
uniform m n creates an m by n matrix where all the elements
follow a uniform distribution in (0,1) interval.
|
| uniform_int [Owl_stats.Rnd] |
uniform_int a b returns a random int between a and b inclusive,
i.e., a random int in a, b
|
| uniform_int [Owl_sparse_complex] |
|
| uniform_int [Owl_sparse_real] |
uniform ~a ~b m n creates an m by n matrix where 10% ~ 15% elements
follow a uniform distribution in [a, b] interval.
|
| uniform_int [Owl_dense_complex] |
|
| uniform_int [Owl_dense_real] |
uniform ~a ~b m n creates an m by n matrix where all the elements
follow a uniform distribution in [a, b] interval.
|
| us_gallon [Owl_const.CGSM] |
|
| us_gallon [Owl_const.CGS] |
|
| us_gallon [Owl_const.MKS] |
|
| us_gallon [Owl_const.SI] |
|
V |
| vacuum_permeability [Owl_const.MKS] |
|
| vacuum_permeability [Owl_const.SI] |
|
| vacuum_permittivity [Owl_const.MKS] |
|
| vacuum_permittivity [Owl_const.SI] |
|
| var_test [Owl_stats] |
var_test ~alpha ~side ~var x returns a test decision for the null
hypothesis that the data in x comes from a normal distribution with
variance var , using the chi-square variance test.
|
| variance [Owl_stats] |
|
| vblock [Owl_types.Dense_complex] |
|
| vblock [Owl_types.Dense_real] |
|
| vdata [Owl_types.Dense_complex] |
|
| vdata [Owl_types.Dense_real] |
|
| vec_struct [Ffi_bindings.Bindings.Dense_complex] |
|
| vec_struct [Ffi_bindings.Bindings.Dense_real] |
|
| vec_struct [Owl_types.Dense_complex] |
|
| vec_struct [Owl_types.Dense_real] |
|
| vector [Owl_dense_complex] |
|
| vector [Owl_dense_real] |
vector m returns an 1 by m row vector x without initialising the
values in x .
|
| vector_ones [Owl_dense_complex] |
|
| vector_ones [Owl_dense_real] |
vector_ones m returns an 1 by m row vector x by initialising the
all values in x to ones.
|
| vector_uniform [Owl_dense_complex] |
|
| vector_uniform [Owl_dense_real] |
vector_zeros m returns an 1 by m row vector x and the values are
drawn from the interval (0,1) with a uniform distribution.
|
| vector_zeros [Owl_dense_complex] |
|
| vector_zeros [Owl_dense_real] |
vector_zeros m returns an 1 by m row vector x by initialising the
all values in x to zeros.
|
| vertical_default [Owl_pretty.Context] |
|
| vowner [Owl_types.Dense_complex] |
|
| vowner [Owl_types.Dense_real] |
|
| vsize [Owl_types.Dense_complex] |
|
| vsize [Owl_types.Dense_real] |
|
W |
| week [Owl_const.CGSM] |
|
| week [Owl_const.CGS] |
|
| week [Owl_const.MKS] |
|
| week [Owl_const.SI] |
|
| weibull [Owl_stats.Pdf] |
|
| weibull [Owl_stats.Rnd] |
|
| weibull_P [Owl_stats.Cdf] |
|
| weibull_Pinv [Owl_stats.Cdf] |
|
| weibull_Q [Owl_stats.Cdf] |
|
| weibull_Qinv [Owl_stats.Cdf] |
|
| when_enough [Owl_optimise] |
|
| when_stable [Owl_optimise] |
|
Y |
| yard [Owl_const.CGSM] |
|
| yard [Owl_const.CGS] |
|
| yard [Owl_const.MKS] |
|
| yard [Owl_const.SI] |
|
| yocto [Owl_const.Prefix] |
|
| yotta [Owl_const.Prefix] |
|
Z |
| z_score [Owl_stats] |
|
| z_test [Owl_stats] |
z_test ~mu ~sigma ~alpha ~side x returns a test decision for the null
hypothesis that the data x comes from a normal distribution with mean mu
and a standard deviation sigma , using the z-test of alpha significance
level.
|
| zepto [Owl_const.Prefix] |
|
| zeros [Owl_sparse_complex] |
|
| zeros [Owl_sparse_real] |
zeros m n creates an m by n matrix where all the elements are zeros.
|
| zeros [Owl_dense_complex] |
|
| zeros [Owl_dense_real] |
zeros m n creates an m by n matrix where all the elements are
initialised to zeros.
|
| zeta [Owl_maths] |
|
| zeta_int [Owl_maths] |
|
| zetta [Owl_const.Prefix] |
|


|
| void | doGet (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException |
| |
| void | doPost (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException |
| |
Servlet implementation class MainServlet All project goes on around this class.
- Author
- sahin_batmaz
| pckg1.MainServlet.MainServlet |
( |
| ) |
|
- See also
- HttpServlet::HttpServlet() It is default for dynamic web project.
| void pckg1.MainServlet.doGet |
( |
HttpServletRequest |
request, |
|
|
HttpServletResponse |
response |
|
) |
| throws ServletException, IOException |
|
protected |
doGet method handles the login page.
- See also
- HttpServlet::doGet(HttpServletRequest request, HttpServletResponse response)
| void pckg1.MainServlet.doPost |
( |
HttpServletRequest |
request, |
|
|
HttpServletResponse |
response |
|
) |
| throws ServletException, IOException |
|
protected |
Main part of the project is here. Whenever a post action is required, program comes to this method. Post actions are after login page, after search button, after show saved entries, after save selected entries. And there is one get action for returning login page. This method handles creating and running html code of the functions that are listed above. And so this method is the main user interface of my project.
- See also
- HttpServlet::doPost(HttpServletRequest request, HttpServletResponse response)
The documentation for this class was generated from the following file:


So I pretty much live in screen permanently these days, and there are a gazillion awesome introductions out there to screen that describe the amazing advantages of screen.
One thing that has been a minor niggle has been the clunky way you pick which screen session you wish to reattach to if you have multiple sessions active, so I whipped up this bash function that I’ve been finding really useful.
function scr() { if [ ! $1 ]; then screen -D -R else i=1 for j in $(screen -list | awk --posix '/^[[:space:]]*[[:digit:]]{2,}.*$/{print $1}'); do screens[${i}]=$j let i=i+1 done # test if integer if ! [ $1 -eq $1 2> /dev/null ]; then echo "You must supply an integer as the argument" elif [ $1 -eq 0 ]; then echo "screens list count starts at 1, not zero." elif [[ ${1} -gt ${#screens[@]} ]]; then echo "only ${#screens[@]} screens exist" screen -list else screen -D -R ${screens[$1]} fi fi }
So you can basically go scr
to reattach to a single screen session, scr 1
to reattach to the first, scr 2
to reattach to the second, etc etc.
I’m kind of expecting someone to pipe up now and point out a much easier way… :)
I certainly don’t claim any semblance of betterness, however I’ve never found the need to sort out which screen session to re-attach to.
My fundamental assumption is that there’s one screen session to rule them all. I call it TRUNK, and it’s bound to ^v rather than ^a.
So, I fire up the main screen session with screen -S TRUNK -e ^vV, and then sub-screen sessions are created inside, like screen -S DEV, screen -S SSH, etc…
So, even though lots of screens are running, I only need to do a screen -rx TRUNK to pick up right where I left off. I also find it nice to be able to attach multiple terminal windows to the same “trunk” screen session, but viewing different nested screens, e.g. SSH or DEV. This also effectively allows copying and pasting of text across different ssh endpoints.
Definitely a cool bash function though. Particularly good example of array use in shell scripts.
my normal rule with bash is if I’m using arrays, I should rewrite it in something else…
After you explained your setup yesterday, I spent a while trying to use it, but just couldn’t seem to get myself to work like that…
I never used to need to work out which session to reattach to, but since starting with a 30″ monitor attached to my laptop at work, I seem to lose the visual link between sessions when attaching/detaching the monitor and/or network.
Are you still just living in one single terminal instance and doing absolutely everything in screen? That might be the difference… I like having 5 specific terminal windows that have differing screen sessions.
Maybe I’m missing something, but what’s the rationale between using multiple instances of screen, given that you can attach to a single instance as many times as needed (from different terminals / hosts / whatever) using screen -x? Each simultaneous attached client can discretely switch between screen windows…
Yet another nifty function using screen (kind of plaything):
Screensaver as desktop background
http://codesnippets.joyent.com/posts/show/1508
I’ve been trying to think why I like having multiple screen instances, and my only conclusion is that I’m used to it. I do use screen -x sometimes, but not consistently.
I do also have different profiles set up due to some internal tools I use requiring different keyboard layouts, backspace/delete, term emulators, etc etc, so I guess that’s part of it. I could just try and work out a unified profile…
I have a little function that draws a menu of screen sessions, it uses a known non-portable switch for dialog (–stdout) but works nicely on my leenuckz box. I don’t have a mac to test it:
Formatting’s all destroyed above, sorry. I’ll post it on my blog in the right format
I actually fixed up the formatting, so it should look ok now?
I quite like the way you’ve done that…. installing dialog via MacPorts now to check it out.