9. Class reference¶
9.1. Support Vector Machines¶
Support Vector Machine algorithms.
| svm.SVC([C, kernel, degree, gamma, coef0, ...]) | C-Support Vector Classification. |
| svm.LinearSVC([penalty, loss, dual, tol, C, ...]) | Linear Support Vector Classification. |
| svm.NuSVC([nu, kernel, degree, gamma, ...]) | Nu-Support Vector Classification. |
| svm.SVR([kernel, degree, gamma, coef0, tol, ...]) | epsilon-Support Vector Regression. |
| svm.NuSVR([nu, C, kernel, degree, gamma, ...]) | Nu Support Vector Regression. |
| svm.OneClassSVM([kernel, degree, gamma, ...]) | Unsupervised Outliers Detection. |
| svm.l1_min_c(X, y[, loss, fit_intercept, ...]) | Return the maximum value for C that yields a model with coefficients |
9.1.8. For sparse data¶
Support Vector Machine algorithms for sparse matrices.
This module should have the same API as sklearn.svm, except that matrices are expected to be in some sparse format supported by scipy.sparse.
Note
Some fields, like dual_coef_ are not sparse matrices strictly speaking. However, they are converted to a sparse matrix for consistency and efficiency when multiplying to other sparse matrices.
| svm.sparse.SVC([C, kernel, degree, gamma, ...]) | SVC for sparse matrices (csr). |
| svm.sparse.NuSVC([nu, kernel, degree, ...]) | NuSVC for sparse matrices (csr). |
| svm.sparse.SVR([kernel, degree, gamma, ...]) | SVR for sparse matrices (csr) |
| svm.sparse.NuSVR([nu, C, kernel, degree, ...]) | NuSVR for sparse matrices (csr) |
| svm.sparse.OneClassSVM([kernel, degree, ...]) | NuSVR for sparse matrices (csr) |
| svm.sparse.LinearSVC([penalty, loss, dual, ...]) | Linear Support Vector Classification, Sparse Version |
9.1.9. Low-level methods¶
| svm.libsvm.fit | Train the model using libsvm (low-level method) |
| svm.libsvm.decision_function | Predict margin (libsvm name for this is predict_values) |
| svm.libsvm.predict | Predict target values of X given a model (low-level method) |
| svm.libsvm.predict_proba | Predict probabilities svm_model stores all parameters needed to predict a given value. |
| svm.libsvm.cross_validation | Binding of the cross-validation routine (low-level routine) |
9.2. Generalized Linear Models¶
sklearn.linear_model is a module to fit genelarized linear models. It includes Ridge regression, Bayesian Regression, Lasso and Elastic Net estimators computed with Least Angle Regression and coordinate descent.
It also implements Stochastic Gradient Descent related algorithms.
| linear_model.LinearRegression([...]) | Ordinary least squares Linear Regression. |
| linear_model.Ridge([alpha, fit_intercept, ...]) | Ridge regression. |
| linear_model.RidgeCV([alphas, ...]) | Ridge regression with built-in cross-validation. |
| linear_model.Lasso([alpha, fit_intercept, ...]) | Linear Model trained with L1 prior as regularizer (aka the Lasso) |
| linear_model.LassoCV([eps, n_alphas, ...]) | Lasso linear model with iterative fitting along a regularization path |
| linear_model.ElasticNet([alpha, rho, ...]) | Linear Model trained with L1 and L2 prior as regularizer |
| linear_model.ElasticNetCV([rho, eps, ...]) | Elastic Net model with iterative fitting along a regularization path |
| linear_model.Lars([fit_intercept, verbose, ...]) | Least Angle Regression model a.k.a. LAR |
| linear_model.LassoLars([alpha, ...]) | Lasso model fit with Least Angle Regression a.k.a. Lars |
| linear_model.LarsCV([fit_intercept, ...]) | Cross-validated Least Angle Regression model |
| linear_model.LassoLarsCV([fit_intercept, ...]) | Cross-validated Lasso, using the LARS algorithm |
| linear_model.LassoLarsIC([criterion, ...]) | Lasso model fit with Lars using BIC or AIC for model selection |
| linear_model.LogisticRegression([penalty, ...]) | Logistic Regression. |
| linear_model.OrthogonalMatchingPursuit([...]) | Orthogonal Mathching Pursuit model (OMP) |
| linear_model.SGDClassifier([loss, penalty, ...]) | Linear model fitted by minimizing a regularized empirical loss with SGD. |
| linear_model.SGDRegressor([loss, penalty, ...]) | Linear model fitted by minimizing a regularized empirical loss with SGD |
| linear_model.BayesianRidge([n_iter, tol, ...]) | Bayesian ridge regression |
| linear_model.ARDRegression([n_iter, tol, ...]) | Bayesian ARD regression. |
| linear_model.lasso_path(X, y[, eps, ...]) | Compute Lasso path with coordinate descent |
| linear_model.lars_path(X, y[, Xy, Gram, ...]) | Compute Least Angle Regression and LASSO path |
| linear_model.orthogonal_mp(X, y[, ...]) | Orthogonal Matching Pursuit (OMP) |
| linear_model.orthogonal_mp_gram(Gram, Xy[, ...]) | Gram Orthogonal Matching Pursuit (OMP) |
9.2.23. For sparse data¶
sklearn.linear_model.sparse is the sparse counterpart of sklearn.linear_model.
| linear_model.sparse.Lasso([alpha, ...]) | Linear Model trained with L1 prior as regularizer |
| linear_model.sparse.ElasticNet([alpha, rho, ...]) | Linear Model trained with L1 and L2 prior as regularizer |
| linear_model.sparse.SGDClassifier([loss, ...]) | Linear model fitted by minimizing a regularized empirical loss with SGD |
| linear_model.sparse.SGDRegressor([loss, ...]) | Linear model fitted by minimizing a regularized empirical loss with SGD |
| linear_model.sparse.LogisticRegression([...]) | Logistic Regression. |
9.3. Naive Bayes¶
9.3.1. Naive Bayes models¶
Naive Bayes algorithms are a set of supervised learning methods based on applying Bayes’ theorem with strong (naive) feature independence assumptions.
See http://scikit-learn.sourceforge.net/modules/naive_bayes.html for complete documentation.
| naive_bayes.GaussianNB | Gaussian Naive Bayes (GaussianNB) |
| naive_bayes.MultinomialNB([alpha, fit_prior]) | Naive Bayes classifier for multinomial models |
| naive_bayes.BernoulliNB([alpha, binarize, ...]) | Naive Bayes classifier for multivariate Bernoulli models. |
9.4. Nearest Neighbors¶
| neighbors.NearestNeighbors([n_neighbors, ...]) | Unsupervised learner for implementing neighbor searches. |
| neighbors.KNeighborsClassifier([...]) | Classifier implementing the k-nearest neighbors vote. |
| neighbors.RadiusNeighborsClassifier([...]) | Classifier implementing a vote among neighbors within a given radius |
| neighbors.NeighborsClassifier(*args, **kwargs) | Classifier implementing the nearest neighbors vote. |
| neighbors.KNeighborsRegressor([n_neighbors, ...]) | Regression based on k-nearest neighbors. |
| neighbors.RadiusNeighborsRegressor([radius, ...]) | Regression based on neighbors within a fixed radius. |
| neighbors.NeighborsRegressor(*args, **kwargs) | Regression based on nearest neighbors. |
| neighbors.BallTree | Ball Tree for fast nearest-neighbor searches : |
| neighbors.kneighbors_graph(X, n_neighbors[, ...]) | Computes the (weighted) graph of k-Neighbors for points in X |
| neighbors.radius_neighbors_graph(X, radius) | Computes the (weighted) graph of Neighbors for points in X |
9.5. Gaussian Mixture Models¶
Mixture modeling algorithms
| mixture.GMM([n_components, cvtype, ...]) | Gaussian Mixture Model |
| mixture.DPGMM([n_components, cvtype, alpha, ...]) | Variational Inference for the Infinite Gaussian Mixture Model. |
| mixture.VBGMM([n_components, cvtype, alpha, ...]) | Variational Inference for the Gaussian Mixture Model |
9.6. Hidden Markov Models¶
| hmm.GaussianHMM([n_components, cvtype, ...]) | Hidden Markov Model with Gaussian emissions |
| hmm.MultinomialHMM([n_components, ...]) | Hidden Markov Model with multinomial (discrete) emissions |
| hmm.GMMHMM([n_components, n_mix, startprob, ...]) | Hidden Markov Model with Gaussin mixture emissions |
9.7. Clustering¶
Clustering algorithms
| cluster.KMeans([k, init, n_init, max_iter, ...]) | K-Means clustering |
| cluster.MiniBatchKMeans([k, init, max_iter, ...]) | Mini-Batch K-Means clustering |
| cluster.MeanShift([bandwidth, seeds, ...]) | MeanShift clustering |
| cluster.SpectralClustering([k, mode, ...]) | Apply k-means to a projection to the normalized laplacian |
| cluster.AffinityPropagation([damping, ...]) | Perform Affinity Propagation Clustering of data |
| cluster.Ward([n_clusters, memory, ...]) | Ward hierarchical clustering: constructs a tree and cuts it. |
9.8. Metrics¶
9.8.2. Classification metrics¶
Metrics module with score functions, performance metrics and pairwise metrics or distances computation
| metrics.confusion_matrix(y_true, y_pred[, ...]) | Compute confusion matrix to evaluate the accuracy of a classification |
| metrics.roc_curve(y_true, y_score) | compute Receiver operating characteristic (ROC) |
| metrics.auc(x, y) | Compute Area Under the Curve (AUC) using the trapezoidal rule |
| metrics.precision_score(y_true, y_pred[, ...]) | Compute the precision |
| metrics.recall_score(y_true, y_pred[, pos_label]) | Compute the recall |
| metrics.fbeta_score(y_true, y_pred, beta[, ...]) | Compute fbeta score |
| metrics.f1_score(y_true, y_pred[, pos_label]) | Compute f1 score |
| metrics.precision_recall_fscore_support(...) | Compute precisions, recalls, f-measures and support for each class |
| metrics.classification_report(y_true, y_pred) | Build a text report showing the main classification metrics |
| metrics.precision_recall_curve(y_true, ...) | Compute precision-recall pairs for different probability thresholds |
| metrics.zero_one_score(y_true, y_pred) | Zero-One classification score |
| metrics.zero_one(y_true, y_pred) | Zero-One classification loss |
| metrics.hinge_loss(y_true, pred_decision[, ...]) | Cumulated hinge loss (non-regularized). |
9.8.2. Regression metrics¶
Metrics module with score functions, performance metrics and pairwise metrics or distances computation
| metrics.r2_score(y_true, y_pred) | R^2 (coefficient of determination) regression score function |
| metrics.mean_square_error(y_true, y_pred) | Mean square error regression loss |
9.8.3. Clustering metrics¶
Utilities to evaluate the clustering performance of models
Functions named as *_score return a scalar value to maximize: the higher the better.
| metrics.adjusted_rand_score(labels_true, ...) | Rand index adjusted for chance |
| metrics.homogeneity_completeness_v_measure(...) | Compute the homogeneity and completeness and V-measure scores at once |
| metrics.homogeneity_score(labels_true, ...) | Homogeneity metric of a cluster labeling given a ground truth |
| metrics.completeness_score(labels_true, ...) | Completeness metric of a cluster labeling given a ground truth |
| metrics.v_measure_score(labels_true, labels_pred) | V-Measure cluster labeling given a ground truth |
9.8.4. Pairwise metrics¶
Utilities to evaluate pairwise distances or affinity of sets of samples.
This module contains both distance metrics and kernels. A brief summary is given on the two here.
Distance metrics are a function d(a, b) such that d(a, b) < d(a, c) if objects a and b are considered “more similar” to objects a and c. Two objects exactly alike would have a distance of zero. One of the most popular examples is Euclidean distance. To be a ‘true’ metric, it must obey the following four conditions:
- d(a, b) >= 0, for all a and b
- d(a, b) == 0, if and only if a = b, positive definiteness
- d(a, b) == d(b, a), symmetry
- d(a, c) <= d(a, b) + d(b, c), the triangle inequality
Kernels are measures of similarity, i.e. s(a, b) > s(a, c) if objects a and b are considered “more similar” to objects a and c. A kernel must also be positive semi-definite.
There are a number of ways to convert between a distance metric and a similarity measure, such as a kernel. Let D be the distance, and S be the kernel:
- S = np.exp(-D * gamma), where one heuristic for choosing gamma is 1 / num_features
- S = 1. / (D / np.max(D))
| metrics.pairwise.euclidean_distances(X[, Y, ...]) | Considering the rows of X (and Y=X) as vectors, compute the |
| metrics.pairwise.l1_distances | |
| metrics.pairwise.linear_kernel(X[, Y]) | Compute the linear kernel between X and Y. |
| metrics.pairwise.polynomial_kernel(X[, Y, ...]) | Compute the polynomial kernel between X and Y. |
| metrics.pairwise.rbf_kernel(X[, Y, gamma]) | Compute the rbf (gaussian) kernel between X and Y. |
| metrics.pairwise.distance_metrics() | Valid metrics for pairwise_distances |
| metrics.pairwise.pairwise_distances(X[, Y, ...]) | Compute the distance matrix from a vector array X and optional Y. |
| metrics.pairwise.kernel_metrics() | Valid metrics for pairwise_kernels |
| metrics.pairwise.pairwise_kernels(X[, Y, metric]) | Compute the kernel between arrays X and optional array Y. |
9.9. Covariance Estimators¶
9.9.1. Covariance estimators¶
sklearn.covariance is a module to fit to estimate robustly the covariance of features given a set of points. The precision matrix defined as the inverse of the covariance is also estimated. Covariance estimation is closely related to the theory of Gaussian Graphical Models.
| covariance.EmpiricalCovariance([store_precision]) | Maximum likelihood covariance estimator |
| covariance.ShrunkCovariance([...]) | Covariance estimator with shrinkage |
| covariance.LedoitWolf([store_precision]) | Ledoit-Wolf shrinkage estimator |
| covariance.OAS([store_precision]) | Oracle Approximating Shrinkage Estimator |
| covariance.empirical_covariance(X[, ...]) | Computes the Maximum likelihood covariance estimator |
| covariance.ledoit_wolf(X[, assume_centered]) | Estimates the shrunk Ledoit-Wolf covariance matrix. |
| covariance.shrunk_covariance(emp_cov[, ...]) | Calculates a covariance matrix shrunk on the diagonal |
| covariance.oas(X[, assume_centered]) | Estimate covariance with the Oracle Approximating Shrinkage algorithm. |
9.10. Signal Decomposition¶
Matrix decomposition algorithms
| decomposition.PCA([n_components, copy, whiten]) | Principal component analysis (PCA) |
| decomposition.ProbabilisticPCA([...]) | Additional layer on top of PCA that adds a probabilistic evaluation |
| decomposition.ProjectedGradientNMF([...]) | Non-Negative matrix factorization by Projected Gradient (NMF) |
| decomposition.RandomizedPCA(n_components[, ...]) | Principal component analysis (PCA) using randomized SVD |
| decomposition.KernelPCA([n_components, ...]) | Kernel Principal component analysis (KPCA) |
| decomposition.FastICA([n_components, ...]) | FastICA; a fast algorithm for Independent Component Analysis |
| decomposition.NMF([n_components, init, ...]) | Non-Negative matrix factorization by Projected Gradient (NMF) |
| decomposition.SparsePCA(n_components[, ...]) | Sparse Principal Components Analysis (SparsePCA) |
| decomposition.MiniBatchSparsePCA(n_components) | Mini-batch Sparse Principal Components Analysis |
| decomposition.DictionaryLearning(n_atoms[, ...]) | Dictionary learning |
| decomposition.MiniBatchDictionaryLearning(n_atoms) | Mini-batch dictionary learning |
| decomposition.fastica(X[, n_components, ...]) | Perform Fast Independent Component Analysis. |
| decomposition.dict_learning(X, n_atoms, alpha) | Solves a dictionary learning matrix factorization problem. |
| decomposition.dict_learning_online(X, ...[, ...]) | Solves a dictionary learning matrix factorization problem online. |
| decomposition.sparse_encode(X, Y[, gram, ...]) | Generic sparse coding |
| decomposition.sparse_encode_parallel(X, Y[, ...]) | Parallel sparse coding using joblib |
9.11. Linear Discriminant Analysis¶
| lda.LDA([n_components, priors]) | Linear Discriminant Analysis (LDA) |
9.12. Partial Least Squares¶
Partial Least Squares regression
| pls.PLSRegression([n_components, scale, ...]) | PLS regression |
| pls.PLSCanonical([n_components, scale, ...]) | PLS canonical. PLSCanonical inherits from PLS with mode=”A” and |
| pls.CCA([n_components, scale, algorithm, ...]) | CCA Canonical Correlation Analysis. CCA inherits from PLS with |
| pls.PLSSVD([n_components, scale, copy]) | Partial Least Square SVD |
9.13. Cross Validation¶
Utilities for cross validation and performance evaluation
| cross_validation.LeaveOneOut(n[, indices]) | Leave-One-Out cross validation iterator. |
| cross_validation.LeavePOut(n, p[, indices]) | Leave-P-Out cross validation iterator |
| cross_validation.KFold(n, k[, indices]) | K-Folds cross validation iterator |
| cross_validation.StratifiedKFold(y, k[, indices]) | Stratified K-Folds cross validation iterator |
| cross_validation.LeaveOneLabelOut(labels[, ...]) | Leave-One-Label_Out cross-validation iterator |
| cross_validation.LeavePLabelOut(labels, p[, ...]) | Leave-P-Label_Out cross-validation iterator |
| cross_validation.Bootstrap(n[, ...]) | Random sampling with replacement cross-validation iterator |
| cross_validation.ShuffleSplit(n[, ...]) | Random permutation cross-validation iterator. |
9.14. Grid Search¶
Tune the parameters of an estimator by cross-validation
| grid_search.GridSearchCV(estimator, param_grid) | Grid search on the parameters of a classifier |
9.15. Feature Selection¶
Feature slection module for python
| feature_selection.rfe.RFE(estimator, ...[, step]) | Feature ranking with recursive feature elimination. |
| feature_selection.rfe.RFECV(estimator[, ...]) | Feature ranking with recursive feature elimination and cross-validated selection of the best number of features. |
| feature_selection.univariate_selection.chi2(X, y) | Compute χ² (chi-squared) statistic for each class/feature combination. |
9.16. Feature Extraction¶
Package for modules that deal with feature extraction from raw data
9.16.1. From images¶
Utilities to extract features from images.
| feature_extraction.image.img_to_graph(img[, ...]) | Graph of the pixel-to-pixel gradient connections |
| feature_extraction.image.grid_to_graph(n_x, n_y) | Graph of the pixel-to-pixel connections |
| feature_extraction.image.extract_patches_2d(...) | Reshape a 2D image into a collection of patches |
| feature_extraction.image.reconstruct_from_patches_2d(...) | Reconstruct the image from all of its patches. |
| feature_extraction.image.PatchExtractor(...) | Extracts patches from a collection of images |
9.16.2. From text¶
Utilities to build feature vectors from text documents
| feature_extraction.text.RomanPreprocessor | Fast preprocessor suitable for Latin alphabet text |
| feature_extraction.text.WordNGramAnalyzer([...]) | Simple analyzer: transform text document into a sequence of word tokens |
| feature_extraction.text.CharNGramAnalyzer([...]) | Compute character n-grams features of a text document |
| feature_extraction.text.CountVectorizer(...) | Convert a collection of raw documents to a matrix of token counts |
| feature_extraction.text.TfidfTransformer([...]) | Transform a count matrix to a normalized tf or tf–idf representation |
| feature_extraction.text.Vectorizer(...[, ...]) | Convert a collection of raw documents to a matrix |
9.17. Preprocessing and normalization¶
Transformers to perform common preprocessing steps.
| preprocessing.Scaler([copy, with_mean, with_std]) | Standardize features by removing the mean and scaling to unit variance |
| preprocessing.Normalizer([norm, copy]) | Normalize samples individually to unit norm |
| preprocessing.Binarizer([threshold, copy]) | Binarize data (set feature values to 0 or 1) according to a threshold |
| preprocessing.LabelBinarizer | Binarize labels in a one-vs-all fashion |
| preprocessing.KernelCenterer | Center a kernel matrix |
| preprocessing.scale(X[, axis, with_mean, ...]) | Standardize a dataset along any axis |
| preprocessing.normalize(X[, norm, axis, copy]) | Normalize a dataset along any axis |
| preprocessing.binarize(X[, threshold, copy]) | Boolean thresholding of array-like or scipy.sparse matrix |
9.18. Manifold learning¶
| manifold.LocallyLinearEmbedding([...]) | Locally Linear Embedding |
| manifold.Isomap([n_neighbors, out_dim, ...]) | Isomap Embedding |
| manifold.locally_linear_embedding(X, ...[, ...]) | Perform a Locally Linear Embedding analysis on the data. |
9.19. Datasets¶
9.19.2. Loaders¶
| datasets.load_files(container_path[, ...]) | Load text files with categories as subfolder names. |
| datasets.load_diabetes() | Load and return the diabetes dataset (regression). |
| datasets.load_digits([n_class]) | Load and return the digits dataset (classification). |
| datasets.load_iris() | Load and return the iris dataset (classification). |
| datasets.load_linnerud() | Load and return the linnerud dataset (multivariate regression). |
| datasets.load_lfw_pairs([download_if_missing]) | Alias for fetch_lfw_pairs(download_if_missing=False) |
| datasets.fetch_lfw_pairs([subset, ...]) | Loader for the Labeled Faces in the Wild (LFW) pairs dataset |
| datasets.load_lfw_people([download_if_missing]) | Alias for fetch_lfw_people(download_if_missing=False) |
| datasets.fetch_lfw_people([data_home, ...]) | Loader for the Labeled Faces in the Wild (LFW) people dataset |
| datasets.load_20newsgroups(*args, **kwargs) | DEPRECATED: Use fetch_20newsgroups instead with download_if_missing=False |
| datasets.fetch_20newsgroups([data_home, ...]) | Load the filenames of the 20 newsgroups dataset |
9.19.2. Samples generator¶
| datasets.make_classification([n_samples, ...]) | Generate a random n-class classification problem. |
| datasets.make_regression([n_samples, ...]) | Generate a random regression problem. |
| datasets.make_blobs([n_samples, n_features, ...]) | Generate isotropic Gaussian blobs for clustering. |
| datasets.make_friedman1([n_samples, ...]) | Generate the “Friedman #1” regression problem as described in Friedman [1] |
| datasets.make_friedman2([n_samples, noise, ...]) | Generate the “Friedman #2” regression problem as described in Friedman [1] |
| datasets.make_friedman3([n_samples, noise, ...]) | Generate the “Friedman #3” regression problem as described in Friedman [1] |
| datasets.make_low_rank_matrix([n_samples, ...]) | Generate a mostly low rank random matrix with bell-shaped singular values profile. |
| datasets.make_sparse_coded_signal(n_samples, ...) | Generate a signal as a sparse combination of dictionary elements. |
| datasets.make_sparse_uncorrelated([...]) | Generate a random regression problem with sparse uncorrelated design as |
| datasets.make_spd_matrix(n_dim[, random_state]) | Generate a random symmetric, positive-definite matrix. |
| datasets.make_swiss_roll([n_samples, noise, ...]) | Generate a swiss roll dataset. |
| datasets.make_s_curve([n_samples, noise, ...]) | Generate an S curve dataset. |
9.20. Pipeline¶
Pipeline: chain transforms and estimators to build a composite estimator.
| pipeline.Pipeline(steps) | Pipeline of transforms with a final estimator |
9.21. Utilities¶
| utils.check_random_state(seed) | Turn seed into a np.random.RandomState instance |
| utils.resample(*arrays, **options) | Resample arrays or sparse matrices in a consistent way |
| utils.shuffle(*arrays, **options) | Shuffle arrays or sparse matrices in a consistent way |


{{ partial "header.html" . }} Welcome! If you want to learn more about the research we do, please visit our homepage. {{ partial "footer.html" . }}
If you want to learn more about the research we do, please visit our homepage.


See: Description
| Class | Description |
|---|---|
| AnyPiece | |
| Archbishop | |
| Bishop | |
| Chancellor | |
| Common | |
| FEN |
Used to import and export games from the FEN notation.
|
| Game |
Represents a Chess game.
|
| Grasshoper | |
| King | |
| Knight | |
| Move | |
| MoveInfo |
This class contains additional information about the state of the game when
the move was played.
|
| MoveList | |
| Notation | |
| Pawn | |
| PGN |
PGN allow recording a game and information about the game.
|
| Piece | |
| Queen | |
| Rook | |
| TimeUtils |
Created by Ran on 31/08/2015.
|
| Utils |
Created by Ran on 31/08/2015.
|
| Enum | Description |
|---|---|
| Common.BOARD_COLUMN |
Game Object


Boat Saved Successfully.
Date posted: 01-Jan-1901
Date relevant to: 01-Jan-1901
Reference:ref001
Manufacturer: HR
Length: 42
Feet
Metres
Hull type: Mono
Minimum required RYA sail cruising qualification: Not too bad
Sailing purpose: Racing
Money: Free
Description: Desc
View All Boats


Find the right people or the right job.
Select the right skill for the job!
We will help you to shortlist Doers based on their and your availability!
We update dependencies to keep things uptodate.
The right Doer will see at your door step
In case of any technical support , please reach us @.


Alerts make it easy to display prominate information to the user. They are styled using colors from your palette or you can use the helper classes. Alerts can have an optional exit button and come in three sizes.
Alerts can have exit buttons with minimal markup:
Note: Juiced has no JavaScript baked in. You must manually add any Javascript functionalty to hide alerts, Juiced makes this simple with CSS helper classes.  Add .btn-sm or .btn-lg classes for smaller or larger buttons. Juiced makes no assumptions on how you will style your buttons so by default there are no colors, transitions, or hover effects. Buttons may be styled using the .radius, .btn-pill, .btn-block, and .btn-outline classes as well as the helper classes.
Outline buttons.
Outline buttons have a transparent background and a border color that matches the font color.
Cards are in. You can create them with minimal markup using .card and child .card-content block elements. They can be styled using the helper classes.
Card containersBy default, cards fill 100% of the available width allowing them to sit nicely inside the Juiced grid. If you don't want to use the grid, you can wrap your cards with a .card-masonry block element, and they will be set to a max-width of 360px as shown in our examples below (see the masonry card below for more details).
Using the .card-img class sets the image to 100% width. This is useful for card with image based headers and footers.
A container with classes .card-content and .card-header
Using .card-header adds a thin border on the bottom of the header section. It also spaces your heading tags and paragraph tags nicely for titles and subtitles.
Create cards with a .card element and use .card-content, .card-header, .card-footer, and .card-img for aligning and spacing content inside cards.
Cards can be styled using the helper classes and also with .radius and .no-border.
Use our built in .card-masonry classes to wrap all your cards. Reponsive breakpoints are the same, so .card-masonry-1 means one column on mobile and .sm-card-masonry-2 would switch to two columns on small screens and up. Juiced supports up to 4 columns for each breakpoint.
Juiced has an opt-in class of .form-control for consistent styling across all your form elements. Radio buttons and checkboxes are minimally styled by default so you won't need to use .form-control on them.
Switches are the new way to stylize checkboxes and radio buttons. Markup a radio input with a class of .switch and a sibling label element with the same .switch class. And viola.. you have a switch! Add .radius, and .outline classes to your label for pretty styles.
<input class="switch" type="checkbox" id="ex1" name="checkbox" value="1">  Switch label
Switches use $color-primary, $color-white, and $color-light for border and background colors.
All .form-control elements sit nicely in the Juiced grid and fill 100% of the available width.
Most Juiced components allow for a .radius helper class to be added for easy border rounding.
If you choose not to use the grid for spacing, Juiced will automatically provide margin's to any input wrapped in a label.
As shown in our example, there is no need for form-groups. Use the grid to nicely space your form elements.
<form>

 Your Name:

 <input id="contact_name" placeholder="John Smith" name="name" type="text" class="form-control radius">

 Email Address:

 <input id="contact_email"<EMAIL_ADDRESS>name="email" type="email" class="form-control radius">

 Phone:

 <input id="contact_tel" placeholder="555.555.1212" name="phone" type="text" class="form-control radius">

 Password:

 <input id="contact_pass" type="password" name="phone" class="form-control radius">

 Selections:

 <select id="selections" class="form-control"> <option value="1">1</option> <option value="2">2</option> <option value="3">3</option> </select>

 Multiple Selections:

 <select id="selections_multi" multiple class="form-control"> <option value="1">1</option> <option value="2">2</option> <option value="3">3</option> <option value="4">4</option> <option value="5">5</option> </select>

 Message:

 <textarea id="contact_message" placeholder="How can we help you?" name="content" class="form-control"></textarea>

  <input type="radio" name="radio" value="1"> Radio Option 1

  <input type="radio" name="radio" value="2" checked> Radio Option 2 Pre-checked

  <input type="radio" name="radio" value="3" disabled> Radio Option 3 Disabled

  <input type="checkbox" name="checkbox" value="3"> And checkbox

 <button type="submit" class="btn radius color-white background-color-green hover-background-color-blue transition-fast cursor-pointer">Submit</button>

 </form>
Copyright 2015 Joey Lea. All rights reserved.


last updated on 2 April 2003
The input formats that can be handled by the translator are DORADE_FORMAT, WSR_88D_FORMAT, UF_FORMAT, NCAR's FOF_FORMAT, HRD_FORMAT and NETCDF_FORMAT. References to P3 and HRD are considered synonymous in this context. In addition in-house formats (e.g., ELDORA_FORMAT and PIRAQ_FORMAT) may be used as input to SOLO.
Translators are driven with environment variables usually set in a script file. This file can be named by the user and must be executable. To make a file executable the protection must be changed with the chmod command.For example:
chmod 755 script_file_name
This will give the owner, group and world executable privileges while providing only the owner with read and write abilities.
A typical script might look like:
# Batch Mode C-Shell script to produce dorade sweep files # from WSR_88D radar tapes # setenv BATCH_MODE # omit for interactive mode setenv INPUT_FORMAT "WSR_88D_FORMAT" setenv OUTPUT_FLAGS "SWEEP_FILES" setenv DORADE_DIR /scr/mead/nexrad setenv PROJECT_NAME "NEXRAD" setenv RADAR_NAME "KFTG" setenv COMPRESSION_SCHEME "HRD_COMPRESSION" setenv TIME_LIMITS "08/03/94:21:30 < 08/03/94:23:30" setenv FIXED_ANGLES "0.0 < 2.0 4.0 < 5.0" setenv SOURCE_DEV /dev/nexa nice +11 /local/bin/xltrsii # be sure to specify the proper # path to the translator #
Typing this executable script name at the prompt should create compressed sweep files and a catalog of scans with elevation angles between 0 and 2 degrees and 4 and 5 degrees in the "/scr/mead/nexrad" directory for the time period indicated on August 3, 1994 from the data tape in the source device /dev/nexa. The last line of the script invokes the actual translator program. Be sure that the full pathname of the executable is specified, or that your environment variable "PATH" is set to include the proper version of the executable. When substituting your source device, be sure to specify a device name which is Berkeley compatible. On Suns running Solaris, this might be /dev/rmt/0bn. If you are not sure which device to use, check with your system administrator.
Interactive mode is also available. The script for the interactive mode can be exactly the same as the batch mode but the line "setenv BATCH_MODE" must be removed. A typical interactive mode script might look like:
# Interactive mode C-Shell script to produce dorade sweep files # from WSR_88D radar tapes # setenv INPUT_FORMAT "WSR_88D_FORMAT" setenv OUTPUT_FLAGS "SWEEP_FILES" setenv DORADE_DIR /scr/mead/nexrad setenv PROJECT_NAME "NEXRAD" setenv RADAR_NAME "KFTG" setenv COMPRESSION_SCHEME "HRD_COMPRESSION" setenv SOURCE_DEV /dev/nexa nice +11 /local/bin/xltrsii #
To invoke the translator, type the script filename at the prompt. The following menu should appear:
-1 = exit program (-2 exits from some other prompts) 0 = continue 1 = repeat last run
You are now in the interactive version of the translator. Typing a 0 and hitting <return>, or just hitting <return> should bring up the next menu which looks like the following:
-2 = Exit -1 = Begin processing 0 = Skip rays 1 = Inventory 2 = Skip files 3 = Rewind 4 = 16-bit integers 5 = hex display 6 = dump as characters 7 = Skip records 8 = Forward time skip 9 = Fixed angle search 10 = Set Input Limits 11 = Display headers 12 = Display data 13 = Time correction 14 = Sweep time tolerance 15 = Rotation angle tolerance Option =
This version of the translator gives you more flexibility to move around in and familiarize yourself with what the data contain, whereas batch mode is more useful if you are familiar with the data and with exactly what times and angles you want to use. The following is a brief description of the options in the above menu.
-1 = Begin processing the data by loading in the number of scans specified in option 10 of the menu or by cataloging the data, whichever was specified in the script. After the requested number of scans have been processed, the program looks for an end-of-file mark and then stops. If the number of scans is not specified before you begin processing, the program will continue until reaching the end-of-tape, unless a time limit was specified in the script. 0 = Skip through the data ray by ray. May not go back as far as you want because only a certain number of records are kept around. This is mainly for formats where there may be several rays per physical record like NEXRAD, where you may want to back up a few rays. 1 = Inventory the data, beam by beam (display azimuth, elevation, etc., for each beam). 2 = Skip forward and backward through the data by files. 3 = Rewind the tape to the begining. 4 = Display the current record as 16-bit integers. 5 = Display the current record as hexidecimal (base 16). Makes it easier to see bit patterns. 6 = Interpret a byte in the data as a character if it can. 7 = Move around in the data by records. Negative numbers can be used in order to skip back. 8 = Skip ahead in time either by giving a specific time, or by specifying the number of hours, minutes, or seconds to skip. 9 = Search forward for a specified fixed angle. Specify the nominal angle, and a tolerance. For example, typing 2.0 0.5 would set the translator searching for a fixed angle between, and including, 1.5 and 2.5 degrees. You only need to give the range number if you want to change its value other wise the last one used will be remembered. The default is a 0.2 degree range. 10 = Brings up the following sub-menu, which allows you to set different limits for the control of sweep file output. 0 = Cease - Go back to previous menu 1 = Enter time span - Specify time limits in which data is processed 2 = Enter scan count - Set the number of sweep files written to disk 3 = Enter volume count - Specifies the number of volumes to process 4 = Enter ray count - Number of rays translator will process 5 = Enter fixed angle limits - Used if you only want certain angles processed 6 = Enter PRF limits - Will only process scans with prf's within this limit 7 = Enter num lines in browser display - allows you to customize the number of lines you want the translator to display in your window 11 = Give a listing of the header information. 12 = Show the actual values for each field contained in the data.
When you are in the options that display headers or data (usually items after item 10), typing a positive number, n, causes a redisplay beginning n lines further than the first line in the current display; typing a negative number causes a redisplay beginning n lines previous to the first line of the display. Typing a number that is greater than the number of lines in the listing causes the final lines in the listing to be displayed, and typing a large negative number causes the first lines in the listing to be displayed. To exit the display, type a non-numeric character followed by a return.
After some data (at least one full sweep) have been loaded to disk, you are ready to begin using SOLO. When using the interactive version of the translator to search through data, you may want to keep it going in one window and to open SOLO in another. SOLO is able to see new data as they are read to disk without exiting and re-entering the program. It may be necessary to "pop up" the sweep widget and display the list of sweeps to display the newer sweeps, since SOLO does not rescan the directory for every sweep it plots.
You might also find it helpful to use the GNU emacs directory editor (dired) for selectively deleting sweep files. On many systems you type emacs preferably from the directory where you want to do the deletion. Then type <CTRL>x and then a "d" and you will be prompted for the directory name. If you are already in the directory you can just type <return>. Once you have a list of files you can move around with the arrows and type a "d" at each file you wish to delete. When you want to delete the files you have flagged, type an "x" and you will get a list of the files emacs is going to delete. Type "yes" to confirm.
setenv BATCH_MODE ""
Since tokens in strings are expected to be seperated by spaces or
tabs, all ordered triplets in environment variables such as
"800 < 2000" in
setenv PRF_LIMITS "800 < 2000"should be seperated by spaces or tabs. The "<" has no significance except to emphasize the relationship between the two values on either side.
Quotes are needed whenever the value of a variable includes blanks or unusual characters. Omission of necessary quotes will cause unexpected results!
A list of currently defined environment variables follows (in the list, the environment variable is provided first, followed by an example of its usage, followed by a description of usage):
setenv NCP_THRESHOLD_VAL "NCP .333"
setenv SW_THRESHOLD_VAL "SW 6.0"
It is also possible to threshold on power using the environment variable:
setenv PWR_THRESHOLD_VAL "DBZ -12.34"It can apply to three cases:
DORADE_FORMAT ELDORA_FORMAT FOF_FORMAT HRD_FORMAT NETCDF_FORMAT PIRAQ_FORMAT PIRAQX_FORMAT SWEEPFILES_FORMAT UF_FORMAT WSR_88D_FORMAT
What follows is a script for DORADE input. The only required variables are INPUT_FORMAT, SOURCE_DEV, and DORADE_DIR. This would produce a catalog of the data in the directory designated by DORADE_DIR.
# C-Shell script to produce dorade sweep files # from DORADE radar tapes or tape images on disk setenv INPUT_FORMAT "DORADE_FORMAT" setenv SOURCE_DEV /dev/rmt/0bn # or a tape image on disk setenv DORADE_DIR /dt/oye setenv OUTPUT_FLAGS "NO_CATALOG SWEEP_FILES" setenv TIME_LIMITS "02/09/93:16:50:50 < 02/09/93:16:53" setenv COMPRESSION_SCHEME "HRD_COMPRESSION" # to save disk space nice +11 /rdss/solo/bin/xltrsii #Other environment variables unique to this format are ASCENDING_ONLY, TIME_CORRECTION, and OPTIONS "ROT_ANG_SECTORS". ASCENDING_ONLY eliminates sweeps where the antenna has repositioned to rescan a lower elevation within the same volume. TIME_CORRECTION expects a floating point time in seconds to be added to the time stamp of each beam. ROT_ANG_SECTORS enforces the use of the rotation angle for the sectors defined by the AZ_SECTORS environment variable.
OPTIONS flags for this format are NEW_NCDC_BLOCKING, REFLECTIVITY_ONLY, VELOCITY_ONLY, MAX_RANGE and RANGE_AMB:nnn (nnn is the reflectivity value assigned whan the range ambiguity flag is set). The NCDC blocking option applies to physical tapes aquired from NCDC after May 2001. Reflectivity data is normally truncated at the point where the velocity ends. For MAX_RANGE the gate spacing becomes 500 meters rather than 250 meters yielding the same number of gates with decimated velocity data.
If you're using the soloii version of the translators (xltrsii), all tables used for translating 88D data are internal. If you need to supply new information not in the internal tables, use the environment variables described above or if you have and edited version of the NEXRAD site information file, you can supply it with the NEXRAD_SITE_INFO environment variable.
OPTIONS flags for this format are UF_360_MAX_SECTOR and UF_FORCE_EOF_VOLS. Max sector forces a new sweep whenever the antenna has swept through a total of 360 degrees and force vols causes a new volume to be defined whenever and EOF is encountered in the input stream.
Additional environment variables are MAX_UF_CELLS, RENAME, WATCH_FIXED_ANGLE, GENERATE_SUBSECOND_TIMES, FORCE_EOF_VOLS, and INPUT_FILES_LIST which points to a file containing more than one source device name. This variable takes precedence over the SOURCE_DEV variable.
Since the number of cells/bins/gates is fixed for DORADE for a given volume, and the number of gates in UF can vary from field to field and ray to ray, MAX_UF_CELLS fixes the DORADE cell vector size in case the number of gates is varying in the UF data.
RENAME expects a set of ordered triplets of the form "old_name < new_name" for changing the radar name (spaces are manditory).
WATCH_FIXED_ANGLE begins a new sweep when the fixed angle changes in case the sweep number doesn't change.
GENERATE_SUBSECOND_TIMES addresses the situation where the time stamp is to the nearest second and more than one beam is generated per second. If a nonzero argument is provided it is assumed to be the fraction of a second increment for subsequent beams within the same second otherwise a calculation if performed based on the PRF and the number of samples per beam.
FORCE_EOF_VOLS forces a new volume flag even if the volume number has not changed in the source data.
# C-Shell script to produce dorade sweep files # from UF radar tapes or tape images on disk setenv INPUT_FORMAT "UF_FORMAT" setenv SOURCE_DEV /dev/rmt/0bn # or a tape image on disk setenv DORADE_DIR /dt/oye setenv OUTPUT_FLAGS "NO_CATALOG SWEEP_FILES" setenv MAX_UF_CELLS 512 # sets max. cell vector size if num gates is varying nice +11 /rdss/solo/bin/xltrsii #
The translators separate the HRD tail radar data as if it were two radars, and data are designated as fore "TF" or aft "TA" depending on the tilt angle. Environment variables unique to this format are:
FORE_ANGLE_LIMITS specifies the limits of the elevation angles for the data assigned to be the fore radar.
AFT_ANGLE_LIMITS specifies the limits of the elevation angles for the data assigned to be the aft radar.
KEEP_ORTHOGONAL_DATA specifies that tail data outside the FORE and AFT_ANGLE_LIMITS is to be preserved. The default is to discard these data. These data have the designation TA (e.g. TA43P3).
HRD_RANGE_DELAY specifies the number of initial gates to ignore. e.g. a value of 19 indicates that the 20th gate should be considered the first gate of data. The range to the first gate is still the same.
HRD_VOLUME_HEADER specifies a fortran-binary file containing volume header information in case these data are missing from the beginning of a particular input file.
Environment variables unique to this format are:
TIME_CORRECTION specifies the additive time correction in seconds.
YEAR_OF_DATA specifies the 4 digit year of the data.
ELDORA_VOLUME_HEADER specifies a fortran-binary file containing volume header information in case these data are missing from the beginning of a particular input file.
AC_NETCDF_FILES specifies the full path names of one or more netCDF Aircraft insitu data files.
AC_NETCDF_ALIASES specifies replacment names for the following variables that were originally assumed to be on the tape. HGME, PITCH, ROLL, THDG, VEWC, VNSC, VNSC, LATC, LONC, PALT, UIC, VIC, and WIC
In the following example LAT becomes the field searched for rather that LATC and the NOT alias implies not to substitude the value from the aircraft insitu tape for the value on the ELDORA raw tape.
AC_TIME_CORRECTION specifies a additive time correction to the aircraft time to help synchronize it with the current radar beam time.
OPTIONS flags for this format are:
AC_COMPARE specifies sending navigation information plus the time stamp to the catalog at the start of each sweep.
DESC_SEARCH specified a search for the next descripter rather than using the size of the current descripter to move to the beginning of the next descripter. There were some data sets where parts of descripters were missing.
ROT_ANG_SECTORS specified using the rotation angle rather than the azimuth in conjunction with the AZ_SECTORS environment variable.
Other applicable environment variables are:
RENAME which renames the radar.
UNIFORM_CELL_SPACING which forces the cell or gate spacing to be the specified number of meters.
RADAR_LATITUDE in degrees as a decimal fraction.
RADAR_LONGITUDE in degrees as a decimal fraction.
RADAR_ALTITUDE in meters.
RCONST_CORRECTION is an additive correction to reflectivity.
IMPROVE_HZO_RCONST_CORR is an additive correction to reflectivity in horizontal only mode.
ZDR_BIAS is an additive correction in db.
LDR_BIAS additive correction in db.
RANGE_CORRECTION additive correction in meters.
TIME_CORRECTION additive time correction as a floating point seconds.
The following set of environment variables are used to attempt scan delineation in the absence of the scan and volume counters in later revs.
MIN_AZ_DIFF (default = .3) is used to detect a turnaround in the SIMPLE_SWEEPS option by comparing the last two anglular differences to this value.
az_turnaround = ( fabs(ddaz) > min_az_diff && fabs(daz) > min_az_diff && (ddaz + daz) * pui->az_diff_sum < 0 ) || short_sum_az_diffs * pui->az_diff_sum < 0;It's also used to detect a possible transitioning to the next RHI by comparing it to the short_avg_az_diff so as not to trigger a new sweep flag
if(fabs(short_avg_az_diff) > min_az_diff) { /* MIN_AZ_DIFF */ /* moving in azimuth hopefully to the next rhi */ return(NO); }to detect the beginning of a PPI;
if(fabs(short_avg_az_diff) > min_az_diff && fabs(short_avg_el_diff) < ppi_el_tol ) { /* * using MIN_AZ_DIFF and PPI_EL_TOL * * moving in azimuth and not moving in elevation */ gri->scan_mode = PPI; pui->lag_rays = lag_rays; return(YES); }and to detect a slowing of azimuthal motion indicating a transition
if(fabs(avgDaz) < .5 * min_az_diff) { /* MIN_AZ_DIFF */ /* * slowing down in azimuth */ pui->transition_count++; printf( "t2:" ); return(NO); }MIN_EL_DIFF (default = .2) is used to detect the start of the next RHI after an RHI
if(fabs(short_avg_el) > min_el_diff) { /* MIN_EL_DIFF */ /* antenna moving vertically */ return(YES); }It's also used to detect if the antenna has stopped moving vertically.
if((fabs(pui->el_diff_run_sum) < min_el_diff)) { /* * we are examining the sum of the differences between * ths last NUM_EL_DIFFS_AVGD rays not the whole sweep * * the antenna has stopped moving vertically */ printf( "t9:" ); pui->transition_count++; return(NO); }to detect along with the RHI_AZ_TOL the beginning of an RHI
if( fabs(short_avg_el_diff) > min_el_diff && fabs(short_avg_az_diff) < rhi_az_tol ) { /* * MIN_EL_DIFF and RHI_AZ_TOL * * moving in elevation and "not" moving in azimuth */ gri->scan_mode = RHI; pui->lag_rays = lag_rays; return(YES); }MIN_FXD_DIFF (default = .15) is used to rule out the transition to a new volume.
if(fabs(pui->swpang_diff_sum) < min_fxdang_diff) { return(NO); }or to detect a new volume
if(fabs(diff = angdiff(sq->last->swpang, gri->fixed)) > min_fxdang_diff) { if(diff * pui->swpang_diff_sum < 0) { /* the antenna has reversed its normal increment */ return(YES); } }or along with the PPI_EL_TOL to detect new sweep
if( fabs(short_sum_el_diffs) < ppi_el_tol ) { /* PPI_EL_TOL */ /* * antenna is stable for several beams but too far away * from the current fixed angle (MIN_FXD_DIFF) */ if(FABS(gri->fixed - short_avg_el ) > min_fxdang_diff) { printf( "t0:" ); return(YES); } }PPI_EL_TOL (default = .77) in addition to the above is used to flag a transition
if( fabs(pui->el_diff_run_sum) > ppi_el_tol ) { /* PPI_EL_TOL */ /* * moving away from cont. elev. */ pui->transition_count++; printf( "t1:" ); return(NO); }RHI_AZ_TOL (default = 1.5) see above.
MAX_RHI_DIFF (default = 9.0) is used to detect the start of a PPI after an RHI
if( fabs(pui->x_az_diff_sum) > max_rhi_diff ) { /* MAX_RHI_DIFF */ /* * change in az since transition began > next reasonable rhi * end of RHIs */ gri->scan_mode = PPI; return(NO); }NUM_AZ_DIFFS_AVGD (default = 5) is used to detect a slow down in azimuth motion,
NUM_EL_DIFFS_AVGD (default = 5)
NUM_SHORT_AVG (default = 5)
VOLUME_HEADER, full path name of a file containing the initial radar header. TAPE_DIR, constructs a list of all the files with the suffix ".tape" and passes through them. ,
OPTIONS flags for this format are:
SIMPLE_SWEEPS specifies scan delineation by detecting the antenna turnaround points. This works for sector PPIs only.
RANGE0_DEFAULT forces the range to the first gate to be 150 meters.
FLIP_VELOCITIES corrects the sign error in somee of the earliest velocity data.
FULL_MATRIX specifies the inclusion of cross correlation fields and where present I and Q fields.
HEADER_SUBSEC specifies use of the subsecond value in the header to assign a time stamp to the beam.
SPOL_HORZ_FLAG causes the pcorr_const to be 0x1000000/1.25E-7 instead of 0x2000000/1.25E-7.
DOW_FLAG flags the presence and use of scan and volume counters for delineating sweeps and volumes.
DZ_TO_DBZ_FLAG forces the naming of the reflectivity field DBZ rather than DZ.
IGNORE_TRANSITIONS specifies omitting beams where the transition flag is on.
HZO_IMPROVE_FLAG sets a fudge factor for the range to the first gate for horizontal only IMPROVE data (currently set to 6.0).
if( hdr->dataformat == DATA_SIMPLEPP && pui->options & HZO_IMPROVE_FLAG ) { gri->range_b1 = 150 - Improve_range0_offset * gri->bin_spacing; }
Applicable environment variables are:
RENAME which renames the radar.
SITE_NAME to set the radar site name.
PROJECT_NAME to set the project name.
RADAR_LATITUDE in degrees as a decimal fraction.
RADAR_LONGITUDE in degrees as a decimal fraction.
RADAR_ALTITUDE in meters.
RCONST_CORRECTION is an additive correction to reflectivity.
ZDR_BIAS is an additive correction in db.
RANGE_CORRECTION additive correction in meters.
TIME_CORRECTION additive time correction as a floating point seconds.
TAPE_DIR constructs a list of all the files with the suffix ".tape" and passes through them.
The following set of environment variables are used to help improve scan delineation:
NEW_SWEEP_AT_AZ, if set, will cause a new sweep to be started whenever the scan mode is PPI or SUR and the azimuth crosses the given angle. When used, NEW_SWEEP_AT_AZ is typically set to 0.0.
MIN_AZ_DIFF (see MIN_AZ_DIFF under PIRAQ_FORMAT)
MIN_EL_DIFF (see MIN_EL_DIFF under PIRAQ_FORMAT)
PPI_EL_TOL (see PPI_EL_TOL under PIRAQ_FORMAT)
RHI_AZ_TOL (see RHI_AZ_TOL under PIRAQ_FORMAT)
NUM_AZ_DIFFS_AVGD (see NUM_AZ_DIFFS_AVGD under PIRAQ_FORMAT)
NUM_EL_DIFFS_AVGD (see NUM_EL_DIFFS_AVGD under PIRAQ_FORMAT)
NUM_SHORT_AVG (see NUM_SHORT_AVG under PIRAQ_FORMAT)
OPTIONS flags for this format are:
DOW_FLAG flags the presence and use of scan and volume counters for delineating sweeps and volumes.
FULL_MATRIX specifies the inclusion of cross correlation fields and (where present) I and Q fields.
HEADER_SUBSEC specifies use of the subsecond value in the header to assign a time stamp to the beam.
IGNORE_TRANSITIONS specifies omitting beams where the transition flag is on.
PIRAQX_TRUST_TIME indicates that the time in ray headers is good to subsecond precision. Otherwise, the 'nanosecs' field of the header is considered useless, so more precise beam times are calculated using the 'pulse_num' field, and the 'secs' and 'nanosecs' fields get overwritten.
PIRAQX_100X_NANOSECS indicates that the 'nanosecs' field of the header contains accurate values, but needs to be multiplied by 100 to get the correct value. This option only has effect if PIRAQX_TRUST_TIME is also set.
RABID_DOW disables scan angle smoothing, which is applied by default to PIRAQX data.
There is a feature where the input and the output are sweepfiles. This feature currently provides for rewriting the files with new correction factors and remerging of aircraft navigation parameters. This feature rewrites the input sweepfiles.
SWEEP_FILES DORADE_DATA UF_DATA NETCDF_DATA GECHO_DATA
Environment variables unique to DORADE_DATA are:
MAX_VOLUME_SIZE in megabytes.
DORADE_VOLUME_INTERVAL Volumes of aircraft data are often very long. This variable is the maximum length in seconds of a volume of data. Normally for ground based data it is desirable to respect the volume boundaries of the original data.
MAX_MEDIA_SIZE in megabytes.
MIN_VOLUME_TIME_SPAN in seconds.
MIN_TIME_GAP in seconds before going to a new volume.
PRESERVE_SWEEP_FILES (default = 0) specifies preserving a sweep file every N seconds for each radar during DORADE output.
DORADE_IO_TYPE " BINARY_IO PHYSICAL_TAPE".
DORADE_DEV If the string "/dev" occurs anywhere in this specification, the software assumes you will be writing to tape(s); if not, the software assumes you are specifying a destination directory for DORADE data different from the DORADE_DIR directory. The name of the file will be manufactured by the translator program.
Other applicable environment variables for UF_DATA are:
UF_OUTPUT_FIELDS "DBZ NCP VR" causes output of only the fields listed otherwise all source fields are output.
OPTIONS "NO_UF_CLIP UF_VOL_TRAP" The option NO_UF_CLIP forces the gate count to be the same for all rays otherwise the ray ends at the last good gate. UF_VOL_TRAP monitors the fixed angle and triggers a new volume when the current fixed angle is less than or equal to the previous fixed angle.
UF_ALIASES. a set of ordered triples "DBZ -> DZ" to rename source fields before they are written out. The first element is the source name the second is an arbitrary separator and the third is the new name. Elements need to be separated by white space
MAX_MEDIA_SIZE in megabytes.
UF_DEV "TF > /dev/nrsx0 TA > /dev/nrsx1". This variable is most often used when going directly from an input to tape output. The arguments are ordered triples where the first element is a unique subset of the radar name, the second is a separator and the third is the device name all separated by white space.
Environment variables unique to GECHO_DATA are:
GECHO_MIN_GATES which sets the minimum number of cells for each ray of ground echo information to include in the ground echo file.
GECHO_REFL specifies the parameter name of the reflectivities used in the ground echo file.
GECHO_VEL specifies the parameter name of the velocities used in the ground echo file.
GECHO_MSL specifies the use of the pressure altitude in the ground echo calculation..
EARTH_RADIUS specifies the earth readius in km. to use in the ground echo calculation.
GECHO_MAX_ROT_ANGLE (default = 100.) specified the CCW limit of the sector where the ground echo location is calculated.
GECHO_MIN_ROT_ANGLE(default = 260.) specified the CW limit of the sector where the ground echo location is calculated.
Unique OPTIONS flags for this output are:
GECHO_10 specified the output of the first 10 gates of data rather than gates surrounding the calculated ground echo location.


{% extends "website/base.html" %} {% block content %} {% include "website/includes/undercutter/fraction-card.html" %} {% if data %} {% include "website/includes/table-card.html" %} {% endif %} {% endblock %}


Garrett Wants To Go To The Moon
When you have tried the rest, why not travel to the best?
"It was fine." - Buzz Aldrin


Working with visible object trees is quite easy and provides immense flexibility to your applications. Entire groups of objects can be added to, removed from, or moved around in the display with a single command. New objects can be created during execution, and others can be destroyed at will.
Often, an object in the visible tree will need to contact its parent or its children. For example, a child that needs to know the state of its parent must be able to find and contact that parent. Likewise, a parent that must notify all its children to redraw themselves must be able to quickly send out the notification.
An object can send a message to its parent by simply specifying
@visParent
as the message recipient. That same object could also contact all its children by specifying the recipient as
@visChildren
. The message sent (only with
@send
since there are multiple destinations) will go to each of the object's children.
If you need more complicated message passing, you can build this into your Vis subclasses. It is not difficult for an object to retrieve the optr of any of its children or of its parent; it can then send the message appropriately. Each recipient can handle it in the same manner, forwarding it on to the next layer of the tree.
VisClass
also employs several messages known as "visual upward queries," or "VUP" messages. These travel up the visible tree until they encounter an object of the proper class, where they will be handled.
VisClass
and
VisCompClass
can handle messages that retrieve various information about the visible tree. They also have messages for altering the visible tree's structure.


Duration
15 minutes
Goals
In this lab, you will code a multi-touch drawing application that will let you draw several lines at the same time. Each line will use a randomly-generated color. The screenshot below shows the finished app with a simple user-created drawing.
Required assets
The Resources folder for this part contains a Start solution you will use as starter code and a Completed solution you can use to check your work.
Challenge
Use the high-level guidelines here to complete the exercise. Detailed instructions are provided below if you would like more information.
The starter project contains a single Activity
that displays a custom View
.
You'll add code to the custom View to track and visualize simultaneous touch events.
- Open the XamPaint solution in the Start folder from the Resources for this part.
- Override the
OnTouchEvent
method. All your code will be added in this method. - Create a
switch
statement based onActionMasked
. - Add cases to the
switch
for each of the 5 Actions you need to handle. - At the end of each case, you will need to return
true
to indicate you have handled the event. - Add a
default
case that returnsfalse
. - When a finger touches the screen: create a new
Path
, move the path to the initial X/Y point, and add the path to dictionary of current lines and the list of all lines. Use the pointer ID as the dictionary key. You will also need to create a newPaint
object using the supplied helper method and add it to theList
ofPaint
s. - When you receive a
Move
action, update all current lines so they include their new X/Y point. - When a finger leaves the screen, remove the associated
Path
from the dictionary. - Run the app to test your work.
Steps
You can either use the above guidelines or follow the step-by-step instructions shown here.
Open the XamPaintMultiTouch start solution
- Open the Start solution in the Resources folder for this part.
- Open PaintView.cs, all your work will be done in this file.
-
Locate the
Dictionary
field. It will store the lines that are currently "in process" (i.e. the ones the user is currently drawing).  Notice that the dictionary maps fromint
toPath
. You will use the pointer ID as the dictionary key and the path as the value. This will let you easily lookup a path using the pointer ID. -
Locate the
List
field that storesPath
objects. This will hold all the lines the user has drawn during the current session. You will add a path to it whenever a new finger contacts the screen. You will not need to remove lines from the list - they only need to be removed when the user clicks the Clear button and that code has been provided for you. Feel free to examine the implementation of theClear
method to see this. -
Locate the
List
field that storesPaint
objects. This will hold the paint colors used for each line. You will use the suppliedGenerateRandomColorPaint
method to create a newPaint
whenever a new finger contacts the screen. You will then add thePaint
to this list. You will not need to removePaint
s from the list - they only need to be removed when the user clicks the Clear button and that code has been provided for you. Feel free to examine the implementation of theClear
method to see this. -
Locate the
OnDraw
method. Notice that it redraws all lines when anything changes. This technique was selected intentionally even though is not the most efficient solution. It is simple to code and keeps us focused on the touch events rather than adding extra code to optimize the drawing performance.
Override OnTouchEvent
-
Override the
OnTouchEvent
method in thePaintView
class. All your work will done inside this method. -
Add a
switch
statement based on theActionMasked
property of theMotionEvent
parameter. -
Add
case
s for theMotionEventActions
valuesDown
,PointerDown
,Move
,PointerUp
andUp
. -
At the end of each case, you will need to return
true
to indicate you have handled the event. -
Add a
default
case that returnsfalse
.
Create a new Path
and Paint
when a finger touches the screen
When a finger touches the screen, you will create a new Path
object for the finger,
add the starting point, and store it in both the dictionary and the list.
You will also need to create and store a Paint
object for this line.
These operations apply to both the Down
and PointerDown
cases.
-
Begin in the
MotionEventActions.Down
case. In this case, you know there is just one finger on the screen and information about it is at index 0. -
Get the current pointer ID using the
GetPointerId
method on theMotionEvent
, passing in0
. -
Get the X and Y coordinates of the finger using the
GetX
andGetY
methods, passing in0
. -
Create a new
Path
object. -
Call
MoveTo
on the path and pass it the X/Y coordinates. -
Add the path to the
Dictionary
using the pointer ID as the key. -
Add the path to the
List
ofPath
objects. -
Use the
GenerateRandomColorPaint
method to create aPaint
object. -
Add the
Paint
to theList
ofPaint
objects. -
Repeat the above steps for the
MotionEventActions.PointerDown
case. This case is used when a new finger contacts the screen while there are other fingers present. The only difference between the this case and the last one is that here you must useActionIndex
in your calls toGetPointerId
,GetX
, andGetY
. The code for the two cases is nearly identical. If you have time, feel free to refactor the code to remove the repeated parts. Note that the solution code does not do the refactoring in order to keep it simple.
Update lines when pointers move
When a Move
action occurs, you need to update all the current Path
s with the new X/Y points.
Remember that a Move
action reports the updated position of all fingers currently touching the screen.
-
Iterate through every active pointer using a
for
loop and thePointerCount
property on theMotionEvent
. -
Retrieve the pointer ID for the current finger using the
GetPointerId
method. Use the loop variable from yourfor
loop as the parameter. -
Retrieve the X and Y coordinates for the current finger using the
GetX
andGetY
methods. Use the loop variable from yourfor
loop as the parameter. -
Retrieve a
Path
from theDictionary
using the pointer ID as the key. -
Call
LineTo
on thePath
and pass it the X/Y coordinates. -
Outside the loop, call
Invalidate
to force a redraw of the view.
Respond to the Up actions
When a finger leaves the screen, you need to remove its associated Path
from the Dictionary
.
You will be working in the MotionEventActions.Up
and MotionEventActions.PointerUp
cases.
The only difference between the two cases is the parameter you use to get the pointer ID:
for MotionEventActions.Up
you use 0
and for MotionEventActions.PointerUp
you use the ActionIndex
.
-
Find the pointer ID using the
MotionEvent
'sGetPointerId
method, passing in0
or theActionIndex
as appropriate. -
Use the ID to remove the
Path
from theDictionary
; remember the ID is the dictionary key. - Run the app to test your work.
Optimize drawing (Optional)
OnDraw
callback.
This requires some knowledge of the Canvas
and Bitmap
classes as well as many
changes to the current code. The guidance provided here is not complete in every detail; however, a
full solution is available in the Completed_OptimizedDrawing folder.
Due to time constraints, this part is intended to be an after-class exercise.
The current implementation redraws all the lines whenever any of them change. As a performance optimization,
you could draw the lines into a bitmap as the user creates them and then copy the entire bitmap to the screen
in OnDraw
.
-
Begin with the solution to the previous part. All your work here will be done in the
PaintView
class. -
Remove the
Dictionary
andList
fields that stored thePath
objects and all code that used thePath
s throughout thePaintView
class. The new drawing technique will not usePath
. -
Add a
Dictionary<int, Paint>
field namedpaints
. Initialize it to a new instance on the line where you declare it. -
A
Bitmap
is a grid of pixels. It has a width and a height. Each pixel can be addressed using an X/Y coordinate pair of integers. Each pixel has a color specified using an integer.Bitmap
provides methods to get/set the values of individual pixels. There are also a few methods to work with a group of pixels simultaneously. Add aBitmap
field nameddrawingSurface
to thePaintView
class. -
A
Canvas
is a collection of drawing methods.Canvas
does not have an intrinsic destination for the drawing; you need to supply aBitmap
when you create theCanvas
. For example,Canvas
has aDrawLine
method that will calculate which pixels in the underlyingBitmap
should be modified and then go ahead and set those pixels for you. Add aCanvas
field nameddrawingCanvas
to thePaintView
class. -
A
MotionEvent.PointerCoords
object is a container for an X/Y coordinate pair. It gives you a convenient way to store the X/Y location of a touch event. This implementation will use aDictionary
ofPointerCoords
objects to remember the last X/Y coordinate pair for each finger currently on the screen. If we know the previous X/Y coordinates and the current X/Y coordinates, we will be able to draw a line between the two points. Add aDictionary<int, MotionEvent.PointerCoords>
field namedcoords
to thePaintView
class. Initialize it to a new instance on the same line where you declare it. -
To create a
Bitmap
, you use one of the staticBitmap.Create
methods. To create aCanvas
, you usenew
and pass aBitmap
to the constructor. Add the following method to yourPaintView
class. TheBitmap
it creates will match the screen dimensions. The code is inside theOnSizeChanged
method so it re-runs when the device is rotated. Note that our implementation will not preserve the user's drawing across orientation changes. -
Modify the
Down
andPointerDown
cases in yourOnTouchEvent
method. The strategy is to locate the X/Y coordinate of the new touch point and add it to thecoords
Dictionary
. The key will be the pointer ID. You should also create a newPaint
object and add it to thepaints
dictionary. The code forDown
is shown below. The code forPointerDown
analogous so it is not shown here. -
Modify the
Move
case in yourOnTouchEvent
method. The goal is to retrieve the new X/Y coordinates for each finger, grab the previous X/Y coordinates from thecoords
Dictionary
and use theCanvas
'sDrawLine
method to draw a line between those two points. Then update the X/Y coordinates in thecoords
Dictionary
to the new values. The core of the code is shown below (this code will be the body of the loop). -
Modify the
PointerUp
andUp
cases in yourOnTouchEvent
method. Remove thePaint
object from itsDictionary
. Remove thePointerCoords
object from itsDictionary
. -
Replace your implementation of the
OnDraw
method with the one given below. This simply copies yourBitmap
into theCanvas
supplied by Android. This should be more efficient than redrawing all the lines as we did in the previous implementation. -
Replace your implementation of the
Clear
method with the one given below. This overwrites all the pixels in theBitmap
and then forces a redraw of the screen. - Run the app to test your work. It should behave identically to the previous implementation from the user's perspective.
protected override void OnSizeChanged(int w, int h, int oldw, int oldh) { base.OnSizeChanged(w, h, oldw, oldh); drawingSurface = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888); // full-screen bitmap drawingCanvas = new Canvas(drawingSurface); // the canvas will draw into the bitmap paints.Clear(); coords.Clear(); }
case MotionEventActions.Down: { int id = e.GetPointerId(0); paints.Add(id, GenerateRandomColorPaint()); var start = new MotionEvent.PointerCoords(); e.GetPointerCoords(id, start); coords.Add(id, start); return true; }
var id = e.GetPointerId(index); float x = e.GetX(index); float y = e.GetY(index); drawingCanvas.DrawLine(coords[id].X, coords[id].Y, x, y, paints[id]); coords[id].X = x; coords[id].Y = y;
protected override void OnDraw(Canvas canvas) { canvas.DrawBitmap(drawingSurface, 0, 0, null); }
public void Clear() { drawingCanvas.DrawColor(Color.Black, PorterDuff.Mode.Clear); Invalidate(); }
Summary
During this lab, you applied what we have learned about multi-touch in Android to track and visualize touch interactions within a custom view.


/**
* Load all library js files.

* This is called from HttpServer.js or Javascirpts that are executed from another process

*/
var pwa = pwa || {};
load("SERVER-SCRIPTS/lib/JavaType.js");
load("SERVER-SCRIPTS/lib/system/System.js");
load("SERVER-SCRIPTS/lib/system/Command.js");
load("SERVER-SCRIPTS/lib/system/Process.js");
load("SERVER-SCRIPTS/lib/util/File.js");
load("SERVER-SCRIPTS/lib/util/Properties.js");
load("SERVER-SCRIPTS/lib/util/CommandWindow.js");
load("SERVER-SCRIPTS/lib/myLib/LoadMyLib.js");


Total questions: {{ sessionScore.totalClues }}
Me
{{ sessionScore.correct }}
{{ sessionScore.incorrect }}
Everyone
{{ allSessionScore.correct }}
{{ allSessionScore.incorrect }}
Correct answer to previous question:
"{{ previous.correctAnswer }}"
Everyone
{{ previous.everyoneCorrect }}
{{ previous.everyoneIncorrect }}
Estimated time until next question: {{ nextClueSecondsRemaining }}s
Next question coming soon!
(usually within 20 seconds...)


All updates regarding the education will be posted in this page.
Courses we offer
Tutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartTutorials Point originated from the idea that there exists a class of readers who respond better to online content and prefer to learn new skills at their own pace from the comforts of their drawing rooms.
Let's StartThe field of computer graphics developed with the emergence of computer graphics hardware. Today computer graphics is use in almost every field. Many powerful tools have been developed to visualize data. Computer graphics field become more popular when companies started using it in video games. Today it is a multibillion dollar industry and main driving force behind the computer graphics development.
To promote education to all,freely and have to made a country with well educated people in the world.So,Be a active member in our website by surfing daily.
To promote education to all,freely and have to made a country with well educated people in the world.So,Be a active member in our website by surfing daily.
To promote education to all,freely and have to made a country with well educated people in the world.So,Be a active member in our website by surfing daily.
Since capturing an image from a camera is a physical process. The sunlight is used as a source of energy. A sensor array is used for the acquisition of the image. So when the sunlight falls upon the object, then the amount of light reflected by that object is sensed by the sensors, and a continuous voltage signal is generated by the amount of sensed data. In order to create a digital image , we need to convert this data into a digital form. This involves sampling and quantization. (They are discussed later on). The result of sampling and quantization results in an two dimensional array or matrix of numbers which are nothing but a digital image.
Indian education system is quite different from that of the foreign nations. The curriculum in the western countries is known to be quite light and based on practical knowledge whereas in India the focus is on theoretical knowledge and acquiring marks by hook or crook. Students are expected to mug up chapter after chapter and fetch good grades in the class. The marking system in the Indian schools begins from the primary classes thereby burdening little kids. The competition is growing by the day. Parents want their children to outperform their peers and teachers want their class to do better than the other classes. They are so blinded by the urge of staying ahead of the competition that they do not realise that they are pushing the children in the wrong direction. At an age when the students should be given the chance to explore their interests and hone their creative side, they are pressurized to follow a set curriculum and slog day and night to get good marks. Instead of making the students understand various concepts of mathematics, physics and other subjects so that they can use them at different stages in their life, the focus is on blindly learning the chapters whether or not the concepts are understood just so that one can get good marks. So, the very basis of the Indian education system is inappropriate.
Indian education system is quite different from that of the foreign nations. The curriculum in the western countries is known to be quite light and based on practical knowledge whereas in India the focus is on theoretical knowledge and acquiring marks by hook or crook. Students are expected to mug up chapter after chapter and fetch good grades in the class. The marking system in the Indian schools begins from the primary classes thereby burdening little kids. The competition is growing by the day. Parents want their children to outperform their peers and teachers want their class to do better than the other classes.
They are so blinded by the urge of staying ahead of the competition that they do not realise that they are pushing the children in the wrong direction. At an age when the students should be given the chance to explore their interests and hone their creative side, they are pressurized to follow a set curriculum and slog day and night to get good marks. Instead of making the students understand various concepts of mathematics, physics and other subjects so that they can use them at different stages in their life, the focus is on blindly learning the chapters whether or not the concepts are understood just so that one can get good marks. So, the very basis of the Indian education system is inappropriate. Instead of making the students understand various concepts of mathematics, physics and other subjects so that they can use them at different stages in their life, the focus is on blindly learning the chapters whether or not the concepts are understood just so that one can get good marks. So, the very basis of the Indian education system is inappropriate.
Life-Time Membership