首先可以先看一下几个常见的核函数，明确一点，核函数的目标是为了更加简便的计算从低维空间映射到高维空间后内积的运算问题，也就是基于现有的低维空间向量，能够计算出映射到高维空间后的内积。
 
 
既然有这个性质，那么每一个核函数必然要对应一个从低维到高维的映射函数，换句话来说，只有能找到一个映射，使得从低维映射到高维后的坐标内积能够与核函数计算出的值相同，那么当前所找出的核函数才是有意义的。
 
例如，线性核：，假定v1是二维向量，对应的映射为，< >代表的是向量内积，可以做如下的推演，可知当前的线性核是有意义的：
 
 
除此之外，可能会有一个思考，为什么从低维映射到高维能够将原始数据从非线性转为线性，并且得到的划分是合理的呢？原因在于，从低维映射到高维后的每一个点，它们与各自原有的点一一对应，并且还满足一个条件就是，在低维空间下距离相近的两个点，在高维空间下仍然相近，注意相近指的是相对于其余的点，只有满足这两个条件，从低维映射到高维去做划分才有意义，这也就是为什么有的核函数应用到某一些数据的时候效果不好的原因，原因就是那一部分数据映射之后在高维空间下的距离和低维空间下的距离存在出入，不一致

 
Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。
 
前言
 
vuex的执行流程
 
组件通过dispatch调用action，action通过commit来触发mutation，mutation来负责修改state，state修改后去重新渲染受影响的dom。
 
安装和引入
 
1、安装
 
npm install vuex -S
 
2、引入
 
新建：store/index.js。
 
import vue from 'vue';
 
import Vuex from 'vuex';
 
vue.use(Vuex);
 
export default new Vuex.Store({
 
strict:true,//严格模式，防止直接修改state(性能很差，发布时改为false)
 
state:{
 
a:1,
 
b:2
 
},
 
mutations:{
 
addA(state,val){
 
state.a+=val;
 
},
 
addB(state,val){
 
state.b+=val;
 
}
 
},
 
actions:{
 
addA({commit},val){
 
//调用mutations中的addA()
 
commit('addA', val);
 
},
 
addB({commit},val){
 
//调用mutations中的addB()
 
commit('addB', val);
 
}
 
},
 
//相当于computed
 
getters:{
 
getA(state){
 
return state.a;
 
},
 
getB(state){
 
return state.b;
 
},
 
count(state){
 
return state.a + state.b;
 
}
 
},
 
modules:{
 
}
 
});
 
3、挂载
 
import store from './store';
 
new Vue({
 
el: '#app',
 
store,
 
components: { App },
 
template: ''
 
})
 
使用
 
映射关系
 
mapState > computed
 
mapGetters > computed
 
mapMutations > methods
 
mapActions > methods
 
State和mapState
 
state是vuex的核心，是统一存放数据的地方。
 
从store中获取值。(不推荐)
 

  
a:{{$store.state.a}}
  
b:{{$store.state.b}}
 
 
官方推荐通过computed来获取，但是如果需要获取多个值就会很麻烦。
 
mapState
 

  
a:{{a}}
  
b:{{b}}
 
 
import {mapState} from 'vuex';
 
export default {
 
name: "MapState",
 
computed:{
 
//将store.state中的属性映射到computed
 
...mapState(['a','b'])
 
}
 
}
 
getters和mapGetters
 
获取getters中的值。
 

  
a:{{$store.getters.getA}}
  
b:{{$store.getters.getB}}
  
a+b={{$store.getters.count}}
 
 
使用mapGetters映射。
 

  
a={{getA}}
  
b={{getB}}
  
a+b={{count}}
 
 
import {mapGetters} from 'vuex';
 
export default {
 
name: "MapGetters",
 
computed:{
 
//将store.getters映射到computed
 
...mapGetters(['getA','getB','count'])
 
}
 
}
 
mutations和mapMutations
 
通过$store.commit来触发mutation。
 
不推荐直接调用mutation来修改。
 

  
a={{$store.state.a}}
  
b={{$store.state.b}}
  
a+b={{$store.getters.count}}
  

  
a+5
 
 
使用mapMutations映射。
 

  
a={{$store.state.a}}
  
b={{$store.state.b}}
  
a+b={{$store.getters.count}}
  

  
a+5
 
 
import {mapMutations} from 'vuex';
 
export default {
 
name: "MapMutations",
 
methods:{
 
//将store.mutations映射到methods
 
...mapMutations(['addA'])
 
}
 
}
 
actions和mapActions
 
官方推荐通过action去触发mutation，虽然比较麻烦。
 
action支持异步，mutation只能同步。
 
通过$store.dispatch来触发action。
 
a+5
 
使用mapActions映射。
 

  
a={{$store.state.a}}
  
b={{$store.state.b}}
  
a+b={{$store.getters.count}}
  

  
a+5
 
 
import {mapActions} from 'vuex';
 
export default {
 
name: "MapActions",
 
methods:{
 
//将store.actions映射到methods
 
...mapMutations(['addA'])
 
}
 
}
 
Modules
 
当系统比较庞大时，store会变得非常臃肿。
 
为了方便store的模块化管理，Vuex 允许我们将 store 分割成 modules。
 
每个模块拥有自己的 state、mutation、action、getter、甚至是嵌套子模块。
 
补充知识：向vuex存储数据和获取数据-和直接调用actions.js中的异步方法
 
向vuex的变量存储数据
 
1.在state.js中添加 userInfo: {},
 
2.actions.js中添加同步用户信息-将参数userInfo传递给USER_INFO
 
创建一个方法-不用异步方法
 
syncUserInfo({commit}, userInfo){
 
commit(USER_INFO, {userInfo});
 
},
 
3.创建一个中间变量mutation-types.js
 
export const USER_INFO = 'user_info';
 
4.在actions.js中引入变量-USER_INFO
 
import {
 
USER_INFO
 
} from './mutation-types'
 
5.在mutations.js中引入变量
 
import {
 
USER_INFO
 
} from './mutation-types'
 
将userInfo赋值给state
 
[USER_INFO](state, {userInfo}) {
 
state.userInfo = userInfo;
 
},
 
6.外界直接调用actions.js中的方法 syncUserInfo
 
import {mapActions} from 'vuex'
 
methods: {
 
// 存到vuex-是个方法。需要...延展符展开
 
...mapActions(['syncUserInfo']),
 
}
 
向vuex中获取数据
 
1.引入 import {mapState} from 'vuex';
 
2.计算属性
 
computed:{
 
...mapState(['userInfo'])
 
},
 
直接调用vuex-中 actions.js的异步方法--
 
this.$store.dispatch
 
created(){
 
// 调用vuex-actions中的方法-刚进入app，就需要验证登录的时效性
 
this.$store.dispatch('getUserInfo')
 
},
 
actions.js
 
// 7. 异步获取用户信息
 
async getUserInfo({commit}){
 
const result = await getUserInfo(); // actions中调用getUserInfo方法---需要引入import
 
console.log(result);
 
if(result.success_code === 200){
 
commit(USER_INFO, {userInfo: result.message});
 
}
 
},
 
actions中调用getUserInfo方法---需要引入
 
import {
 
getUserInfo,
 
} from '../api'
 
----------------------
 
api-index.js
 
// 2.9 获取登录的用户信息
 
export const getUserInfo = () => ajax(BASE_URL + '/api/user_info');
 
以上这篇vuex存取值和映射函数使用说明就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

 
集合、映射与函数
 
一、集合
1. 集合的定义
2. 集合的特性
3. 集合之间的包含关系
4. 数集与点集
  
二、映射
1. 映射的定义
2. 映射的三要素
3. 满射
4. 单射
5. 双射（一一映射）
6. 逆映射
7. 集合元素的个数
  
三、函数
1. 函数的定义
2. 反函数
3. 函数的特性
4. 基本初等函数
(1) 幂函数 y = xα（α $\in$ R）
(2) 对数函数 y = logαx（α > 0，α $\ne$ 1）
(3) 指数函数 y = αx（α > 0，α $\ne$ 1）
(4) 三角函数
(5) 反三角函数
   
5.初等函数
  
四、函数

 
一、集合
 
1. 集合的定义
 
 
具有一个特定属性的，确定的，有区别的事物（不论是抽象的还是具体的）的全体称为集合，集合中的事物称为元素。
 
 
若a是集合A中的元素，记为a $\in$ A。
 
 
若a不是集合A中的元素，记为a $\notin$ A。
 
 
2. 集合的特性
 
 
确定性
 
 
互异性
 
 
无序性
 
 
3. 集合之间的包含关系
 
 
两个集合A、B，若 $\forall$ x $\in$ A，都有x $\in$ B，则称A是B的子集，记为A $\subset$ B。
 
 
A $\subset$ B，若 $\exists$ x $\in$ B且x $\notin$ A，则A是B的真子集，记为A $\subseteq$ B。
 
 
4. 数集与点集
 
 
集合中的元素是数，实数集R、整数集Z。
 
 
集合中的元素是坐标系中的点，{(x, y) | x + y < 3}。
 
 
 
二、映射
 
1. 映射的定义
 
 
设A、B是两个非空集合，如果存在一个法则f，使得对A中的每个元素a，按法则f，在B中有唯一确定的元素b与之对应，那么称f为从A到B的映射，记作：f : A → B。
 
 
b称为元素a在映射f下的像，记为b = f(a)。
 
 
a称为元素b在映射f下的一个原像。
 
 
A称为映射f的定义域，记作Df。
 
 
A中所有元素的像所组成的集合称为映射f的值域，记为Rf。
 
  
Rf = f(A) = {f(a) | a $\in$ A}
 
 
2. 映射的三要素
 
 
定义域：Df = A
 
 
值域：Rf $\subset$ B
 
 
对应法则
 
  
对于每个a $\in$ A，元素a的像b唯一
对于每一个b $\in$ Rf，元素b的原像不一定唯一
 
 
3. 满射
 
设f是集合A到集合B的映射，满足Rf = B
 
4. 单射
 
对于A中的任意两个不同的元素，若a1 ≠ a2，则f(a1) ≠ f(a2)
 
5. 双射（一一映射）
 
f既是单射，又是满射
 
6. 逆映射
 
 
7. 集合元素的个数
 
如果存在一种映射关系，使A、B两个集合一一映射，则称A、B元素个数相同。
 
 
三、函数
 
1. 函数的定义
 
函数是从实数集到实数集的映射
 
2. 反函数
 
 
定义：设映射f : D → E为双射（D $\subset$ R，E $\subset$ R），则它的逆映射f-1 : E → D称为f的反函数。
 
 
示例：求f(x) = x2，x $\in$ [-2, 2]，y $\in$ [0, 4]的反函数？
 
  
原函数：y = x2，x $\in$ [-2, 2]
将x换为y，y换为x：x = y2，x $\in$ [0, 4]
反函数：y = $\sqrt{x}$，x $\in$ [0, 4]
 
 
3. 函数的特性
 
单调性 
  
单调递增：x1 < x2，f(x1) < f(x2)
单调递减：x1 < x2，f(x1) > f(x2)
 
 
 
 
增减区间交界处通常是极值点
 
 
奇偶性 
  
奇函数：f(-x) = -f(x)，图像关于原点对称
偶函数：f(-x) = f(x)，图像关于y轴对称
 
 
 
 
定义域必须对称
 
 
周期性
 
4. 基本初等函数
 
(1) 幂函数 y = xα（α $\in$ R）
 

 
 
 
 
 
 
 
 
公约数只有1的两个数互质
 
 
(2) 对数函数 y = logαx（α > 0，α $\ne$ 1）
 
 
 
(3) 指数函数 y = αx（α > 0，α $\ne$ 1）
 
 
 
 
指数函数与对数函数互为反函数
 指数函数与对数函数的图像均关于y = x对称
 
 
(4) 三角函数
 
 
正弦函数 y = αsin(ωx + φ)
 
  
振幅：|α|
频率：ω
初始相位：φ
最小正周期：|$\frac{2\pi }{\omega }$|
值域：[-|α|, |α|]
在对称轴ωx + φ = $\frac{\pi }{2}$ + 2k$\pi$处取得最大值（k $\in$ Z）
在对称轴ωx + φ = -$\frac{\pi }{2}$ + 2k$\pi$处取得最小值（k $\in$ Z）
 
 
余弦函数 y = αcos(ωx + φ)
 
  
振幅：|α|
频率：ω
初始相位：φ
最小正周期：|$\frac{2\pi }{\omega }$|
值域：[-|α|, |α|]
在对称轴x = ωx + φ = 2k$\pi$处取得最大值（k $\in$ Z）
在对称轴x = ωx + φ = $\pi$ + 2k$\pi$处取得最小值（k $\in$ Z）
 
 
(5) 反三角函数
 
5.初等函数
 
 
定义：由常数和基本初等函数经过有限次的四则运算和有限次的复合步骤所构成并可用一个式子表示的函数。
 
 
一次函数 y = ax + b（a $\ne$ 0）
 
  
定义域：R
值域：R
a > 0，函数单调递增
a < 0，函数单调递减
b = 0，函数过原点，是奇函数
 
 
二次函数 y = ax2 + bx + c（a $\ne$ 0）
 
  
定义域：R
对称轴：x = -$\frac{b}{2a}$
a > 0： 
    
函数图像开口向上
函数在(-$\infty$, -$\frac{b}{2a}$)区间单调递减；函数在(-$\frac{b}{2a}$, +$\infty$)区间单调递增
函数的最小值在x = -$\frac{b}{2a}$处取得，值为$\frac{4ac-b^2}{4a}$；函数的最大值为+$\infty$
 
a < 0： 
    
函数图像开口向下
函数在(-$\infty$, -$\frac{b}{2a}$)区间单调递增；函数在(-$\frac{b}{2a}$, +$\infty$)区间单调递减
函数的最大值在x = -$\frac{b}{2a}$处取得，值为$\frac{4ac-b^2}{4a}$；函数的最小值为-$\infty$
 
顶点式：y = a(x - m)2 + n，a $\ne$ 0 
    
顶点坐标为(m, n)
 
 
 
 
四、函数
 
函数一定是方程，方程不一定是函数

 
简短的回答：内置的函数ARRAYFUN完成了你的映射函数对数值数组的作用：
 
>> y = arrayfun(@(x) x^2,1:10) y = 1 4 9 16 25 36 49 64 81 100
 
还有另外两个内置函数的行为类似： CELLFUN (对单元arrays的元素进行操作)和STRUCTFUN (对结构的每个字段进行操作)。
 
但是，如果利用向量化，通常不需要这些函数，特别是使用基于元素的算术运算符 。 对于你给的例子，一个vector化的解决scheme是：
 
>> x = 1:10; >> y = x.^2 y = 1 4 9 16 25 36 49 64 81 100
 
有些操作会自动跨元素操作(比如向向量添加标量值)，而其他操作符则有特殊的元素操作语法(在操作符之前用“。”表示)。 MATLAB中的许多函数被devise为使用基于元素的操作对向量和matrix参数进行操作，因此不需要映射函数。
 
总结一下，下面是一些不同的方法来排列数组中的每个元素：
 
x = 1:10; %// Sample array f = @(x) x.^2; %// Anonymous function that squares each element of its input %// Option #1: y = x.^2; %// Use the element-wise power operator %// Option #2: y = f(x); %// Pass a vector to f %// Option #3: y = arrayfun(f,x); %// Pass each element to f separately
 
当然，对于这样一个简单的操作，选项＃1是最明智的select。