Question

我有两个矩阵A和B，矩阵A的第一行（1，：）= [1 2]是指行数和列矩阵B（1,2）= 21，现在我想做这项工作适用于没有循环的另一行矩阵A？

A=[1 2;2 3;1 3;3 3];
B=[1 21 34;45 65 87;4 55 66];
for i=1:4
d(i,:)=B(A(i,1),A(i,2))
end
d =[21; 87;34;66]

Answer 1

使用sub2ind获取B所需值的线性索引，然后使用这些索引检索这些值。

d = B(sub2ind(size(B), A(:,1), A(:,2)));

Answer 2

我想以下代码必须适合您：

# Serving an API

Enough chit-chat about type-level combinators and representing an API as a
type. Can we have a webservice already?

## A first example

Equipped with some basic knowledge about the way we represent APIs, let's now write our first webservice.

The source for this tutorial section is a literate haskell file, so first we need to have some language extensions and imports:

``` haskell
> {-# LANGUAGE DataKinds #-}
> {-# LANGUAGE DeriveGeneric #-}
> {-# LANGUAGE FlexibleInstances #-}
> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
> {-# LANGUAGE MultiParamTypeClasses #-}
> {-# LANGUAGE OverloadedStrings #-}
> {-# LANGUAGE ScopedTypeVariables #-}
> {-# LANGUAGE TypeOperators #-}

> module Server where

> import Prelude ()
> import Prelude.Compat

> import Control.Monad.Except
> import Control.Monad.Reader
> import Data.Aeson.Compat
> import Data.Aeson.Types
> import Data.Attoparsec.ByteString
> import Data.ByteString (ByteString)
> import Data.List
> import Data.Maybe
> import Data.String.Conversions
> import Data.Time.Calendar
> import GHC.Generics
> import Lucid
> import Network.HTTP.Media ((//), (/:))
> import Network.Wai
> import Network.Wai.Handler.Warp
> import Servant
> import System.Directory
> import Text.Blaze
> import Text.Blaze.Html.Renderer.Utf8
> import qualified Data.Aeson.Parser
> import qualified Text.Blaze.Html
```

**Important**: the `Servant` module comes from the **servant-server** package, the one that lets us run webservers that implement a particular API type. It reexports all the types from the **servant** package that let you declare API types as well as everything you need to turn your request handlers into a fully-fledged webserver. This means that in your applications, you can just add **servant-server** as a dependency, import `Servant` and not worry about anything else.

We will write a server that will serve the following API.

``` haskell
> type UserAPI1 = "users" :> Get '[JSON] [User]
```

Here's what we would like to see when making a GET request to `/users`.

``` javascript
[ {"name": "Isaac Newton", "age": 372, "email": "isaac@newton.co.uk", "registration_date": "1683-03-01"}
, {"name": "Albert Einstein", "age": 136, "email": "ae@mc2.org", "registration_date": "1905-12-01"}
]
```

Now let's define our `User` data type and write some instances for it.

``` haskell
> data User = User
>   { name :: String
>   , age :: Int
>   , email :: String
>   , registration_date :: Day
>   } deriving (Eq, Show, Generic)

> instance ToJSON User
```

Nothing funny going on here. But we now can define our list of two users.

``` haskell
> users1 :: [User]
> users1 =
>   [ User "Isaac Newton"    372 "isaac@newton.co.uk" (fromGregorian 1683  3 1)
>   , User "Albert Einstein" 136 "ae@mc2.org"         (fromGregorian 1905 12 1)
>   ]
```

Let's also write our API type.

``` haskell ignore
type UserAPI1 = "users" :> Get '[JSON] [User]
```

We can now take care of writing the actual webservice that will handle requests to such an API. This one will be very simple, being reduced to just a single endpoint. The type of the web application is determined by the API type, through a *type family* named `Server`. (Type families are just functions that take types as input and return types.)  The `Server` type family will compute the right type that a bunch of request handlers should have just from the
corresponding API type.

The first thing to know about the `Server` type family is that behind the
scenes it will drive the routing, letting you focus only on the business
logic. The second thing to know is that for each endpoint, your handlers will by default run in the `Handler` monad. This is overridable very
easily, as explained near the end of this guide. Third thing, the type of the value returned in that monad must be the same as the second argument of the HTTP method combinator used for the corresponding endpoint. In our case, it means we must provide a handler of type `Handler [User]`. Well,
we have a monad, let's just `return` our list:

``` haskell
> server1 :: Server UserAPI1
> server1 = return users1
```

That's it. Now we can turn `server` into an actual webserver using
[wai](http://hackage.haskell.org/package/wai) and
[warp](http://hackage.haskell.org/package/warp):

``` haskell
> userAPI :: Proxy UserAPI1
> userAPI = Proxy
```

'serve' comes from servant and hands you a WAI Application,
which you can think of as an "abstract" web application,
not yet a webserver.

```haskell
> app1 :: Application
> app1 = serve userAPI server1
```

The `userAPI` bit is, alas, boilerplate (we need it to guide type inference).
But that's about as much boilerplate as you get.

And we're done! Let's run our webservice on the port 8081.

```haskell
> main :: IO ()
> main = run 8081 app1
```

Answer 3

sub2ind的替代方案是

d = B(A(:,1)+ (A(:,2)-1)*size(B,1));

根据matlab中的行和列numder查找值数组

3 个答案: