偏头痛

丙戊酸镁缓释片
尼麦角林片
复方天麻蜜环糖肽片
CT、磁共振、脑电图、心电图、血糖、血脂均检查过，没问题
拍颈椎片，4至6椎骨质增生
黎刚大夫诊断为偏头痛，上次开了三种药：丙戊酸镁缓释片、尼麦角林片、复方天麻蜜环糖肽片。吃一个月之后头痛头晕好像更严重。20161021
但是吃药前头晕呕吐，现在仅头晕，不呕吐了
http://shengming.haodf.com/thread/finish?threadId=4863099055

黛立新

不能控制的话可以考虑 艾司唑仑

websphere note

A node is an administrative grouping of application servers for configuration and operational
management within one operating system instance (virtualization allows multiple operating
systems on one machine).

A cell is a grouping of nodes into a single administrative domain.
 In the Base and Express
configurations, a cell contains one node. That node contains one server.
yment managers
The deployment manager is the central administration point of a cell, which consists of
multiple nodes and node groups in a distributed server configuration.

A proxy server is a specific type of application server that routes requests to content servers
that perform the work.

The web server plug-in
will send the request to the application server using the host name and port number in the
transport setting for that server.

An unmanaged node does not have a node agent to manage its servers.

 If your web server is the IBM HTTP Server, you can
configure the server on an unmanaged node, and still be able to administer the web server
using the WebSphere administrative tools. This unmanaged node does not need a node
agent on the web server machine.
A managed node has a node agent for managing web servers.

Programming in Scala 16/

1.
List(1, 2, 3) creates the list1 :: (2 :: (3 :: Nil)).
2.
List(List(1, 2), List(3), List(), List(4, 5)).flatten
The zip operation takes two lists and forms a list of pairs
3.
The operation xs map f takes as operands a list xs of type List[T] and a function f of type T => U. It
returns the list that results from applying the function f to each list element in xs. For instance:
scala> List(1, 2, 3) map (_ + 1)
res32: List[Int] = List(2, 3, 4)

iPhone 7 model for China Mobile 4G

From the below official website, iPhone 7 Plus Model A1661 works for ChinaMobile 4G while A1784 does not.
https://support.apple.com/en-ca/HT201296
https://support.apple.com/en-us/HT202909

Live and learn

Mahatma Gandhi: “Live as if you were to die tomorrow. Learn as if you were to live forever.”

Programming in Scala 11/12/13/14/15

1.
Any is a superclass of every other class, Nothing is a subclass of every other class.
== and !=, are declared final in class Any, so they cannot be overridden in subclasses.
2.

Class Null is the type of the null reference; it is a subclass of every reference class (i.e., every class that

itself inherits from AnyRef). Null is not compatible with value types. You cannot, for example, assign

a null value to an integer variable.

Type Nothing is at the very bottom of Scala's class hierarchy; it is a subtype of every other type.

you can

do anything in a trait definition that you can do in a class definition, and the syntax looks exactly the

same, with only two exceptions.

First, a trait cannot have any "class" parameters.

The other difference between classes and traits is that whereas in classes, super calls are statically

bound, in traits, they are dynamically bound. If you write "super.toString" in a class, you know exactly

which method implementation will be invoked. When you write the same thing in a trait, however, the

method implementation to invoke for the super call is undefined when you define the trait.
3.
Using the modifier case makes the
Scala compiler add some syntactic conveniences to your class.
First, it adds a factory method with the name of the class.
The second syntactic convenience is that all arguments in the parameter list of a case class implicitly
get a val prefix, so they are maintained as fields.
Finally, the compiler adds a copy method to your class for making modified copies.
However, the biggest advantage
of case classes is that they support pattern matching.
4.
Constant patterns:
def describe(x: Any) = x match {
case 5 => "five"
case true => "truth"
case "hello" => "hi!"
case Nil => "the empty list"
case _ => "something else"
}
Scala uses a simple lexical rule for disambiguation: a simple
name starting with a lowercase letter is taken to be a pattern variable; all other references are taken to
be constants.

If that
does not work (because pi is a local variable, say), you can alternatively enclose the variable name in
back ticks. For instance, `pi` would again be interpreted as a constant, not as a variable