TITANIC
Is it really the critic's province to concern himself with how much it cost to make a movie and/or what is the likelihood the film will turn a profit.? I am inclined to think not. Let, in the instance of TITANIC, 20th-Century Fox and Paramount worry about it. It is not as if they did not know of James Cameron's reputed perfectionism. Before he was tapped to direct, they knew that how the movie turns out is Cameron's one and only concern. Based on that, I would say they and viewers got their money's worth.
>From the opening scenes of the round "submarines" (built in Russia and manned by real-life Russians) as they entered the openings in the ship's hull, the barnacles and eroded parts of the ship bringing the disaster close, it was obvious that Cameron was giving us some excellent special effects with the 90% to scale of the original Titanic. And later, when the ship goes down like a monstrous whale diving beneath the surface, more magnificent footage.
What the explorers entering openings in the hull were seeking was the safe which surely contained untold wealth as the ship's passengers (in First Class) were in the multi-millionaire class. To capture the safe would be a treasure. As it turned out, Brock Lovett (Bill Paxton) was in for a great disappointment when the safe which was brought on deck of the mother ship revealed nothing but soggy papers. Not exactly, though. There was also a photo of a young woman, Rose (Kate Winslet) wearing what looked like a valuable locket with a blue diamond When the picture was shown on TV news, the real Rose, (Gloria Stuart) , now 101-years-old, came forth to say it was she in that picture taken a long time ago, just before the Titanic, billed as "unsinkable," hit the iceberg and sank in the icy waters of the Atlantic Ocean on April 15, 1912.
This is the thread on which the script hangs. As the aged Rose starts to describe the fanfare and excitement of the boarding of the ship and what transpired until the disaster, director Cameron allows us to see that about which she is talking. It tells of how the young and beautiful Rose met Jack, (Leonardo DiCaprio) a "nobody" with an artist's soul and fell in love with him to the great dismay of her social-climbing mother (Frances Fisher) who worries that Rose will lose her very wealthy fianc‚, Cal Hockley (Billy Zane ).
Great effort went into the ship's interior with its dining room and ballroom and the wealthy patrons on upper decks living it up as if in a grand hotel. Drinking and dancing away the days and nights, waited on hand and foot by the stewards, oblivious to the disaster that lay ahead.
When it became obvious that the ship was going to sink, it was the first class "women and children" who were lowered into boats . . . about which there were insufficient number . . .followed by the men. Those in steerage were not allowed into the boats until all the first class passengers had been evacuated . . . if indeed there were still boats left for them.
The film brings out that the ship was going at a faster than safe speed because the Captain (Bernard Hill) was prevailed upon to set a record. It was J Bruce Ismay (Jonathan Hyde), a newspaperman who urged "The maiden voyage of the Titanic must make headlines." It sure did!
One bit of carping. The film implied that the two lookouts on the forward deck were diverted by Jack and Rose kissing on the deck below. Had they had there eyes searching the darkness ahead, perhaps they would have seen the iceberg sooner and been able to alert the helmsman to veer away. After trying so hard for verite, Cameron should have skipped that bit of make believe.
In any case, a most significant and entertaining film.
Others in the cast included Kathy Bates as "The Unsinkable Molly Brown."
Directed by James Cameron
3.5 Bytes
4 Bytes = Superb 3 Bytes = Too good to miss 2 Bytes = Average 1 Byte = Save your money
Copyright 1997 Ben Hoffman
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


paragraph with border style solid color hexadecimal
paragraph with border style dotted color name
paragraph with border style dashed color rgb
paragraph with border style groove color rgba
paragraph with border style ridge color hsl
paragraph with border style inset color hsla
paragraph with border style outset
paragraph with border style hidden


| Job | Min-Rank | Reward | Issuer | Time Limit | |
|---|---|---|---|---|---|
| Guide 10 People to the Zoo | Iron | 10 Iron, $20 | Alisabeauty | 1 Day | |
| Guide 17 People to the Museum | Iron | 15 Iron, $15 | beautyface | - 4 Hours Remaining | |
| Guide 10 People to 2 tourist attractions in Malang | Iron | 30 Iron, $25 | Vaniartax | - 12 Hours Remaining |


--- layout: page title: sant joan-fair and holidays region: girona permalink: girona/santjoan/fair_and_holiday ---
September
June 27 ~ 30
July 6 ~ August 21


Cripto Wallet
Secure generator cripto wallets
BTC: 1C3PD714V6K5VizmC4SLTKqs7ijLnBFd6n
|
ETH: 0x97889886F769C3b28E788105568822D7c8641884
Made with
♥
by Daniel Pereira


{% extends 'base.html'%} {% import 'macros.html' as macro%} {% block styles%} {{ super() }} {% endblock %} {% block content %}
In life, you only have 60 seconds to impress someone. 1 minute can make or break you. How do we make sure that you use your 1 minute to actually say something meaningful.


App Name:
{{appname}}
DataSourceController
date:
Set the date:
ThreadCount:
ButtonStart {{threadCount}} threads


Soprdaily a few seconds ago
Hi Gurdeep Singh, Welcome to Soprdaily!
Please choose an option that best describes the issue you are facing so that we can assist you better. false
General queries
Delivered a few seconds ago
Soprdaily
Please describe the issue you are facing in detial
What COVID-19 precautions are taken
Delivered a few seconds ago
Soprdaily
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.


EastEnders SPOILERS: Keanu 'flees abroad and survives Phil's revenge'
Will he be leaving the soap via an airport?
by Entertainment DailyIt looks like Keanu Taylor will survive Phil Mitchell's revenge at Christmas in EastEnders.
Fans know mechanic Keanu has got both Phil's daughter Louise and wife Sharon pregnant - and the secret is set to explode at Christmas.
They have been left fearing Keanu will be murdered at the end of the storyline after it was revealed actor Danny Walters had quit the soap.
And now some filming pictures released on Metro.co.uk appear to show a surprisingly happy ending for the character.
Read more: EastEnders fans beg Jack Branning to bring down Leo Cameron
He can be seen running for a plane at an airport after saying an emotional goodbye to his mum Karen.
It has not yet been revealed whether these are Danny's final scenes or whether he is drawn back to Walford and leaves another way.
Previous reports claimed Martin Fowler will shoot Keanu in a tense showdown with Linda Carter present as a hostage.
Fans speculated that Martin would come under the control of Phil after he remembers what really happened to him the night he was attacked and blackmail him, like Ben did.
Read more: EastEnders' Max Bowden brings his nan and aunt to Albert Square
But they think that when Phil orders Martin to kill Keanu, he will double-cross him and fake it so Keanu has time to escape.
Actor Danny announced he had quit as Keanu earlier this month.
He said in a statement: "It has been a joy to play Keanu Taylor for the last two and a half years.
"I have been blessed to work with the most fantastic creative team. I will miss them and my fellow actors immensely.
"EastEnders will always hold a special place in my heart and I will continue to be an avid fan."
EastEnders' executive producer Jon Sen added: "Keanu's story is set to come to a dramatic and blistering conclusion in the near future as one of the best kept secrets on the Square is finally revealed with devastating consequences."
How do you think Keanu will leave? Leave us a comment on our Facebook page @EntertainmentDailyFix and let us know what you think!


--- title: Deploy SavedModel to CloudML type: docs repo: https://github.com/rstudio/cloudml menu: main: name: Deploy SavedModel to CloudML - cloudml parent: cloudml-reference aliases: - /reference/cloudml/cloudml_deploy.html - /cloudml/reference/cloudml_deploy.html - /guide/cloudml/reference/cloudml_deploy.html - /tools/tools/cloudml/reference/cloudml_deploy.html - /installation/cloudml/reference/cloudml_deploy.html - /tutorials/cloudml/reference/cloudml_deploy.html - /guide/tools/cloudml/reference/cloudml_deploy.html - /deploy/cloudml/reference/cloudml_deploy.html - /tools/cloudml/reference/cloudml_deploy.html - /tutorials/tools/cloudml/reference/cloudml_deploy.html ---
Deploys a SavedModel to CloudML model for online predictions.
cloudml_deploy(export_dir_base, name, version = paste0(name, "_1"),
region = NULL, config = NULL)
| export_dir_base | A string containing a directory containing an
exported SavedModels. Consider using |
| name | The name for this model (required) |
| version | The version for this model. Versions start with a letter and contain only letters, numbers and underscores. Defaults to name_1 |
| region | The region to be used to deploy this model. |
| config | A list, |
cloudml_predict()
Other CloudML functions: cloudml_predict
,
cloudml_train


Buildings consume 40% of all energy produced in the United States and are responsible for roughly the same proportion of US carbon emissions. Improving the energy efficiency of buildings across the country therefore represents a highly impactful approach to reaching carbon reduction goals.
Local governments have identified Strategic Energy Management (SEM) as an effective approach to reaching their carbon reduction goals. SEM comes in many forms, but can generally be defined as a systematic approach to improving the energy efficiency of buildings – leading to significant reductions in energy usage, operating costs and associated carbon emissions. Due to the systematic approach, SEM programs represent one of the most easily adoptable, cost-effective, and impactful approaches for cities to reach their energy efficiency and carbon reduction goals.
One of the first technical steps of any SEM program involves the collection of building and energy-use data. The most common approach for collecting basic data is with the publically available Energy Star Portfolio Manager. Before analytically-driven insights can be generated, however, data must be properly formatted, validated, and prepared. This represents one of the most time-consuming processes in data analysis and often requires third party guidance, resulting in high costs and slow turnaround.
In the first of three tools to help with data-driven SEM program management, Maalka released the Data Quality Tool to enable municipalities to validate benchmarking data against typical national values to ensure the quality of their analysis.
After benchmarking the buildings in their portfolios, many municipalities take the next step to identify specific opportunities to improve the energy efficiency of their buildings. In order to identify these specific opportunities, information about more complex building characteristics and systems must be collected. This process is commonly called a Building Energy Audit.
Building Energy Audits can significantly vary in depth and complexity. The American Society of Heating, Refrigerating and Air-Conditioning Engineers (ASHRAE) has established a standard scale that reflects the depth of audits.
Furthermore, while most Building Energy Audits aim to identify the best improvement opportunities, data collection is not standardized across energy auditors and tools. This drives up costs and makes it difficult to leverage public and private tools designed to automate data analysis.
The Building Life Cycle Tool offers municipalities and energy service providers a transparent, cost-effective approach to collecting and structuring building energy audit data in a standardized way.
The Building Life Cycle Tool guides users in the collection of the most relevant building information that can be used to assess strategies for upgrading the building to run more efficiently. Users are guided by a dynamic survey for collecting data on the most important building Systems (e.g. HVAC, Ventilation, Lighting Systems) and relevant Measures (e.g. Boiler Improvements, Lighting Upgrades). In this way, users can follow a standardized approach for collecting initial Building Audit data, as each system and measure is defined by a set of associated, standardized fields.
As the tool is open-source, new systems, measures, and features can be easily added to extend functionality for specific program needs.
Systems”: The section to the right of the survey input, labeled “Required Fields” provides a list of the most common building systems that impact the energy efficiency of a building. When a user clicks on a System in the list, the survey to the left dynamically adjusts to reflect the associated fields to be populated for the System. If the field value is unknown by the user, they can skip over it to the next field
Upon completing the questions for a System, the user can click the ‘Add to List’ button to save the system. This will be reflected in the list when the icon for the System changes from a red ‘X’ to a blue checkmark. This allows users to track the systems for which they have the required data.
Users can add data for additional systems not in the list by selecting a System type from the top Dropdown menu in the survey. The survey will similarly update to reflect the data related the System, which can be added to the saved list of systems.
“Measures”: Measures are specific actions that can be taken to improve the energy efficiency of a building. To enable SEM, it is essential to track which measures have been implemented and which are planned to be implemented. The Building Life Cycle Tool allows users to enter and track measures in a standardized way.
Similar to adding a System, users can toggle to the tab labeled ‘Measures’ at the top of the survey section and select one of twelve Measures from the top dropdown. Each measure will have generic details associated with implementation status as well as Measure specific fields that can be populated.
After filling in details for a measure, a user can click ‘Add to List’ to save the measure. Users can add as many measures as necessary, which will be graphed on the visual timeline based on start date.
The visual timeline can be printed and integrated in building reports.
In addition to guiding users in the collection of data for the most common building systems and measures, the Building Life Cycle Tool allows users to export the data in a standardized format so that it can be analyzed and used by third parties to jump start Building Energy Audits.
The tool leverages the Building Energy Data Exchange Specification (BEDES) and the BuildingSync® schema to standardize data for use across a range of applications. BuildingSync® is a standardized language for commercial building energy audit data that software developers can use to exchange data between audit tools.
Structured, standardized data can be exported from the tool by clicking the ‘Print JSON’ button.Primarily intended for software developers, this button will print the Systems and Measures data in a machine-readable BuildingSync-compatible format. The intention of this feature is to enable third parties to leverage the Building Life Cycle Tool for automating data collection and integrating with powerful BuildingSync compatible data analysis tools. One powerful public platform is OpenStudio®, which is a collection of software tools for whole building energy modeling using EnergyPlus and advanced daylight analysis using Radiance.
The Building Life Cycle Tool will ensure that collected data is compatible with OpenStudio®, which will enable valuable downstream applications such as remote building audits.
The Building Life Cycle Tool is fully open-source and can be downloaded here. With additional technical knowledge, users can extend the Systems and Measures supported in Data Collection and integrate the tool into other data collection and reporting processes.
The tool also sits within the Maalka platform as part of an integrated workflow that allows municipalities to track the collection of Systems and Measures across an entire Portfolio. The data can be dynamically combined with energy-use data collected during the Benchmarking Process and then automatically passed to OpenStudio to create a fully calibrated EnergyPlus model. These models can be used to assess the potential of measures to improve Energy Efficiency across a whole portfolio.
To learn more about how Maalka enables you to launch and manage your data-driven Strategic Energy Management Program, please inquire here.


quick-start.Rmd
# Install development version from GitHub
install_github("spatialnetworkslab/homelocator")
#load homelocator package
library(homelocator)
#> Welcome to homelocator package!
The test data includes 100 random users, and it can be used as an example to get started with homelocator
package.
data("test_sample", package = "homelocator")
The validate_dataset()
function makes sure your input dataset contains all three necessary variables: user, location and timestamp. There are 4 arguments in this function:
user
: name of column that holds a unique identifier for each user.timestamp
: name of column that holds specific timestamp for each data point. This timestamp should be in POSIXct
format.location
: name of column that holds a unique identifier for each location.keep_other_vars
: option to keep or remove any other variables of the input dataset. The default is FALSE
.When validating the dataset, please specify the names of column for user, timestamp and location.
validate_dataset(test_sample, user = "u_id", timestamp = "created_at", location = "grid_id", keep_other_vars = FALSE)
#> 🎉 Congratulations!! Your dataset has passed validation.
#> 👤 There are 100 unique users in your dataset.
#> 🌏 Now start your journey identifying their meaningful location(s)!
#> 👏 Good luck!
#>
#> # A tibble: 16,300 x 3
#> u_id grid_id created_at
#> <int> <int> <dttm>
#> 1 92298565 1581 2016-04-17 22:43:06
#> 2 33908340 1461 2014-10-03 16:29:48
#> 3 92298565 1136 2014-02-07 07:26:15
#> 4 11616678 1375 2014-07-18 10:08:21
#> 5 11616678 1375 2013-11-24 23:16:24
#> 6 47727539 736 2016-06-21 15:59:49
#> 7 54875363 1572 2013-01-23 01:56:07
#> 8 40153763 759 2016-06-23 00:36:25
#> 9 9982726 1340 2015-03-12 17:00:39
#> 10 90403900 339 2014-08-04 19:10:12
#> # … with 16,290 more rows
Weighs data points across multiple time frames to ‘score’ potentially meaningful locations for each user
# recipe: homelocator -- HMLC
identify_location(test_sample, user = "u_id", timestamp = "created_at", location = "grid_id", show_n_loc = 1, recipe = "HMLC")
Selects the most frequently ‘visited’ location assuming a user is active mainly around their home location.
# recipe: Frequency -- FREQ
identify_location(test_sample, user = "u_id", timestamp = "created_at", location = "grid_id", show_n_loc = 1, recipe = "FREQ")
Finds the most ‘popular’ location during ‘rest’, ‘active’ and ‘leisure time. Here we focus on ’rest’ and ‘leisure’ time to find the most possible home location for each user.
# recipe: Online Social Network Activity -- OSNA
identify_location(test_sample, user = "u_id", timestamp = "created_at", location = "grid_id", show_n_loc = 1, recipe = "OSNA")
Calculates the average and standard deviation of start time data points by a single user, in a single location.
# recipe: Online Social Network Activity -- APDM
## APDM recipe strictly returns the most likely home location
## It is important to load the neighbors table before you use the recipe!!
## example: st_queen <- function(a, b = a) st_relate(a, b, pattern = "F***T****")
## neighbors <- st_queen(df_sf) ===> convert result to dataframe
data("df_neighbors", package = "homelocator")
identify_location(test_sample, user = "u_id", timestamp = "created_at", location = "grid_id", recipe = "APDM", keep_score = F)


background: #1e5799; /* Old browsers */ background: -moz-linear-gradient(top, #1e5799 0%, #2989d8 50%, #207cca 51%, #7db9e8 100%); /* FF3.6-15 */ background: -webkit-linear-gradient(top, #1e5799 0%,#2989d8 50%,#207cca 51%,#7db9e8 100%); /* Chrome10-25,Safari5.1-6 */ background: linear-gradient(to bottom, #1e5799 0%,#2989d8 50%,#207cca 51%,#7db9e8 100%); /* W3C, IE10+, FF16+, Chrome26+, Opera12+, Safari7+ */ filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#1e5799', endColorstr='#7db9e8',GradientType=0 ); /* IE6-9 */
Implementations of unstable features that are described in W3C specifications but are not interoperable should not be released broadly for general use; but may be released for limited, experimental use in controlled environments.
We want to allow both authors and implementors to experiment with the feature and give feedback, but prevent authors from relying on them in production websites and thereby accidentally "locking in" (through content dependence) certain syntax or behavior that might change later.
... A CSS feature is a proprietary extension if it is meant for use in a closed environment accessible only to a single vendor’s user agent(s). A UA should support such proprietary extensions only through a vendor-prefixed syntax and not expose them to open (multi-UA) environments such as the World Wide Web.
For example, Firefox’s XUL-based UI, Apple’s iTunes UI, and Microsoft’s Universal Windows Platform app use extensions to CSS implemented by their respective UAs.
The grid lines are the ones dividing horizontally and vertically a grid. And they’re actually numbered, starting at 1.
.grid{
display: grid;
grid-template-columns: 300px 200px 100px;
grid-template-rows: 100px 50px;
}
The long way:
.item{
grid-column-start: 2;
grid-column-end: 4;
grid-row-start: 1;
grid-row-end 2;
}
Easier with shorthands:
.item{
grid-column: 2 / 4;
grid-row: 1 / 2;
}
The same position using span.
.item{
grid-column: 2 / span 2;
grid-row: 1;
}
Negative numbers allow you to reference the lines starting from the end of the grid. It's like a reverse.
Useful if you want to be sure that the item is in the last column, independently of the number of tracks, you’ll just need to set: grid-column-end: -1;
You can name the grid lines, so you don’t need to remember the specific number to reference to them.
.item{
display: grid;
grid-template-columns: [start] 300px [main] 200px [aside] 100px [end];
grid-template-rows: [top] 100px [middle] 50px [bottom];
}
One line can have several names, you just need to set them in the definition:
.grid{
grid-template-rows: [top start] 100px [middle center] 50px [bottom end];
}
The names of the lines can be repeated. To reference them you’ve to use a number that can be again positive or negative.
.grid{
display: grid;
grid-template-columns: [col] 200px [gap] 50px
[col] 200px [gap] 50px [col] 200px [gap];
}
.item1{ grid-column: col 2;}
.item2{ grid-column: col 1 / gap 2;}
.item3{ grid-column: col -1;}
And of course, you can span to a named grid line.
.item{
grid-column: col 2 / span 2 gap;
}
You can define grid areas and place items directly on them. You have to use the grid-template-areas property to put names to the different areas in your grid. And you could use the grid-area shorthand directly to place the items.
.grid{
display: grid;
grid-template-columns: 100px 100px 100px 100px 100px;
grid-template-rows: 100px 100px 100px 100px;
grid-template-areas:
'title title title title aside'
'nav main main main aside'
'nav main main main aside'
'footer footer footer footer footer';
}
.item1{grid-area: title;}
.item2{grid-area: nav;}
.item3{grid-area: main;}
.item4{grid-area: aside;}
.item5{grid-area: footer;}
Grid areas create implicit names for the grid lines surrounding them. These implicit names use the “-start” and “-end” suffixes.
E.g. the “title” area creates 4 implicit names for the lines (2 in each axis):
And you can reference those lines when placing an item, instead of using the whole area.
It's possible to place items outside of the explicit grid, creating implicit tracks automatically. The size of these tracks is controlled by grid-auto-columns and grid-auto-rows properties.
.grid{
display: grid;
grid-template-columns: 200px 200px;
grid-auto-columns: 100px;
}
.item{
grid-column:5;
}
.grid{
display: grid;
grid-template-columns: 200px 200px;
grid-auto-columns: 100px;
}
.item{
grid-column:2 / span 3;
}
.item{
grid-column:-5;
}
There's more about Implicit grid & Named grid lines, and special cases...
The fr unit can be used for grid-rows and grid-columns values. It stands for "fraction of available space". Think of it as percentages for available space when you've taken off fixed-sized and content-based columns/rows. As the spec says:
The distribution of fractional space occurs after all 'length' or content-based row and column sizes have reached their maximum.
It allows you to define a pattern repeated X times.
Let's say you want to do 12 equal-width columns spaced from each other by a 1% margin:
grid-template-column:1fr repeat(11, 1% 1fr);
It is the same as:
grid-template-column:1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr 1% 1fr;
The specification is really flexible regarding how to place items on the grid.
Enable the flag called Enable experimental Web Platform features going to:
chrome://flags/#enable-experimental-web-platform-features
Enable the flag called layout.css.grid.enabled going to:
about:config
Enable the flag called Enable experimental Web Platform features going to:
opera://flags/#enable-experimental-web-platform-features
Check the CSS Grid Layout polyfill by François Remy.
:root{
--color:#f2b806;
}
.foo{
color:var(--color);
}
This example shows a custom property safely using a variable:
:root {
--main-color: #c06;
--accent-background: linear-gradient(to top, var(--main-color), white);
}
The --accent-background property will automatically update when the --main-color property is changed.
:root {
--one: calc(var(--two) + 20px);
--two: calc(var(--one) - 20px);
}
one { --foo: 10px; }
two { --bar: calc(var(--foo) + 10px); }
three { --foo: calc(var(--bar) + 10px); }
If a custom property is declared multiple times, the standard cascade rules help resolve it
:root { --color: yellow; }
div { --color: pink; }
#alert { --color: blue; }
* { color: var(--color); }
I inherited blue from the root element!
I got green set directly on me!
While I got red set directly on me!
I’m red too, because of inheritance!
Enable the flag called Enable experimental Web Platform features going to:
chrome://flags/#enable-experimental-web-platform-features
Supported in next release 49
Supported
Not supported
Supporten in next release 9.3
W3C Editor's Draft
W3C Editor's Draft
@custom-selector :--heading h1, h2, h3, h4, h5, h6;
:--heading { /* styles for all headings */ }
:--heading + p { /* more styles */ }
/* etc */
We’ve worked around the issues of global scope with a series of naming conventions like OOCSS, SMACSS, BEM and SUIT, each providing a way for us to avoid naming collisions and emulate sane scoping rules.
The .foo class does not have to be unique on the project as it is not the actual class name that will be rendered.
/* style.css */
.foo {
color: gold;
width: 40em;
margin: 0 auto;
}
import styles from './styles.css';
element.innerHTML = `
CSS Modules are fun.
`;
This will generate something like this:
CSS Modules are fun.
._20WEds96_Ee1ra54-24ePy {
color: gold;
width: 40em;
margin: 0 auto;
}
When using it through webpack with the default setup
We can configure the class format in our Webpack config as a parameter to css-loader:
loaders: [
...
{
test: /\.css$/,
loader: 'css?localIdentName=[name]__[local]___[hash:base64:5]'
}
]
.foo class identifier from earlier would compile into this:
.MyComponent__foo___1rJwx { … }
It's possible to compose selectors.
/** theme.css **/
.background {
background: rgba(0,0,0,.5);
}
/** MyComponent.css **/
.root {
composes: background from "./theme.css"; /*or composes: background;*/
margin: 10px;
}
div class="MyComponent__root _theme__background">
The css-loader has CSS Modules built-in. Simply activate it by using the ?modules flag.
The plugin css-modulesify gives your Browserify build the ability to require a CSS file and compile it as a CSS Module.
The experimental JSPM loader jspm-loader-css-modules adds CSS Modules support to SystemJS & JSPM
The css-modules-require-hook works similarly to the Browserify plugin, but patches NodeJS's require to interpret CSS files as CSS Modules. This gives complete flexibility in how the output is handled, ideal for server-side rendering.
Currently, PostCSS has more than 200 plugins
It's possible


DDRedeemCodeSecurityType Constants Reference
| Declared in | DDRedeemCode.h |
DDRedeemCodeSecurityType
This type definition is used to determine current verification mode.
Before starting, set the DD_SECURITY_TYPE
macro in the beginning of this header file to the corespodning type.
A. Local Verification
- Simple, which uses CRC32 and has much shorter numeric codes. Ability to generate temporary codes (hour, day, week, month and year), besides master and custom codes.
- Complex, which uses partial serial number verification and generates 20-character alpha-numeric keys. Valid keys have no time limitation.
B. Server Side Verification
- Remote Server, which verifies the code against it’s database of allowed codes.
If you have chosen the server side verification, then don’t forget to configure all macros starting with DD_SERVER_
.
Warning: The macro DD_SECURITY_TYPE
has to be set to a proper value before building your project with DDRedeemCode.
Definition
typedef NS_ENUM(NSUInteger, DDRedeemCodeSecurityType ) {
DDRedeemCodeSecurityTypeLocalSimple,
DDRedeemCodeSecurityTypeLocalComplex,
DDRedeemCodeSecurityTypeServerSide,
};
Constants
DDRedeemCodeSecurityTypeLocalSimple
-
Simple security type using CRC32 to check code.
Declared In
DDRedeemCode.h
. DDRedeemCodeSecurityTypeLocalComplex
-
Complex security type using partial code verification to verify provided code.
Declared In
DDRedeemCode.h
. DDRedeemCodeSecurityTypeServerSide
-
This security type verifies the code against a specified server.
Declared In
DDRedeemCode.h
.
Declared In
DDRedeemCode.h


Some days ago we did an optimized version of our series with Spring Web, now we will try to improve further the numbers using a reactive platform, for this we will use Spring WebFlux and R2DBC.
Here, as a reference, are the numbers that we got so far :
C. Users
Pods
ART
TPS
Max CPU
Max MEM
Service
1
1
39.16
25.49
403
474
01 Base
1
1
34.61
28.85
209
252
02 Spring Web
10
1
570.47
16.73
916
487
01 Base
10
1
111.61
85.53
626
350
02 Spring Web
25
3
1615.82
14.72
1049
1454
01 Base
25
1
266.03
89.44
686
369
02 Spring Web
50
5
3190.98
14.89
1351
2499
01 Base
50
3
1982.03
23.95
774
1060
02 Spring Web
01 Base = Java 8 - Spring Boot 2.2.2 - Spring Web - Spring Data JDBC default settings, unoptimized 02 Spring Web = Java 11 - Spring Boot 2.2.2 - Spring Web - Spring Data JDBC optimized
Bootstrapping a Spring Boot application
We are going to use Spring Initializr https://start.spring.io/ to quickly bootstrap our application.
We will create a Maven Project using Java 1 and Spring Boot version 2.2.4, we will set the Group to be org.learning.by.example.movies, and the Artifact to spring-webflux, the rest of the values should be automatically populated.
For dependencies we will search and add :
Spring Reactive Web
Spring Data R2DBC [Experimental]
PostgreSQL Driver
Spring Boot Actuator
Now we will click on Generate to download our zip file : spring-webflux.zip, we will uncompress it and leave it ready to be opened with our favorite IDE.
Creating a Reactive repository
First we will create our POJO that we will use to retrive a movie.
This is identical as we did in our JDBC example.
Now we will create our reactive repository.
This is very similar of the JDBC repository that we create before.
Now we need to create a converter.
This is doing almost what our mapper was doing for JDBC.
Next we will need to create a ConfigurationProperties to have our database configuration.
This is very similar to our JDBC example however we are not use a JDBC string so will be set the host, port and database in separate variables.
Finally we will setup our data base configuration.
This is how setup a connection to our database with a connection pool and set our converter.
Creating our Routes
We wil continue creating our router
As we could see this is a simple RouterFunction for our /movies/genre URL.
Next will be the handler.
The handler is using the repository to retrieve the movies and return the response back to the router.
Finally we will setup our configuration in our application.yml
Configuring our deployment
First we will copy our Dockerfile, deployment.yml, JMeter scripts and bash scripts for our previous example and rename movies-spring-web to movies-spring-webflux on them.
Them we will modify our deployment.yml
We are setting up additional JAVA_OPTS that are require to use native buffers in Netty on Java 9+.
Them we will edit our jlink.sh script to include an additional module :
Finally we could build and deploy our application :
Running the complete set
With this we are ready to run our final test following the procedure that we stablish in the first part of the series, and we will get this numbers :
C. Users
Pods
ART
TPS
Max CPU
Max MEM
Service
1
1
39.16
25.49
403
474
01 Base
1
1
34.61
28.85
209
252
02 Spring Web
1
1
31.21
31.99
335
310
03 Spring WebFlux
10
1
570.47
16.73
916
487
01 Base
10
1
111.61
85.53
350
626
02 Spring Web
10
1
100.93
94.59
1036
355
03 Spring WebFlux
25
3
1615.82
14.72
1049
1454
01 Base
25
1
266.03
89.44
686
369
02 Spring Web
25
1
368.0
76.33
1046
511
03 Spring WebFlux
50
5
3190.98
14.89
1351
2499
01 Base
50
3
1982.03
23.95
774
1060
02 Spring Web
50
1
631.65
75.24
1063
515
03 Spring WebFlux
01 Base = Java 8 - Spring Boot 2.2.2 - Spring Web - Spring Data JDBC default settings, unoptimized 02 Spring Web = Java 11 - Spring Boot 2.2.2 - Spring Web - Spring Data JDBC optimized 03 Spring WebFlux = Java 11 - Spring Boot 2.2.4 - Spring WebFlux - Spring Data R2DBC optimized
Conclusions
As we could see the performance of the reactive solution is great, we could even handle 50 concurrent users with just one Pod, and that is because we are not so bound to threads in this implementation.
However we could see that with 25 concurrent users we are not doing so great, and that is probably because we setup very a very small heap and the GC is cleaning more often that it should, but I’ve setup this to minimize memory consumption, we could increase a bit the heap this will cause less GC runs, better ART but more MEM usage, and this is key in our overall optimization strategy, if we care more about ART of use of MEM.
Finally, Spring Data R2DBC still on experimental stage, numbers will change with future relases.
Note: The full code of this service is available at this repository.


Catenates all the Cell_Sets of the same Cell type within a mesh into a single Cell_Set.
module CatCellSets <NEx=286.,NEy=154.,src_file="cat_cs.cxx"> { cxxmethod+notify_inst+req update; Mesh+read+notify+req &mesh_in <NEportLevels={2,0}>; Mesh+write mesh_out <NEportLevels={0,2}> { nspace => <-.mesh_in.nspace; nnodes => <-.mesh_in.nnodes; coordinates { values => <-.<-.mesh_in.coordinates.values; }; }; };
Though the Express documentation states that in a mesh there should be only one Cell_Set of each Cell type (e.g. Tri Prism2) this is not enforced and it is possible for such meshes to be created especially by 3D object readers. It far more eficient to render a single Cell_Set than several of the same type. This module parses the mesh_in and then creates a mesh_out with all the Cell_Sets of a single Cell type catenated into one.
&mesh_in
Reference to a Field with a Mesh containing Cell_Sets.
mesh_out
A Mesh with the catenated Cell_Sets, the Coordinates are reference from the input mesh_in.
The Add_Data_to_Mesh recombines the mesh_out from cat_cell_sets with any original node data in the User Macro cat_cell_sets. Note that Add_Data_to_Mesh is pure V code and does not require compilation.
xp_comm_proj/cat_cs/ccs_mods.v contains the CatCellSets and Add_Data_to_Mesh modules.
The module should run in the same process as the Mesh which it takes as input. By default the CatCellSets runs in the user process. Use the following command in the VCP to compile this project:$compile XP_COMM_PROJ.CatCellSets.CatCSMods
James Perrin Manchester Visualiation Centre Manchester Computing The University Oxford Road Manchester UK M13 9PL<EMAIL_ADDRESS>Add_Data_to_Mesh


Stunner is a set of powerful HTML templates designed for store owners and app makers who deal with Shopify email communications.
These templates are compatible with 60+ email clients and devices, Popular clients include: Apple iPhone, Gmail, Apple iPad, Apple Mail, Outlook, Samsung Mail, Google Android and Yahoo! Mail and Windows Live Mail and more!
Default Shopify emails for Order, Shipping, Customer and Templates.
To install the email templates you’ll need access to Files and Notifications in your store’ Settings.
Go to your stores admin to get starterd, then click Settings > Files
. Click Upload files
and select all the files from the images
folder.
Next you will need to upload all email-related images to your store. To do this go to your store’s admin, then Settings > Files
and click Upload files
. Select all the files from images folder. Once the upload is done head over to Notifications
(Settings menu).
The Notifications
section has a complete list of emails your store sends out (Order, Shipping, Customer and Templates). We’ll overwrite the default emails with our custom code.
Selecting one of the notifications from the list. Next, replace the content of the Email body (HTML)
field with the content of the corresponding .txt
file (e.g. Order Confirmation > 01 Order confirmation.txt). Hit Save
once you are done.
Repeat the process for all the email notifications you want to update.
#protip Use the Revert to default
at the end of the edit page to restore your email to their default state.
Click the Customize
button from the Notifications
page to update the Accent color or add a image-based logo (maximum width 200px).
You can add extra information to the email footer.
You can find the information options at the start of every .txt file, e.g. Order Confirmation.
{% capture email_title %}Thank you for your purchase! {% endcapture %} {% capture email_body %} {% if requires_shipping %} Hi {{ customer.first_name }}, we're getting your order ready to be shipped. We will notify you when it has been sent. {% endif %} {% endcapture %} {% assign facebook_href = "" %} {% assign instagram_href = "" %} {% assign twitter_href = "" %} {% assign pinterest_href = "" %} {% assign store_address = "" %} <!DOCTYPE html> <html lang="en"> ...
Example of information options for the material theme.
Add extra information to the email footer by adding your social links to the footer icon variables or add the store address ( store_address = “Store Address” ).
facebook_href adds Facebook icon
instagram_href add Instagram icon
twitter_href add Twitter icon
pinterest_href add Pinterest icon
store_address adds store address
tracking_url custom shipping tracking URL | this option is only available in Fulfillment request theme (09 Fulfillment request.txt)
After Add extra information, e.g. Order Confirmation.
{% assign facebook_href = "https://www.facebook.com/example" %} {% assign instagram_href = "https://www.instagram.com/example" %} {% assign twitter_href = "https://www.twitter.com/example" %} {% assign pinterest_href = "https://www.pinterest.com/example" %} {% assign store_address = "10019, West 55th Street, New York, NY" %}


{% extends 'new_template.html' %} {% block content %}
Type name to search for public participants and full e-mail + search button for others.
Invite people to benefit together from Consensus
1. Suggestion tell them first all about Consensus and why you are using it going to user.
2. Type your contacts e-mail to send them an invitation to connect with you:


RxBluetoothKit is an Bluetooth library that makes interaction with BLE devices much more pleasant. It’s backed by RxSwift and CoreBluetooth. Provides nice API to work with, and makes your code more readable, reliable and easier to maintain.
- 3.0 version supports Swift 3.0 and 3.1
- 5.0 version of the library supports Swift 3.2 and 4.0
Documentation & Support
Documentation can be found here.
Want to talk about it? Ask questions? Give feedback? Join our discussion on Gitter!
For support head to StackOverflow or open an issue on GitHub.
Follow Polidea’s Blog blog to get all the news and updates!
Features
- [x] CBCentralManger RxSwift support
- [x] CBPeripheral RxSwift support
- [x] Scan sharing
- [x] Scan queueing
- [x] Bluetooth error bubbling
Sample
In Example folder you can find application we’ve provided to you. It’s a great place to dig in, once you want to see everything in action. App provides most of the common usages of RxBluetoothKit.
Installation
CocoaPods
CocoaPods is a dependency manager for CocoaProjects.
To integrate RxBluetoothKit into your Xcode project using CocoaPods specify it in your Podfile
:
pod 'RxBluetoothKit'
Then, run following command:
$ pod install
Carthage
Carthage is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.
To integrate RxBluetoothKit into your Xcode project using Carthage specify it in your Cartfile
:
github "Polidea/RxBluetoothKit"
Then, run carthage update
to build framework and drag RxBluetoothKit.framework
into your Xcode project.
Swift Package Manager
Versions >= 4.0 of the library integrate with the Swift Package Manager. In order to do that please specify our project as one of your dependencies in Package.swift
file.
Architecture
Library is built on top of Apple’s CoreBluetooth. It has multiple components, that should be familiar to you:
- CentralManager
- ScannedPeripheral
- Peripheral
- Service
- Characteristic
- Descriptor
Every one of them is backed by it’s CB counterpart hidden behind layer of abstraction. We’ve chosen this architecture, because we believe in testing.
Usage
To begin work you should create an instance of CentralManager. Doing it is really easy - all you need to specify is queue(main queue is used by default):
let manager = CentralManager(queue: .main)
You are responsible for maintaining instance of manager object, and passing it between parts of your app. Note: All operations are executed in queue which you have provided, so make sure to observe UI related effects in main thread when it’s needed.
Scanning peripherals
To start any interaction, with bluetooth devices, you have to first scan some of them. So - get ready!
Basic
manager.scanForPeripherals(withServices: serviceIds)
.subscribe(onNext: { scannedPeripheral in
let advertisementData = scannedPeripheral.advertisementData
})
This is the simplest version of this operation. After subscription to observable, scan is performed infinitely. What you receive from method is ScannedPeripheral
instance, that provides access to following information:
- Peripheral: object that you can use, to perform actions like connecting, discovering services etc.
- AdvertisementData: strongly typed wrapper around CBPeripheral advertisement data dictionary.. Thanks to it, you no longer have to worry about all of the keys needed to pull out information.
- RSSI
Cancelling
By default scanning operation is not cancelled. It’s the user’s responsibility to do that in situations where scanning in not needed anymore. Fortunately, this is also really easy to do, thanks to awesome RxSwift operators.
manager.scanForPeripherals(withServices: [serviceIds]).take(1)
//Doing this, after first received result, scan is immediately cancelled.
Ok, that’s fun, but what if you also want to apply timeout policy? That’s also easy to do:
manager.scanForPeripherals(withServices: [serviceIds]).timeout(3.0, timerScheduler)
As you can see: thanks to all available RxSwift operators, in a simple way you might create really interesting and complex usage scenarios, like for example retrying scans, if you receive timeout.
Waiting for proper BluetoothState
In a following scenario: just after app launch, you want to perform scans. But, there are some problems with this approach - in order to perform work with bluetooth, you’re manager should be in .poweredOn state. Specially for this case, our library provides you with another observable, that you should use for monitoring state.
let stateObservable = manager.observeState()
This observable will emit next event with new value of BluetoothManager state every time state changes.
You could easily chain it with operation you want to perform after changing to proper state. To get current bluetooth state, use CentralManager.state
property. Let’s see how it looks with scanning:
manager.observeState()
.startWith(manager.state)
.filter { $0 == .poweredOn }
.timeout(3.0, scheduler)
.take(1)
.flatMap { _ in manager.scanForPeripherals(withServices: [serviceId]) }
Firstly, use CentralManager.state
as a start value, next filter .poweredOn from states stream. Like above, we want to apply timeout policy to state changes. Also, we use take to be sure, that after getting .poweredOn state, nothing else ever will be emitted by the observable.
In last flatMap
operation bluetooth is ready to perform further operations.
Connecting
After receiving scanned peripheral, to do something with it, we need to first call establishConnection
.
It’s really straightforward: just flatMap result into another Observable!
manager.scanForPeripherals(withServices: [serviceId]).take(1)
.flatMap { $0.peripheral.establishConnection() }
.subscribe(onNext: { peripheral in
print("Connected to: \(peripheral)")
})
Discovering services
After connecting, the most common task is to discover Services.
Because all of wanted services are discovered at once, method returns Single<[Service]>
. In order to make it into Observable<Service>
and fire for each of service discovered, we advice you to use our RxSwift operator Observable.from()
Here’s how it works in RxBluetoothKit:
peripheral.establishConnection()
.flatMap { $0.discoverServices([serviceId]) }.asObservable()
.flatMap { Observable.from($0) }
.subscribe(onNext: { service in
print("Discovered service: \(service)")
})
Discovering characteristics
Discovering characteristics method is very similar to discoverServices.
This time API’s returning Observable<[Characteristic]>
and to process one
characteristic at a time, you need to once again use Observable.from()
peripheral.establishConnection()
.flatMap { $0.discoverServices([serviceId]) }.asObservable()
.flatMap { Observable.from($0) }
.flatMap { $0.discoverCharacteristics([characteristicId])}.asObservable()
.flatMap { Observable.from($0) }
.subscribe(onNext: { characteristic in
print("Discovered characteristic: \(characteristic)")
})
Reading value of characteristic
Once you’ve got characteristic, next common step is to read value from it.
In order to do that, you should use readValue()
function defined on Characteristic
. It returns Observable<Characteristic>
which emits element, when value of characteristic is ready to read.
We decided to return Characteristic
instead of NSData
due to one purpose - to allow you chain operations on characteristic in easy way.
peripheral.establishConnection()
.flatMap { $0.discoverServices([serviceId]) }.asObservable()
.flatMap { Observable.from($0) }
.flatMap { $0.discoverCharacteristics([characteristicId])}.asObservable()
.flatMap { Observable.from($0) }
.flatMap { $0.readValue() }
.subscribe(onNext: {
let data = $0.value
})
Notifying on characteristic changes
Notifying on characteristic value changes? Nothing easier. After subscribing observable returned by this method, you will get proper message every single time:
let disposable = characteristic.observeValueUpdateAndSetNotification()
.subscribe(onNext: {
let newValue = $0.value
})
If you are not interested anymore in updates, just unsubscribe:
disposable.dispose()
Writing value to characteristic
While deciding to write to characteristic you have two writing options, that determine write behavior:
- withResponse
- withoutResponse
Choosing withResponse
, you’re waiting to receive .next event on Observable while device has confirmed that value has been written to it. Also, if any error has ocurred - you will receive .error
on Observable.
On the other hand - if you decided to go with withoutResponse
- you’re receiving Characteristic just after write command has been called. Also, no errors will be emitted.
Let’s jump over to the code:
characteristic.writeValue(data, type: .withResponse)
.subscribe { event in
//respond to errors / successful read
}
Convenience calling methods
In order to enable even easier interaction with RxBluetooth, we’ve provided custom protocols we advice you to implement.
Thats ServiceIdentifier
, CharacteristicIdentifier
and DescriptorIdentifier
. Most of the time you’re writing Bluetooth code to communicate with specific device, while knowing its specification like services and characteristic. Thats exactly the case, where you should implement these protocols. Sample implementation might look like:
enum DeviceCharacteristic: String, CharacteristicIdentifier {
case manufacturerName = "2A29"
var uuid: CBUUID {
return CBUUID(string: self.rawValue)
}
//Service to which characteristic belongs
var service: ServiceIdentifier {
switch self {
case .ManufacturerName:
return XXXService.DeviceInformation
}
}
}
enum DeviceService: String, ServiceIdentifier {
case deviceInformation = "180A"
var uuid: CBUUID {
return CBUUID(string: self.rawValue)
}
}
After implementing these types, whole set of new new methods is becoming available. Earlier implementation of reading from characteristic looked like that:
peripheral.establishConnection()
.flatMap { $0.discoverServices([serviceId]) }.asObservable()
.flatMap { Observable.from($0) }
.flatMap { $0.discoverCharacteristics([characteristicId])}.asObservable()
.flatMap { Observable.from($0) }
.flatMap { $0.readValue() }
.subscribe(onNext: {
let data = $0.value
})
When you use new CharacteristicIdentifier
protocol, you could do it way simpler:
peripheral.establishConnection()
.flatMap { $0.readValue(for: DeviceCharacteristic.manufacturerName)
.subscribe(onNext: {
let data = $0.value
})
Set of methods that are taking instances conforming CharacteristicIdentifier
or DescriptorIdentifier
does all of the heavy lifting like discovering services, characteristics and descriptors for you. Moreover, in order to optimise - when one of these is available in cache, discovery is not called at all.
We really encourage you to use these versions of methods in order to make your code even shorter and cleaner.
Other useful functionalities
Here you’ll find other useful functionalities of library
Bluetooth state restoration
By giving proper identifier to CentralManager
in constructor(options
property), you can achieve state restoration functionality. Later, just make sure to subscribe to listenOnRestoredState
observable, and inspect RestoredState
instance, which consists any useful info about restored state.
Monitoring state of Bluetooth
Used earlier observeState
is very useful function on CentralManager
. It emits next
event with new value of BluetoothManager state every time it changes. To get current bluetooth state, you should use CentralManager.state
property.
Monitor connection state of Peripheral
Property isConnected
on Peripheral
allows checking if Peripheral is connected. To monitor Peripheral connection state changes use observeConnection
method. It emits new element after connection state changes.
Retrieving Peripherals
CentralManager
also lets to retrieve peripherals in two ways:
- via its identifier using array of
UUID
objects, - connected ones via services identifiers using array of
CBUUID
objects. In both cases, return type is[Peripheral]
.
Cancel connection
Connection can be cancelled. To do this dispose Disposable that you get during Peripheral connection.
Read RSSI
Triggers read of Peripheral RSSI value. To do it, call readRSSI()
on Peripheral instance.
Method returns Single<(Peripheral, Int)>
. Peripheral is returned in order to enable chaining.
Monitor services modification
When you want to know, when services are modified, call observeServicesModification() -> Observable<(Peripheral, [Service])>
on Peripheral. Next event is generated each time, when service changes.
Monitor name update
Call observeNameUpdate() -> Observable<(Peripheral, String?)>
in order to know, when peripheral changes its name.
Monitoring write
By calling observeWrite(for characteristic: Characteristic) -> Observable<Characteristic>
you’re able to receive event each time, when value is being written to characteristic.
Additional features
Error bubbling
Library supports complex Bluetooth error handling functionalities. Errors from Bluetooth delegate methods are propagated into all of the API calls. So for example - if during services discovery bluetooth state changes to .poweredOff
, proper error containing this information will be propagated into discoverServices
call.
Requirements
- iOS 8.0+
- OSX 10.10+
- watchOS 4.0+
- tvOS 11.0+
- Xcode 7.3+
Authors
- Przemysław Lenart<EMAIL_ADDRESS>- Kacper Harasim<EMAIL_ADDRESS>Contributing
If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request.
To keep code in order, we advice you to use SwiftLint. In repository, we provide configured .swiftlint.yml
file, that matches our criteria of clean and Swifty
code.
Contributors, thanks!
Maciek Oczko<EMAIL_ADDRESS>License
RxBluetoothKit is available under the Apache License, Version 2.0. See the LICENSE file for more info.


Let us discuss about another way of solving a quadratic equation.
That is, by completing the square. Completing the square method. In the previous videos, we have covered factorization method.
Now I'll tell you the algorithm that is used in completing the square method.
So, let us apply the completing the square method to the standard form of quadratic equation.
The first step of completing the square method is to make the coefficient of x^2 equal to 1.
What we do is we divide by the coefficient of x^2 on both sides so that the coefficient of x^2 becomes 1. Let's do it, and then you will understand.
Dividing the equation by a.
What do we get?
ax^2/a+bx/a+c/a is equal to 0/a. That is nothing but 0.
The coefficient of x^2 here has become 1.
That was our purpose of doing this step. bx/a+c/a is equal to 0.
In the second step what we need to do is we will add and subtract half of the coefficient of x, square of half of coefficient of x.
That is b/2a.
It is (b/(2a))^2.
We need to add and subtract this thing in this equation.
x^2+bx/a+(b/(2a))^2. If we add something to an equation, we need to subtract the same amount to keep the equation intact. +c/a is equal to 0. I haven't made any changes to the original equation. I've just added something and subtracted the same thing.
Now, if you notice carefully, this expression has become of the form a^2+b^2+2ab. So, we can write it as (a+b)^2.
This expression can be written as (x+b/(2a))^2, and the rest of the expression, (b/(2a))^2+c/a is equal to 0.
We will keep this complete square on the left hand side, and let us take the rest of the things to the right hand side of the equation.
Now, let us further solve this equation.
This will become b^2/(4a^2)-c/a, and this will become (b^2-4ac)/(4a^2). Let me take another page, then I'll explain.
(x+b/(2a))^2 is equal to b^2-4ac is equal to (b^2-4ac)/4a^2.
(b^2-4ac)/4a^2. Next logical step would be to take the square root.
I'll get x+b/(2a) is equal to plus or minus and the sqrt(b^2-4ac)/2a..
The entire purpose of this exercise is to get the values of x, so we'll keep x on the left hand side and take this b/(2a) to the right hand side.
We'll change the sign. -b/(2a)+/-(b^2-4ac)/2a.
Here we got the values of x, so we can further simplify it.
-b+/-(b^2-4ac)/2a.
These are the values of x that we get by completing the square method. We'll further discuss various terms in this expression, but this is how we do solutions of quadratic equations using completing the square method. I'll take some examples to further simplify it in further videos.


dependsOnGroups
groups
@Test
The quick-fix adds an undefined name to a list of known groups.
Use the Defined Groups field to define a comma-separated list of known groups.