1634790054

Learn Quantum Mechanics from the Beginning to the End

Quantum Physics Full Course | Quantum Mechanics Course

Quantum physics also known as Quantum mechanics is a fundamental theory in physics that provides a description of the physical properties of nature at the scale of atoms and subatomic particles. It is the foundation of all Quantum Physics including quantum chemistry, quantum field theory, quantum technology, and quantum information science.

In this course you will learn about Quantum Mechanics from the beginning to the end. The following topics of Quantum mechanics have been discussed in this course:

⌨️  (0:00:00) Introduction to quantum mechanics
⌨️  (0:16:23) The domain of quantum mechanics
⌨️  (0:24:18) Key concepts of quantum mechanics
⌨️  (0:34:04) A review of complex numbers for QM
⌨️  (0:48:12) Examples of complex numbers
⌨️  (1:01:47) Probability in quantum mechanics
⌨️  (1:12:17) Variance of probability distribution
⌨️  (1:26:16) Normalization of wave function
⌨️  (1:51:47) Position, velocity and momentum from the wave function
⌨️  (2:10:59) Introduction to the uncertainty principle
⌨️  (2:24:32) Key concepts of QM - revisited
⌨️  (2:37:45) Separation of variables and Schrodinger equation
⌨️  (3:09:55) Stationary solutions to the Schrodinger equation
⌨️  (3:15:47) Superposition of stationary states
⌨️  (3:25:37) Potential function in the Schrodinger equation
⌨️  (3:48:10) Infinite square well (particle in a box)
⌨️  (4:00:58) Infinite square well states, orthogonality - Fourier series
⌨️  (4:08:07) Infinite square well example - computation and simulation
⌨️  (4:39:27) Quantum harmonic oscillators via ladder operators
⌨️  (5:16:48) Quantum harmonic oscillators via power series
⌨️  (5:28:32) Free particles and Schrodinger equation
⌨️  (5:34:37) Free particles wave packets and stationary states
⌨️  (6:10:33) Free particle wave packet example
⌨️  (6:13:43) The Dirac delta function
⌨️  (6:20:49) Boundary conditions in the time independent Schrodinger equation
⌨️  (6:24:39) The bound state solution to the delta function potential TISE
⌨️  (6:43:29) Scattering delta function potential
⌨️  (6:55:49) Finite square well scattering states
⌨️  (7:07:39) Linear algebra introduction for quantum mechanics
⌨️  (7:10:34) Linear transformation
⌨️  (7:13:04) Mathematical formalism is Quantum mechanics
⌨️  (7:37:52) Hermitian operator  eigen-stuff
⌨️  (8:01:23) Statistics in formalized quantum mechanics
⌨️  (8:24:26) Generalized uncertainty principle
⌨️  (8:54:36) Energy time uncertainty
⌨️  (9:16:33) Schrodinger equation in 3d
⌨️  (9:19:56) Hydrogen spectrum
⌨️  (9:31:14) Angular momentum operator algebra
⌨️  (9:57:17) Angular momentum eigen function
⌨️  (10:18:08) Spin in quantum mechanics
⌨️  (10:22:23) Two particles system
⌨️  (10:58:03) Free electrons in conductors
⌨️  (11:09:23) Band structure of energy levels in solids

#quantum #developer

1651383480

A Simple Wrapper Around Amplify AppSync Simulator

This serverless plugin is a wrapper for amplify-appsync-simulator made for testing AppSync APIs built with serverless-appsync-plugin.

Install

``````npm install serverless-appsync-simulator
# or
``````

Usage

This plugin relies on your serverless yml file and on the `serverless-offline` plugin.

``````plugins:
- serverless-dynamodb-local # only if you need dynamodb resolvers and you don't have an external dynamodb
- serverless-appsync-simulator
- serverless-offline
``````

Note: Order is important `serverless-appsync-simulator` must go before `serverless-offline`

To start the simulator, run the following command:

``````sls offline start
``````

You should see in the logs something like:

``````...
Serverless: AppSync endpoint: http://localhost:20002/graphql
Serverless: GraphiQl: http://localhost:20002
...
``````

Configuration

Put options under `custom.appsync-simulator` in your `serverless.yml` file

| option | default | description | | ------------------------ | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | | apiKey | `0123456789` | When using `API_KEY` as authentication type, the key to authenticate to the endpoint. | | port | 20002 | AppSync operations port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20002, 20012, 20022, etc.) | | wsPort | 20003 | AppSync subscriptions port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20003, 20013, 20023, etc.) | | location | . (base directory) | Location of the lambda functions handlers. | | refMap | {} | A mapping of resource resolutions for the `Ref` function | | getAttMap | {} | A mapping of resource resolutions for the `GetAtt` function | | importValueMap | {} | A mapping of resource resolutions for the `ImportValue` function | | functions | {} | A mapping of external functions for providing invoke url for external fucntions | | dynamoDb.endpoint | http://localhost:8000 | Dynamodb endpoint. Specify it if you're not using serverless-dynamodb-local. Otherwise, port is taken from dynamodb-local conf | | dynamoDb.region | localhost | Dynamodb region. Specify it if you're connecting to a remote Dynamodb intance. | | dynamoDb.accessKeyId | DEFAULT_ACCESS_KEY | AWS Access Key ID to access DynamoDB | | dynamoDb.secretAccessKey | DEFAULT_SECRET | AWS Secret Key to access DynamoDB | | dynamoDb.sessionToken | DEFAULT_ACCESS_TOKEEN | AWS Session Token to access DynamoDB, only if you have temporary security credentials configured on AWS | | dynamoDb.* | | You can add every configuration accepted by DynamoDB SDK | | rds.dbName | | Name of the database | | rds.dbHost | | Database host | | rds.dbDialect | | Database dialect. Possible values (mysql | postgres) | | rds.dbUsername | | Database username | | rds.dbPassword | | Database password | | rds.dbPort | | Database port | | watch | - *.graphql
- *.vtl | Array of glob patterns to watch for hot-reloading. |

Example:

``````custom:
appsync-simulator:
location: '.webpack/service' # use webpack build directory
dynamoDb:
endpoint: 'http://my-custom-dynamo:8000'
``````

By default, the simulator will hot-relad when changes to `*.graphql` or `*.vtl` files are detected. Changes to `*.yml` files are not supported (yet? - this is a Serverless Framework limitation). You will need to restart the simulator each time you change yml files.

You can change the files being watched with the `watch` option, which is then passed to watchman as the match expression.

e.g.

``````custom:
appsync-simulator:
watch:
- ["match", "handlers/**/*.vtl", "wholename"] # => array is interpreted as the literal match expression
- "*.graphql"                                 # => string like this is equivalent to `["match", "*.graphql"]`
``````

Or you can opt-out by leaving an empty array or set the option to `false`

Note: Functions should not require hot-reloading, unless you are using a transpiler or a bundler (such as webpack, babel or typescript), un which case you should delegate hot-reloading to that instead.

Resource CloudFormation functions resolution

This plugin supports some resources resolution from the `Ref`, `Fn::GetAtt` and `Fn::ImportValue` functions in your yaml file. It also supports some other Cfn functions such as `Fn::Join`, `Fb::Sub`, etc.

Note: Under the hood, this features relies on the cfn-resolver-lib package. For more info on supported cfn functions, refer to the documentation

Basic usage

You can reference resources in your functions' environment variables (that will be accessible from your lambda functions) or datasource definitions. The plugin will automatically resolve them for you.

``````provider:
environment:
BUCKET_NAME:
Ref: MyBucket # resolves to `my-bucket-name`

resources:
Resources:
MyDbTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: myTable
...
MyBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: my-bucket-name
...

dataSources:
- type: AMAZON_DYNAMODB
name: dynamosource
config:
tableName:
Ref: MyDbTable # resolves to `myTable`
``````

Override (or mock) values

Sometimes, some references cannot be resolved, as they come from an Output from Cloudformation; or you might want to use mocked values in your local environment.

In those cases, you can define (or override) those values using the `refMap`, `getAttMap` and `importValueMap` options.

• `refMap` takes a mapping of resource name to value pairs
• `getAttMap` takes a mapping of resource name to attribute/values pairs
• `importValueMap` takes a mapping of import name to values pairs

Example:

``````custom:
appsync-simulator:
refMap:
# Override `MyDbTable` resolution from the previous example.
MyDbTable: 'mock-myTable'
getAttMap:
# define ElasticSearchInstance DomainName
ElasticSearchInstance:
DomainEndpoint: 'localhost:9200'
importValueMap:
other-service-api-url: 'https://other.api.url.com/graphql'

dataSources:
- type: AMAZON_ELASTICSEARCH
name: elasticsource
config:
# endpoint resolves as 'http://localhost:9200'
endpoint:
Fn::Join:
- ''
- - https://
- Fn::GetAtt:
- ElasticSearchInstance
- DomainEndpoint
``````

Key-value mock notation

In some special cases you will need to use key-value mock nottation. Good example can be case when you need to include serverless stage value (`\${self:provider.stage}`) in the import name.

This notation can be used with all mocks - `refMap`, `getAttMap` and `importValueMap`

``````provider:
environment:
FINISH_ACTIVITY_FUNCTION_ARN:
Fn::ImportValue: other-service-api-\${self:provider.stage}-url

custom:
serverless-appsync-simulator:
importValueMap:
- key: other-service-api-\${self:provider.stage}-url
value: 'https://other.api.url.com/graphql'
``````

Limitations

This plugin only tries to resolve the following parts of the yml tree:

• `provider.environment`
• `functions[*].environment`
• `custom.appSync`

If you have the need of resolving others, feel free to open an issue and explain your use case.

For now, the supported resources to be automatically resovled by `Ref:` are:

• DynamoDb tables
• S3 Buckets

Feel free to open a PR or an issue to extend them as well.

External functions

When a function is not defined withing the current serverless file you can still call it by providing an invoke url which should point to a REST method. Make sure you specify "get" or "post" for the method. Default is "get", but you probably want "post".

``````custom:
appsync-simulator:
functions:
method: post
url: https://jsonplaceholder.typicode.com/posts
method: post
``````

Supported Resolver types

This plugin supports resolvers implemented by `amplify-appsync-simulator`, as well as custom resolvers.

From Aws Amplify:

• NONE
• AWS_LAMBDA
• AMAZON_DYNAMODB
• PIPELINE

Implemented by this plugin

• AMAZON_ELASTIC_SEARCH
• HTTP
• RELATIONAL_DATABASE

Relational Database

Sample VTL for a create mutation

``````#set( \$cols = [] )
#set( \$vals = [] )
#foreach( \$entry in \$ctx.args.input.keySet() )
#set( \$regex = "([a-z])([A-Z]+)")
#set( \$replacement = "\$1_\$2")
#set( \$toSnake = \$entry.replaceAll(\$regex, \$replacement).toLowerCase() )
#if( \$util.isBoolean(\$ctx.args.input[\$entry]) )
#if( \$ctx.args.input[\$entry] )
#else
#end
#else
#end
#end
#set( \$valStr = \$vals.toString().replace("[","(").replace("]",")") )
#set( \$colStr = \$cols.toString().replace("[","(").replace("]",")") )
#if ( \$valStr.substring(0, 1) != '(' )
#set( \$valStr = "(\$valStr)" )
#end
#if ( \$colStr.substring(0, 1) != '(' )
#set( \$colStr = "(\$colStr)" )
#end
{
"version": "2018-05-29",
"statements":   ["INSERT INTO <name-of-table> \$colStr VALUES \$valStr", "SELECT * FROM    <name-of-table> ORDER BY id DESC LIMIT 1"]
}
``````

Sample VTL for an update mutation

``````#set( \$update = "" )
#set( \$equals = "=" )
#foreach( \$entry in \$ctx.args.input.keySet() )
#set( \$cur = \$ctx.args.input[\$entry] )
#set( \$regex = "([a-z])([A-Z]+)")
#set( \$replacement = "\$1_\$2")
#set( \$toSnake = \$entry.replaceAll(\$regex, \$replacement).toLowerCase() )
#if( \$util.isBoolean(\$cur) )
#if( \$cur )
#set ( \$cur = "1" )
#else
#set ( \$cur = "0" )
#end
#end
#if ( \$util.isNullOrEmpty(\$update) )
#set(\$update = "\$toSnake\$equals'\$cur'" )
#else
#set(\$update = "\$update,\$toSnake\$equals'\$cur'" )
#end
#end
{
"version": "2018-05-29",
"statements":   ["UPDATE <name-of-table> SET \$update WHERE id=\$ctx.args.input.id", "SELECT * FROM <name-of-table> WHERE id=\$ctx.args.input.id"]
}
``````

Sample resolver for delete mutation

``````{
"version": "2018-05-29",
"statements":   ["UPDATE <name-of-table> set deleted_at=NOW() WHERE id=\$ctx.args.id", "SELECT * FROM <name-of-table> WHERE id=\$ctx.args.id"]
}
``````

Sample mutation response VTL with support for handling AWSDateTime

``````#set ( \$index = -1)
#set ( \$result = \$util.parseJson(\$ctx.result) )
#foreach (\$column in \$meta)
#set (\$index = \$index + 1)
#if ( \$column["typeName"] == "timestamptz" )
#set (\$time = \$result["sqlStatementResults"][1]["records"][0][\$index]["stringValue"] )
#set ( \$nowEpochMillis = \$util.time.parseFormattedToEpochMilliSeconds("\$time.substring(0,19)+0000", "yyyy-MM-dd HH:mm:ssZ") )
#set ( \$isoDateTime = \$util.time.epochMilliSecondsToISO8601(\$nowEpochMillis) )
\$util.qr( \$result["sqlStatementResults"][1]["records"][0][\$index].put("stringValue", "\$isoDateTime") )
#end
#end
#set ( \$res = \$util.parseJson(\$util.rds.toJsonString(\$util.toJson(\$result)))[1][0] )
#set ( \$response = {} )
#foreach(\$mapKey in \$res.keySet())
#set ( \$s = \$mapKey.split("_") )
#set ( \$camelCase="" )
#set ( \$isFirst=true )
#foreach(\$entry in \$s)
#if ( \$isFirst )
#set ( \$first = \$entry.substring(0,1) )
#else
#set ( \$first = \$entry.substring(0,1).toUpperCase() )
#end
#set ( \$isFirst=false )
#set ( \$stringLength = \$entry.length() )
#set ( \$remaining = \$entry.substring(1, \$stringLength) )
#set ( \$camelCase = "\$camelCase\$first\$remaining" )
#end
\$util.qr( \$response.put("\$camelCase", \$res[\$mapKey]) )
#end
\$utils.toJson(\$response)
``````

Using Variable Map

Variable map support is limited and does not differentiate numbers and strings data types, please inject them directly if needed.

Will be escaped properly: `null`, `true`, and `false` values.

``````{
"version": "2018-05-29",
"statements":   [
"UPDATE <name-of-table> set deleted_at=NOW() WHERE id=:ID",
"SELECT * FROM <name-of-table> WHERE id=:ID and unix_timestamp > \$ctx.args.newerThan"
],
variableMap: {
":ID": \$ctx.args.id,
##    ":TIMESTAMP": \$ctx.args.newerThan -- This will be handled as a string!!!
}
}``````

Requires

Author: Serverless-appsync
Source Code: https://github.com/serverless-appsync/serverless-appsync-simulator

1648972740

Generis: Versatile Go Code Generator

Generis

Versatile Go code generator.

Description

Generis is a lightweight code preprocessor adding the following features to the Go language :

• Generics.
• Free-form macros.
• Conditional compilation.
• HTML templating.
• Allman style conversion.

Sample

``````package main;

// -- IMPORTS

import (
"html"
"io"
"log"
"net/http"
"net/url"
"strconv"
);

// -- DEFINITIONS

#define DebugMode
#as true

// ~~

#define HttpPort
#as 8080

// ~~

#define WriteLine( {{text}} )
#as log.Println( {{text}} )

// ~~

#define local {{variable}} : {{type}};
#as var {{variable}} {{type}};

// ~~

#define DeclareStack( {{type}}, {{name}} )
#as
// -- TYPES

type {{name}}Stack struct
{
ElementArray []{{type}};
}

// -- INQUIRIES

func ( stack * {{name}}Stack ) IsEmpty(
) bool
{
return len( stack.ElementArray ) == 0;
}

// -- OPERATIONS

func ( stack * {{name}}Stack ) Push(
element {{type}}
)
{
stack.ElementArray = append( stack.ElementArray, element );
}

// ~~

func ( stack * {{name}}Stack ) Pop(
) {{type}}
{
local
element : {{type}};

element = stack.ElementArray[ len( stack.ElementArray ) - 1 ];

stack.ElementArray = stack.ElementArray[ : len( stack.ElementArray ) - 1 ];

return element;
}
#end

// ~~

#define DeclareStack( {{type}} )
#as DeclareStack( {{type}}, {{type:PascalCase}} )

// -- TYPES

DeclareStack( string )
DeclareStack( int32 )

// -- FUNCTIONS

func HandleRootPage(
response_writer http.ResponseWriter,
request * http.Request
)
{
local
boolean : bool;
local
natural : uint;
local
integer : int;
local
real : float64;
local
escaped_html_text,
escaped_url_text,
text : string;
local
integer_stack : Int32Stack;

boolean = true;
natural = 10;
integer = 20;
real = 30.0;
text = "text";
escaped_url_text = "&escaped text?";
escaped_html_text = "<escaped text/>";

integer_stack.Push( 10 );
integer_stack.Push( 20 );
integer_stack.Push( 30 );

#write response_writer
<!DOCTYPE html>
<html lang="en">
<meta charset="utf-8">
<title><%= request.URL.Path %></title>
<body>
<% if ( boolean ) { %>
<%= "URL : " + request.URL.Path %>
<br/>
<%@ natural %>
<%# integer %>
<%& real %>
<br/>
<%~ text %>
<%^ escaped_url_text %>
<%= escaped_html_text %>
<%= "<%% ignored %%>" %>
<%% ignored %%>
<% } %>
<br/>
Stack :
<br/>
<% for !integer_stack.IsEmpty() { %>
<%# integer_stack.Pop() %>
<% } %>
</body>
</html>
#end
}

// ~~

func main()
{
http.HandleFunc( "/", HandleRootPage );

#if DebugMode
WriteLine( "Listening on http://localhost:HttpPort" );
#end

log.Fatal(
http.ListenAndServe( ":HttpPort", nil )
);
}
``````

Syntax

#define directive

Constants and generic code can be defined with the following syntax :

``````#define old code
#as new code

#define old code
#as
new
code
#end

#define
old
code
#as new code

#define
old
code
#as
new
code
#end
``````

#define parameter

The `#define` directive can contain one or several parameters :

``````{{variable name}} : hierarchical code (with properly matching brackets and parentheses)
{{variable name#}} : statement code (hierarchical code without semicolon)
{{variable name\$}} : plain code
{{variable name:boolean expression}} : conditional hierarchical code
{{variable name#:boolean expression}} : conditional statement code
{{variable name\$:boolean expression}} : conditional plain code
``````

They can have a boolean expression to require they match specific conditions :

``````HasText text
HasPrefix prefix
HasSuffix suffix
HasIdentifier text
false
true
!expression
expression && expression
expression || expression
( expression )
``````

The `#define` directive must not start or end with a parameter.

#as parameter

The `#as` directive can use the value of the `#define` parameters :

``````{{variable name}}
{{variable name:filter function}}
{{variable name:filter function:filter function:...}}
``````

Their value can be changed through one or several filter functions :

``````LowerCase
UpperCase
MinorCase
MajorCase
SnakeCase
PascalCase
CamelCase
RemoveBlanks
PackStrings
PackIdentifiers
ReplacePrefix old_prefix new_prefix
ReplaceSuffix old_suffix new_suffix
ReplaceText old_text new_text
ReplaceIdentifier old_identifier new_identifier
RemovePrefix prefix
RemoveSuffix suffix
RemoveText text
RemoveIdentifier identifier
``````

#if directive

Conditional code can be defined with the following syntax :

``````#if boolean expression
#if boolean expression
...
#else
...
#end
#else
#if boolean expression
...
#else
...
#end
#end
``````

The boolean expression can use the following operators :

``````false
true
!expression
expression && expression
expression || expression
( expression )
``````

#write directive

Templated HTML code can be sent to a stream writer using the following syntax :

``````#write writer expression
<% code %>
<%@ natural expression %>
<%# integer expression %>
<%& real expression %>
<%~ text expression %>
<%= escaped text expression %>
<%! removed content %>
<%% ignored tags %%>
#end
``````

Limitations

• There is no operator precedence in boolean expressions.
• The `--join` option requires to end the statements with a semicolon.
• The `#writer` directive is only available for the Go language.

Installation

Install the DMD 2 compiler (using the MinGW setup option on Windows).

Build the executable with the following command line :

``````dmd -m64 generis.d
``````

Command line

``````generis [options]
``````

Options

``````--prefix # : set the command prefix
--parse INPUT_FOLDER/ : parse the definitions of the Generis files in the input folder
--process INPUT_FOLDER/ OUTPUT_FOLDER/ : reads the Generis files in the input folder and writes the processed files in the output folder
--trim : trim the HTML templates
--join : join the split statements
--create : create the output folders if needed
--watch : watch the Generis files for modifications
--pause 500 : time to wait before checking the Generis files again
--tabulation 4 : set the tabulation space count
--extension .go : generate files with this extension
``````

Examples

``````generis --process GS/ GO/
``````

Reads the Generis files in the `GS/` folder and writes Go files in the `GO/` folder.

``````generis --process GS/ GO/ --create
``````

Reads the Generis files in the `GS/` folder and writes Go files in the `GO/` folder, creating the output folders if needed.

``````generis --process GS/ GO/ --create --watch
``````

Reads the Generis files in the `GS/` folder and writes Go files in the `GO/` folder, creating the output folders if needed and watching the Generis files for modifications.

``````generis --process GS/ GO/ --trim --join --create --watch
``````

Reads the Generis files in the `GS/` folder and writes Go files in the `GO/` folder, trimming the HTML templates, joining the split statements, creating the output folders if needed and watching the Generis files for modifications.

Version

2.0

Author: Senselogic
Source Code: https://github.com/senselogic/GENERIS

1619247660

Google's TPU's being primed for the Quantum Jump

The liquid-cooled Tensor Processing Units, built to slot into server racks, can deliver up to 100 petaflops of compute.

The liquid-cooled Tensor Processing Units, built to slot into server racks, can deliver up to 100 petaflops of compute.

As the world is gearing towards more automation and AI, the need for quantum computing has also grown exponentially. Quantum computing lies at the intersection of quantum physics and high-end computer technology, and in more than one way, hold the key to our AI-driven future.

Quantum computing requires state-of-the-art tools to perform high-end computing. This is where TPUs come in handy. TPUs or Tensor Processing Units are custom-built ASICs (Application Specific Integrated Circuits) to execute machine learning tasks efficiently. TPUs are specific hardware developed by Google for neural network machine learning, specially customised to Google’s Machine Learning software, Tensorflow.

The liquid-cooled Tensor Processing units, built to slot into server racks, can deliver up to 100 petaflops of compute. It powers Google products like Google Search, Gmail, Google Photos and Google Cloud AI APIs.

1634216592

Quickstart

``````flutter pub global activate readme_helper
``````

2. Start using these "magical" comment commands:

``````Insert code example from external file:
<!-- #code path/to/file.dart -->

<!-- #toc -->

This will include another markdown file:
<!-- #include path/to/other_markdown.md -->
``````

3. Run readme_helper for current project:

``````flutter pub global run readme_helper
``````

Quickstart

Motivation

Usage

Commands

Motivation

A good documentation is the key in connecting package creators and developers.

Embedding code examples is essential, but they might deprecate over the time. This tool enables you to use external code files, the correctness is ensured by your IDE.

Usage

The readme_helper is a Dart application, that can be installed or updated with:

``````flutter pub global activate readme_helper
``````

You can run the readme_helper with:

``````flutter pub global run readme_helper
``````

It will take care of all markdown files within the current directory and it's sub-directories.

Alternately you can process only a single file with:

``````flutter pub global run readme_helper path/to/file.md
``````

Commands

You can specify commands by using HTML comments in your markdown files. Each readme_helper command starts with a `#`:

``````<!-- #command argument -->
``````

Code embedding

You can embed external files by defining the relative path to it.

``````<!-- #code path/to/code.dart -->
``````

This will add a code block with the content of that file.

You can use comments to control the part of the external file shown.

``````import 'dart:math';

// #begin
class MyClass {
// #skip
int someMethod() {
return Random().nextInt(1);
}
// #resume

String interestingMethod() {
return 'Foo';
}
}
// #end
``````

This will add the following code block:

``````class MyClass {
...

String interestingMethod() {
return 'Foo';
}
}
``````

Indentions

By indenting the `// #begin` scope comments, you can hint to remove leading whitespace.

``````class AnotherClass {
// #begin
int importantMethod() {
return 42;
}
// #end
}
``````

This will add the following code block:

``````int importantMethod() {
return 42;
}
``````

The readme_helper will scan all markdown headlines (`##` and `###`) and generate a table of contents.

``````# project_name

<!-- #toc -->

## chapter a
### section 1
### section 2

## chapter b
### section 3
### section 4
``````

This will create something like this:

Include markdown files

You can include parts from other files into the current markdown file, by using an include:

``````<!-- #include path/to/part.md -->
``````

Generate line breaks

By default you can't have more then one new line. For esthetics you might want to extend this limit.

``````<!-- #space 2 -->
``````

This will generate line breaks with `&nbsp;` characters.

Use this package as a library

Depend on it

Run this command:

With Dart:

`` \$ dart pub add readme_helper``

With Flutter:

`` \$ flutter pub add readme_helper``

This will add a line like this to your package's pubspec.yaml (and run an implicit `dart pub get`):

``````dependencies:

Alternatively, your editor might support `dart pub get` or `flutter pub get`. Check the docs for your editor to learn more.

Import it

Now in your Dart code, you can use:

``````import 'package:readme_helper/code.dart';

Author: felixblaschke

1599315300

Quantum Physics Full Course | Quantum Mechanics Course

Quantum physics also known as Quantum mechanics is a fundamental theory in physics that provides a description of the physical properties of nature at the scale of atoms and subatomic particles. It is the foundation of all #quantum #physics including quantum chemistry, quantum field theory, quantum technology, and quantum information science.

In this course you will learn about Quantum #mechanics from the beginning to the end. The following topics of Quantum mechanics have been discussed in this course:

⌨️  (0:00:00) Introduction to quantum mechanics
⌨️  (0:16:23) The domain of quantum mechanics
⌨️  (0:24:18) Key concepts of quantum mechanics
⌨️  (0:34:04) A review of complex numbers for QM
⌨️  (0:48:12) Examples of complex numbers
⌨️  (1:01:47) Probability in quantum mechanics
⌨️  (1:12:17) Variance of probability distribution
⌨️  (1:26:16) Normalization of wave function
⌨️  (1:51:47) Position, velocity and momentum from the wave function
⌨️  (2:10:59) Introduction to the uncertainty principle
⌨️  (2:24:32) Key concepts of QM - revisited
⌨️  (2:37:45) Separation of variables and Schrodinger equation
⌨️  (3:09:55) Stationary solutions to the Schrodinger equation
⌨️  (3:15:47) Superposition of stationary states
⌨️  (3:25:37) Potential function in the Schrodinger equation
⌨️  (3:48:10) Infinite square well (particle in a box)
⌨️  (4:00:58) Infinite square well states, orthogonality - Fourier series
⌨️  (4:08:07) Infinite square well example - computation and simulation
⌨️  (4:39:27) Quantum harmonic oscillators via ladder operators
⌨️  (5:16:48) Quantum harmonic oscillators via power series
⌨️  (5:28:32) Free particles and Schrodinger equation
⌨️  (5:34:37) Free particles wave packets and stationary states
⌨️  (6:10:33) Free particle wave packet example
⌨️  (6:13:43) The Dirac delta function
⌨️  (6:20:49) Boundary conditions in the time independent Schrodinger equation
⌨️  (6:24:39) The bound state solution to the delta function potential TISE
⌨️  (6:43:29) Scattering delta function potential
⌨️  (6:55:49) Finite square well scattering states
⌨️  (7:07:39) Linear algebra introduction for quantum mechanics
⌨️  (7:10:34) Linear transformation
⌨️  (7:13:04) Mathematical formalism is Quantum mechanics
⌨️  (7:37:52) Hermitian operator  eigen-stuff
⌨️  (8:01:23) Statistics in formalized quantum mechanics
⌨️  (8:24:26) Generalized uncertainty principle
⌨️  (8:54:36) Energy time uncertainty
⌨️  (9:16:33) Schrodinger equation in 3d
⌨️  (9:19:56) Hydrogen spectrum
⌨️  (9:31:14) Angular momentum operator algebra
⌨️  (9:57:17) Angular momentum eigen function
⌨️  (10:18:08) Spin in quantum mechanics
⌨️  (10:22:23) Two particles system
⌨️  (10:58:03) Free electrons in conductors
⌨️  (11:09:23) Band structure of energy levels in solids

#quantum #developer #programming