FlightSurety
Select flight
Buy insurance for selected flight (pay between 0.01 - 1 Eth)
Buy insurance
Collect insurance in case your flight was delayed due to airline fault
Collect insurance
Query Oracles for flight status to determine if you are eligible for insurance payout
Submit to Oracles


Messages received:
View the console to see logging and to inspect the MediaStream object localStream.
MediaStream
localStream


I am Lawren-Chabad my name means victorious women of God.
I am from Pennsylvania and I have live in Georgia for 12 years so far.
I have a lot of talents and a lot of friends.
I have a lot of aspirations and a lot of goals and I complete anything I
put my mind to with flying colors.
This is my link to google.
I like :
Maltese Puppies
Swimming
Dancing
Inner beauty
Singing
Animals
Real people
Food
coconut choclate chip icecream
Hanging out with friends
Fake people
mean people
hurintg peoples feelings
Food I'm allergic too.
Swimming
Dancing
Inner beauty
Singing
Hanging out with people
Long boarding
Been on a swim meet for 6 years.
I am in the STEM program at my school.
I have an A, B honor role
I am in accelorated chorus
I am on the swim team
I am doing dual enrolllment next years
I have done many accodemic competitions
I Can:
Swim
Dance
Sing
Long boarding
Play the piano
Likes
Dislike
Hobbies
Accomplishments
School Activities/Skills


Building a Unix-shell in Rust - Part 2
This is the 2nd part of a series where I document writing a command shell in Rust. In the previous post I reviewed what a shell is, and broke that down into stages I can use to organize my code.
Getting user input🔗
First thing we need to do is create a project. Let’s use Cargo to create this for us.
$ cargo new --bin rust-shell
For now, I'm going to assume we are only running interactively. So I'm just going to get a simple loop set up that asks for an input, and echoes it back to me.
use std::io;
fn main() {
loop {
let mut command = String::new();
io::stdin().read_line(&mut command)
.expect("Failed to read in command");
println!("{0}", command);
}
}
I’m using std::io to read input into the mutable command variable binding, then I println() to echo my input back to the screen.
Then we build:
$ cargo build
Compiling rust-shell v0.1.0 (file:///Users/telant/src/rust-shell)
Finished dev [unoptimized + debuginfo] target(s) in 0.25 secs
No errors.
And testing it out:
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/rust-shell`
123
123
test
test
Great. Looks like that was easy.
What we see here is me trying 2 commands: 123
and test
. We see the command printed right back. (Printing a short prompt might make that more obvious… )
Parsing the input into tokens🔗
Next step is to break the user input from a single continuous string into smaller pieces that we can evaluate.
I am just going to tokenize the string using spaces as delimiters (because it is easy. It is, however, not always accurate, but, Dear Reader, I already know this is not the final way I am going to implement tokens. Splitting on spaces is too greedy of an approach. Quoted arguments are usually evaluated to be a single argument, including spaces, for uses that include passing entire raw strings to other programs. Let's not get perfection distract us. I'll stay focused on getting something that works...)
I actually ran into a little bit of trouble getting this working on a single line, with the original variable because of the type checker.
This did not work:
$ cargo build
Compiling rust-shell v0.1.0 (file:///Users/telant/src/rust-shell)
error[E0282]: unable to infer enough type information about `B`
--> src/main.rs:11:41
|
11 | println!("{:?}", command.split(' ').collect());
| ^^^^^^^ cannot infer type for `B`
|
= note: type annotations or generic parameter binding required
I’m lazy, and I didn’t look into how to explicitly reference the type.
This did work.
let command_split : Vec<&str> = command.split(' ').collect();
println!("{:?}", command_split);
This is the relevant output
test test test
["test", "test", "test\n"]
blah blah "string in quotes"
["blah", "blah", "\"string", "in", "quotes\"\n"]
I’m going to have to learn how type inference works in Rust sooner or later, but I’m not going to deal with it now. String types in Rust are kind of confusing coming from Python where I don’t have to deal with types very often.
(This is a warning from the future. You should lightly understand the idiomatic difference between String and &str. You find this out the hard way when you get to refactoring… see you in the future)
I’m going to use this moment to make the interface a more obvious when the we are ready to take user input by printing a prompt character.
use std::io::{self,Write};
fn main() {
let prompt_char = "%";
loop {
print!("{0} ", prompt_char);
io::stdout().flush().unwrap();
let mut command = String::new();
io::stdin().read_line(&mut command)
.expect("Failed to read in command");
println!("DEBUG: {:?}", command);
let command_split : Vec<&str> = command.split(' ').collect();
println!("DEBUG: {:?}", command_split);
}
}
I added DEBUG:
to our debug statements. Also I had to include a new use
, use the print!
macro, and flush the buffer so it would print to the screen immediately.
I got this pattern from the Rust docs for print!
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/rust-shell`
% Feeling a little more shell-like now
DEBUG: "Feeling a little more shell-like now\n"
DEBUG: ["Feeling", "a", "little", "more", "shell-like", "now\n"]
%
Classifying parsed input🔗
Last thing I’m going to do is identify the keyword from the arguments, then I’ll do a little refactoring to help organize the new complexity. (I expect to do a little fighting with the borrow checker at this point.)
Getting the keyword is easy. I just need to pick off the first element of our tokenized command.
The arguments is a vector slice of everything but the first element of the command. Can I slice a vector as easily as slicing lists in Python? Yes.
use std::io::{self,Write};
fn main() {
let prompt_char = "%";
loop {
print!("{0} ", prompt_char);
io::stdout().flush().unwrap();
let mut command = String::new();
io::stdin().read_line(&mut command)
.expect("Failed to read in command");
println!("DEBUG: Raw input: {:?}", command);
let command_split : Vec<&str> = command.split(' ').collect();
println!("DEBUG: Split input: {:?}", command_split);
let keyword = command_split[0];
let arguments = &command_split[1..];
println!("DEBUG: Keyword: {0}", keyword);
println!("DEBUG: Number of arguments: {0:?}\nDEBUG: Arguments: {1:?}", arguments.len(), arguments);
}
}
I have to call the slice by reference using &
with the vector, and I specified the range I wanted to slice with the element I want to start from and ..
without an ending element. Rust figures out the bounds in this case.
Time to refactor!🔗
I’m going to make the main loop look a little more functional (inside the loop).
Printing the prompt? Easy. Function call.
fn print_prompt() {
let prompt_char = "%";
print!("{0} ", prompt_char);
io::stdout().flush().unwrap();
}
Reading the command from user input? I had to look up how to return variables. The style is to use an implicit return, and no semicolon. You can use return
, but it isn't very idiomatic.
fn read_command() -> String {
let mut command = String::new();
io::stdin().read_line(&mut command)
.expect("Failed to read in command");
println!("DEBUG: Raw input: {:?}", command);
command
}
Tokenizing the command? Gonna get a little more complicated. I’m going to set up a struct to represent the command so I can keep the tokenized command together in a single object.
Optional : First fight with borrow checker🔗
I almost lost the motivation to continue the documenting my thought process because of this obstacle. This section can be skipped if you are looking to follow my happy path, and don't want to follow my confusion.

I have to learn a little bit about lifetimes in order to get this to compile. This makes some sense, since the struct will need to own the slice data, and in the original code, we were just borrowing the slice.
I’m finding it confusing thinking about what I need to do in order to make the tokenizing function use the Command struct. If I can copy the args to the struct, and give ownership of the string to the struct, then I assume this will compile?
What type is the copied slice, and how do I specify that in the struct? How do I use the lifetime in code to find my use case? I don’t even know what other questions to ask next.
Rather than try to figure out how to compile, and get the struct working with tokenizing the command, I’ll try to play around in main() and try instantiating my struct.
What I need to be able to do is copy the data in the vector. I tried for a while trying to pass ownership of a slice, but I ended up finding a way to take the first element out of the vector, and having the rest be the arguments be what is left.
This is what the struct looked like.
/// Bad.
struct Command <'a> {
keyword : String,
arguments : &'a [&'a str],
}
The reason I went with this approach was I thought I could pass the ownership of the heap from when I split the command by whitespace. This was really not a good approach, and I wasted quite a lot of time fighting with the borrow checker.
Back to the show🔗
I ended up changing the way I split the original command string so I would have a Vec
I think I have a much more straightforward function.
struct Command {
keyword : String,
args : Vec<String>,
}
fn tokenize_command(c : String) -> Command {
let mut command_split : Vec<String> = c.split_whitespace().map(|s| s.to_string()).collect();
println!("DEBUG: Split input: {:?}", command_split);
let command = Command {
keyword : command_split.remove(0),
args : command_split,
};
command
}
Before getting to the next step of evaluating the parsed command, I want to take a moment to learn how to set up tests that will run with the builds. See you next time.


Your Assignment!
- Create a new Component => DashboardComponent
- Output any content of your choice in that component
- Add a property 'loadState' to your component and set its initial value
to 'loading'
- Output the Loading state (the content of the 'loadState property)
in your template
- Add a button to the component's template and make sure that clicks
on the button set the property 'loadState' to 'finished'
- Allow the user to set his/ her own loading text via two-way-binding


I'm a third year student of computer science at the University of Waterloo. I've previously interned at Asana, Google, and Mitre Media. I'm interested in internship opportunities for Winter 2020! In my spare time, I've worked on some cool projects described below.
VIEW RESUMELook up historical stock info such as value and volatility, and see how effective a moving average trading strategy would have been. Developed using pandas and PyQt. Demo coming soon.


UKCloud Limited (“UKC”) and Virtual Infrastructure Group Limited (“VIG”) (together “the Companies”) – in Compulsory Liquidation
On 25 October 2022, the Companies were placed into Liquidation with the Official Receiver appointed as Liquidator and J Robinson and A M Hudson simultaneously appointed as Special Managers to manage the liquidation process on behalf of the Official Receiver.
Further information regarding the Liquidations can be found here: https://www.gov.uk/government/news/virtual-infrastructure-group-limited-and-ukcloud-limited-information-for-creditors-and-interested-parties
Contact details:
For any general queries relating to the Liquidations please email<EMAIL_ADDRESS>For customer related queries please email<EMAIL_ADDRESS>For supplier related queries please email<EMAIL_ADDRESS>Data collected by UKCloud's Anti-Virus as a Service
Overview
UKCloud harnesses the market-leading cyber security services of SentinelOne as the engine that powers our Anti-Virus as a Service product.
To ensure the utmost accuracy, reliability and protection of our Anti-Virus as a Service product, key endpoint metadata must be securely exchanged between SentinelOne's central cloud platform, which sits outside of UKCloud's data centres, and any customer endpoint that has the SentinelOne Agent installed.
This article defines any such metadata that may be exchanged between a customer's endpoint that has the SentinelOne Agent installed and the SentinelOne central cloud platform.
Note
Any data collected or processed by SentinelOne will be used solely for the delivery of this Anti-Virus as a Service product. A copy of the full data processing agreement that is in place between UKCloud and SentinelOne may be made available upon request.
Data collected by endpoint agent
Virtual machine data
Architecture
Memory
CPU information
Core count
Mac address
User and device data
Agent ID
Endpoint name
Workgroup/domain
User name
Disk encryption state
Installed applications:
Installation time
Size
Publisher
Version
OS type
OS version
SentinelOne Agent version
SMTP username
User login/out time
Process activity
Time of machine activity
Full file path
In cases of suspected threats, the SentinelOne Agent collects for each process:
Hash
File type
Command-line arguments
Network access metadata only:
IP Address
Protocol
Registry:
Created keys
Deleted keys
Modified key names
Network data
Internal network IP address
Public IP address
Inbound/outbound connections, metadata only (source, target, port, and application)
Fetched files
- Any file fetched by user for further inspection (encrypted at rest, deleted after 72 hours)
SentinelOne central platform
General
Users usernames, emails, and phone numbers (UKCloud credentials)
SentinelOne customer corporate name (UKCloud credentials)
Solutions agent information, including endpoint name and user ID
Policies names and policies creator name (UKCloud credentials)
Threat information (exchanged by end-point agent):
File path
Agent IDs
Time stamp
Threat description
Resolution (Yes/No)
Detection source
Agent information
Number of endpoints and respective operating systems
Endpoint grouping information (named as per users selection)
Endpoint crash dumps
Agent logs
Endpoint information:
- Global configuration of connected endpoints
Research data collection
Research data includes certain telemetric data sent from the customer's management consoles to the SentinelOne cloud. From the SentinelOne cloud, the research team extracts research data and uses it to improve the understanding of known malicious behaviors, predict additional likely malicious behaviors, and otherwise improve artificial intelligence-based detection of unknown malware. Research data is stored on AWS servers in the U.S. and consists of the following data components:
Endpoint and Agent build information
Agent boot – Uptime of the Agent service, indicating when endpoints are rebooted, restarted, or the time in which Agents are down due to bugs or other issues
Agent id – Internal identifier of the SentinelOne Agent in use, for communication with its Management
Agent version – SentinelOne software version
Operating system – Which OS is installed on the device
Has timestamp – Internal time stamp
Endpoint Name – Endpoint name given by the customer
File Name – Name of files inspected for suspected malware presence as given by the customer
Process data
- RootName – Process name
Deep visibility data
This data is collected by Agents and correlated by Deep Visibility to provide enhanced details, search and monitor capabilities
General
Network actions
Processes
DNS actions
URL actions
Files
Registry actions
Scheduled Tasks
Logins
Indicators
Modules
K8S/containers
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


Toggle navigation
SPECIAL
Home
Strength
Preception
Endurance
Charisma
Intelligence
Agility
Luck
Do you know
what make' You
Special?
No? Well No worries there thats
What this app is for. Find out what
makes you special in the up coming
game Fallout 4, Just click a Letter.


|
goog.ui.SplitPane.resizeWarningWorkaround_.resize(size)
No description.
Arguments:
|
code » |
|
CSS class names for splitpane outer container.
|
Code » | |
|
CSS class name for first splitpane container.
|
Code » | |
|
CSS class name for the splitpane handle.
|
Code » | |
|
CSS class name for the splitpane handle in horizontal orientation.
|
Code » | |
|
CSS class name for the splitpane handle in horizontal orientation.
|
Code » | |
|
CSS class name for second splitpane container.
|
Code » | |
|
Dummy object to work around compiler warning.
TODO: Fix compiler or refactor to not depend on resize()
|
Code » |


We have changed our mind and so what? – Sammy Gyamfi to NPP
The opposition National Democratic Congress (NDC) continues to justify why they made a u-turn and decided to campaign against the upcoming referendum.
The Minority in Parliament supported the amendment of Article 55 of the 1992 Constitution until the National Chairman of the NDC at a press conference indicated a change of mind and called on Ghanaians to vote ‘No’ in the December 17 referendum.
This decision has been met with some criticisms from the ruling New Patriotic Party (NPP) who feel the NDC acted in bad faith.
The National Communications Officer of the NDC, Sammy Gyamfi reacting to the NPP on UTV's morning show 'Adekye Nsroma' queried; "we have changed our mind and so what?"
Watch his take in the video below:


Who Am I ?
It is simply Im Duha, 28 years old.
really I dont like talke alot,
I prefer to simplify evre things. do you know why because we dont have alot of time
we must take a chances to do all things we love it.
NOW I will tell you what I love and what I dont
The first of all I am in love with spaghetti but I dont like food in general.
I like Puzzles, its make you relax and you have to think deeply to solve it.
I've an eye for detail and identifying problems and seek to find solutions, really I like puzzles.
Belive me its not a big problem and you have to be patient, and but your eyes on details that's it.
And the most important thing is I explored the coding is my passion. It is really like puzzle
Education
When coding is your passion, then you are a real software developer. It is a matter of learning more and more . You have not to stop that. You are in a game and when you stop running and learning you are kicked out. but I am Electrical engineer. And I decided to change my career path to be a software developer.
EXPERIENCE
- 1- Al-Masera Textiles Co, Irbid , Jordan , Quality Assurance , Aug 2019 – Nov 2019
- - Manage implement and maintain a quality plan
- - Monitored performance by gathering relevant production data and producing reports.
- - Assisting technicians with checking patterns, specification and construction, identifying and resolving production impracticalities in an appropriately timely manner.
- 2- Irbid District Electricity Company, Irbid- Jordan , Low Voltage Network Design Trainee Engineer, Jun 2018 – Jun 2019
- - Undertaking system studies such as load flow.
- - Producing detailed engineering reports.
- - Find solutions to improve the network.


{% extends "../../layout.html" %} {% block sectionClasses %}plugins hasBreadCrumb plugins-spincast-logback-utils{% endblock %} {% block meta_title %}Plugins - Spincast Logback Utils{% endblock %} {% block meta_description %}Spincast Logback Utils plugin - Logback easy configuration{% endblock %} {% block scripts %} {% endblock %} {% block body %}
Logback is one of the most popular logger implementations for Java. It works very well with the SLF4J logging facade which is used by Spincast itself.
A challenge with a regular installation of Logback is to configure it
differently on each environment. For example to specify a
DEBUG
level for logs during development but a WARN
level in production.
Logback does provide a way to do some kind of conditional processing of configuration files
but this involves an untyped syntax using a third-party library and requires
passing extra command line arguments or setting extra environment variables.
This plugin provides an easy way to configure Logback, fully integrated with Spincast: you use Java code, with dependency injection support, and you can:
logback-dev.xml
", "logback-acc.xml
" or "logback-prod.xml
",
depending on some logic.
XML
configuration file, for example by replacing some
placeholders before Logback is configured.
Finally, if required, this plugin also allows you to dynamically generate the configurations to be used by Logback, without even requiring a configuration file at all!
When you add this plugin to your application, the default behavior is similar to
including Logback as a regular dependency: a logback.xml
file will be
looked for on the classpath and its content will be used as is.
To get control over how Logback is configured, you need to bind a custom implementation of SpincastLogbackConfigurerConfig. You can extends SpincastLogbackConfigurerConfigDefault as a base for your implementation.
In this implementation, you can specify:
ResourceInfo getResourceInfo()
The path to the XML
Logback configuration file to use.
You can use any logic you need to pick the correct file. For example,
you may choose a logback-dev.xml
file during development and
a logback-prod.xml
file otherwise:
{% verbatim %}
@Override public ResourceInfo getResourceInfo() { String path = getAppConfig().isDevelopmentMode() ? "/config/logback-dev.xml" : "/config/logback-prod.xml"; return new ResourceInfo(path, true); }
By returning an instance of ResourceInfo, you specify if the path you provide refers to a file on the classpath or on the file system.
Note that you can also return null
here! By doing so, you are responsible to
provide the full XML
configuration, as a String, in the tweakContent(...)
method.
String tweakContent(String logbackContent)
This method allows you to modify the content of the configurations as loaded using the getResourceInfo() method.
If you return null
from getResourceInfo(),
you will receive an empty String and you are responsible to build the entire
XML
configurations for Logback.
A common usage of this method is to replace some placeholders in the
base XML
content. For example, let's say the content of the file is:
{% verbatim %}
<?xml version="1.0" encoding="UTF-8"?> <configuration> <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <charset>UTF-8</charset> <pattern>%d{yyyy-MM-dd HH:mm:ss} [%level] %msg ~ %caller{1}</pattern> </encoder> </appender> <root level="{{LEVEL}}"> <appender-ref ref="stdout"/> </root> </configuration>
You could use tweakContent(...)
to replace the {{LEVEL}}
placeholder using logic such as:
@Override public String tweakContent(String logbackContent) { String level = getAppConfig().isDevelopmentMode() ? "debug" : "warn"; return logbackContent.replace("{{LEVEL}}", level); }
Your SpincastLogbackConfigurerConfig
implementation will be automatically used by
the SpincastLogbackConfigurer
component that the plugin will bind using asEagerSingleton().
Because of this, Logback is going to be configured very early during the application startup.
1. Add this Maven artifact to your project:
<dependency> <groupId>org.spincast</groupId> <artifactId>spincast-plugins-logback-utils</artifactId> <version>{{spincast.spincastCurrrentVersion}}</version> </dependency>
2. Add an instance of the SpincastLogbackUtilsPlugin plugin to your Spincast Bootstrapper: {% verbatim %}
Spincast.configure() .plugin(new SpincastLogbackUtilsPlugin()) // ...


We need to verify your identity
We just need some additional information from you to complete the authentication process. Below are the questions based on your Company’s Credit Profile. Please read the questions carefully and select the correct answer to proceed.


This resource offers 37 audios. The production was carried out with the purpose of adding audio to the dialogues and readings included in the Teacher´s Guide for seventh grade.
Start new unit
May I come in? Classroom objects...
This is my _classroom objects_ greetings.
Meeting a new friend-greetings, introductions.
Completing an online profile-questions, introductions.
Scenario: Here I am!
Start new unit
A Day in the life of my high school.
Mario’s daily routine.
Sarah’s daily routine.
Maria’s daily routine.
Letter from a pen pal.
Katherine’s weekly routines.
What Marta and Dan do with free time.
Scenario: Enjoying life
Start new unit
Lauren’s trip to Arenal.
Weekend plans.
My favorite place in Costa Rica.
Where should I go on vacation?
My class trip to Manzanillo.
I love my Costa Rica.
Scenario: Getting back to nature.
Start new unit
At the Store.
My family’s grocery store.
Grocery shopping.
Going shopping.
Does this fit me?
Bargain shopping at the "mercado".
How much does it cost?
Scenario: Checking things off a shopping list.
Start new unit
Mother’s Day.
Christmas.
Weekend plans.
Lantern parade.
Dancing Devils.
Day of the Virgin of the Sea.
Day of the Virgin of "Los Ángeles".
Scenario: Let´s celebrate Costa Rican culture!
Start new unit
Dear diary.
Knowing where it is.
Asking for and giving directions.
Knowing how to get there.
Planning a beach trip.
Making a hotel reservation.
Scenario: Getting from here to there.


Copyright Bruce Wilcox<EMAIL_ADDRESS>www.brilligunderstanding.com
Revision 10/24/2022 cs12.31
Simple output puts words into the output stream, a magical place that queues up each word you write in a rule output. What I didn’t tell you before was that if the rule fails along the way, an incomplete stream is canceled and says nothing to the user. For example,
t: I love this rule. ^fail(RULE)
Processing the above gambits successively puts the words I, love, this, rule, . into the output stream of that rule.
If somewhere along the way that rule fails (in this case by the call at the end), the stream is discarded. If the rule completes and this is a top level rule, the stream is converted into a line of output and stored in the responses list.
When the system is finished processing all rules, it will display the
responses list to the user, in the order they were generated (unless you
used ^preprint
or ^insertprint
to generate
responses in a different order). If the output was destined for storing
on a variable or becoming the argument to a function or macro, then the
output stream is stored in the appropriate place instead.
I also didn’t tell you that the system monitors what it says, and won’t repeat itself (even if from a different rule) within the last 20 outputs. So if, when converting the output stream into a response to go in the responses list, the system finds it already had such a response sent to the user in some recently earlier volley, the output is also discarded and the rule “fails”.
Actually, it’s a bit more complicated than that. Let’s imagine a
stream is being built up. And then suddenly the rule calls another rule
(^reuse
, ^gambit
, ^respond
). What
happens? E.g.
u: ( some test ) I like fruit and vegetables. ^reuse(COMMON) And so do you.
What happens is this- when the system detects the transfer of control
(the ^reuse
call), if there is output pending it is
finished off (committed) and packaged for the user. The current stream
is cleared, and the rule is erased (if allowed to be). Then the
^reuse()
happens. Even if it fails, this rule has produced
output and been erased.
Assuming the reuse doesn’t fail, it will have sent whatever it wants into the stream and been packaged up for the user. The rest of the message for this rule now goes into the output stream and so do you and then that too is finished off and packaged for the user. The rule is erased because it has output in the stream when it ends (but it was already erased so it doesn’t matter).
So, output does two things. It queues up tokens to send to the user, which may be discarded if the rule ultimately fails. And it can call out to various functions. Things those functions may do are permanent, not undone if the rule later fails.
There is a system variable %response
which will tell you
the number of committed responses. Some code (like Harry’s control
script) do something like this:
$_response = %response
...
if ($_response == %response) {...}
which is intented to mean if no response has been generated so far, try the code in the ^if. But you have to be wary of the pending buffer. Calling some code, even if it fails, may commit the pending buffer. If there is a chance you will have pending output, the correct and safe way to code this is:
^flushoutput()
$_response = %response
...
if ($_response == %response) {...}
^flushoutput
will commit pending output.
An output script cannot embed another rule inside it. Output is executed during the current volley whereas rules (like rejoinder rules) may be executed in a different volley. Therefore this is illegal:
u: GREETING ( ~emohello )
if ($username)
{
Hi $username!
}
else
{
I don't believe we've met, what's your name?
a: (_*) So your name is '_0?
}
and needs to be written like this:
u: GREETING ( ~emohello )
if ($username)
{
Hi $username!
}
else
{
I don't believe we've met, what's your name?
}
a: (_*) So your name is '_0?
Of course you don’t want the rejoinder triggered if you can from the
if
side, so you’d also need to add a call to
^setnorejoinder
from inside it.
Because you can intermix program script with ordinary output words, ChatScript normally autoformats output code. But programming languages allow you to control your output with format strings and ChatScript is no exception.
In the case of ChatScript, the active string ^"xxx"
string is a format string. The system will remove the ^
and
the quotes and put it out exactly as you have it, except, it will
substitute variables (which you learn about shortly) with their values
and it will accept [ ]
[ ]
choice blocks. And
will allow function calls. You can’t do assignment statements or loops
or if statements.
t: ^"I like you."

When you want special characters in the format string like
"
, you need to backslash them, which the format string
removes when it executes. For example:
u: () $tmp = [ hi ^"there \"john\"" ]
the quote inside the format string need protecting using
\"
.
You can write \n
, \r
, \t
and
those will be translated into newline, newline, and tab. However, you
should avoid \r
because on LINUX it is not needed and in
Windows the system will change \n
to carriage-return and
newline. The use is for API function ^testoutput where you want to emit
a newline but the incoming system will be sending newlines itself to
allow errors to be reported by line number.
Format strings evaluate themselves as soon as they can. If you write:
u: () $tmp = ^" This is $var output"
then $tmp
will be set to the result of evaluating the
format string. Similarly, if you write:
u: () $tmp = ^myfunc(^" This is $var output")
then the format string is evaluated before being sent to
^myfunc
.
You can continue a format string across multiple source lines. It will always have a single space representing the line change, regardless of how many spaces were before or after the line break. E.g
^"this is my life" # -> ^"this is my life"
regardless of whether there were no spaces after is or 100 spaces after is. You may not have comments at the ends of such lines (they would be absorbed into the string).
While an active string tries to detect and substitute variables, it can’t succeed if you have letters immediately after the variable name. E.g.
^"T$$time_computed_hrs:$$time_computed_mins:$$time_computed_secsZ"
The Z at the end of the $$time_computed_secs
will make
that variable hard to detect, since it will look like the variable is
$$time_computed_secsZ
.
You can fix that by escaping the next character not part of the name.
$$time_computed_secs\Z
.
While you can have function calls inside an active string, the system
will strip a single space in front of the call. E.g., if ^mycall returns
test
$_var = ^"this is ^mycall(x)"
then the above sets $_var to this istest
and you need to
add an extra space in front of the call if you want a space. This is
because you cannot do without the space in front of the function call
merely to recognize the call (lest it join as part of the prior token).
And you may want to merge the result together. Hence extra space if you
want one.
^' xxxxxx '
is another kind of active string. It is
intended for writing easy JSON, because you don’t have to escape
doublequotes unless json would need to.
It will converting \n
,\t
, \r
into their control characters, convert \\
into just
\
, and leave all other characters alone. Eg
^'{ "test" : "my \"value\" \x" }
will become
^'{ "test" : "my \"value\" \x" }
Whenever format strings are placed in tables, they become a slightly different flavor, called functional strings. They are like regular output- they are literally output script.
Formatting is automatic and you get to make them do any kind of executable thing, as though you were staring at actual output script. So you lose the ability to control spacing, but gain full other output execution abilities.
They have to be different because there is no user context when compiling a table. As a consequence, if you have table code that looks like this:
^createfact( x y ^" This is $var output")
the functional string does NOT evaluate itself before going to createfact. It gets stored as its original self.
We will now learn functions that can be called that might fail or have interesting other effects. And some control constructs.
Loop allows you to repeat script. It takes an optional argument
within parens, which is how many times to loop. It executes the code
within { }
until the loop count expires or until a
FAIL
or END
code of some kind is issued.
End(loop)
signals merely the end of the loop, not
really the rule, and will not cancel any pending output in the output
stream.
Fail(LOOP)
will terminate both loop and rule
enclosing. All other return codes have their usual effect.
Deprecated is fail(rule)
and
end(rule)
which merely terminated the loop.
t: Hello. ^loop (5) { me }
t: ^loop () { This is forever, not. end(LOOP)}
The first gambit prints Hello. me me me me me. The second loop would print forever, but actually prints out This is forever, not. because after starting output, the loop is terminated.
Loop also has a built in limit of 1000 so it will never run forever.
You can override this if you define $cs_looplimit
to have
some value you prefer.
^loop
( n )Loop can be given a count. This can be either a number, function call
that results in a number, or you can use a factset id to loop through
each item of the factset via ^loop (@0)
.
A non-json loop has a global limit to protect against really big loops. The loop count you give locally will only go as far as that global limit. UNLESS, you use a pure numeric loop count. If you do, that wins over the global. So
$_tmp = 2000
^loop($_tmp) -- will run to global limit 1000.
^loop(2000) -- will run to local limit 2000.
^jsonloop
( $jsonvar
$_val1 $_val2 )See ^jsonloop in Json manual for looping through a JSON object or array.
if
or
^if
The if allows you to conditionally execute blocks of script. The full syntax is:
if ( test1 )
{
script1
}
else if ( test2 )
{
script2
}
# ...
else
{
script3
}
You can omit the else if section, having just if and else, and you can omit the else section, having just if or if and else if. You may have any number of else if sections. The test condition can be:
!
variable - if it is not defined, the test passes
(same as relation variable ==
null)==
!=
<
<=
>
>=
?
!?
For the purposes of numeric comparison
(< <= > >=)
a null value compared against a
number will be considered as 0. But == will not consider a null value as
0 because this conflicts with the ability to detect if the variable has
some value or not.
You may have a series of test conditions separated by
AND
and OR
. The failure of the test condition
can be any end or fail code. It does not affect outside the condition;
it merely controls which branch of the if gets taken.
if ($var) { } # if $var has a value
if ($var == 5 and foo(3)) {} # if $var is 5 and foo(3) doesn't fail or return 0 or false
Comparison tests between two text strings is case insensitive.
A word of warning on the ?
(in set) relation test. It
only works for actual concepts that have enumerated values. A number of
sets marked by the engine for patterns do not consist of enumerated
members.
All of the pos-tagging and parse-related concepts are like this, so
you cannot use ~number
, ~noun
,
~verb
, etc here.
It will work if you compare a match variable derived from input, because that has access to knowing all the marked concepts of that particular word.
An alternative If test condition is the pattern If. You write the test using the word pattern at the start, and then you write exactly what you can write when you write a rule pattern. Eg.
if (pattern bingo _*1 ~helo) { ... }
This gives you the full power of the pattern matcher, including the ability to match and memorize from the current input.
Normally output evaluates things it sees. This includes
$user
variables, which print out their value. But if you
put quote in front of it, it prints its own name. '$name
will print $name.
The exception to this rule is that internal functions that process
their own arguments uniquely can do what they want, and the query
function defines '$name
to mean use the contents of
$name
, just don’t expand it if it is a concept or topic
name as value.
Similarly, a function variable like ^name
will pretend
it was its content originally. This means if the value was
$var
then, had $var been there in the output originally, it
would have printed out its content. So normally ^name
will
print out the contents of its content. Again, you can suppress with
using '^name
to force it to only print its content
directly.
Normal English sentences do not contain underscores. Wordnet uses underscores in composite words involving spaces.
ChatScript, therefore has a special use for underscores internally and if you put underscores in your output text, when they are shipped to the user they are converted to spaces.
This doesn’t apply to internal uses like storing on variables. So normally you cannot output an underscore to a user. But a web address might legitimately contain underscores. So, if you put two underscores in a row, ChatScript will output a single underscore to the user.
Having said that CS automatically changes underscores to spaces, you
can alter this and other default response output processing. The
variable $cs_response
can be set to some combination of
values to alter behavior. The default value is #ALL_RESPONSES which
consists of
$cs_response = #RESPONSE_UPPERSTART +
#RESPONSE_REMOVESPACEBEFORECOMMA +
#RESPONSE_ALTERUNDERSCORES +
#RESPONSE_REMOVETILDE +
#RESPONSE_NOCONVERTSPECIAL
which controls automatically up-casing the first letter of output,
removing spaces before commas, and converting underscores to spaces,
removing ~
from concept names, and not converting carriage
return, newline, and tabs from CS backslashed notation to actual ASCII
character.
Equivalently
$cs_response = #ALL_RESPONSES
which if you want all is what you should use in case new ones are added in the system later.
Just as you can write your own common routines (functions) for handling pattern code with patternmacro:, you can do the same for output code.
Outputmacro: name (^arg1 ^arg2 ...)
and then your code. Only now you use output script instead of pattern stuff. Again, when calling the macro, arguments are separated with spaces and not commas.
Whereas most programming language separate their arguments with commas because they are reserved tokens in their language, in ChatScript a comma is a normal word. So you separate arguments to functions just with spaces.
?: ( hi) ^FiveArgFunction( 1 3 my , word)
Outputmacros can return a value, just like a normal function. You just dump the text as you would a message to the user.
outputmacro: ^mymac()
tested here
TOPIC: ~patterns keep repeat []
#! what time is it?
u: ( << what time >> ) $test = ^mymac() join(ok $test)
will print oktested here.
However, it is clearer and cleaner if you are returning data to be
stored somewhere else (not to be merely immediately sent to the user),
to use ^return("tested here")
. This both creates the
result, and ends the function immediately even if other code
follows.
Note - calls to macros use “pass by reference”, so the actual
value of the ^variable
is the name of what was passed in,
and it is generally (but not always) evaluated on use.
You may make references to outputmacros before they are defined, EXCEPT when the Function is directly or indirectly referenced from a table. Tables immediately execute as they are compiled, and you will get an error if a function it tries to use is not defined.
NOTE: arguments to functions must be simple literal valus and/or variables. You may not use arguments that compute values.
^myfunc( ^pos(10)) -- not legal
^myfunc( 1 + 2) -- not legal (this is 3 arguments)
Strings and active strings are considered simple literal values.
^myfunc( "this is a single argument")
^myfunc( ^"this is $word also a single argument using $foo")
You can store an outputmacro name on a variable and then call that indirectly.
^$_xx(value1) if $_xx holds a function name
ChatScript requires that a function be defined before use. When you
use that function from multiple files, you may have trouble ordering the
files for compilation if you merely name the folder in
filesxxx.txt
since you cannot guarantee compilation order
unless you explicitly name the files. But you can also just put your
functions in a top level file and then have your other files in folders,
and name it and then them in your filesxxx.txt
file.
$$xxx
and $xxx
variables are global, merely
transient and permanent.
Function variables like ^myval
are restricted in use to
the function declaring them, so they are sort of local variables, but
they are stand-ins for the arguments passed, which means if you write
indirectly the function variable you are changing something above you as
well.
Fortunately there are local variables, $_xxx
.
Without local variables, it is easy to accidentally reuse the same name of a transient variable that you used above you in the call chain. Imagine this:
outputmacro: ^mycall()
$$counter = 0
loop()
{
# ...
$$counter += 1
}
and this:
$$counter = 0
loop()
{
$$tmp = ^mycall()
# ...
$$counter += 1
}
You have two areas using the same counter variable and the inner one destroys the outer one. Here is where save-restore variables come in.
You can either use local variables, when you don’t need to pass information between places except via function args. Or you can use save-restore variables.
You can declare a list of variables whose contents will be memorized
on entry to a function or a topic, and restored to their former values
on exit.
You can safely write all over them within the function or topic, without
harming a caller. And they are still global, in that they are visible to
anyone your function calls.
Of course if you intend to pass back data in a global variable, don’t put it in your save-restore list.
Outputmacro: ^myfunc(^arg1)($$tmp $global $$tmp2) # $$bestscore exported
# code
Topic: ~mytopic(keyword1 keyword2) ($$tmp $$global $$tmp2)
# rules
You can protect both transient and permanent variables, but usually you would just protect all of the transient variables you assign values to inside your function or topic. The comment is what I would say if I intended a variable be returned outside in addition to a primary return value. That way anyone reading the code would know $$bestscore was not accidentally left off the save-restore list.
 ChatScript does that automatically.
Outputmacro: ^myfunc(^arg1)($$tmp $global $$tmp2) # $$bestscore exported ... code
You can protect both transient and permanent variables, but usually you would just protect all of the transient variables you assign values to inside your function.
The comment is what I would say if I intended a local variable be
returned outside in addition to a primary return value. That way anyone
reading the code would know $$bestscore
was not
accidentally left off the save-restore list.
dualmacro: name(...)
is exactly like outputmacro:
, but the function can be
called on then side or on the output side. Typically this makes most
sense for a function that performs a fixed ^query
which you
can see if it fails in pattern side or as a test on the output side or
inside an if condition.
Output macros can be passed system function names and output macro names, allowing you to indirectly call things. E.g.
outputmacro: ^indirect(^fn ^value)
$$tmp = ^fn(^value)
The above will evaluate ^fn
, and if it finds that it is
a function name, will use that in a call. The only tricky part is
creating the name of the function to call in the first place.
If you just write a function name with ^ in output, the compiler will complain about your call. So you have to synthesize the name somehow. Here are two ways:
outputmacro: ^mycall()
$$tmpfn = ^join( ^"\^" func)
^indirect($$tmpfn 34)
^indirect( ^"\^func" 34)
You can also store function names on user and match variables and then call them. E.g.
$$tmp = ^"\^func"
$$tmp(34)
You can declare an outputmacro to accept a variable number of arguments. You define the macro with the maximum and then put “variable” before the argument list. All missing arguments will be set to null on the call.
outputmacro: ^myfn variable (^arg1 ^arg2 ^arg3 ^arg4)
^reuse()
An outputmacro is a block of code, treated as a kind of function. But
another way to make a block of code is create a rule and
^reuse
it. E.g.
s: MYCODE ( ? ) here is a block of code that goes on and on
Code you write in an output macro could be code you write on the
output side of a ^reused
rule. Notice that this rule can
never trigger on its own (an input sentence cannot be a statement and a
question simultaneously).
So what are the distinctions between the two? The distinction is not in tracing. You can trace a single rule or an outputmacro equally. And both return to their caller when normally complete.
An advantage for outputmacros is that you can pass them arguments, making them more easily tailorable. To do the same with a rule, you have to store values on globals, which is more inconvenient, harder to understand, and subject to the risk that you accidentally reuse the same variable in something the rule calls. Similarly outputmacros can return a value, while you have to use globals to return a value from a rule.
An advantage for rules is that they can have rejoinders. So if the
rule generates output, it may also have rejoinders to react to it.
Another advantage for rules is that you can terminate their execution
early ^end(RULE)
without impacting the calling rule. There
is no such ability in an outputmacro, so you’d have to organize if
statements to manage early termination effects.
[ ]
Remember this construct:
?: ( hi ) [How are you feeling?][Why are you here?]
These choices are picked equally. But maybe you don’t want some choices. You can put an existence test of a variable at the start of a choice to restrict it.
?: ( hi ) [$ready How are you feeling?][Why are you here?]
In the above, the first choice is controlled by $ready
.
If it is undefined, the choice cannot be used. You can also use negative
tests.
?: ( hi ) [!$ready this is a][This is b]
In the above only if $ready
is undefined can you say
this is a
If you want the variable to be a lead item in the actual output of a choice, you can do this:
?: (hi) [^eval($ready) is part of the output]
or the more clunky:
?: ( hi ) _0 = $ready [ _0 is part of the output]
Choices lead to issues when you want rejoinders. You can label
rejoinder branches of choices. Those without labels default to
a:
?: ( what meat ) [c: rabbit ] [e: steak] [ h: lamb] [pork]
a: this rejoinders pork
c: this rejoinders rabbit
e: this rejoinders steak
f: this rejoinders on e:
h: this rejoinders lamb
In the above, pork rejoinders at a:
, while the other
choices name their rejoinder value. Each new starting label needs to be
at least one higher than the rejoinder before it. That allows the system
to detect rejoinders on rejoinders from choice branches.
If you do both variable control and rejoinder label, the control comes first and label after you have successful control.
?: ( what meat ) [$ready c: rabbit ] [e: steak] [ g: lamb] [pork]


About This Site
This website was designed as part of my application for Founders and Coders. I drew inspiration from the collaborative and community-driven spirit of FAC to design a platform I - and other independent visitors -
would find a useful resource. I wanted to create a simple webpage which would be a starting-point for ideas for monthly days out, so that we don't only spend our time at the cinema.
I didn't want anything to distract from the Activity Generator, so I kept the design very plain and the key info colourful. I created a wireframe to flesh out my ideas and aim for while building.
The design deliberately does not allow the user to select the 'Boys' or 'Girls' buttons when finding an activity, as a nod towards my belief that activities should not be prescribed a gender.
It was also my intention for the favoured activity from the generator to be shared between the young person and their IV. I was unable to code this at this time, but would love to return to this
when I have greater knowledge of web development.


Ice Sickle is an open-source WarCraft III world editor written in Electron. It's core design principle is to be as extendable as possible through its plugin system.
App path {{appDataPath}}
{{appDataPath}}
Plugin path {{pluginPath}}
{{pluginPath}}


Listing all 904 registered packages for the Julia programming language.
Last updated 2016-03-18 — Package ecosystem pulse
Packages tested on
Julia versions:
v0.3.12 (previous release) —
v0.4.3 (current release) —
v0.5-pre (unstable)


Tweet at me @PressureJs with the project you are working on that uses pressure.js and I will add you here to the expo! :)
Examples
Henry Blyth Valentines
Pressure.js Scale
This is still a work in progress, the "zero" doesn't work, but it is a cool example of what can be done with 3D Touch on the new iPhone 6s
Press


Select this checkbox to use a live template inside a file template. In doing so, one has to put the live template
fragments into Velocity escape syntax.
For example:
#[[ $MY_VARIABLE$ $END$ ]]#
Thus, one can specify the cursor position. Note that it is required to use the live template variables here!
(When you expand a live template abbreviation, its variables either appear as input fields where you can type
values or are replaced with values. These may be default values that you can modify or values calculated using
functions.)


Fire Down Below (1997)
A movie review by Michael J. Legeros Copyright 1997 by Michael J. Legeros
(WB) Directed by Filix Enrmquez Alcala Written by Jeb Stuart and Philip Morton Cast Steven Seagal, Marg Helgenberger, Harry Dean Stanton, Stephen Lang, Kris Kristofferson, Levon Helm, Brad Hunt MPAA Rating "R" (presumably for violence and language) Running Time 107 min. Reviewed at General Cinemas at Pleasant Valley, Raleigh, NC (05SEP97)
==
Ah, the refreshing vapidity of a Steven Seagal movie.  The first hour is pretty bad, with Seagal's EPA agent attempting to infiltrate a small mining town as a church sponsored handyman whose work attire inexplicably includes designer black-leather jackets. He tries to blend in, making friends with the locals and only kicking their asses when provoked. (Obviously intending to *instruct* as well as entertain, Seagal demonstrates the fine art of redneck whupping in a *variety* of locations: lumberyard, city street, etc.) The second hour, however, is where the *really* awful fun begins. How about Marg Helgenberg's love- interest, a spinster (!) outcast (!!) beekeeper (!!!) whose overprotec- tive brother becomes increasingly psychotic? Or the Bubba-falls-down fight sequence, set in a pool hall, where ol' Stone Face's fists o' fury are filmed in fast motion!? Or, my favorite-- and the last in a long line of canyon-spanning logic leaps-- Seagal taking his final shot at the villain and then walking away, completely ignoring the accompanying FBI agent who was shot in the gut a few second before!? Hilarious. With appearances by a bunch of country music folk, including Mark Col- lie, Randy Travis, Patsy and Peggy Lynn, Travis Tritt, and Marty Stuart, who picks along with Stevie in one scene. And who was the guy that walked away from the poker game? He looked familiar, too.
Grade: F
-- Mike Legeros - Movie Hell http://www.nonvirtual.com/hell
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Syntax:
setq {pair}* => result
pair::= var form
Pronunciation:
['set,kyoo]
Arguments and Values:
var---a symbol naming a variable other than a constant variable.
form---a form.
result---the primary value of the last form, or nil if no pairs were supplied.
Description:
Assigns values to variables.
(setq var1 form1 var2 form2 ...) is the simple variable assignment statement of Lisp. First form1 is evaluated and the result is stored in the variable var1, then form2 is evaluated and the result stored in var2, and so forth. setq may be used for assignment of both lexical and dynamic variables.
If any var refers to a binding made by symbol-macrolet, then that var is treated as if setf (not setq) had been used.
Examples:
;; A simple use of SETQ to establish values for variables. (setq a 1 b 2 c 3) => 3 a => 1 b => 2 c => 3 ;; Use of SETQ to update values by sequential assignment. (setq a (1+ b) b (1+ a) c (+ a b)) => 7 a => 3 b => 4 c => 7 ;; This illustrates the use of SETQ on a symbol macro. (let ((x (list 10 20 30))) (symbol-macrolet ((y (car x)) (z (cadr x))) (setq y (1+ z) z (1+ y)) (list x y z))) => ((21 22 30) 21 22)
Side Effects:
The primary value of each form is assigned to the corresponding var.
Affected By: None.
Exceptional Situations: None.
See Also:
Notes: None.


Yes, for the figure the mouseOver
event is ignored.
No, for the button the mouseOver
event changes the mouse
pointer from an arrow to a hand.
(Some browsers don't do this.)
Of course, when you click the button this is another kind of event, and is not ignored, either.
A GUI program consists of three types of software:
The graphical components are Swing objects. You either use then as they are defined or extend them into your own classes. Listener methods and application methods are Java methods that you write. Listener methods respond to events by calling application methods. Application methods are ordinary Java methods that perform useful computations. They receive data from the GUI and send data to the GUI to be displayed, but are not usually themselves conderned with the user interface.
Your Web browser has components (such as the "back" and "forward" buttons), listener methods that receive events (such as a click on the "back" button) and application methods that do useful things (such as moving back or forward one page.)
To write a GUI application, keep the three types software separated (while keeping the big picture in mind.) In a big software project an entire team of programmers is assigned to each of the tasks.


3.5. Feature selection¶
3.5.1. Univariate feature selection¶
Univariate feature selection works by selecting the best features based on univariate statistical tests. It can seen as a preprocessing step to an estimator. The scikit.learn exposes feature selection routines a objects that implement the transform method. The k-best features can be selected based on:
- scikits.learn.feature_selection.univariate_selection.SelectKBest(score_func, k=10)¶
Filter : Select the k lowest p-values
or by setting a percentile of features to keep using
- scikits.learn.feature_selection.univariate_selection.SelectPercentile(score_func, percentile=10)¶
Filter : Select the best percentile of the p_values
or using common statistical quantities:
- scikits.learn.feature_selection.univariate_selection.SelectFpr(score_func, alpha=0.050000000000000003)¶
Filter : Select the pvalues below alpha
- scikits.learn.feature_selection.univariate_selection.SelectFdr(score_func, alpha=0.050000000000000003)¶
Filter : Select the p-values corresponding to an estimated false discovery rate of alpha. This uses the Benjamini-Hochberg procedure
- scikits.learn.feature_selection.univariate_selection.SelectFwe(score_func, alpha=0.050000000000000003)¶
Filter : Select the p-values corresponding to a corrected p-value of alpha
These objects take as input a scoring function that returns univariate p-values.
Examples:
<IP_ADDRESS>. Feature scoring functions¶
Warning
Beware not to use a regression scoring function with a classification problem.
<IP_ADDRESS>.1. For classification¶
- scikits.learn.feature_selection.univariate_selection.f_classif(X, y)¶
Compute the Anova F-value for the provided sample
Parameters : X : array of shape (n_samples, n_features)
the set of regressors sthat will tested sequentially
y : array of shape(n_samples)
the data matrix
Returns : F : array of shape (m),
the set of F values
pval : array of shape(m),
the set of p-values
<IP_ADDRESS>.2. For regression¶
- scikits.learn.feature_selection.univariate_selection.f_regression(X, y, center=True)¶
Quick linear model for testing the effect of a single regressor, sequentially for many regressors This is done in 3 steps: 1. the regressor of interest and the data are orthogonalized wrt constant regressors 2. the cross correlation between data and regressors is computed 3. it is converted to an F score then to a p-value
Parameters : X : array of shape (n_samples, n_features)
the set of regressors sthat will tested sequentially
y : array of shape(n_samples)
the data matrix
center : True, bool,
If true, X and y are centered
Returns : F : array of shape (m),
the set of F values
pval : array of shape(m)
the set of p-values